@askrjs/askr 0.0.51 → 0.0.53

package/dist/data-DnxnDxD-.js

@@ -0,0 +1,559 @@
+import { n as enqueueRuntimeTask, v as logger } from "./access-Bg4RJNC8.js";
+import { f as notifyReadableReaders, l as markReactivePropsDirtySource, p as recordReadableRead, u as markReadableDerivedSubscribersDirty } from "./fastlane-Dw8SOBr9.js";
+import { f as getCurrentComponentInstance, i as claimHookIndex } from "./component-scope-CC3cojX9.js";
+import { n as getActiveRenderContext } from "./render-context-Clw3rFiO.js";
+import { c as windowFocused, i as routeActive, n as documentVisible, s as timer } from "./lifecycle-operations-D9va7GOU.js";
+import { a as getMutationSlotStore, c as resolveDataRuntimeState, i as getDefaultDataRuntime, n as ensureMutationCleanup, o as getQuerySlotStore, r as ensureQueryCleanup, s as invalidateQueriesForRuntime } from "./data-runtime-SJ1BSUvk.js";
+//#region src/data/query-key.ts
+function serializeQueryKeyNumber(part) {
+	if (Number.isNaN(part)) return "NaN";
+	if (Object.is(part, -0)) return "-0";
+	if (part === Infinity) return "Infinity";
+	if (part === -Infinity) return "-Infinity";
+	return String(part);
+}
+function serializeQueryKeyPart(part) {
+	if (typeof part === "symbol") throw new Error("[Askr] queryScope() key parts cannot be symbols.");
+	if (part === null) return "null";
+	if (part === void 0) return "undefined";
+	switch (typeof part) {
+		case "string": return `s=${encodeURIComponent(part)}`;
+		case "number": return `n=${serializeQueryKeyNumber(part)}`;
+		case "boolean": return `b=${part ? "1" : "0"}`;
+		case "object":
+			if (Array.isArray(part)) return `a[${part.map((item) => serializeQueryKeyPart(item)).join(",")}]`;
+			const objectPart = part;
+			return `o{${Object.keys(objectPart).sort().map((key) => `${encodeURIComponent(key)}=${serializeQueryKeyPart(objectPart[key])}`).join(",")}}`;
+		default: return String(part);
+	}
+}
+function createQueryScope(namespace, invalidate) {
+	if (typeof namespace !== "string" || namespace.trim().length === 0) throw new Error("[Askr] queryScope() requires a non-empty namespace string.");
+	const build = (parts) => [namespace, ...parts].map(serializeQueryKeyPart).join(":") + ":";
+	return {
+		key(...parts) {
+			return build(parts);
+		},
+		prefix(...parts) {
+			return build(parts);
+		},
+		invalidate(parts, options) {
+			invalidate(build(parts), options);
+		}
+	};
+}
+//#endregion
+//#region src/data/invalidation.ts
+function invalidate(prefix, options) {
+	invalidateQueriesForRuntime(resolveDataRuntimeState(options?.runtime), prefix, options?.markPendingWrite ?? false);
+}
+function queryScope(namespace) {
+	return createQueryScope(namespace, invalidate);
+}
+const INVALIDATE_ON_INTERVAL_OPTIONS_ERROR = "[Askr] invalidateOnInterval() requires an options object with a finite numeric intervalMs.";
+function invalidateOnInterval(prefix, options) {
+	if (!options || typeof options !== "object" || typeof options.intervalMs !== "number" || !Number.isFinite(options.intervalMs)) throw new Error(INVALIDATE_ON_INTERVAL_OPTIONS_ERROR);
+	const runtimeState = resolveDataRuntimeState(options.runtime);
+	const when = [];
+	if (options.activeOn) when.push(routeActive(options.activeOn));
+	if (options.visibleOnly) when.push(documentVisible());
+	if (options.focusedOnly) when.push(windowFocused());
+	timer(options.intervalMs, () => {
+		invalidateQueriesForRuntime(runtimeState, prefix, options.markPendingWrite ?? false);
+	}, when.length > 0 ? { when } : void 0);
+}
+//#endregion
+//#region src/data/shared.ts
+function createReadableSource() {
+	return (() => void 0);
+}
+function notifySource(source) {
+	markReadableDerivedSubscribersDirty(source);
+	markReactivePropsDirtySource(source);
+	notifyReadableReaders(source);
+}
+function isAbortError(error, signal) {
+	return signal.aborted || error instanceof Error && error.name === "AbortError" || typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError";
+}
+function normalizeAsyncDataError(error, fallbackMessage) {
+	if (error instanceof Error) return error;
+	return new Error(error == null ? fallbackMessage : String(error));
+}
+//#endregion
+//#region src/data/mutation-cell.ts
+var MutationCell = class {
+	constructor(options, runtimeState) {
+		this.source = createReadableSource();
+		this.controller = null;
+		this.generation = 0;
+		this.state = {
+			status: "idle",
+			error: null,
+			result: null
+		};
+		this.runtimeState = runtimeState;
+		this.action = options.action;
+		this.affects = options.affects;
+		this.afterSuccess = options.afterSuccess;
+	}
+	setOptions(options) {
+		this.action = options.action;
+		this.affects = options.affects;
+		this.afterSuccess = options.afterSuccess;
+	}
+	get status() {
+		recordReadableRead(this.source);
+		return this.state.status;
+	}
+	get pending() {
+		recordReadableRead(this.source);
+		return this.state.status === "pending";
+	}
+	get error() {
+		recordReadableRead(this.source);
+		return this.state.error;
+	}
+	get result() {
+		recordReadableRead(this.source);
+		return this.state.result;
+	}
+	setState(next) {
+		this.state = {
+			...this.state,
+			...next
+		};
+		notifySource(this.source);
+	}
+	async execute(input) {
+		const action = this.action;
+		const affects = this.affects;
+		const afterSuccess = this.afterSuccess;
+		this.generation += 1;
+		const generation = this.generation;
+		this.controller?.abort();
+		const controller = new AbortController();
+		this.controller = controller;
+		this.setState({
+			status: "pending",
+			error: null,
+			result: null
+		});
+		let result;
+		try {
+			result = await action(input, { signal: controller.signal });
+		} catch (error) {
+			if (this.generation !== generation || this.controller !== controller) throw error;
+			if (isAbortError(error, controller.signal)) {
+				this.setState({
+					status: "idle",
+					error: null
+				});
+				throw error;
+			}
+			this.setState({
+				status: "error",
+				error: normalizeAsyncDataError(error, "Unknown mutation error")
+			});
+			throw error;
+		}
+		if (this.generation !== generation || this.controller !== controller) return result;
+		this.setState({
+			status: "success",
+			error: null,
+			result
+		});
+		if (afterSuccess === "invalidate") {
+			const prefixes = affects?.(input, result) ?? [];
+			for (const prefix of new Set(prefixes)) invalidateQueriesForRuntime(this.runtimeState, prefix, true);
+		}
+		return result;
+	}
+	abort() {
+		if (this.state.status !== "pending") return;
+		this.generation += 1;
+		this.controller?.abort();
+		this.controller = null;
+		this.setState({
+			status: "idle",
+			error: null,
+			result: null
+		});
+	}
+	reset() {
+		this.generation += 1;
+		this.controller?.abort();
+		this.controller = null;
+		this.setState({
+			status: "idle",
+			error: null,
+			result: null
+		});
+	}
+};
+function createMutation(options) {
+	const instance = getCurrentComponentInstance();
+	const runtimeState = resolveDataRuntimeState(options.runtime);
+	if (!instance) return new MutationCell(options, runtimeState);
+	const hookIndex = claimHookIndex(instance, "mutation");
+	ensureMutationCleanup(runtimeState, instance);
+	const slotStore = getMutationSlotStore(runtimeState, instance);
+	const existing = slotStore.get(hookIndex);
+	if (existing) {
+		existing.setOptions(options);
+		return existing;
+	}
+	const created = new MutationCell(options, runtimeState);
+	slotStore.set(hookIndex, created);
+	return created;
+}
+//#endregion
+//#region src/data/query-cell.ts
+const RECONCILE_MAX_ATTEMPTS = 3;
+const RECONCILE_RETRY_DELAY_MS = 25;
+var QueryCell = class {
+	constructor(options, key, cache) {
+		this.source = createReadableSource();
+		this.controller = null;
+		this.generation = 0;
+		this.startQueued = false;
+		this.pendingRefresh = null;
+		this.pendingRefreshResolve = null;
+		this.pendingRefreshToken = 0;
+		this.reconcileAttemptCount = 0;
+		this.destroyed = false;
+		this.ownerCount = 0;
+		this.owners = /* @__PURE__ */ new Map();
+		this.warnedDefinitionConflictKeys = /* @__PURE__ */ new Set();
+		this.state = {
+			data: null,
+			error: null,
+			loading: true,
+			refreshing: false,
+			stale: false,
+			consistency: "fresh",
+			staleReason: null
+		};
+		this.options = options;
+		this.key = key;
+		this.cache = cache;
+		if (options.initialData !== void 0) this.state = {
+			data: options.initialData,
+			error: null,
+			loading: false,
+			refreshing: false,
+			stale: false,
+			consistency: "fresh",
+			staleReason: null
+		};
+	}
+	attach(generation, hookIndex) {
+		let hooks = this.owners.get(generation);
+		if (!hooks) {
+			hooks = /* @__PURE__ */ new Set();
+			this.owners.set(generation, hooks);
+		}
+		if (hooks.has(hookIndex)) return;
+		hooks.add(hookIndex);
+		this.ownerCount += 1;
+	}
+	detach(generation, hookIndex) {
+		const hooks = this.owners.get(generation);
+		if (!hooks || !hooks.delete(hookIndex)) return;
+		this.ownerCount -= 1;
+		if (hooks.size === 0) this.owners.delete(generation);
+		if (this.ownerCount <= 0) this.destroy();
+	}
+	warnOnConflictingDefinition(options) {
+		const conflicts = this.getDefinitionConflicts(options);
+		if (conflicts.length === 0) return;
+		const conflictKey = conflicts.join(",");
+		if (this.warnedDefinitionConflictKeys.has(conflictKey)) return;
+		this.warnedDefinitionConflictKeys.add(conflictKey);
+		const callbackLabel = conflicts.length === 1 ? `callback \`${conflicts[0]}\`` : `callbacks ${conflicts.map((field) => `\`${field}\``).join(", ")}`;
+		logger.warn(`[askr] Conflicting shared query definition for key "${this.key}". Shared queries are canonical by key, so reuse the same ${callbackLabel} for every reader of that key.`);
+	}
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.controller?.abort();
+		this.controller = null;
+		this.startQueued = false;
+		this.reconcileAttemptCount = 0;
+		this.ownerCount = 0;
+		this.owners.clear();
+		this.cache.delete(this.key);
+		this.finishPendingRefresh();
+	}
+	getDefinitionConflicts(options) {
+		const conflicts = [];
+		if (this.options.fetch !== options.fetch) conflicts.push("fetch");
+		if (this.options.isConsistent !== options.isConsistent) conflicts.push("isConsistent");
+		if (this.options.reconcile !== options.reconcile) conflicts.push("reconcile");
+		return conflicts;
+	}
+	get data() {
+		recordReadableRead(this.source);
+		return this.state.data;
+	}
+	get error() {
+		recordReadableRead(this.source);
+		return this.state.error;
+	}
+	get loading() {
+		recordReadableRead(this.source);
+		return this.state.loading;
+	}
+	get refreshing() {
+		recordReadableRead(this.source);
+		return this.state.refreshing;
+	}
+	get stale() {
+		recordReadableRead(this.source);
+		return this.state.stale;
+	}
+	get consistency() {
+		recordReadableRead(this.source);
+		return this.state.consistency;
+	}
+	get staleReason() {
+		recordReadableRead(this.source);
+		return this.state.staleReason;
+	}
+	ensureStarted() {
+		if (this.destroyed || this.state.data !== null || this.pendingRefresh || this.startQueued || this.options.skipInitialFetch) return;
+		this.queueStart("initial");
+	}
+	refresh() {
+		if (this.destroyed) return Promise.resolve();
+		if (this.pendingRefresh) return this.pendingRefresh;
+		this.queueStart("manual");
+		return this.pendingRefresh ?? Promise.resolve();
+	}
+	invalidate() {
+		if (this.destroyed) return;
+		if (this.pendingRefresh) {
+			this.controller?.abort();
+			this.finishPendingRefresh(this.pendingRefreshToken);
+		}
+		this.queueStart("invalidate");
+	}
+	markPendingWrite() {
+		if (this.destroyed) return;
+		if (this.state.data === null) return;
+		this.setState({
+			loading: false,
+			error: null,
+			refreshing: true,
+			stale: true,
+			consistency: "pending-write",
+			staleReason: null
+		});
+	}
+	queueStart(reason) {
+		if (this.destroyed) return;
+		this.startQueued = true;
+		const token = ++this.pendingRefreshToken;
+		this.pendingRefresh = new Promise((resolve) => {
+			this.pendingRefreshResolve = resolve;
+			enqueueRuntimeTask(() => {
+				this.startQueued = false;
+				if (this.destroyed) {
+					this.finishPendingRefresh(token);
+					return;
+				}
+				this.start(reason).finally(() => {
+					this.finishPendingRefresh(token);
+				});
+			});
+		});
+	}
+	finishPendingRefresh(token = this.pendingRefreshToken) {
+		if (token !== this.pendingRefreshToken) return;
+		const resolve = this.pendingRefreshResolve;
+		this.pendingRefresh = null;
+		this.pendingRefreshResolve = null;
+		resolve?.();
+	}
+	setState(next) {
+		if (this.destroyed) return;
+		this.state = {
+			...this.state,
+			...next
+		};
+		notifySource(this.source);
+	}
+	async start(reason) {
+		if (this.destroyed) return;
+		this.generation += 1;
+		const generation = this.generation;
+		this.controller?.abort();
+		const controller = new AbortController();
+		this.controller = controller;
+		const hasData = this.state.data !== null;
+		this.setState({
+			loading: !hasData,
+			refreshing: hasData,
+			stale: hasData,
+			consistency: reason === "pending-write" ? "pending-write" : hasData ? "refreshing" : "fresh",
+			error: null,
+			staleReason: null
+		});
+		let nextData;
+		try {
+			nextData = await this.options.fetch({ signal: controller.signal });
+		} catch (error) {
+			if (this.destroyed || this.generation !== generation || this.controller !== controller) return;
+			if (isAbortError(error, controller.signal)) {
+				this.setState(hasData ? {
+					loading: false,
+					refreshing: false,
+					stale: true,
+					consistency: "stale",
+					error: null,
+					staleReason: "aborted"
+				} : {
+					loading: true,
+					refreshing: false,
+					stale: false,
+					consistency: "fresh",
+					error: null,
+					staleReason: null
+				});
+				return;
+			}
+			this.setState({
+				loading: false,
+				refreshing: false,
+				stale: true,
+				consistency: "stale",
+				error: normalizeAsyncDataError(error, "Unknown query error"),
+				staleReason: "error"
+			});
+			return;
+		}
+		if (this.destroyed || this.generation !== generation || this.controller !== controller) return;
+		let isConsistent;
+		try {
+			isConsistent = this.options.isConsistent?.(nextData) ?? true;
+		} catch (error) {
+			this.setState({
+				loading: false,
+				refreshing: false,
+				stale: true,
+				consistency: "stale",
+				error: normalizeAsyncDataError(error, "Query consistency check failed"),
+				staleReason: "error"
+			});
+			return;
+		}
+		if (!isConsistent) {
+			this.setState({
+				data: nextData,
+				loading: false,
+				refreshing: false,
+				stale: true,
+				consistency: "stale",
+				staleReason: "inconsistent"
+			});
+			try {
+				await this.reconcile(nextData);
+			} catch (error) {
+				if (this.generation === generation && this.controller === controller) this.setState({
+					loading: false,
+					refreshing: false,
+					stale: true,
+					consistency: "stale",
+					error: normalizeAsyncDataError(error, "Query reconciliation failed"),
+					staleReason: "error"
+				});
+			}
+			return;
+		}
+		this.reconcileAttemptCount = 0;
+		this.setState({
+			data: nextData,
+			loading: false,
+			refreshing: false,
+			stale: false,
+			consistency: "fresh",
+			error: null,
+			staleReason: null
+		});
+	}
+	async reconcile(data) {
+		if (!await (this.options.reconcile?.(data, { key: this.options.key }) ?? false) || this.destroyed) return;
+		this.reconcileAttemptCount += 1;
+		if (this.reconcileAttemptCount > RECONCILE_MAX_ATTEMPTS) {
+			this.setState({
+				consistency: "stale",
+				refreshing: false,
+				staleReason: "inconsistent"
+			});
+			return;
+		}
+		await new Promise((resolve) => setTimeout(resolve, RECONCILE_RETRY_DELAY_MS));
+		if (this.destroyed || this.state.consistency === "fresh") return;
+		this.invalidate();
+	}
+};
+function createLegacyQuery(options) {
+	const instance = getCurrentComponentInstance();
+	const runtimeState = resolveDataRuntimeState(options.runtime);
+	const cache = runtimeState.queryCache;
+	if (!instance) {
+		let cell = cache.get(options.key);
+		if (!cell) {
+			cell = new QueryCell(options, options.key, cache);
+			cache.set(options.key, cell);
+			cell.ensureStarted();
+		} else cell.warnOnConflictingDefinition(options);
+		return cell;
+	}
+	const hookIndex = claimHookIndex(instance, "query");
+	ensureQueryCleanup(runtimeState, instance);
+	const slotStore = getQuerySlotStore(runtimeState, instance);
+	const existingSlot = slotStore.get(hookIndex);
+	if (existingSlot && existingSlot.key === options.key) {
+		existingSlot.cell.warnOnConflictingDefinition(options);
+		return existingSlot.cell;
+	}
+	if (existingSlot) existingSlot.cell.detach(instance._ownershipGeneration, hookIndex);
+	let cell = cache.get(options.key);
+	if (!cell) {
+		cell = new QueryCell(options, options.key, cache);
+		cache.set(options.key, cell);
+		cell.ensureStarted();
+	} else cell.warnOnConflictingDefinition(options);
+	slotStore.set(hookIndex, {
+		key: options.key,
+		cell
+	});
+	cell.attach(instance._ownershipGeneration, hookIndex);
+	return cell;
+}
+function createDefinedQuery(definition, input, options = {}) {
+	const runtime = options.runtime;
+	const context = getActiveRenderContext();
+	const key = definition.key(input);
+	const dataRuntime = runtime ?? getActiveRenderContext()?.dataRuntime ?? getDefaultDataRuntime();
+	const initialData = dataRuntime?.queryData.get(key);
+	return createLegacyQuery({
+		...options,
+		key,
+		fetch: ({ signal }) => definition.fetch({
+			...input,
+			signal
+		}),
+		isConsistent: definition.isConsistent,
+		reconcile: definition.reconcile,
+		initialData,
+		skipInitialFetch: context?.mode === "ssr" || context?.mode === void 0 && typeof window === "undefined",
+		runtime: dataRuntime ?? options.runtime
+	});
+}
+function createQuery(optionsOrDefinition, input, options) {
+	if (typeof optionsOrDefinition === "object" && "key" in optionsOrDefinition && typeof optionsOrDefinition.key === "function") return createDefinedQuery(optionsOrDefinition, input, options);
+	return createLegacyQuery(optionsOrDefinition);
+}
+//#endregion
+export { queryScope as a, invalidateOnInterval as i, createMutation as n, invalidate as r, createQuery as t };

package/dist/{data/data-runtime.js → data-runtime-SJ1BSUvk.js}

@@ -1,20 +1,24 @@
-import { getActiveRenderContext } from "../common/render-context.js";
-import { emitInvalidation } from "./invalidation-listeners.js";
+import { n as getActiveRenderContext } from "./render-context-Clw3rFiO.js";
+import { n as emitInvalidation } from "./invalidation-listeners-Des3AHYs.js";
 //#region src/data/data-runtime.ts
 const dataRuntimeStates = /* @__PURE__ */ new WeakMap();
 const dataRuntimeByQueryCache = /* @__PURE__ */ new WeakMap();
-function createDataRuntimeState(queryCache) {
+function createDataRuntimeState(queryCache, queryData) {
 	return {
 		queryCache,
-		querySlotsByInstance: /* @__PURE__ */ new WeakMap(),
-		mutationSlotsByInstance: /* @__PURE__ */ new WeakMap(),
+		queryData,
+		querySlotsByGeneration: /* @__PURE__ */ new WeakMap(),
+		mutationSlotsByGeneration: /* @__PURE__ */ new WeakMap(),
 		queryCleanupRegistered: /* @__PURE__ */ new WeakSet(),
 		mutationCleanupRegistered: /* @__PURE__ */ new WeakSet()
 	};
 }
 function createDataRuntime(options = {}) {
-	const runtime = Object.freeze({ queryCache: options.queryCache ?? /* @__PURE__ */ new Map() });
-	dataRuntimeStates.set(runtime, createDataRuntimeState(runtime.queryCache));
+	const runtime = Object.freeze({
+		queryCache: options.queryCache ?? /* @__PURE__ */ new Map(),
+		queryData: options.queryData ?? /* @__PURE__ */ new Map()
+	});
+	dataRuntimeStates.set(runtime, createDataRuntimeState(runtime.queryCache, runtime.queryData));
 	dataRuntimeByQueryCache.set(runtime.queryCache, runtime);
 	return runtime;
 }
@@ -51,49 +55,45 @@ function resolveDataRuntimeState(runtime) {
 	return runtime ? getDataRuntimeState(runtime) : getActiveDataRuntimeState();
 }
 function getQuerySlotStore(runtimeState, instance) {
-	let store = runtimeState.querySlotsByInstance.get(instance);
+	const generation = instance._ownershipGeneration;
+	let store = runtimeState.querySlotsByGeneration.get(generation);
 	if (!store) {
 		store = /* @__PURE__ */ new Map();
-		runtimeState.querySlotsByInstance.set(instance, store);
+		runtimeState.querySlotsByGeneration.set(generation, store);
 	}
 	return store;
 }
 function getMutationSlotStore(runtimeState, instance) {
-	let store = runtimeState.mutationSlotsByInstance.get(instance);
+	const generation = instance._ownershipGeneration;
+	let store = runtimeState.mutationSlotsByGeneration.get(generation);
 	if (!store) {
 		store = /* @__PURE__ */ new Map();
-		runtimeState.mutationSlotsByInstance.set(instance, store);
+		runtimeState.mutationSlotsByGeneration.set(generation, store);
 	}
 	return store;
 }
 function ensureQueryCleanup(runtimeState, instance) {
-	if (runtimeState.queryCleanupRegistered.has(instance)) return;
-	runtimeState.queryCleanupRegistered.add(instance);
-	instance.cleanupFns.push(() => {
-		const slots = runtimeState.querySlotsByInstance.get(instance);
-		if (!slots) {
-			runtimeState.queryCleanupRegistered.delete(instance);
-			return;
-		}
-		for (const [hookIndex, slot] of slots) slot.cell.detach(instance, hookIndex);
+	const generation = instance._ownershipGeneration;
+	if (runtimeState.queryCleanupRegistered.has(generation)) return;
+	runtimeState.queryCleanupRegistered.add(generation);
+	const slots = getQuerySlotStore(runtimeState, instance);
+	(instance.cleanupFns ??= []).push(() => {
+		for (const [hookIndex, slot] of slots) slot.cell.detach(generation, hookIndex);
 		slots.clear();
-		runtimeState.querySlotsByInstance.delete(instance);
-		runtimeState.queryCleanupRegistered.delete(instance);
+		runtimeState.querySlotsByGeneration.delete(generation);
+		runtimeState.queryCleanupRegistered.delete(generation);
 	});
 }
 function ensureMutationCleanup(runtimeState, instance) {
-	if (runtimeState.mutationCleanupRegistered.has(instance)) return;
-	runtimeState.mutationCleanupRegistered.add(instance);
-	instance.cleanupFns.push(() => {
-		const slots = runtimeState.mutationSlotsByInstance.get(instance);
-		if (!slots) {
-			runtimeState.mutationCleanupRegistered.delete(instance);
-			return;
-		}
+	const generation = instance._ownershipGeneration;
+	if (runtimeState.mutationCleanupRegistered.has(generation)) return;
+	runtimeState.mutationCleanupRegistered.add(generation);
+	const slots = getMutationSlotStore(runtimeState, instance);
+	(instance.cleanupFns ??= []).push(() => {
 		for (const cell of slots.values()) cell.abort();
 		slots.clear();
-		runtimeState.mutationSlotsByInstance.delete(instance);
-		runtimeState.mutationCleanupRegistered.delete(instance);
+		runtimeState.mutationSlotsByGeneration.delete(generation);
+		runtimeState.mutationCleanupRegistered.delete(generation);
 	});
 }
 function invalidateQueriesForRuntime(runtimeState, prefix, markPendingWrite) {
@@ -101,14 +101,13 @@ function invalidateQueriesForRuntime(runtimeState, prefix, markPendingWrite) {
 		prefix,
 		markPendingWrite
 	});
+	for (const key of runtimeState.queryData.keys()) if (key.startsWith(prefix)) runtimeState.queryData.delete(key);
 	const cache = runtimeState.queryCache;
 	for (const [key, query] of cache) {
 		if (!key.startsWith(prefix)) continue;
 		if (markPendingWrite) query.markPendingWrite();
-		query.refresh();
+		query.invalidate();
 	}
 }
 //#endregion
-export { createDataRuntime, ensureMutationCleanup, ensureQueryCleanup, getDefaultDataRuntime, getMutationSlotStore, getQuerySlotStore, invalidateQueriesForRuntime, resolveDataRuntimeState };
-
-//# sourceMappingURL=data-runtime.js.map
+export { getMutationSlotStore as a, resolveDataRuntimeState as c, getDefaultDataRuntime as i, ensureMutationCleanup as n, getQuerySlotStore as o, ensureQueryCleanup as r, invalidateQueriesForRuntime as s, createDataRuntime as t };