@gonvex/client 0.5.2-staging.2 → 0.5.2-staging.20

package/dist/indexeddb-replica.js

@@ -1,12 +1,39 @@
 import { Dexie } from "dexie";
+import { entityRecord, indexedDBReadView } from './indexeddb-read-view.js';
+import { mergeReplicaRecord } from './replica-record.js';
 const defaultReplicaScope = "default";
-const replicaSchemaVersion = 3;
+const replicaSchemaVersion = 5;
+// Keep native IDB request bursts short so another database's durable intent
+// journal can run between batches. All batches remain in one atomic transaction.
+const writeBatchSize = 4;
+// Small replica checkpoints usually change only a few rows. IndexedDB getAll
+// avoids a JS/Dexie continuation per row. The fallback remains streaming so a
+// large peer update cannot pull an unbounded table into a temporary array.
+async function visitRecords(collection, visit) {
+    const page = await collection.clone().limit(128).toArray();
+    for (const record of page)
+        visit(record);
+    if (page.length === 128)
+        await collection.clone().offset(128).each(visit);
+}
 /** Atomic normalized web persistence for the Gonvex Local Replica. */
 export class IndexedDBLocalReplicaStorage {
     database;
     initialized;
+    channel;
+    peers = new Set();
     constructor(name = "gonvex-local-replica") {
-        this.database = new Dexie(name);
+        this.database = new Dexie(name, { cache: 'disabled' });
+        // Gonvex owns subscription delivery and peer synchronization. These private
+        // tables are never queried through Dexie.liveQuery; collecting index ranges
+        // and retaining a second query cache duplicates work on every replica write.
+        this.database.unuse({ stack: 'dbcore', name: 'Cache' });
+        this.database.unuse({ stack: 'dbcore', name: 'Observability' });
+        this.channel = typeof BroadcastChannel === 'function' ? new BroadcastChannel(`gonvex-replica:${name}`) : undefined;
+        if (this.channel)
+            this.channel.onmessage = event => { if (typeof event.data?.scope === 'string')
+                for (const listener of this.peers)
+                    listener(event.data.scope); };
         this.database.version(1).stores({ snapshots: "&key" });
         this.database.version(2).stores({ snapshots: "&scope" }).upgrade(async (transaction) => {
             await transaction.table("snapshots").toCollection().modify((record) => {
@@ -14,7 +41,7 @@ export class IndexedDBLocalReplicaStorage {
                 delete record.key;
             });
         });
-        this.database.version(replicaSchemaVersion).stores({
+        this.database.version(3).stores({
             entities: "[scope+entity+id], scope, [scope+entity]",
             windows: "[scope+signature], scope",
             meta: "[scope+key], scope",
@@ -47,71 +74,348 @@ export class IndexedDBLocalReplicaStorage {
             // row-bearing server-state store indefinitely.
             await transaction.table("snapshots").clear();
         });
+        this.database.version(4).stores({
+            entities: '[scope+entity+id], scope, [scope+entity], *lookupKeys',
+        }).upgrade(async (transaction) => {
+            await transaction.table('entities').toCollection().modify((record) => {
+                record.lookupKeys = entityRecord(record.scope, record.entity, record.id, JSON.parse(record.value)).lookupKeys;
+            });
+        });
+        this.database.version(replicaSchemaVersion).stores({
+            entities: '[scope+entity+id], scope, [scope+entity], *lookupKeys, [scope+sequence]',
+            windows: '[scope+signature], scope, [scope+sequence]',
+        });
+    }
+    subscribePeer(listener) { this.peers.add(listener); return () => { this.peers.delete(listener); }; }
+    async nextSequence(scope) {
+        const prior = await this.database.meta.get([scope, 'sequence']);
+        const sequence = Number(prior?.value ?? 0) + 1;
+        await this.database.meta.put({ scope, key: 'sequence', value: String(sequence) });
+        return sequence;
+    }
+    versionedRecord(scope, entity, id, row, cursor, sequence, previous) {
+        const resolved = cursor ?? { epoch: previous?.authority?.epoch ?? '', revision: 0 };
+        const before = previous ? { row: previous.deleted ? null : JSON.parse(previous.value), authority: previous.authority ?? { epoch: resolved.epoch, fields: {} } } : undefined;
+        const merged = mergeReplicaRecord(before, row, resolved);
+        // Reconnect snapshots often repeat the same projected values/revisions.
+        // Preserve the stored record for a no-op; a revision-only advance reuses
+        // its serialized value and secondary keys while updating authority.
+        if (previous && merged === before)
+            return previous;
+        if (previous && before && merged.row === before.row)
+            return { ...previous, authority: merged.authority, sequence };
+        const record = merged.row ? entityRecord(scope, entity, id, merged.row) : { scope, entity, id, value: 'null', lookupKeys: [], deleted: true };
+        return { ...record, authority: merged.authority, sequence };
+    }
+    async writeEntity(scope, entity, id, row, cursor, sequence) {
+        const previous = await this.database.entities.get([scope, entity, id]);
+        const record = this.versionedRecord(scope, entity, id, row, cursor, sequence, previous);
+        if (record !== previous)
+            await this.database.entities.put(record);
+        return record;
+    }
+    async writeRows(scope, entity, key, rows, cursor, sequence) {
+        return this.writeRowEntries(scope, entity, rows.map(row => [String(row[key]), row]), cursor, sequence);
+    }
+    async writeRowEntries(scope, entity, rows, cursor, sequence) {
+        // Bounded batches retain only the incoming rows and their previous values.
+        for (let offset = 0; offset < rows.length; offset += writeBatchSize) {
+            const batch = rows.slice(offset, offset + writeBatchSize);
+            const prior = await this.database.entities.bulkGet(batch.map(([id]) => [scope, entity, id]));
+            const records = batch.map(([id, row], index) => this.versionedRecord(scope, entity, id, row, cursor, sequence, prior[index])).filter((record, index) => record !== prior[index]);
+            if (records.length)
+                await this.database.entities.bulkPut(records);
+        }
+    }
+    async writeWindows(scope, windows, sequence) {
+        const prior = await this.database.windows.bulkGet(windows.map(window => [scope, window.signature]));
+        await this.database.windows.bulkPut(windows.flatMap((window, index) => {
+            const record = prior[index];
+            const before = record && !record.deleted ? JSON.parse(record.value) : undefined;
+            if (before?.cursor && (!window.cursor || (before.cursor.epoch === window.cursor.epoch && before.cursor.revision > window.cursor.revision)))
+                return [{ ...record, sequence }];
+            return [{ scope, sequence, signature: window.signature, value: JSON.stringify(normalizeWindow(window)) }];
+        }));
+    }
+    async saveCursor(scope, cursor) {
+        if (!cursor)
+            return;
+        const epoch = await this.database.meta.get([scope, 'epoch']);
+        if (epoch && JSON.parse(epoch.value).current !== cursor.epoch)
+            throw new Error('This tab has an obsolete replica epoch. Reconnect before continuing.');
+        const prior = await this.database.meta.get([scope, 'cursor']);
+        const before = prior ? JSON.parse(prior.value) : undefined;
+        if (before?.epoch === cursor.epoch && before.revision > cursor.revision)
+            return;
+        await this.database.meta.put({ scope, key: 'cursor', value: JSON.stringify(cursor) });
+    }
+    async acceptEpoch(scope, cursor, sequence) {
+        if (!cursor)
+            return;
+        const prior = await this.database.meta.get([scope, 'epoch']);
+        const legacyCursor = prior ? undefined : await this.database.meta.get([scope, 'cursor']);
+        const state = prior ? JSON.parse(prior.value) : legacyCursor ? { current: JSON.parse(legacyCursor.value).epoch, retired: [] } : undefined;
+        if (state?.current === cursor.epoch) {
+            if (!prior)
+                await this.database.meta.put({ scope, key: 'epoch', value: JSON.stringify(state) });
+            return;
+        }
+        if (state?.retired.includes(cursor.epoch))
+            throw new Error('This tab has an obsolete replica epoch. Reconnect before continuing.');
+        if (state) {
+            await this.database.entities.where('scope').equals(scope).delete();
+            await this.database.windows.where('scope').equals(scope).delete();
+            await this.database.meta.put({ scope, key: 'resetSequence', value: String(sequence) });
+        }
+        await this.database.meta.put({ scope, key: 'epoch', value: JSON.stringify({ current: cursor.epoch, retired: state ? [...state.retired, state.current] : [] }) });
+    }
+    async pruneRows(scope, window, ids, cursor, sequence) {
+        if (!ids.length)
+            return;
+        const retained = new Set();
+        await visitRecords(this.database.windows.where('scope').equals(scope), record => {
+            if (record.deleted || record.signature === window.signature)
+                return;
+            const other = JSON.parse(record.value);
+            if (other.entity === window.entity)
+                for (const id of other.ids)
+                    retained.add(id);
+        });
+        for (const id of ids)
+            if (!retained.has(id))
+                await this.writeEntity(scope, window.entity, id, null, cursor, sequence);
+    }
+    async readChanges(scope, afterSequence, interest) {
+        await this.initialize();
+        return this.database.transaction('r', this.database.entities, this.database.windows, this.database.meta, async () => {
+            const sequence = Number((await this.database.meta.get([scope, 'sequence']))?.value ?? 0);
+            const reset = afterSequence < Number((await this.database.meta.get([scope, 'resetSequence']))?.value ?? 0);
+            const changes = { sequence, reset, entities: {}, windows: {} };
+            if (sequence === afterSequence)
+                return changes;
+            const wanted = interest ? new Map(Object.entries(interest.rows).map(([table, ids]) => [table, new Set(ids)])) : undefined;
+            let availableRows = interest ? reset ? interest.maxRows : interest.availableRows : 0;
+            let availableBytes = interest ? reset ? interest.maxBytes : interest.availableBytes : 0;
+            const windows = reset ? this.database.windows.where('scope').equals(scope) : this.database.windows.where('[scope+sequence]').between([scope, afterSequence], [scope, sequence], false, true);
+            await visitRecords(windows, record => {
+                const window = record.deleted ? null : JSON.parse(record.value);
+                changes.windows[record.signature] = window;
+                if (window && wanted && interest?.windows.includes(record.signature)) {
+                    let ids = wanted.get(window.entity);
+                    if (!ids) {
+                        ids = new Set();
+                        wanted.set(window.entity, ids);
+                    }
+                    for (const id of window.ids)
+                        ids.add(id);
+                }
+            });
+            const rows = reset ? this.database.entities.where('scope').equals(scope) : this.database.entities.where('[scope+sequence]').between([scope, afterSequence], [scope, sequence], false, true);
+            await visitRecords(rows, record => {
+                if (wanted && !wanted.get(record.entity)?.has(record.id)) {
+                    const size = record.value.length * 2 + 256;
+                    if (record.deleted || availableRows <= 0 || availableBytes < size)
+                        return;
+                    availableRows--;
+                    availableBytes -= size;
+                }
+                (changes.entities[record.entity] ??= {})[record.id] = record.deleted ? null : JSON.parse(record.value);
+            });
+            return changes;
+        });
     }
     initialize() {
         return this.initialized ??= this.database.open().then(() => undefined);
     }
+    async withReadView(scope, coverage, run) {
+        await this.initialize();
+        return this.database.transaction('r', this.database.entities, async () => {
+            // Database reads run normally in this transaction. Dexie.waitFor must
+            // never surround work that also uses this transaction; keep it limited
+            // to the deterministic crypto promise supplied by the ID allocator.
+            return run({ ...indexedDBReadView(this.database.entities, normalizeScope(scope), coverage),
+                keepAliveFor: promise => Dexie.waitFor(promise),
+            });
+        });
+    }
+    async listScopes() {
+        await this.initialize();
+        const [entities, windows, meta] = await Promise.all([
+            this.database.entities.orderBy("scope").uniqueKeys(),
+            this.database.windows.orderBy("scope").uniqueKeys(),
+            this.database.meta.orderBy("scope").uniqueKeys(),
+        ]);
+        return [...new Set([...entities, ...windows, ...meta].map(String))];
+    }
+    async loadSession(scope) {
+        await this.initialize();
+        const record = await this.database.meta.get([scope, "session"]);
+        return record ? JSON.parse(record.value) : undefined;
+    }
+    async saveSession(scope, session) {
+        await this.initialize();
+        if (session)
+            await this.database.meta.put({ scope, key: "session", value: JSON.stringify(session) });
+        else
+            await this.database.meta.delete([scope, "session"]);
+    }
     async load(scope = defaultReplicaScope) {
         await this.initialize();
         const normalizedScope = normalizeScope(scope);
-        const [entityRecords, windowRecords, cursor] = await Promise.all([
-            this.database.entities.where("scope").equals(normalizedScope).toArray(),
-            this.database.windows.where("scope").equals(normalizedScope).toArray(),
-            this.database.meta.get([normalizedScope, "cursor"]),
-        ]);
-        if (entityRecords.length === 0 && windowRecords.length === 0 && !cursor)
-            return undefined;
-        const entities = {};
-        for (const record of entityRecords)
-            (entities[record.entity] ??= {})[record.id] = JSON.parse(record.value);
-        const liveQueries = {};
-        for (const record of windowRecords)
-            liveQueries[record.signature] = JSON.parse(record.value);
-        return {
-            cursor: cursor ? JSON.parse(cursor.value) : undefined,
-            entities,
-            liveQueries,
-        };
+        return this.database.transaction('r', this.database.entities, this.database.windows, this.database.meta, async () => {
+            const [entityRecords, windowRecords, cursor] = await Promise.all([
+                this.database.entities.where("scope").equals(normalizedScope).toArray(),
+                this.database.windows.where("scope").equals(normalizedScope).toArray(),
+                this.database.meta.get([normalizedScope, "cursor"]),
+            ]);
+            if (entityRecords.length === 0 && windowRecords.length === 0 && !cursor)
+                return undefined;
+            const entities = {};
+            for (const record of entityRecords)
+                if (!record.deleted)
+                    (entities[record.entity] ??= {})[record.id] = JSON.parse(record.value);
+            const liveQueries = {};
+            for (const record of windowRecords)
+                if (!record.deleted)
+                    liveQueries[record.signature] = JSON.parse(record.value);
+            return {
+                storageSequence: Number((await this.database.meta.get([normalizedScope, 'sequence']))?.value ?? 0),
+                cursor: cursor ? JSON.parse(cursor.value) : undefined,
+                entities,
+                liveQueries,
+            };
+        });
+    }
+    async loadWorkingSet(scope, budget) {
+        await this.initialize();
+        return this.database.transaction('r', this.database.entities, this.database.windows, this.database.meta, async () => {
+            const entities = {}, liveQueries = {}, partial = new Set();
+            let bytes = 0, count = 0, hasRows = false, full = false;
+            // getAll-backed pages avoid one JS/Dexie cursor continuation per row.
+            // Keep both temporary decoding and retained rows bounded independently.
+            let after;
+            while (!full) {
+                const page = await this.database.entities.where('[scope+entity+id]')
+                    .between(after ?? [scope], [scope, []], !after, false)
+                    .limit(Math.min(256, Math.max(1, budget.maxRows - count + 1))).toArray();
+                if (!page.length)
+                    break;
+                for (const record of page) {
+                    if (record.deleted)
+                        continue;
+                    hasRows = true;
+                    const size = record.value.length * 2 + 256;
+                    if (count >= budget.maxRows || bytes + size > budget.maxBytes) {
+                        partial.add(record.entity);
+                        full = true;
+                        break;
+                    }
+                    (entities[record.entity] ??= {})[record.id] = JSON.parse(record.value);
+                    bytes += size;
+                    count++;
+                }
+                const last = page[page.length - 1];
+                after = [last.scope, last.entity, last.id];
+            }
+            await visitRecords(this.database.windows.where('scope').equals(scope), record => {
+                if (record.deleted)
+                    return;
+                const window = JSON.parse(record.value);
+                liveQueries[record.signature] = window;
+                if (window.ids.some(id => !entities[window.entity]?.[id]))
+                    partial.add(window.entity);
+            });
+            const cursor = await this.database.meta.get([scope, 'cursor']);
+            if (!hasRows && !Object.keys(liveQueries).length && !cursor)
+                return undefined;
+            return { entities, liveQueries, residentPartialTables: [...partial], cursor: cursor ? JSON.parse(cursor.value) : undefined, storageSequence: Number((await this.database.meta.get([scope, 'sequence']))?.value ?? 0) };
+        });
+    }
+    async loadEntityRows(scope, entity, ids) {
+        await this.initialize();
+        return this.database.transaction('r', this.database.entities, async () => {
+            const rows = [];
+            for (let offset = 0; offset < ids.length; offset += 500) {
+                const records = await this.database.entities.bulkGet(ids.slice(offset, offset + 500).map(id => [scope, entity, id]));
+                for (const record of records)
+                    if (record && !record.deleted)
+                        rows.push({ id: record.id, row: JSON.parse(record.value) });
+            }
+            return rows;
+        });
+    }
+    async loadWindowRows(scope, signature) {
+        await this.initialize();
+        return this.database.transaction('r', this.database.entities, this.database.windows, async () => {
+            const record = await this.database.windows.get([scope, signature]);
+            if (!record || record.deleted)
+                return undefined;
+            const window = JSON.parse(record.value);
+            return { window, rows: (await this.loadEntityRows(scope, window.entity, window.ids)).map(entry => entry.row) };
+        });
     }
     async applyTransaction(transaction, _snapshot, scope = defaultReplicaScope) {
         await this.initialize();
         const normalizedScope = normalizeScope(scope);
         await this.database.transaction("rw", this.database.entities, this.database.windows, this.database.meta, async () => {
-            const previous = await this.database.meta.get([normalizedScope, "cursor"]);
-            if (previous && JSON.parse(previous.value).epoch !== transaction.cursor.epoch) {
-                await this.database.entities.where("scope").equals(normalizedScope).delete();
-                await this.database.windows.where("scope").equals(normalizedScope).delete();
-            }
+            const sequence = await this.nextSequence(normalizedScope);
+            await this.acceptEpoch(normalizedScope, transaction.cursor, sequence);
+            const grouped = new Map();
             for (const change of transaction.changes) {
-                if (change.operation === "delete") {
-                    await this.database.entities.delete([normalizedScope, change.entity, change.id]);
-                    const windows = await this.database.windows.where("scope").equals(normalizedScope).toArray();
-                    for (const record of windows) {
-                        const window = JSON.parse(record.value);
-                        if (!window.ids.includes(change.id))
+                const key = JSON.stringify([change.entity, change.id]);
+                let entry = grouped.get(key);
+                if (!entry) {
+                    entry = { entity: change.entity, id: change.id, changes: [] };
+                    grouped.set(key, entry);
+                }
+                entry.changes.push(change);
+            }
+            const entries = [...grouped.values()];
+            const deleted = new Map();
+            for (let offset = 0; offset < entries.length; offset += writeBatchSize) {
+                const batch = entries.slice(offset, offset + writeBatchSize);
+                const previous = await this.database.entities.bulkGet(batch.map(entry => [normalizedScope, entry.entity, entry.id]));
+                const records = [];
+                for (const [index, entry] of batch.entries()) {
+                    let record = previous[index];
+                    for (const change of entry.changes) {
+                        if (change.operation !== 'delete' && !change.newValue)
                             continue;
-                        window.ids = window.ids.filter((id) => id !== change.id);
-                        await this.database.windows.put({ ...record, value: JSON.stringify(window) });
+                        record = this.versionedRecord(normalizedScope, entry.entity, entry.id, change.operation === 'delete' ? null : change.newValue, transaction.cursor, sequence, record);
+                    }
+                    if (!record)
+                        continue;
+                    records.push(record);
+                    if (record.deleted) {
+                        let ids = deleted.get(entry.entity);
+                        if (!ids) {
+                            ids = new Set();
+                            deleted.set(entry.entity, ids);
+                        }
+                        ids.add(entry.id);
                     }
                 }
-                else if (change.newValue) {
-                    await this.database.entities.put({
-                        scope: normalizedScope,
-                        entity: change.entity,
-                        id: change.id,
-                        value: JSON.stringify(change.newValue),
-                    });
-                }
+                await this.database.entities.bulkPut(records);
             }
-            for (const membership of transaction.memberships ?? []) {
-                await this.database.windows.put({
-                    scope: normalizedScope,
-                    signature: membership.signature,
-                    value: JSON.stringify(normalizeWindow(membership)),
-                });
+            if (deleted.size) {
+                const windows = await this.database.windows.where('scope').equals(normalizedScope).toArray();
+                const changed = [];
+                for (const record of windows) {
+                    if (record.deleted)
+                        continue;
+                    const window = JSON.parse(record.value);
+                    const ids = deleted.get(window.entity);
+                    if (!ids || !window.ids.some(id => ids.has(id)) || (window.cursor?.epoch === transaction.cursor.epoch && window.cursor.revision > transaction.cursor.revision))
+                        continue;
+                    window.ids = window.ids.filter(id => !ids.has(id));
+                    changed.push({ ...record, sequence, value: JSON.stringify(window) });
+                }
+                await this.database.windows.bulkPut(changed);
             }
-            await this.database.meta.put({ scope: normalizedScope, key: "cursor", value: JSON.stringify(transaction.cursor) });
+            await this.writeWindows(normalizedScope, transaction.memberships ?? [], sequence);
+            await this.saveCursor(normalizedScope, transaction.cursor);
         });
+        this.channel?.postMessage({ scope: normalizedScope });
     }
     async advanceWatermark(windows, cursor, scope = defaultReplicaScope) {
         await this.initialize();
@@ -120,101 +424,98 @@ export class IndexedDBLocalReplicaStorage {
         // window metadata and the shared cursor so large normalized replicas are
         // never rewritten once per retained collection.
         await this.database.transaction("rw", this.database.windows, this.database.meta, async () => {
-            for (const window of windows) {
-                await this.database.windows.put({
-                    scope: normalizedScope,
-                    signature: window.signature,
-                    value: JSON.stringify(normalizeWindow(window)),
-                });
-            }
-            if (cursor) {
-                await this.database.meta.put({ scope: normalizedScope, key: "cursor", value: JSON.stringify(cursor) });
-            }
+            const sequence = await this.nextSequence(normalizedScope);
+            await this.writeWindows(normalizedScope, windows, sequence);
+            await this.saveCursor(normalizedScope, cursor);
         });
+        this.channel?.postMessage({ scope: normalizedScope });
     }
-    async replaceWindow(window, snapshot, scope = defaultReplicaScope) {
+    async replaceWindow(window, snapshot, scope = defaultReplicaScope, projection) {
         await this.initialize();
         const normalizedScope = normalizeScope(scope);
         await this.database.transaction("rw", this.database.entities, this.database.windows, this.database.meta, async () => {
+            const sequence = await this.nextSequence(normalizedScope);
+            await this.acceptEpoch(normalizedScope, window.cursor ?? snapshot.cursor, sequence);
             // A window replacement owns only its projected entity rows. Rewriting the
             // complete normalized replica for every snapshot made startup quadratic:
             // each newly opened collection persisted every entity loaded by all prior
             // collections, and `replica.ready` repeated the same work. Persist this
             // window atomically while leaving unrelated entity tables untouched.
-            const rows = snapshot.entities[window.entity] ?? {};
+            const rows = () => snapshot.entities[window.entity] ?? {};
             const previousRecord = await this.database.windows.get([normalizedScope, window.signature]);
-            if (previousRecord) {
+            if (previousRecord && !previousRecord.deleted) {
                 const previous = JSON.parse(previousRecord.value);
                 const nextIDs = new Set(window.ids);
-                for (const id of previous.ids) {
-                    // The in-memory snapshot already accounts for every other window and
-                    // transaction owner. Absence here means the entity is no longer
-                    // authorized/referenced and must not survive restart hydration.
-                    if (!nextIDs.has(id) && rows[id] === undefined) {
-                        await this.database.entities.delete([normalizedScope, window.entity, id]);
-                    }
-                }
+                await this.pruneRows(normalizedScope, window, previous.ids.filter(id => !nextIDs.has(id) && rows()[id] === undefined), window.cursor ?? snapshot.cursor, sequence);
             }
-            for (const id of window.ids) {
-                const value = rows[id];
-                if (value !== undefined) {
-                    await this.database.entities.put({
-                        scope: normalizedScope,
-                        entity: window.entity,
-                        id,
-                        value: JSON.stringify(value),
-                    });
-                }
-            }
-            await this.database.windows.put({ scope: normalizedScope, signature: window.signature, value: JSON.stringify(normalizeWindow(window)) });
-            if (snapshot.cursor)
-                await this.database.meta.put({ scope: normalizedScope, key: "cursor", value: JSON.stringify(snapshot.cursor) });
+            await this.writeRows(normalizedScope, window.entity, window.key, projection ?? window.ids.flatMap(id => rows()[id] ? [rows()[id]] : []), window.cursor ?? snapshot.cursor, sequence);
+            await this.writeWindows(normalizedScope, [window], sequence);
+            await this.saveCursor(normalizedScope, snapshot.cursor);
         });
+        this.channel?.postMessage({ scope: normalizedScope });
     }
-    async applyWindowDelta(window, _delta, snapshot, scope = defaultReplicaScope) {
-        // The in-memory replica has already computed the normalized result. The
-        // storage transaction receives that result and persists it atomically;
-        // retaining unrelated entities is deliberate and conservative.
-        await this.replaceWindow(window, snapshot, scope);
+    async applyWindowDelta(window, delta, snapshot, scope = defaultReplicaScope) {
+        await this.initialize();
+        const normalizedScope = normalizeScope(scope);
+        await this.database.transaction("rw", this.database.entities, this.database.windows, this.database.meta, async () => {
+            const sequence = await this.nextSequence(normalizedScope);
+            await this.acceptEpoch(normalizedScope, window.cursor ?? snapshot.cursor, sequence);
+            const rows = delta.deleted.length ? snapshot.entities[window.entity] ?? {} : {};
+            await this.pruneRows(normalizedScope, window, delta.deleted.filter(id => rows[id] === undefined), window.cursor ?? snapshot.cursor, sequence);
+            await this.writeRows(normalizedScope, window.entity, window.key, delta.upserts, window.cursor ?? snapshot.cursor, sequence);
+            await this.writeWindows(normalizedScope, [window], sequence);
+            await this.saveCursor(normalizedScope, snapshot.cursor);
+        });
+        this.channel?.postMessage({ scope: normalizedScope });
     }
     async removeWindow(signature, snapshot, scope = defaultReplicaScope) {
         await this.initialize();
         const normalizedScope = normalizeScope(scope);
         await this.database.transaction("rw", this.database.windows, this.database.meta, async () => {
-            await this.database.windows.delete([normalizedScope, signature]);
-            if (snapshot.cursor)
-                await this.database.meta.put({ scope: normalizedScope, key: "cursor", value: JSON.stringify(snapshot.cursor) });
+            const sequence = await this.nextSequence(normalizedScope);
+            await this.database.windows.put({ scope: normalizedScope, signature, value: 'null', deleted: true, sequence });
+            await this.saveCursor(normalizedScope, snapshot.cursor);
         });
+        this.channel?.postMessage({ scope: normalizedScope });
     }
     async replaceSnapshot(snapshot, scope = defaultReplicaScope) {
         await this.initialize();
         const normalizedScope = normalizeScope(scope);
         await this.database.transaction("rw", this.database.entities, this.database.windows, this.database.meta, async () => {
+            const sequence = await this.nextSequence(normalizedScope);
+            await this.acceptEpoch(normalizedScope, snapshot.cursor, sequence);
             await this.database.entities.where("scope").equals(normalizedScope).delete();
             await this.database.windows.where("scope").equals(normalizedScope).delete();
             await this.database.meta.delete([normalizedScope, "cursor"]);
+            await this.database.meta.put({ scope: normalizedScope, key: 'resetSequence', value: String(sequence) });
             for (const [entity, rows] of Object.entries(snapshot.entities)) {
-                for (const [id, value] of Object.entries(rows)) {
-                    await this.database.entities.put({ scope: normalizedScope, entity, id, value: JSON.stringify(value) });
-                }
-            }
-            for (const [signature, window] of Object.entries(snapshot.liveQueries)) {
-                await this.database.windows.put({ scope: normalizedScope, signature, value: JSON.stringify(normalizeWindow(window)) });
+                const entries = Object.entries(rows);
+                // Empty tables have no IndexedDB work. Repeatedly awaiting already
+                // resolved native async helpers can let a browser commit this transaction
+                // before the next populated table is written (Dexie.PrematureCommitError).
+                if (entries.length)
+                    await this.writeRowEntries(normalizedScope, entity, entries, snapshot.cursor, sequence);
             }
-            if (snapshot.cursor)
-                await this.database.meta.put({ scope: normalizedScope, key: "cursor", value: JSON.stringify(snapshot.cursor) });
+            await this.writeWindows(normalizedScope, Object.values(snapshot.liveQueries), sequence);
+            await this.saveCursor(normalizedScope, snapshot.cursor);
         });
+        this.channel?.postMessage({ scope: normalizedScope });
     }
     async clear(scope = defaultReplicaScope) {
         await this.initialize();
         const normalizedScope = normalizeScope(scope);
         await this.database.transaction("rw", this.database.entities, this.database.windows, this.database.meta, async () => {
+            const sequence = await this.nextSequence(normalizedScope);
             await this.database.entities.where("scope").equals(normalizedScope).delete();
             await this.database.windows.where("scope").equals(normalizedScope).delete();
-            await this.database.meta.where("scope").equals(normalizedScope).delete();
+            await this.database.meta.where("scope").equals(normalizedScope).and(record => record.key !== 'sequence' && record.key !== 'epoch').delete();
+            await this.database.meta.put({ scope: normalizedScope, key: 'resetSequence', value: String(sequence) });
         });
+        this.channel?.postMessage({ scope: normalizedScope });
     }
     close() {
+        this.channel?.close();
+        this.peers.clear();
         this.database.close();
     }
 }