@verdant-web/store 2.7.7-next.0 → 2.7.7

package/dist/esm/metadata/Metadata.js

@@ -1,351 +1,351 @@
-import { applyPatch, assert, assignOid, EventSubscriber, isFileRef, getOidRoot, HybridLogicalClockTimestampProvider, PatchCreator, substituteRefsWithObjects, } from '@verdant-web/common';
-import { AckInfoStore } from './AckInfoStore.js';
-import { BaselinesStore } from './BaselinesStore.js';
-import { getAllFromObjectStores, getSizeOfObjectStore, storeRequestPromise, } from '../idb.js';
-import { LocalReplicaStore } from './LocalReplicaStore.js';
-import { MessageCreator } from './MessageCreator.js';
-import { OperationsStore } from './OperationsStore.js';
-import { SchemaStore } from './SchemaStore.js';
-export class Metadata extends EventSubscriber {
-    constructor({ disableRebasing, context, }) {
-        super();
-        this.time = new HybridLogicalClockTimestampProvider();
-        this.disableRebasing = false;
-        /**
-         * indicates the client is shutting down and we should stop
-         * accessing the database.
-         */
-        this._closing = false;
-        this.setContext = (context) => {
-            this.context = context;
-        };
-        this.close = () => {
-            this._closing = true;
-        };
-        /**
-         * Methods for accessing data
-         */
-        this.createTransaction = (stores) => {
-            return this.db.transaction(stores, 'readwrite');
-        };
-        /**
-         * Gets the OID and every sub-object OID for a given document.
-         * Includes any sub-objects that are not referenced by the root object
-         * but still happen to be in storage.
-         */
-        this.getAllDocumentRelatedOids = async (oid) => {
-            const oids = new Set();
-            const documentOid = getOidRoot(oid);
-            assert(documentOid === oid, 'Must be root document OID');
-            oids.add(documentOid);
-            // readwrite mode to block on other write transactions
-            const transaction = this.db.transaction(['baselines', 'operations'], 'readwrite');
-            await Promise.all([
-                this.baselines.iterateOverAllForDocument(documentOid, (baseline) => {
-                    oids.add(baseline.oid);
-                }, { transaction }),
-                this.operations.iterateOverAllOperationsForDocument(documentOid, (patch) => {
-                    oids.add(patch.oid);
-                }, { transaction }),
-            ]);
-            return Array.from(oids);
-        };
-        this.getDocumentSnapshot = async (oid, options = {}) => {
-            const documentOid = getOidRoot(oid);
-            assert(documentOid === oid, 'Must be root document OID');
-            const transaction = this.db.transaction(['baselines', 'operations'], 'readwrite');
-            const baselines = await this.baselines.getAllForDocument(documentOid, {
-                transaction,
-            });
-            const objectMap = new Map();
-            for (const baseline of baselines) {
-                if (baseline.snapshot) {
-                    assignOid(baseline.snapshot, baseline.oid);
-                }
-                objectMap.set(baseline.oid, baseline.snapshot);
-            }
-            await this.operations.iterateOverAllOperationsForDocument(documentOid, (op) => {
-                const obj = objectMap.get(op.oid) || undefined;
-                const newObj = applyPatch(obj, op.data);
-                if (newObj) {
-                    assignOid(newObj, op.oid);
-                }
-                objectMap.set(op.oid, newObj);
-            }, {
-                transaction,
-                // only apply operations up to the current time
-                to: options.to || this.now,
-            });
-            const root = objectMap.get(documentOid);
-            if (root) {
-                substituteRefsWithObjects(root, objectMap);
-            }
-            return root;
-        };
-        /**
-         * Methods for writing data
-         */
-        /**
-         * Acks that we have seen a timestamp to the server
-         * and stores it as our local ackedLogicalTime if it's
-         * greater than our current ackedLogicalTime.
-         */
-        this.ack = async (timestamp) => {
-            const localReplicaInfo = await this.localReplica.get();
-            // can't ack timestamps from the future.
-            if (timestamp > this.now)
-                return;
-            this.emit('message', {
-                type: 'ack',
-                replicaId: localReplicaInfo.id,
-                timestamp,
-            });
-            if (!this._closing &&
-                (!localReplicaInfo.ackedLogicalTime ||
-                    timestamp > localReplicaInfo.ackedLogicalTime)) {
-                this.localReplica.update({ ackedLogicalTime: timestamp });
-            }
-        };
-        /**
-         * Applies a patch to the document and stores it in the database.
-         * @returns the oldest local history timestamp
-         */
-        this.insertLocalOperation = async (operations) => {
-            if (operations.length === 0)
-                return;
-            // await this.rebaseLock;
-            this.log(`Inserting ${operations.length} local operations`);
-            // add local flag, in place.
-            for (const operation of operations) {
-                operation.isLocal = true;
-            }
-            await this.operations.addOperations(operations);
-            const message = await this.messageCreator.createOperation({ operations });
-            this.emit('message', message);
-            // we can now enqueue and check for rebase opportunities
-            this.tryAutonomousRebase();
-        };
-        /**
-         * Inserts remote operations. This does not affect local history.
-         * @returns a list of affected document OIDs
-         */
-        this.insertRemoteOperations = async (operations) => {
-            if (operations.length === 0)
-                return [];
-            // await this.rebaseLock;
-            this.log(`Inserting ${operations.length} remote operations`);
-            const affectedDocumentOids = await this.operations.addOperations(operations.map((patch) => (Object.assign(Object.assign({}, patch), { isLocal: false }))));
-            this.ack(operations[operations.length - 1].timestamp);
-            return affectedDocumentOids;
-        };
-        this.insertRemoteBaselines = async (baselines) => {
-            if (baselines.length === 0)
-                return [];
-            this.log(`Inserting ${baselines.length} remote baselines`);
-            await this.baselines.setAll(baselines);
-            // this.ack(baselines[baselines.length - 1].timestamp);
-            const affectedOidSet = new Set();
-            baselines.forEach((baseline) => {
-                affectedOidSet.add(getOidRoot(baseline.oid));
-            });
-            return Array.from(affectedOidSet);
-        };
-        this.updateLastSynced = async (timestamp) => {
-            if (this._closing)
-                return;
-            return this.localReplica.update({
-                lastSyncedLogicalTime: timestamp,
-            });
-        };
-        this.lastSyncedTimestamp = async () => {
-            const localReplicaInfo = await this.localReplica.get();
-            return localReplicaInfo.lastSyncedLogicalTime;
-        };
-        this.tryAutonomousRebase = async () => {
-            if (this.disableRebasing)
-                return;
-            const localReplicaInfo = await this.localReplica.get();
-            if (localReplicaInfo.lastSyncedLogicalTime)
-                return; // cannot autonomously rebase if we've synced
-            // but if we have never synced... we can rebase everything!
-            await this.runRebase(this.now);
-        };
-        /**
-         * Attempt to autonomously rebase local documents without server intervention.
-         * This can currently only happen for a client who has never synced before.
-         * The goal is to allow local-only clients to compress their history to exactly
-         * their undo stack.
-         */
-        this.runRebase = async (globalAckTimestamp) => {
-            if (this._closing)
-                return;
-            // find all operations before the global ack
-            let lastTimestamp;
-            const toRebase = new Set();
-            const transaction = this.db.transaction(['baselines', 'operations'], 'readwrite');
-            let operationCount = 0;
-            await this.operations.iterateOverAllOperations((patch) => {
-                toRebase.add(patch.oid);
-                lastTimestamp = patch.timestamp;
-                operationCount++;
-            }, {
-                before: globalAckTimestamp,
-                transaction,
-            });
-            if (!toRebase.size) {
-                this.log('Cannot rebase, no operations prior to', globalAckTimestamp);
-                return;
-            }
-            if (this._closing) {
-                return;
-            }
-            // rebase each affected document
-            let newBaselines = [];
-            for (const oid of toRebase) {
-                newBaselines.push(await this.rebase(oid, lastTimestamp || globalAckTimestamp, transaction));
-            }
-            this.emit('rebase', newBaselines);
-        };
-        this.rebase = async (oid, upTo, providedTx) => {
-            // including replica Id for testing I guess
-            const replicaId = (await this.localReplica.get()).id;
-            this.log('[', replicaId, ']', 'Rebasing', oid, 'up to', upTo);
-            const transaction = providedTx ||
-                this.db.transaction(['operations', 'baselines'], 'readwrite');
-            const baseline = await this.baselines.get(oid, { transaction });
-            let current = (baseline === null || baseline === void 0 ? void 0 : baseline.snapshot) || undefined;
-            let operationsApplied = 0;
-            const deletedRefs = [];
-            await this.operations.iterateOverAllOperationsForEntity(oid, (patch, store) => {
-                // FIXME: this seems like the wrong place to do this
-                // but it's here as a safety measure...
-                if (!baseline || patch.timestamp > baseline.timestamp) {
-                    current = applyPatch(current, patch.data, deletedRefs);
-                }
-                // delete all prior operations to the baseline
-                operationsApplied++;
-                store.delete(patch.oid_timestamp);
-            }, {
-                to: upTo,
-                transaction,
-            });
-            if (current) {
-                assignOid(current, oid);
-            }
-            const newBaseline = {
-                oid,
-                snapshot: current,
-                timestamp: upTo,
-            };
-            if (newBaseline.snapshot) {
-                await this.baselines.set(newBaseline, { transaction });
-            }
-            else {
-                await this.baselines.delete(oid, { transaction });
-            }
-            this.log('successfully rebased', oid, 'up to', upTo, ':', current, 'and deleted', operationsApplied, 'operations');
-            // cleanup deleted refs
-            if (deletedRefs.length) {
-                const fileRefs = deletedRefs.filter(isFileRef);
-                if (fileRefs.length) {
-                    this.emit('filesDeleted', fileRefs);
-                }
-            }
-            return newBaseline;
-        };
-        this.reset = async () => {
-            await this.operations.reset();
-            await this.baselines.reset();
-            await this.localReplica.reset();
-        };
-        this.updateSchema = async (schema, overrideConflict) => {
-            const storedSchema = await this.schema.get();
-            if (storedSchema) {
-                // version changes will be handled by migration routines in
-                // the actual idb database loading code (see: initializeDatabases)
-                // but this check determines if the schema has been changed without
-                // a version change. if so, it will error.
-                if (overrideConflict === storedSchema.version &&
-                    storedSchema.version === schema.version &&
-                    JSON.stringify(storedSchema) !== JSON.stringify(schema)) {
+import { applyPatch, assert, assignOid, EventSubscriber, isFileRef, getOidRoot, HybridLogicalClockTimestampProvider, PatchCreator, substituteRefsWithObjects, } from '@verdant-web/common';
+import { AckInfoStore } from './AckInfoStore.js';
+import { BaselinesStore } from './BaselinesStore.js';
+import { getAllFromObjectStores, getSizeOfObjectStore, storeRequestPromise, } from '../idb.js';
+import { LocalReplicaStore } from './LocalReplicaStore.js';
+import { MessageCreator } from './MessageCreator.js';
+import { OperationsStore } from './OperationsStore.js';
+import { SchemaStore } from './SchemaStore.js';
+export class Metadata extends EventSubscriber {
+    constructor({ disableRebasing, context, }) {
+        super();
+        this.time = new HybridLogicalClockTimestampProvider();
+        this.disableRebasing = false;
+        /**
+         * indicates the client is shutting down and we should stop
+         * accessing the database.
+         */
+        this._closing = false;
+        this.setContext = (context) => {
+            this.context = context;
+        };
+        this.close = () => {
+            this._closing = true;
+        };
+        /**
+         * Methods for accessing data
+         */
+        this.createTransaction = (stores) => {
+            return this.db.transaction(stores, 'readwrite');
+        };
+        /**
+         * Gets the OID and every sub-object OID for a given document.
+         * Includes any sub-objects that are not referenced by the root object
+         * but still happen to be in storage.
+         */
+        this.getAllDocumentRelatedOids = async (oid) => {
+            const oids = new Set();
+            const documentOid = getOidRoot(oid);
+            assert(documentOid === oid, 'Must be root document OID');
+            oids.add(documentOid);
+            // readwrite mode to block on other write transactions
+            const transaction = this.db.transaction(['baselines', 'operations'], 'readwrite');
+            await Promise.all([
+                this.baselines.iterateOverAllForDocument(documentOid, (baseline) => {
+                    oids.add(baseline.oid);
+                }, { transaction }),
+                this.operations.iterateOverAllOperationsForDocument(documentOid, (patch) => {
+                    oids.add(patch.oid);
+                }, { transaction }),
+            ]);
+            return Array.from(oids);
+        };
+        this.getDocumentSnapshot = async (oid, options = {}) => {
+            const documentOid = getOidRoot(oid);
+            assert(documentOid === oid, 'Must be root document OID');
+            const transaction = this.db.transaction(['baselines', 'operations'], 'readwrite');
+            const baselines = await this.baselines.getAllForDocument(documentOid, {
+                transaction,
+            });
+            const objectMap = new Map();
+            for (const baseline of baselines) {
+                if (baseline.snapshot) {
+                    assignOid(baseline.snapshot, baseline.oid);
+                }
+                objectMap.set(baseline.oid, baseline.snapshot);
+            }
+            await this.operations.iterateOverAllOperationsForDocument(documentOid, (op) => {
+                const obj = objectMap.get(op.oid) || undefined;
+                const newObj = applyPatch(obj, op.data);
+                if (newObj) {
+                    assignOid(newObj, op.oid);
+                }
+                objectMap.set(op.oid, newObj);
+            }, {
+                transaction,
+                // only apply operations up to the current time
+                to: options.to || this.now,
+            });
+            const root = objectMap.get(documentOid);
+            if (root) {
+                substituteRefsWithObjects(root, objectMap);
+            }
+            return root;
+        };
+        /**
+         * Methods for writing data
+         */
+        /**
+         * Acks that we have seen a timestamp to the server
+         * and stores it as our local ackedLogicalTime if it's
+         * greater than our current ackedLogicalTime.
+         */
+        this.ack = async (timestamp) => {
+            const localReplicaInfo = await this.localReplica.get();
+            // can't ack timestamps from the future.
+            if (timestamp > this.now)
+                return;
+            this.emit('message', {
+                type: 'ack',
+                replicaId: localReplicaInfo.id,
+                timestamp,
+            });
+            if (!this._closing &&
+                (!localReplicaInfo.ackedLogicalTime ||
+                    timestamp > localReplicaInfo.ackedLogicalTime)) {
+                this.localReplica.update({ ackedLogicalTime: timestamp });
+            }
+        };
+        /**
+         * Applies a patch to the document and stores it in the database.
+         * @returns the oldest local history timestamp
+         */
+        this.insertLocalOperation = async (operations) => {
+            if (operations.length === 0)
+                return;
+            // await this.rebaseLock;
+            this.log(`Inserting ${operations.length} local operations`);
+            // add local flag, in place.
+            for (const operation of operations) {
+                operation.isLocal = true;
+            }
+            await this.operations.addOperations(operations);
+            const message = await this.messageCreator.createOperation({ operations });
+            this.emit('message', message);
+            // we can now enqueue and check for rebase opportunities
+            this.tryAutonomousRebase();
+        };
+        /**
+         * Inserts remote operations. This does not affect local history.
+         * @returns a list of affected document OIDs
+         */
+        this.insertRemoteOperations = async (operations) => {
+            if (operations.length === 0)
+                return [];
+            // await this.rebaseLock;
+            this.log(`Inserting ${operations.length} remote operations`);
+            const affectedDocumentOids = await this.operations.addOperations(operations.map((patch) => (Object.assign(Object.assign({}, patch), { isLocal: false }))));
+            this.ack(operations[operations.length - 1].timestamp);
+            return affectedDocumentOids;
+        };
+        this.insertRemoteBaselines = async (baselines) => {
+            if (baselines.length === 0)
+                return [];
+            this.log(`Inserting ${baselines.length} remote baselines`);
+            await this.baselines.setAll(baselines);
+            // this.ack(baselines[baselines.length - 1].timestamp);
+            const affectedOidSet = new Set();
+            baselines.forEach((baseline) => {
+                affectedOidSet.add(getOidRoot(baseline.oid));
+            });
+            return Array.from(affectedOidSet);
+        };
+        this.updateLastSynced = async (timestamp) => {
+            if (this._closing)
+                return;
+            return this.localReplica.update({
+                lastSyncedLogicalTime: timestamp,
+            });
+        };
+        this.lastSyncedTimestamp = async () => {
+            const localReplicaInfo = await this.localReplica.get();
+            return localReplicaInfo.lastSyncedLogicalTime;
+        };
+        this.tryAutonomousRebase = async () => {
+            if (this.disableRebasing)
+                return;
+            const localReplicaInfo = await this.localReplica.get();
+            if (localReplicaInfo.lastSyncedLogicalTime)
+                return; // cannot autonomously rebase if we've synced
+            // but if we have never synced... we can rebase everything!
+            await this.runRebase(this.now);
+        };
+        /**
+         * Attempt to autonomously rebase local documents without server intervention.
+         * This can currently only happen for a client who has never synced before.
+         * The goal is to allow local-only clients to compress their history to exactly
+         * their undo stack.
+         */
+        this.runRebase = async (globalAckTimestamp) => {
+            if (this._closing)
+                return;
+            // find all operations before the global ack
+            let lastTimestamp;
+            const toRebase = new Set();
+            const transaction = this.db.transaction(['baselines', 'operations'], 'readwrite');
+            let operationCount = 0;
+            await this.operations.iterateOverAllOperations((patch) => {
+                toRebase.add(patch.oid);
+                lastTimestamp = patch.timestamp;
+                operationCount++;
+            }, {
+                before: globalAckTimestamp,
+                transaction,
+            });
+            if (!toRebase.size) {
+                this.log('Cannot rebase, no operations prior to', globalAckTimestamp);
+                return;
+            }
+            if (this._closing) {
+                return;
+            }
+            // rebase each affected document
+            let newBaselines = [];
+            for (const oid of toRebase) {
+                newBaselines.push(await this.rebase(oid, lastTimestamp || globalAckTimestamp, transaction));
+            }
+            this.emit('rebase', newBaselines);
+        };
+        this.rebase = async (oid, upTo, providedTx) => {
+            // including replica Id for testing I guess
+            const replicaId = (await this.localReplica.get()).id;
+            this.log('[', replicaId, ']', 'Rebasing', oid, 'up to', upTo);
+            const transaction = providedTx ||
+                this.db.transaction(['operations', 'baselines'], 'readwrite');
+            const baseline = await this.baselines.get(oid, { transaction });
+            let current = (baseline === null || baseline === void 0 ? void 0 : baseline.snapshot) || undefined;
+            let operationsApplied = 0;
+            const deletedRefs = [];
+            await this.operations.iterateOverAllOperationsForEntity(oid, (patch, store) => {
+                // FIXME: this seems like the wrong place to do this
+                // but it's here as a safety measure...
+                if (!baseline || patch.timestamp > baseline.timestamp) {
+                    current = applyPatch(current, patch.data, deletedRefs);
+                }
+                // delete all prior operations to the baseline
+                operationsApplied++;
+                store.delete(patch.oid_timestamp);
+            }, {
+                to: upTo,
+                transaction,
+            });
+            if (current) {
+                assignOid(current, oid);
+            }
+            const newBaseline = {
+                oid,
+                snapshot: current,
+                timestamp: upTo,
+            };
+            if (newBaseline.snapshot) {
+                await this.baselines.set(newBaseline, { transaction });
+            }
+            else {
+                await this.baselines.delete(oid, { transaction });
+            }
+            this.log('successfully rebased', oid, 'up to', upTo, ':', current, 'and deleted', operationsApplied, 'operations');
+            // cleanup deleted refs
+            if (deletedRefs.length) {
+                const fileRefs = deletedRefs.filter(isFileRef);
+                if (fileRefs.length) {
+                    this.emit('filesDeleted', fileRefs);
+                }
+            }
+            return newBaseline;
+        };
+        this.reset = async () => {
+            await this.operations.reset();
+            await this.baselines.reset();
+            await this.localReplica.reset();
+        };
+        this.updateSchema = async (schema, overrideConflict) => {
+            const storedSchema = await this.schema.get();
+            if (storedSchema) {
+                // version changes will be handled by migration routines in
+                // the actual idb database loading code (see: initializeDatabases)
+                // but this check determines if the schema has been changed without
+                // a version change. if so, it will error.
+                if (overrideConflict === storedSchema.version &&
+                    storedSchema.version === schema.version &&
+                    JSON.stringify(storedSchema) !== JSON.stringify(schema)) {
                     console.error(`Schema mismatch for version ${schema.version}
 					${JSON.stringify(storedSchema)}
-					${JSON.stringify(schema)}`);
-                    throw new Error('Schema has changed without a version change! Any changes to your schema must be accompanied by a change in schema version and a migration routine.');
-                }
-            }
-            await this.schema.set(schema);
-        };
-        this.setGlobalAck = async (timestamp) => {
-            if (this._closing)
-                return;
-            await this.ackInfo.setGlobalAck(timestamp);
-            if (!this.disableRebasing) {
-                await this.runRebase(timestamp);
-            }
-        };
-        this.export = async () => {
-            const db = this.db;
-            const [baselines, operations] = await getAllFromObjectStores(db, [
-                'baselines',
-                'operations',
-            ]);
-            const localReplica = await this.localReplica.get();
-            const schema = await this.schema.get();
-            if (!schema) {
-                throw new Error('Cannot export Client data before initializing');
-            }
-            return {
-                operations,
-                baselines,
-                localReplica,
-                schema,
-            };
-        };
-        /**
-         * Resets local metadata and clears operation/baseline stores.
-         * DOES NOT add operations/baselines - this should be done
-         * through the normal higher level systems.
-         */
-        this.resetFrom = async (data) => {
-            const db = this.db;
-            const transaction = db.transaction(['baselines', 'operations', 'info'], 'readwrite');
-            await storeRequestPromise(transaction.objectStore('baselines').clear());
-            await storeRequestPromise(transaction.objectStore('operations').clear());
-            await storeRequestPromise(transaction.objectStore('info').clear());
-            await this.localReplica.update({
-                ackedLogicalTime: data.localReplica.ackedLogicalTime,
-                lastSyncedLogicalTime: data.localReplica.lastSyncedLogicalTime,
-            }, { transaction });
-        };
-        this.stats = async () => {
-            const db = this.db;
-            const operationsSize = await getSizeOfObjectStore(db, 'operations');
-            const baselinesSize = await getSizeOfObjectStore(db, 'baselines');
-            return {
-                operationsSize,
-                baselinesSize,
-            };
-        };
-        this.context = context;
-        this.schema = new SchemaStore(context.metaDb, context.schema.version);
-        this.operations = new OperationsStore(this.db);
-        this.baselines = new BaselinesStore(this.db);
-        this.localReplica = new LocalReplicaStore(this.db);
-        this.ackInfo = new AckInfoStore(this.db);
-        this.messageCreator = new MessageCreator(this);
-        this.patchCreator = new PatchCreator(() => this.now);
-        if (disableRebasing)
-            this.disableRebasing = disableRebasing;
-    }
-    get db() {
-        return this.context.metaDb;
-    }
-    get log() {
-        return this.context.log;
-    }
-    get now() {
-        return this.time.now(this.schema.currentVersion);
-    }
-}
+					${JSON.stringify(schema)}`);
+                    throw new Error('Schema has changed without a version change! Any changes to your schema must be accompanied by a change in schema version and a migration routine.');
+                }
+            }
+            await this.schema.set(schema);
+        };
+        this.setGlobalAck = async (timestamp) => {
+            if (this._closing)
+                return;
+            await this.ackInfo.setGlobalAck(timestamp);
+            if (!this.disableRebasing) {
+                await this.runRebase(timestamp);
+            }
+        };
+        this.export = async () => {
+            const db = this.db;
+            const [baselines, operations] = await getAllFromObjectStores(db, [
+                'baselines',
+                'operations',
+            ]);
+            const localReplica = await this.localReplica.get();
+            const schema = await this.schema.get();
+            if (!schema) {
+                throw new Error('Cannot export Client data before initializing');
+            }
+            return {
+                operations,
+                baselines,
+                localReplica,
+                schema,
+            };
+        };
+        /**
+         * Resets local metadata and clears operation/baseline stores.
+         * DOES NOT add operations/baselines - this should be done
+         * through the normal higher level systems.
+         */
+        this.resetFrom = async (data) => {
+            const db = this.db;
+            const transaction = db.transaction(['baselines', 'operations', 'info'], 'readwrite');
+            await storeRequestPromise(transaction.objectStore('baselines').clear());
+            await storeRequestPromise(transaction.objectStore('operations').clear());
+            await storeRequestPromise(transaction.objectStore('info').clear());
+            await this.localReplica.update({
+                ackedLogicalTime: data.localReplica.ackedLogicalTime,
+                lastSyncedLogicalTime: data.localReplica.lastSyncedLogicalTime,
+            }, { transaction });
+        };
+        this.stats = async () => {
+            const db = this.db;
+            const operationsSize = await getSizeOfObjectStore(db, 'operations');
+            const baselinesSize = await getSizeOfObjectStore(db, 'baselines');
+            return {
+                operationsSize,
+                baselinesSize,
+            };
+        };
+        this.context = context;
+        this.schema = new SchemaStore(context.metaDb, context.schema.version);
+        this.operations = new OperationsStore(this.db);
+        this.baselines = new BaselinesStore(this.db);
+        this.localReplica = new LocalReplicaStore(this.db);
+        this.ackInfo = new AckInfoStore(this.db);
+        this.messageCreator = new MessageCreator(this);
+        this.patchCreator = new PatchCreator(() => this.now);
+        if (disableRebasing)
+            this.disableRebasing = disableRebasing;
+    }
+    get db() {
+        return this.context.metaDb;
+    }
+    get log() {
+        return this.context.log;
+    }
+    get now() {
+        return this.time.now(this.schema.currentVersion);
+    }
+}
 //# sourceMappingURL=Metadata.js.map