zova-module-a-model 5.1.37 → 5.1.39

package/dist/index.js

@@ -2,8 +2,9 @@ import { BeanBase, BeanInfo, BeanScopeBase, BeanSimple, SymbolBeanFullName, Virt
 import { Bean, Scope, Service } from "zova-module-a-bean";
 import { QueryCache, QueryClient, VueQueryPlugin, defaultShouldDehydrateQuery, dehydrate, hashKey, hydrate, useMutation, useQuery, useQueryClient } from "@tanstack/vue-query";
 import localforage from "localforage";
+import { CancelledError, notifyManager } from "@tanstack/query-core";
 import { experimental_createQueryPersister } from "@tanstack/query-persist-client-core";
-import { markRaw } from "vue";
+import { markRaw, shallowRef } from "vue";
 //#region src/lib/queryRefetch.ts
 function createQueryRefetch(refetch, getQuery) {
 	return async (refetchOptions) => {
@@ -26,6 +27,56 @@ function resolveMaxAgeTime(maxAge, query) {
 	return typeof maxAge === "function" ? maxAge(query) : maxAge;
 }
 //#endregion
+//#region src/lib/persistenceQueue.ts
+var PersistenceQueue = class {
+	constructor() {
+		this._tail = Promise.resolve();
+		this._sequence = 0;
+		this._failure = void 0;
+		this._generation = 0;
+		this._keyGenerations = /* @__PURE__ */ new Map();
+	}
+	generation(key) {
+		return `${this._generation}:${this._keyGenerations.get(key) ?? 0}`;
+	}
+	invalidate(key) {
+		this._keyGenerations.set(key, (this._keyGenerations.get(key) ?? 0) + 1);
+	}
+	invalidateAll() {
+		this._generation++;
+		this._keyGenerations.clear();
+	}
+	enqueue(operation) {
+		const sequence = ++this._sequence;
+		const result = this._tail.then(operation);
+		this._tail = result.catch((error) => {
+			this._failure ??= {
+				sequence,
+				error
+			};
+		});
+		return result;
+	}
+	async flush() {
+		const sequence = this._sequence;
+		await this._tail;
+		if (this._failure && this._failure.sequence <= sequence) {
+			const { error } = this._failure;
+			this._failure = void 0;
+			throw error;
+		}
+	}
+};
+var queues = /* @__PURE__ */ new WeakMap();
+function getPersistenceQueue(storage) {
+	let queue = queues.get(storage);
+	if (!queue) {
+		queue = new PersistenceQueue();
+		queues.set(storage, queue);
+	}
+	return queue;
+}
+//#endregion
 //#region src/.metadata/this.ts
 var __ThisModule__ = "a-model";
 //#endregion
@@ -57,6 +108,149 @@ var CookieWrapper = class extends BeanSimple {
 	}
 };
 //#endregion
+//#region src/lib/modelPersistence.ts
+var normalize = (value) => value == null ? null : String(value);
+function getModelPersistenceStorageKey(appName, scope, logicalKey) {
+	return JSON.stringify([
+		"zova-model-db",
+		1,
+		appName,
+		scope,
+		logicalKey
+	]);
+}
+function isModelPersistenceDb(options) {
+	if (options === false) return false;
+	const persister = options && typeof options === "object" ? options : {};
+	return (persister.storage ?? (persister.sync ? "local" : "db")) === "db";
+}
+function emptyQueryState() {
+	return {
+		data: void 0,
+		dataUpdateCount: 0,
+		dataUpdatedAt: 0,
+		error: null,
+		errorUpdateCount: 0,
+		errorUpdatedAt: 0,
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchMeta: null,
+		isInvalidated: false,
+		status: "pending",
+		fetchStatus: "idle"
+	};
+}
+/** App-owned identity; independent of the module providing the current Passport. */
+var ModelPersistenceContext = class {
+	constructor(_queryClient, siteId) {
+		this._queryClient = _queryClient;
+		this._epoch = 0;
+		this._version = shallowRef(0);
+		this._scope = void 0;
+		this._registered = false;
+		this._hydrated = /* @__PURE__ */ new Set();
+		this._listeners = /* @__PURE__ */ new Set();
+		markRaw(this);
+		this._scope = Object.freeze([
+			null,
+			normalize(siteId),
+			null
+		]);
+	}
+	get epoch() {
+		this._version.value;
+		return this._epoch;
+	}
+	capture() {
+		return Object.freeze({
+			scope: this._scope,
+			epoch: this.epoch
+		});
+	}
+	current(token) {
+		return token.epoch === this.epoch && token.scope === this._scope;
+	}
+	markHydrated(queries) {
+		if (!this._registered) for (const query of queries) this._hydrated.add(query);
+	}
+	touch(query) {
+		if (query) this._hydrated.delete(query);
+	}
+	subscribe(listener) {
+		this._listeners.add(listener);
+		return () => this._listeners.delete(listener);
+	}
+	update(values, options = {}) {
+		const scope = Object.freeze([
+			normalize(values.instanceId),
+			normalize(values.siteId),
+			normalize(values.userId)
+		]);
+		const adopt = !this._registered && options.initial === true;
+		this._registered = true;
+		if (scope.every((value, index) => value === this._scope[index])) {
+			this._hydrated.clear();
+			return;
+		}
+		const affected = this._queryClient.getQueryCache().getAll().filter((query) => isModelPersistenceDb(query.meta?.persister) && !(adopt && this._hydrated.has(query)));
+		this._scope = scope;
+		this._hydrated.clear();
+		this._invalidate(affected);
+		if (options.refetchActive === false) return;
+		const token = this.capture();
+		Promise.resolve().then(() => {
+			if (this.current(token)) return this._queryClient.refetchQueries({
+				type: "active",
+				predicate: (query) => affected.includes(query)
+			});
+		});
+	}
+	clear() {
+		this._hydrated.clear();
+		this._invalidate(this._queryClient.getQueryCache().getAll());
+	}
+	_invalidate(queries) {
+		this._epoch++;
+		for (const query of queries) query.cancel({
+			silent: true,
+			revert: false
+		});
+		notifyManager.batch(() => {
+			for (const query of queries) {
+				query.setOptions({
+					...query.options,
+					initialData: void 0,
+					initialDataUpdatedAt: void 0
+				});
+				for (const observer of query.observers) observer.setOptions({
+					...observer.options,
+					initialData: void 0,
+					initialDataUpdatedAt: void 0,
+					placeholderData: void 0
+				});
+				query.setState(emptyQueryState());
+			}
+		});
+		this._version.value++;
+		const token = this.capture();
+		for (const listener of this._listeners) listener(token);
+	}
+	/** Keep later observer option reapplication from reinstalling an old identity. */
+	guardOptions(options) {
+		if (!isModelPersistenceDb(options.meta?.persister)) return options;
+		const token = this.capture();
+		const initialData = options.initialData;
+		const initialDataUpdatedAt = options.initialDataUpdatedAt;
+		const placeholderData = options.placeholderData;
+		return {
+			...options,
+			initialData: () => this.current(token) ? typeof initialData === "function" ? initialData() : initialData : void 0,
+			initialDataUpdatedAt: () => this.current(token) ? typeof initialDataUpdatedAt === "function" ? initialDataUpdatedAt() : initialDataUpdatedAt : void 0,
+			placeholderData: (...args) => this.current(token) ? typeof placeholderData === "function" ? placeholderData(...args) : placeholderData : void 0
+		};
+	}
+};
+//#endregion
 //#region src/lib/queryPersister.ts
 function createQueryPersister(persisterFn) {
 	return (queryFn, context, query) => {
@@ -86,50 +280,102 @@ var BeanModelLast = class extends BeanBase {
 //#endregion
 //#region src/bean/bean.model/bean.model.persister.ts
 var BeanModelPersister = class extends BeanModelLast {
-	_persisterLoad_inner(storage, storageKey, storedData, query, options) {
-		if (!storedData) return void 0;
+	constructor(...args) {
+		super(...args);
+		this._persisterRestoreErrors = /* @__PURE__ */ new Set();
+	}
+	$persisterError(queryKey) {
+		const query = this.self.$queryFind({ queryKey });
+		const options = this._adjustPersisterOptions(query?.meta?.persister);
+		return !!options && this._persisterRestoreErrors.has(this._getPersisterStorageKey(options, query, queryKey));
+	}
+	_persisterLoad_inner(storedData, query, options) {
+		if (!storedData) return { remove: false };
 		const persistedQuery = options.deserialize ? options.deserialize(storedData, options.deserializeDefault) : options.deserializeDefault(storedData);
 		if (persistedQuery.state.dataUpdatedAt) {
 			const expired = Date.now() - persistedQuery.state.dataUpdatedAt > (resolveMaxAgeTime(options.maxAge, query) ?? Infinity);
 			const busted = persistedQuery.buster !== options.buster;
-			if (expired || busted) storage.removeItem(storageKey);
-			else {
-				query.setState({
+			if (!expired && !busted) return {
+				data: persistedQuery.state.data,
+				remove: false,
+				timestamps: {
 					dataUpdatedAt: persistedQuery.state.dataUpdatedAt,
 					errorUpdatedAt: persistedQuery.state.errorUpdatedAt
-				});
-				return persistedQuery.state.data;
-			}
-		} else storage.removeItem(storageKey);
+				}
+			};
+		}
+		return { remove: true };
 	}
 	$persisterLoad(queryKey) {
+		const ctx = this.ctx;
+		if (ctx?.disposed) return void 0;
+		const persistence = this.$modelPersistence;
 		const query = this.self.$queryFind({ queryKey });
 		if (!query) return void 0;
 		const options = this._adjustPersisterOptions(query.meta?.persister);
 		if (!options) return void 0;
 		const storage = this._getPersisterStorage(options, query);
 		if (!storage) return void 0;
-		const storageKey = this._getPersisterStorageKey(options, query);
+		const token = persistence.capture();
+		if (options.storage === "db") persistence.touch(query);
+		const storageKey = this._getPersisterStorageKey(options, query, void 0, token);
+		this._persisterRestoreErrors.delete(storageKey);
+		const queue = getPersistenceQueue(storage);
+		const generation = queue.generation(storageKey);
+		const current = () => !ctx?.disposed && generation === queue.generation(storageKey) && (options.storage !== "db" || persistence.current(token));
+		if (!options.sync) return queue.enqueue(async () => {
+			if (!current()) return void 0;
+			const storedData = await storage.getItem(storageKey);
+			if (!current()) return void 0;
+			try {
+				const result = this._persisterLoad_inner(storedData, query, options);
+				if (!current()) return void 0;
+				if (result.timestamps) query.setState(result.timestamps);
+				if (result.remove) await storage.removeItem(storageKey);
+				return current() ? result.data : void 0;
+			} catch {
+				if (!current()) return void 0;
+				this._persisterRestoreErrors.add(storageKey);
+				await storage.removeItem(storageKey);
+				this._reportPersisterError("restore");
+				return;
+			}
+		}).catch(() => {
+			if (current()) {
+				this._persisterRestoreErrors.add(storageKey);
+				this._reportPersisterError("restore");
+			}
+		});
 		try {
-			const storedData = storage.getItem(storageKey);
-			if (options.sync) return this._persisterLoad_inner(storage, storageKey, storedData, query, options);
-			else return storedData.then((storedData) => {
-				return this._persisterLoad_inner(storage, storageKey, storedData, query, options);
-			});
-		} catch (err) {
-			if (process.env.DEV) {
-				console.error(err);
-				console.warn("Encountered an error attempting to restore query cache from persisted location.");
+			const result = this._persisterLoad_inner(storage.getItem(storageKey), query, options);
+			if (result.timestamps) query.setState(result.timestamps);
+			if (result.remove) storage.removeItem(storageKey);
+			return result.data;
+		} catch {
+			this._persisterRestoreErrors.add(storageKey);
+			this._reportPersisterError("restore");
+			try {
+				storage.removeItem(storageKey);
+			} catch {
+				this._reportPersisterError("remove");
 			}
-			storage.removeItem(storageKey);
 		}
 	}
+	$persisterGeneration(queryKey) {
+		const query = this.self.$queryFind({ queryKey });
+		const options = this._adjustPersisterOptions(query?.meta?.persister);
+		if (!options) return "";
+		const storage = this._getPersisterStorage(options, query);
+		if (!storage) return "";
+		const storageKey = this._getPersisterStorageKey(options, query, queryKey);
+		return `${options.storage === "db" ? this.$modelPersistence.epoch : ""}:${storageKey}:${getPersistenceQueue(storage).generation(storageKey)}`;
+	}
 	$persisterSave(queryKey) {
 		const query = this.self.$queryFind({ queryKey });
-		if (!query) return;
+		if (!query) return Promise.resolve();
 		const options = this._adjustPersisterOptions(query.meta?.persister);
-		if (!options) return;
-		this._persisterSave(query, options);
+		if (!options) return Promise.resolve();
+		return this._persisterSave(query, options);
 	}
 	$persisterSaveTo(queryKey, storageTarget, value) {
 		const query = this.self.$queryFind({ queryKey });
@@ -144,13 +390,9 @@ var BeanModelPersister = class extends BeanModelLast {
 			sync: true,
 			serializeDefault: (obj) => storageTarget === "cookie" ? String(obj?.state?.data ?? "") : JSON.stringify(obj?.state?.data)
 		});
-		if (!options) return;
-		this._persisterSave(query, options, value);
+		if (options) this._persisterSave(query, options, value);
 	}
-	_persisterSave(query, options, value) {
-		const storage = this._getPersisterStorage(options, query);
-		if (!storage) return;
-		const storageKey = this._getPersisterStorageKey(options, query);
+	_serializePersister(query, options, value) {
 		const params = {
 			state: value === void 0 ? query.state : {
 				...query.state,
@@ -160,42 +402,183 @@ var BeanModelPersister = class extends BeanModelLast {
 			queryHash: query.queryHash,
 			buster: options.buster
 		};
-		const data = options.serialize ? options.serialize(params, options.serializeDefault) : options.serializeDefault(params);
-		if (options.sync === true) storage.setItem(storageKey, data);
-		else setTimeout(() => {
+		return options.serialize ? options.serialize(params, options.serializeDefault) : options.serializeDefault(params);
+	}
+	_persisterSave(query, options, value) {
+		const storage = this._getPersisterStorage(options, query);
+		if (!storage) return Promise.resolve();
+		if (options.storage === "db") this.$modelPersistence.touch(query);
+		const storageKey = this._getPersisterStorageKey(options, query);
+		const queue = getPersistenceQueue(storage);
+		queue.invalidate(storageKey);
+		let data;
+		try {
+			data = this._serializePersister(query, options, value);
+		} catch (error) {
+			return this._handlePersisterOperation(queue.enqueue(() => {
+				throw error;
+			}), "save");
+		}
+		if (options.sync === true && options.storage !== "db") try {
 			storage.setItem(storageKey, data);
-		}, 0);
+			return Promise.resolve();
+		} catch (error) {
+			return this._handlePersisterOperation(Promise.reject(error), "save");
+		}
+		return this._handlePersisterOperation(queue.enqueue(async () => {
+			await storage.setItem(storageKey, data);
+		}), "save");
 	}
-	$persisterRemove(queryKey) {
+	$persisterRemove(queryKey, persister) {
 		const query = this.self.$queryFind({ queryKey });
-		if (!query) return;
-		const options = this._adjustPersisterOptions(query.meta?.persister);
-		if (!options) return;
+		if (!query && !persister) return Promise.resolve();
+		const options = this._adjustPersisterOptions(persister ?? query?.meta?.persister);
+		if (!options) return Promise.resolve();
 		const storage = this._getPersisterStorage(options, query);
-		if (!storage) return;
-		const storageKey = this._getPersisterStorageKey(options, query);
-		if (options.sync === true) storage.removeItem(storageKey);
-		else setTimeout(() => {
+		if (!storage) return Promise.resolve();
+		if (options.storage === "db") this.$modelPersistence.touch(query);
+		const storageKey = this._getPersisterStorageKey(options, query, queryKey);
+		const queue = getPersistenceQueue(storage);
+		queue.invalidate(storageKey);
+		if (options.sync === true && options.storage !== "db") try {
 			storage.removeItem(storageKey);
-		}, 0);
+			return Promise.resolve();
+		} catch (error) {
+			return this._handlePersisterOperation(Promise.reject(error), "remove");
+		}
+		return this._handlePersisterOperation(queue.enqueue(async () => {
+			await storage.removeItem(storageKey);
+		}), "remove");
+	}
+	async $persisterFlush() {
+		if (process.env.SERVER) return;
+		await getPersistenceQueue(localforage).flush();
+	}
+	_handlePersisterOperation(operation, action) {
+		operation.catch(() => this._reportPersisterError(action));
+		return operation;
+	}
+	_reportPersisterError(action) {
+		if (process.env.DEV) console.warn(`Encountered an error attempting to ${action} persisted query cache.`);
 	}
 	_createPersister(options) {
 		options = this._adjustPersisterOptions(options);
 		if (!options) return void 0;
-		const persisterFn = experimental_createQueryPersister({
-			storage: this._getPersisterStorage(options),
-			maxAge: options.maxAge,
-			refetchOnRestore: options.refetchOnRestore,
-			prefix: options.prefix,
-			buster: options.buster
-		}).persisterFn;
-		return createQueryPersister(persisterFn);
+		if (options.storage === "db") return this._createDbPersister(options);
+		const storage = this._getPersisterStorage(options);
+		const persisterOptions = options;
+		return createQueryPersister((queryFn, context, query) => {
+			const queue = storage ? getPersistenceQueue(storage) : void 0;
+			const storageKey = `${persisterOptions.prefix}-${query.queryHash}`;
+			const generation = queue?.generation(storageKey);
+			const current = () => generation === queue?.generation(storageKey);
+			const orderedStorage = storage && queue && !persisterOptions.sync ? {
+				getItem: (key) => queue.enqueue(() => current() ? storage.getItem(key) : void 0),
+				setItem: (key, data) => this._handlePersisterOperation(queue.enqueue(async () => {
+					if (current()) await storage.setItem(key, data);
+				}), "save"),
+				removeItem: (key) => this._handlePersisterOperation(queue.enqueue(async () => {
+					if (current()) await storage.removeItem(key);
+				}), "remove")
+			} : storage;
+			return experimental_createQueryPersister({
+				storage: orderedStorage,
+				maxAge: persisterOptions.maxAge,
+				refetchOnRestore: persisterOptions.refetchOnRestore,
+				prefix: persisterOptions.prefix,
+				buster: persisterOptions.buster
+			}).persisterFn(queryFn, context, query);
+		});
+	}
+	_createDbPersister(options) {
+		const ctx = this.ctx;
+		const persistence = this.$modelPersistence;
+		return async (queryFn, context, query) => {
+			if (ctx?.disposed) throw new CancelledError({
+				silent: true,
+				revert: false
+			});
+			persistence.touch(query);
+			const token = persistence.capture();
+			const storage = this._getPersisterStorage(options, query);
+			const queue = storage && getPersistenceQueue(storage);
+			const storageKey = this._getPersisterStorageKey(options, query, void 0, token);
+			const generation = queue?.generation(storageKey);
+			const current = () => !ctx?.disposed && persistence.current(token) && generation === queue?.generation(storageKey);
+			const assertCurrent = () => {
+				if (!current()) throw new CancelledError({
+					silent: true,
+					revert: false
+				});
+			};
+			const bypass = query.state.fetchMeta?.bypassPersister === true;
+			if (!bypass && storage && queue && query.state.data === void 0) {
+				this._persisterRestoreErrors.delete(storageKey);
+				const restored = await queue.enqueue(async () => {
+					if (!current()) return void 0;
+					try {
+						const storedData = await storage.getItem(storageKey);
+						if (!current()) return void 0;
+						const result = this._persisterLoad_inner(storedData, query, options);
+						if (!current()) return void 0;
+						if (result.remove) await storage.removeItem(storageKey);
+						return current() ? result : void 0;
+					} catch {
+						if (current()) {
+							this._persisterRestoreErrors.add(storageKey);
+							await storage.removeItem(storageKey);
+							this._reportPersisterError("restore");
+						}
+						return;
+					}
+				}).catch(() => {
+					if (current()) {
+						this._persisterRestoreErrors.add(storageKey);
+						this._reportPersisterError("restore");
+					}
+				});
+				assertCurrent();
+				if (restored?.data !== void 0) {
+					notifyManager.schedule(() => {
+						if (!current()) return;
+						if (restored.timestamps) query.setState(restored.timestamps);
+						if (options.refetchOnRestore === "always" || options.refetchOnRestore === true && query.isStale()) query.fetch().catch(() => void 0);
+					});
+					return restored.data;
+				}
+			}
+			assertCurrent();
+			let result;
+			try {
+				result = await queryFn(context);
+			} catch (error) {
+				assertCurrent();
+				throw error;
+			}
+			assertCurrent();
+			if (!bypass && storage && queue) notifyManager.schedule(() => {
+				if (!current()) return;
+				let data;
+				try {
+					data = this._serializePersister(query, options, result);
+				} catch (error) {
+					this._handlePersisterOperation(queue.enqueue(() => {
+						throw error;
+					}), "save");
+					return;
+				}
+				this._handlePersisterOperation(queue.enqueue(async () => {
+					if (current()) await storage.setItem(storageKey, data);
+				}), "save");
+			});
+			return result;
+		};
 	}
 	_adjustPersisterOptions(options) {
 		if (options === false) return void 0;
-		if (options === void 0 || options === true) options = {};
-		else options = { ...options };
+		options = options === void 0 || options === true ? {} : { ...options };
 		options.storage = options.storage ?? (options.sync ? "local" : "db");
+		if (options.storage === "db") options.sync = false;
 		options.maxAge = options.maxAge ?? this.scopeSelf.config.persister.maxAge[options.storage];
 		options.refetchOnRestore = options.refetchOnRestore ?? this.scopeSelf.config.persister.refetchOnRestore;
 		options.prefix = options.prefix ?? this._getPersisterPrefix();
@@ -204,9 +587,10 @@ var BeanModelPersister = class extends BeanModelLast {
 		options.deserializeDefault = options.deserializeDefault ?? JSON.parse;
 		return options;
 	}
-	_getPersisterStorageKey(options, query) {
-		if (options.storageKeySimplify) return String(query.queryKey[query.queryKey.length - 1]);
-		return `${options.prefix}-${query.queryHash}`;
+	_getPersisterStorageKey(options, query, queryKey, token) {
+		const key = query?.queryKey ?? this._forceQueryKeyPrefix(queryKey);
+		const logicalKey = options.storageKeySimplify ? String(key[key.length - 1]) : `${options.prefix}-${query?.queryHash ?? hashKey(key)}`;
+		return options.storage === "db" ? getModelPersistenceStorageKey(this.sys.env.APP_NAME ?? "", (token ?? this.$modelPersistence.capture()).scope, logicalKey) : logicalKey;
 	}
 	_getPersisterStorage(options, query) {
 		options = this._adjustPersisterOptions(options);
@@ -331,9 +715,13 @@ var BeanModelQuery = class extends BeanModelCookie {
 		})?.setData(value);
 	}
 	async $clear() {
-		const queries = this.$queryClient.getQueryCache().getAll();
-		for (const query of queries) query?.setData(void 0);
-		await localforage.clear();
+		const queue = getPersistenceQueue(localforage);
+		queue.invalidateAll();
+		const clear = process.env.SERVER ? Promise.resolve() : queue.enqueue(async () => {
+			await localforage.clear();
+		});
+		this.$modelPersistence.clear();
+		await clear;
 	}
 	$normalizeFilters(filters) {
 		if (!filters) filters = {};
@@ -350,10 +738,10 @@ var BeanModelUseQuery = class extends BeanModelQuery {
 	$useQuery(options, queryClient) {
 		const queryKey = this.self._forceQueryKeyPrefix(options.queryKey);
 		const persister = this._createPersister(options.meta?.persister);
-		options = Object.assign({}, options, {
+		options = this.$modelPersistence.guardOptions(Object.assign({}, options, {
 			queryKey,
 			persister
-		});
+		}));
 		if ((typeof options.meta?.persister === "object" && options.meta?.persister?.sync) !== true) {
 			const staleTime = options.staleTime ?? this.scopeSelf.config.query.staleTime.async;
 			const queryCacheExists = this.$queryFind({ queryKey })?.state.data !== void 0;
@@ -501,16 +889,24 @@ var BeanModelUseState = class extends BeanModelUseQuery {
 		return this[SymbolUseQueries][queryHash];
 	}
 	_handleAsyncDataGet(options, queryClient, persister) {
+		if (this.ctx?.disposed) return void 0;
+		this.$modelPersistence.epoch;
 		const query = this.$useStateData(options, queryClient);
 		if (query.data !== void 0) return query.data;
 		return this._handleAsyncDataGet_inner(options, queryClient, persister);
 	}
 	async _handleAsyncDataGet_inner(options, queryClient, persister) {
+		const ctx = this.ctx;
+		if (ctx?.disposed) return void 0;
+		const persistence = this.$modelPersistence;
 		const queryKey = options.queryKey;
+		const token = persistence.capture();
 		const query = this.$useStateData(options, queryClient);
 		if (persister) {
+			const generation = this.$persisterGeneration(queryKey);
 			const data = await this.$persisterLoad(queryKey);
-			if (data !== void 0) this.$setQueryData(queryKey, data, false);
+			if (ctx?.disposed || !persistence.current(token) || generation !== this.$persisterGeneration(queryKey)) return;
+			if (data !== void 0 && query.data === void 0) this.$setQueryData(queryKey, data, false);
 		}
 		if (query.data === void 0) this._handleSyncDataGet_defaultData(queryKey, options);
 		return query.data;
@@ -595,6 +991,31 @@ var ServiceStorage = (_dec$1 = Service(), _dec2$1 = BeanInfo({ module: "a-model"
 	constructor(...args) {
 		super(...args);
 		this._queryClient = void 0;
+		this._persistence = void 0;
+	}
+	get epoch() {
+		return this._persistence.epoch;
+	}
+	capture() {
+		return this._persistence.capture();
+	}
+	current(token) {
+		return this._persistence.current(token);
+	}
+	update(values, options) {
+		this._persistence.update(values, options);
+	}
+	subscribe(listener) {
+		return this._persistence.subscribe(listener);
+	}
+	clear() {
+		this._persistence.clear();
+	}
+	touch(query) {
+		this._persistence.touch(query);
+	}
+	guardOptions(options) {
+		return this._persistence.guardOptions(options);
 	}
 	async moduleLoaded() {
 		const options = deepExtend({}, this.scope.config.queryClientConfig.defaultOptions);
@@ -603,10 +1024,12 @@ var ServiceStorage = (_dec$1 = Service(), _dec2$1 = BeanInfo({ module: "a-model"
 			options.queries.gcTime = Infinity;
 		}
 		const queryCache = new QueryCache();
-		const vueQueryPluginOptions = { queryClient: this._queryClient = new QueryClient({
+		const queryClient = this._queryClient = new QueryClient({
 			defaultOptions: options,
 			queryCache
-		}) };
+		});
+		this._persistence = new ModelPersistenceContext(queryClient, this.sys.env.SITE_ID);
+		const vueQueryPluginOptions = { queryClient };
 		this.app.vue.use(VueQueryPlugin, vueQueryPluginOptions);
 	}
 	async appInitialize() {
@@ -616,7 +1039,14 @@ var ServiceStorage = (_dec$1 = Service(), _dec2$1 = BeanInfo({ module: "a-model"
 			} });
 			this._queryClient?.clear();
 		});
-		if (process.env.CLIENT && this.ctx.meta.$ssr.isRuntimeSsrPreHydration) hydrate(this._queryClient, this.ctx.meta.$ssr.stateDefer.query);
+		if (process.env.CLIENT && this.ctx.meta.$ssr.isRuntimeSsrPreHydration) {
+			const state = this.ctx.meta.$ssr.stateDefer.query;
+			hydrate(this._queryClient, state);
+			this._persistence.markHydrated((state?.queries ?? []).flatMap((item) => {
+				const query = this._queryClient.getQueryCache().get(item.queryHash);
+				return query ? [query] : [];
+			}));
+		}
 	}
 }) || _class$1) || _class$1);
 //#endregion
@@ -679,6 +1109,11 @@ var Monkey = class extends BeanSimple {
 		if (this._moduleSelf === module) await (await this.getStorage()).moduleLoaded();
 	}
 	async beanInit(bean, beanInstance) {
+		bean.defineProperty(beanInstance, "$modelPersistence", {
+			enumerable: false,
+			configurable: true,
+			get: () => this._storage
+		});
 		bean.defineProperty(beanInstance, "$queryClient", {
 			enumerable: false,
 			configurable: true,
@@ -690,8 +1125,6 @@ var Monkey = class extends BeanSimple {
 };
 //#endregion
 //#region src/.metadata/index.ts
-/** monkey: end */
-/** scope: begin */
 var _dec;
 var _dec2;
 var _class;
@@ -742,6 +1175,6 @@ async function _QueryEnsureLoadedInner(fn) {
 	return query;
 }
 //#endregion
-export { $QueriesEnsureLoaded, $QueryEnsureFresh, $QueryEnsureLoaded, $QueryGetFresh, BeanModelBase, Model, Monkey, ScopeModuleAModel, ServiceStorage, config, resolveMaxAgeTime, resolveStaleTime };
+export { $QueriesEnsureLoaded, $QueryEnsureFresh, $QueryEnsureLoaded, $QueryGetFresh, BeanModelBase, Model, ModelPersistenceContext, Monkey, ScopeModuleAModel, ServiceStorage, config, getModelPersistenceStorageKey, isModelPersistenceDb, resolveMaxAgeTime, resolveStaleTime };
 
 //# sourceMappingURL=index.js.map