@verdant-web/store 5.4.0 → 5.4.3

package/src/client/Client.ts

@@ -101,10 +101,8 @@ export class Client<Presence = any, Profile = any> extends EventSubscriber<{
 			ctx: this.context,
 			files: this._fileManager,
 		});
-		// note: query cache must be initialized after EntityStore,
-		// since EntityStore needs to clear its cache before queries
-		// refresh.
-		// FIXME: make this less fragile
+		// note: historically querycache needed to be constructed after entities,
+		// not sure if this is still the case.
 		this._queryCache = new QueryCache({
 			context: this.context,
 			evictionTime: this.context.config.queries?.evictionTime,
@@ -142,6 +140,11 @@ export class Client<Presence = any, Profile = any> extends EventSubscriber<{
 				documentManager: this.documentManager,
 			});
 		}
+
+		if (typeof window !== 'undefined') {
+			(window as Window & { __VERDANT_CLIENT__?: Client }).__VERDANT_CLIENT__ =
+				this;
+		}
 	}
 
 	private importingPromise = Promise.resolve();
@@ -325,6 +328,14 @@ export class Client<Presence = any, Profile = any> extends EventSubscriber<{
 		this.context.persistenceShutdownHandler.shutdown();
 		this.context.internalEvents.disable();
 		this.context.entityEvents.disable();
+		if (typeof window !== 'undefined') {
+			const browserWindow = window as Window & {
+				__VERDANT_CLIENT__?: Client;
+			};
+			if (browserWindow.__VERDANT_CLIENT__ === this) {
+				delete browserWindow.__VERDANT_CLIENT__;
+			}
+		}
 
 		// the idea here is to flush the microtask queue -
 		// we may have queued tasks related to queries that

package/src/entities/Entity.ts

@@ -103,6 +103,9 @@ export class Entity<
 	// provided from external creators, this is a method to delete
 	// this entity.
 	private _deleteSelf: () => void;
+	// set manually when deleting the entity, this silences pruning warnings
+	// for missing data while the deletion is being processed.
+	private _deleting = false;
 
 	constructor({
 		oid,
@@ -239,13 +242,15 @@ export class Entity<
 				for (let i = 0; i < rawView.length; i++) {
 					const child = this.get(i);
 					if (this.childIsNull(child) && !isNullable(schema)) {
-						this.ctx.log(
-							'error',
-							'Child missing in non-nullable field',
-							this.oid,
-							'index:',
-							i,
-						);
+						if (!this._deleting) {
+							this.ctx.log(
+								'error',
+								'Child missing in non-nullable field',
+								this.oid,
+								'index:',
+								i,
+							);
+						}
 
 						// this item will be pruned.
 					} else {
@@ -286,13 +291,15 @@ export class Entity<
 				}
 				const child = this.get(key as any);
 				if (this.childIsNull(child) && !isNullable(schema)) {
-					this.ctx.log(
-						'error',
-						'Child entity is missing for non-nullable field',
-						this.oid,
-						'key:',
-						key,
-					);
+					if (!this._deleting) {
+						this.ctx.log(
+							'error',
+							'Child entity is missing for non-nullable field',
+							this.oid,
+							'key:',
+							key,
+						);
+					}
 					if (this.schema.type !== 'map') {
 						/**
 						 * PRUNE - this is a prune point. we can't continue
@@ -334,14 +341,6 @@ export class Entity<
 		return this.viewData.deleted || this.view === null;
 	}
 
-	/**
-	 * Doesn't compute view data; simply uses available cached
-	 * view info to determine deletion status.
-	 */
-	private get quickDeleted() {
-		return this._viewData?.deleted || this.cachedView === null;
-	}
-
 	get invalid() {
 		return !!this.validate();
 	}
@@ -603,6 +602,12 @@ export class Entity<
 		if (this.access) {
 			for (const op of operations) {
 				op.authz = this.access;
+
+				// if op is init, reset _deleting flag - this is not a functional flag, only
+				// hides some warnings. if we're here, we must be re-initializing and we can reset it.
+				if (op.data.op === 'initialize') {
+					this._deleting = false;
+				}
 			}
 		}
 
@@ -1397,6 +1402,10 @@ export class Entity<
 		this.metadataFamily.discardPendingOperation(operation);
 		this.invalidateCachedView();
 	};
+
+	__markDeleting__ = () => {
+		this._deleting = true;
+	};
 }
 
 function assertNotSymbol<T>(key: T): asserts key is Exclude<T, symbol> {

package/src/entities/EntityMetadata.ts

@@ -37,6 +37,10 @@ export class EntityMetadata {
 	// soon as the user makes modifications to the entity, this
 	// ephemeral pruned data is applied underneath it.
 	private ephemeralOperations?: Operation[] = [];
+	// pending operations are 'in flight' into persistence, but
+	// if you killed the power now they'd be lost. they don't have an
+	// officially applied timestamp yet either, so they are applied
+	// last, after all confirmed/ephemerals.
 	private pendingOperations: Operation[] = [];
 	readonly oid;
 
@@ -209,7 +213,6 @@ export class EntityMetadata {
 				this.confirmedOperations.push(op);
 				totalAdded++;
 			}
-			// FIXME: seems inefficient
 			// remove this incoming op from pending if it's in there
 			const pendingPrior = this.pendingOperations.length;
 			this.discardPendingOperation(op);
@@ -235,10 +238,19 @@ export class EntityMetadata {
 		return old;
 	};
 
+	// while this may not be the most efficient way to remove an operation,
+	// in practice the ops we discard are generally some of the first in
+	// the list, so the find is quick.
 	discardPendingOperation = (operation: Operation) => {
-		this.pendingOperations = this.pendingOperations.filter(
-			(op) => op.timestamp !== operation.timestamp,
+		// only one op can match, so - avoiding filter() here,
+		// we want short circuiting.
+		const indexOfOperation = this.pendingOperations.findIndex(
+			(op) => op.timestamp === operation.timestamp,
 		);
+		if (indexOfOperation === -1) {
+			return;
+		}
+		this.pendingOperations.splice(indexOfOperation, 1);
 	};
 
 	private applyOperations = (

package/src/entities/EntityStore.ts

@@ -414,6 +414,7 @@ export class EntityStore extends Disposable {
 					op.authz = entity.access;
 				}
 				operations.push(...deletes);
+				entity.__markDeleting__();
 			}
 		}
 

package/src/persistence/MessageCreator.ts

@@ -59,7 +59,7 @@ export class MessageCreator {
 				storeNames: ['operations', 'baselines'],
 			},
 			async (tx) => {
-				// FIXME: this branch gives bad vibes. should we always
+				// TODO: this branch gives bad vibes. should we always
 				// send all operations from other replicas too? is there
 				// ever a case where we have a "since" timestamp and there
 				// are foreign ops that match it?

package/src/persistence/PersistenceMetadata.ts

@@ -2,6 +2,7 @@ import {
 	applyPatch,
 	assert,
 	assignOid,
+	decomposeOid,
 	DocumentBaseline,
 	getOidRoot,
 	ObjectIdentifier,
@@ -293,15 +294,31 @@ export class PersistenceMetadata {
 		);
 	};
 
+	// worst case of this is rather expensive but currently only used for migration
+	// and deletion. if usage is expanded, consider caching...
 	getDocumentAuthz = async (oid: ObjectIdentifier) => {
 		let authz;
-		await this.db.iterateEntityOperations(oid, (op) => {
-			if (op.data.op === 'initialize') {
-				authz = op.authz;
-				return true;
-			}
-		});
-		return authz;
+
+		// find the latest initialize op - this is most up to date authz.
+		await this.db.iterateEntityOperations(
+			oid,
+			(op) => {
+				if (op.data.op === 'initialize') {
+					authz = op.authz;
+					return true;
+				}
+			},
+			{
+				reverse: true,
+			},
+		);
+
+		// found initialize, this is the answer.
+		if (authz) return authz;
+
+		// all initialize ops may have been rebased, in which case we use the baseline.
+		const baseline = await this.db.getBaseline(oid);
+		return baseline?.authz;
 	};
 
 	insertData = async (
@@ -512,4 +529,47 @@ export class PersistenceMetadata {
 			this.updateLocalReplica({ ackedLogicalTime: timestamp });
 		}
 	};
+
+	// upkeep - not called automatically as of today
+
+	/**
+	 * Removes all metadata entries related to collections which are no
+	 * longer present in the schema.
+	 */
+	__unstable__purgeRemovedCollections = async () => {
+		const schema = this.ctx.schema;
+		const collectionsInSchema = new Set(Object.keys(schema.collections));
+		const oidsToPurge = new Set<ObjectIdentifier>();
+		await this.db.iterateAllBaselines((baseline) => {
+			const { collection } = decomposeOid(baseline.oid);
+			if (!collectionsInSchema.has(collection)) {
+				this.ctx.log(
+					'debug',
+					`Deleting baseline for removed collection ${collection}`,
+					baseline.oid,
+				);
+				oidsToPurge.add(baseline.oid);
+			}
+		});
+		await this.db.iterateAllOperations((op) => {
+			const { collection } = decomposeOid(op.oid);
+			if (!collectionsInSchema.has(collection)) {
+				this.ctx.log(
+					'debug',
+					`Deleting operation for removed collection ${collection}`,
+					op.oid,
+				);
+				oidsToPurge.add(op.oid);
+			}
+		});
+
+		for (const oid of oidsToPurge) {
+			await this.db.purgeDocumentData(oid);
+		}
+
+		this.ctx.log(
+			'debug',
+			`Purged ${oidsToPurge.size} document metadata groups for removed collections`,
+		);
+	};
 }

package/src/persistence/PersistenceRebaser.ts

@@ -136,7 +136,7 @@ export class PersistenceRebaser {
 		await this.db.iterateEntityOperations(
 			oid,
 			(patch) => {
-				// FIXME: this seems like the wrong place to do 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);

package/src/persistence/idb/IdbService.ts

@@ -18,7 +18,7 @@ export class IdbService extends Disposable {
 		super();
 		const abortController = new AbortController();
 		this.globalAbortController = abortController;
-		// FIXME: replace with event? I can't get this to work.
+		// TODO: replace with event? I can't get this to work. (Illegal invocation on abort?)
 		// this.addDispose(abort);
 		this.db.addEventListener('versionchange', this.onVersionChange);
 		this.addDispose(() => {

package/src/persistence/idb/indexNames.ts

@@ -0,0 +1,5 @@
+export const OPERATION_INDEX_NAMES = {
+	IS_LOCAL__TIMESTAMP: 'l_t',
+	ROOT_OID__TIMESTAMP: 'd_t',
+	OID__TIMESTAMP: 'oid_timestamp', // never got migrated to o_t because it's the primary key
+} as const;

package/src/persistence/idb/metadata/IdbMetadataDb.ts

@@ -3,7 +3,6 @@ import {
 	createLowerBoundIndexValue,
 	createUpperBoundIndexValue,
 	DocumentBaseline,
-	getLegacyDotOidSubIdRange,
 	getOidRoot,
 	getOidSubIdRange,
 	ObjectIdentifier,
@@ -19,13 +18,14 @@ import {
 	PersistenceMetadataDb,
 } from '../../interfaces.js';
 import { IdbService } from '../IdbService.js';
+import { OPERATION_INDEX_NAMES } from '../indexNames.js';
 import { closeDatabase, getSizeOfObjectStore } from '../util.js';
 
 export type StoredClientOperation = ClientOperation & {
 	/** This acts as the primary key */
-	oid_timestamp: string;
-	l_t: string;
-	d_t: string;
+	[OPERATION_INDEX_NAMES.OID__TIMESTAMP]: string;
+	[OPERATION_INDEX_NAMES.IS_LOCAL__TIMESTAMP]: string;
+	[OPERATION_INDEX_NAMES.ROOT_OID__TIMESTAMP]: string;
 };
 
 export type StoredSchema = {
@@ -123,12 +123,9 @@ export class IdbMetadataDb
 			(store) => {
 				const root = getOidRoot(rootOid);
 				const [start, end] = getOidSubIdRange(rootOid);
-				// FIXME: get rid of legacy dot OIDs...
-				const [dotStart, dotEnd] = getLegacyDotOidSubIdRange(rootOid);
 				return [
 					store.openCursor(IDBKeyRange.only(root)),
 					store.openCursor(IDBKeyRange.bound(start, end, false, false)),
-					store.openCursor(IDBKeyRange.bound(dotStart, dotEnd, false, false)),
 				];
 			},
 			iterator,
@@ -204,7 +201,7 @@ export class IdbMetadataDb
 		return this.iterate<StoredClientOperation>(
 			'operations',
 			(store) => {
-				const index = store.index('d_t');
+				const index = store.index(OPERATION_INDEX_NAMES.ROOT_OID__TIMESTAMP);
 				const start = createLowerBoundIndexValue(rootOid);
 				const end = opts?.to
 					? createCompoundIndexValue(rootOid, opts.to)
@@ -221,7 +218,7 @@ export class IdbMetadataDb
 	iterateEntityOperations = (
 		oid: string,
 		iterator: (op: StoredClientOperation) => void,
-		opts?: CommonQueryOptions & { to?: string | null },
+		opts?: CommonQueryOptions & { to?: string | null; reverse?: boolean },
 	): Promise<void> => {
 		// NOTE: this is simplified from original impl.
 		// perhaps I missed some nuance as to why it was
@@ -236,7 +233,7 @@ export class IdbMetadataDb
 					: createUpperBoundIndexValue(oid);
 
 				const range = IDBKeyRange.bound(start, end, false, false);
-				return store.openCursor(range);
+				return store.openCursor(range, opts?.reverse ? 'prev' : 'next');
 			},
 			iterator,
 			opts,
@@ -296,7 +293,7 @@ export class IdbMetadataDb
 					? createCompoundIndexValue(true, opts.after)
 					: createLowerBoundIndexValue(true);
 				const end = createUpperBoundIndexValue(true);
-				const index = store.index('l_t');
+				const index = store.index(OPERATION_INDEX_NAMES.IS_LOCAL__TIMESTAMP);
 				return index.openCursor(
 					// NOTE: differs from original impl -- last arg is 'false' instead of 'true'
 					IDBKeyRange.bound(start, end, !!opts?.after, false),
@@ -425,11 +422,71 @@ export class IdbMetadataDb
 	): StoredClientOperation => {
 		return {
 			...op,
-			oid_timestamp: createCompoundIndexValue(op.oid, op.timestamp) as string,
-			l_t: createCompoundIndexValue(op.isLocal, op.timestamp) as string,
-			d_t: createCompoundIndexValue(getOidRoot(op.oid), op.timestamp) as string,
+			[OPERATION_INDEX_NAMES.OID__TIMESTAMP]: createCompoundIndexValue(
+				op.oid,
+				op.timestamp,
+			) as string,
+			[OPERATION_INDEX_NAMES.IS_LOCAL__TIMESTAMP]: createCompoundIndexValue(
+				op.isLocal,
+				op.timestamp,
+			) as string,
+			[OPERATION_INDEX_NAMES.ROOT_OID__TIMESTAMP]: createCompoundIndexValue(
+				getOidRoot(op.oid),
+				op.timestamp,
+			) as string,
 		};
 	};
+
+	purgeDocumentData(
+		oid: ObjectIdentifier,
+		opts?: CommonQueryOptions<IDBTransaction> | undefined,
+	): Promise<void> {
+		const rootOid = getOidRoot(oid);
+		const tx = opts?.transaction as IDBTransaction | undefined;
+
+		return this.transaction(
+			{
+				mode: 'readwrite',
+				storeNames: ['baselines', 'operations'],
+			},
+			async (ownedTx) => {
+				const transaction = tx ?? ownedTx;
+
+				await this.iterate<DocumentBaseline>(
+					'baselines',
+					(store) => {
+						const [start, end] = getOidSubIdRange(rootOid);
+						return [
+							store.openCursor(IDBKeyRange.only(rootOid)),
+							store.openCursor(IDBKeyRange.bound(start, end, false, false)),
+						];
+					},
+					(baseline, store) => {
+						store.delete(baseline.oid);
+					},
+					{ mode: 'readwrite', transaction },
+				);
+
+				await this.iterate<StoredClientOperation>(
+					'operations',
+					(store) => {
+						const index = store.index(
+							OPERATION_INDEX_NAMES.ROOT_OID__TIMESTAMP,
+						);
+						const start = createLowerBoundIndexValue(rootOid);
+						const end = createUpperBoundIndexValue(rootOid);
+						return index.openCursor(
+							IDBKeyRange.bound(start, end, false, false),
+						);
+					},
+					(op, store) => {
+						store.delete(op[OPERATION_INDEX_NAMES.OID__TIMESTAMP]);
+					},
+					{ mode: 'readwrite', transaction },
+				);
+			},
+		);
+	}
 }
 
 const writeOpts = { mode: 'readwrite' } as const;

package/src/persistence/idb/metadata/openMetadataDatabase.ts

@@ -1,6 +1,7 @@
 import { replaceLegacyOidsInObject } from '@verdant-web/common';
-import { getMetadataDbName } from '../util.js';
 import { Context } from '../../../context/context.js';
+import { OPERATION_INDEX_NAMES } from '../indexNames.js';
+import { getMetadataDbName } from '../util.js';
 
 const migrations = [version1, version2, version3, version4, version5, version6];
 export const CURRENT_METADATA_VERSION = migrations.length;
@@ -55,7 +56,7 @@ async function version1(db: IDBDatabase, tx: IDBTransaction) {
 		keyPath: 'oid',
 	});
 	const operationsStore = db.createObjectStore('operations', {
-		keyPath: 'oid_timestamp',
+		keyPath: OPERATION_INDEX_NAMES.OID__TIMESTAMP,
 	});
 	const infoStore = db.createObjectStore('info', { keyPath: 'type' });
 	baselinesStore.createIndex('timestamp', 'timestamp');
@@ -84,8 +85,8 @@ async function version2(db: IDBDatabase, tx: IDBTransaction) {
 					cursor.value;
 				cursor.update({
 					...value,
-					l_t: isLocal_timestamp,
-					d_t: documentOid_timestamp,
+					[OPERATION_INDEX_NAMES.IS_LOCAL__TIMESTAMP]: isLocal_timestamp,
+					[OPERATION_INDEX_NAMES.ROOT_OID__TIMESTAMP]: documentOid_timestamp,
 				});
 				cursor.continue();
 			} else {
@@ -100,9 +101,16 @@ async function version2(db: IDBDatabase, tx: IDBTransaction) {
 	operations.deleteIndex('isLocal_timestamp');
 	operations.deleteIndex('documentOid_timestamp');
 	// create the new indexes
-	operations.createIndex('l_t', 'l_t', { unique: false });
-	operations.createIndex('o_t', 'o_t', { unique: false });
-	operations.createIndex('d_t', 'd_t', { unique: false });
+	operations.createIndex(
+		OPERATION_INDEX_NAMES.IS_LOCAL__TIMESTAMP,
+		OPERATION_INDEX_NAMES.IS_LOCAL__TIMESTAMP,
+		{ unique: false },
+	);
+	operations.createIndex(
+		OPERATION_INDEX_NAMES.ROOT_OID__TIMESTAMP,
+		OPERATION_INDEX_NAMES.ROOT_OID__TIMESTAMP,
+		{ unique: false },
+	);
 }
 
 /**

package/src/persistence/idb/queries/ranges.ts

@@ -46,15 +46,14 @@ const rangeIndexToIdbKeyRange = (filter: RangeCollectionIndexFilter) => {
 };
 
 const compoundIndexToIdbKeyRange = (
-	// FIXME:
-	schema: any,
+	schema: StorageSchema,
 	collection: string,
 	filter: CollectionCompoundIndexFilter,
 ) => {
 	// validate the usage of the compound index:
 	// - all match fields must be contiguous at the start of the compound order
 	const indexDefinition =
-		schema.collections[collection].compounds[filter.where];
+		schema.collections[collection].compounds?.[filter.where];
 	assert(
 		indexDefinition,
 		`Index ${filter.where} does not exist on collection ${collection}`,

package/src/persistence/interfaces.ts

@@ -105,7 +105,7 @@ export interface PersistenceMetadataDb<
 	iterateEntityOperations(
 		oid: string,
 		iterator: Iterator<ClientOperation>,
-		opts?: CommonQueryOptions<Tx> & { to?: string | null },
+		opts?: CommonQueryOptions<Tx> & { to?: string | null; reverse?: boolean },
 	): Promise<void>;
 	iterateCollectionOperations(
 		collection: string,
@@ -138,6 +138,10 @@ export interface PersistenceMetadataDb<
 		ops: ClientOperation[],
 		opts?: CommonQueryOptions<Tx>,
 	): Promise<ObjectIdentifier[]>;
+	purgeDocumentData(
+		oid: ObjectIdentifier,
+		opts?: CommonQueryOptions<Tx>,
+	): Promise<void>;
 
 	/* WARNING: deletes all data */
 	reset(opts?: { clearReplica?: boolean; transaction?: Tx }): Promise<void>;

package/src/persistence/migration/engine.ts

@@ -174,10 +174,9 @@ export async function getMigrationEngine({
 						!!rootOid,
 						`Document is missing an OID: ${JSON.stringify(doc)}`,
 					);
-					// FIXME: this could be optimized (making n queries for authz
-					// when the snapshots themselves are derived from the same data...)
-					// maybe don't use the findAll query, and instead go a level
-					// lower to retain access to lower level data here?
+					// while querying again for data we already discarded in the findAll
+					// above isn't ideal, in practice the get authz method is
+					// fairly quick because it short-circuits.
 					const authz = await meta.getDocumentAuthz(rootOid);
 					const original = cloneDeep(doc);
 					// @ts-ignore - excessive type resolution

package/src/queries/BaseQuery.ts

@@ -2,6 +2,12 @@ import { EventSubscriber } from '@verdant-web/common';
 import { Context } from '../context/context.js';
 import { Entity } from '../entities/Entity.js';
 import { Disposable } from '../utils/Disposable.js';
+import {
+	getDiagnosticResult,
+	QueryDiagnostic,
+	QueryRun,
+	QueryTiming,
+} from './diagnostics.js';
 import { filterResultSet } from './utils.js';
 
 export type BaseQueryEvents = {
@@ -37,12 +43,20 @@ export abstract class BaseQuery<T> extends Disposable {
 	private _allUnsubscribedHandler?: (query: BaseQuery<T>) => void;
 	private _status: QueryStatus = 'initial';
 	private _executionPromise: Promise<T> | null = null;
+	private _timing: QueryTiming = {
+		sweep: null,
+		hydration: null,
+		total: null,
+	};
+	private _startedAt: number | null = null;
+	private _timingHistory: QueryRun[] = [];
 
 	protected context;
 
 	readonly collection;
 	readonly key;
 	readonly isListQuery;
+	readonly type;
 
 	constructor({
 		initial,
@@ -65,6 +79,7 @@ export abstract class BaseQuery<T> extends Disposable {
 		this.context = context;
 		this.key = key;
 		this.collection = collection;
+		this.type = this.constructor.name;
 		const shouldUpdateFn =
 			shouldUpdate ||
 			((collections: string[]) => collections.includes(collection));
@@ -223,13 +238,9 @@ export abstract class BaseQuery<T> extends Disposable {
 	};
 
 	execute = () => {
-		const startTime = new Date();
-		this.context.log(
-			'debug',
-			`[${startTime.toLocaleTimeString()}]`,
-			'Executing query',
-			this.key,
-		);
+		const startTime = performance.now();
+		this._startedAt = Date.now();
+		this.context.log('debug', 'Executing query', this.key);
 
 		if (this.status === 'initial') {
 			this.status = 'initializing';
@@ -255,11 +266,14 @@ export abstract class BaseQuery<T> extends Disposable {
 				}
 			})
 			.finally(() => {
-				const endTime = new Date();
-				const duration = endTime.getTime() - startTime.getTime();
+				const duration = performance.now() - startTime;
+				this._timing.total = duration;
+				this._timingHistory = [
+					...this._timingHistory,
+					{ startedAt: this._startedAt ?? Date.now(), ...this._timing },
+				].slice(-100);
 				this.context.log(
 					'debug',
-					`[${endTime.toLocaleTimeString()}]`,
 					'Query executed',
 					this.key,
 					`Duration: ${duration}ms`,
@@ -267,6 +281,38 @@ export abstract class BaseQuery<T> extends Disposable {
 			});
 		return this._executionPromise;
 	};
+
+	protected measureSweep = async <V>(work: () => Promise<V>): Promise<V> => {
+		const start = performance.now();
+		try {
+			return await work();
+		} finally {
+			this._timing.sweep = performance.now() - start;
+		}
+	};
+
+	protected measureHydration = async <V>(
+		work: () => Promise<V>,
+	): Promise<V> => {
+		const start = performance.now();
+		try {
+			return await work();
+		} finally {
+			this._timing.hydration = performance.now() - start;
+		}
+	};
+
+	getDiagnostic = (active: boolean): QueryDiagnostic => ({
+		key: this.key,
+		startedAt: this._startedAt,
+		collection: this.collection,
+		type: this.type,
+		status: this.status,
+		active,
+		result: getDiagnosticResult(this.current),
+		timing: { ...this._timing },
+		runs: this._timingHistory.map((run) => ({ ...run })),
+	});
 	protected abstract run(): Promise<void>;
 
 	[ON_ALL_UNSUBSCRIBED] = (handler: (query: BaseQuery<T>) => void) => {