@askrjs/askr 0.3.0 → 0.4.0

package/dist/{data-2edW0jhF.js → data-BCwClJiF.js}

@@ -1,11 +1,9 @@
-import { b as ScheduledWork, f as requestRuntimeWork, v as logger } from "./access-CEA2pOry.js";
-import { d as getCurrentAppRenderRuntime, f as getCurrentComponentInstance, i as claimHookIndex } from "./scope-Cq_iYbTR.js";
-import { a as ownComponentCleanup, r as getComponentLifetimeIdentity } from "./capabilities-Bbf0mlp9.js";
-import { v as recordReadableRead } from "./notify-DxxuDPeY.js";
-import { n as getActiveRenderContext } from "./render-context-B7ohlh6t.js";
-import { a as routeActive, i as windowFocused, n as documentVisible, t as timer } from "./timer-C7uqnJVt.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-CxoY98lX.js";
-import { a as normalizeAsyncDataError, i as isCurrentAsyncOperation, n as isAbortError, o as notifySource, t as createReadableSource } from "./shared-kU8yvryp.js";
+import { C as schedule, F as logger } from "./instance-BAnfmXOR.js";
+import { i as currentComponent, n as createSource, r as currentAppRuntime, s as notify, t as claimHookIndex, u as readSource } from "./hooks-BimKStr4.js";
+import { n as getActiveRenderContext } from "./render-context-DGHnEveC.js";
+import { a as getDefaultDataRuntime, c as invalidateQueriesForRuntime, f as invalidateCollectionCell, l as readQueryData, m as unregisterCollectionCell, n as ensureMutationCleanup, o as getMutationSlotStore, p as registerCollectionCell, r as ensureQueryCleanup, s as getQuerySlotStore, u as resolveDataRuntimeState } from "./data-runtime-C1bFAlba.js";
+import { a as routeActive, n as windowFocused, s as timer, t as documentVisible } from "./browser-activity-CB8e-V4f.js";
+import { i as normalizeAsyncDataError, r as isCurrentAsyncOperation, t as isAbortError } from "./shared-O2ZnmYAf.js";
 //#region src/data/query-key.ts
 function serializeQueryKeyNumber(part) {
 	if (Number.isNaN(part)) return "NaN";
@@ -46,18 +44,28 @@ function createQueryScope(namespace, invalidate) {
 }
 //#endregion
 //#region src/data/invalidation.ts
-/** Mark all cached queries whose key starts with `prefix` as stale, triggering a refresh. */
+/**
+* Mark all cached queries under `prefix` as stale, triggering a refresh.
+* Matching is by `:`-delimited segment: a key matches when it equals `prefix`,
+* when `prefix` ends in `:`, or when the key continues `prefix` at a `:`
+* (`'user:1'` matches `user:1:posts` but not `user:10`). Only `:` is a
+* segment boundary; the empty prefix matches every key.
+*/
 function invalidate(prefix, options) {
 	invalidateQueriesForRuntime(resolveDataRuntimeState(options?.runtime), prefix, options?.markPendingWrite ?? false);
 }
-/** Create a {@link QueryScope} that namespaces keys and invalidations under `namespace`. */
-function queryScope(namespace) {
-	return createQueryScope(namespace, invalidate);
+/** Create a {@link QueryScope} that namespaces keys and can bind invalidations to a runtime. */
+function queryScope(namespace, options) {
+	return createQueryScope(namespace, (prefix, callOptions) => invalidate(prefix, {
+		...callOptions,
+		runtime: callOptions?.runtime ?? options?.runtime
+	}));
 }
 const INVALIDATE_ON_INTERVAL_OPTIONS_ERROR = "[Askr] invalidateOnInterval() requires an options object with a finite numeric intervalMs.";
 /**
 * Periodically invalidate queries matching `prefix` on a fixed interval,
 * optionally gated by active route, document visibility, or window focus.
+* `prefix` matches key segments the same way as {@link invalidate}.
 */
 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);
@@ -74,8 +82,10 @@ function invalidateOnInterval(prefix, options) {
 //#region src/data/mutation-cell.ts
 var MutationCell = class {
 	constructor(options, runtimeState) {
-		this.source = createReadableSource();
+		this.source = createSource();
 		this.controller = null;
+		this.activeControllers = /* @__PURE__ */ new Set();
+		this.rollbacks = /* @__PURE__ */ new Map();
 		this.generation = 0;
 		this.state = {
 			status: "idle",
@@ -84,28 +94,30 @@ var MutationCell = class {
 		};
 		this.runtimeState = runtimeState;
 		this.action = options.action;
+		this.optimistic = options.optimistic;
 		this.affects = options.affects;
 		this.afterSuccess = options.afterSuccess;
 	}
 	setOptions(options) {
 		this.action = options.action;
+		this.optimistic = options.optimistic;
 		this.affects = options.affects;
 		this.afterSuccess = options.afterSuccess;
 	}
 	get status() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.status;
 	}
 	get pending() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.status === "pending";
 	}
 	get error() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.error;
 	}
 	get result() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.result;
 	}
 	setState(next) {
@@ -113,17 +125,18 @@ var MutationCell = class {
 			...this.state,
 			...next
 		};
-		notifySource(this.source);
+		notify(this.source);
 	}
 	async execute(input) {
 		const action = this.action;
+		const optimistic = this.optimistic;
 		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.activeControllers.add(controller);
 		this.setState({
 			status: "pending",
 			error: null,
@@ -131,8 +144,17 @@ var MutationCell = class {
 		});
 		let result;
 		try {
+			const rollback = optimistic?.(input, { signal: controller.signal });
+			if (rollback) this.rollbacks.set(controller, rollback);
 			result = await action(input, { signal: controller.signal });
-		} catch (error) {
+			this.rollbacks.delete(controller);
+		} catch (cause) {
+			let error = cause;
+			try {
+				this.rollbackOptimistic(controller);
+			} catch (rollbackError) {
+				error = new AggregateError([cause, rollbackError], "Mutation failed and its optimistic rollback failed");
+			}
 			if (!isCurrentAsyncOperation(this.generation, generation, this.controller, controller)) throw error;
 			if (isAbortError(error, controller.signal)) {
 				this.setState({
@@ -146,6 +168,9 @@ var MutationCell = class {
 				error: normalizeAsyncDataError(error, "Unknown mutation error")
 			});
 			throw error;
+		} finally {
+			this.activeControllers.delete(controller);
+			this.rollbacks.delete(controller);
 		}
 		if (isCurrentAsyncOperation(this.generation, generation, this.controller, controller)) this.setState({
 			status: "success",
@@ -159,25 +184,44 @@ var MutationCell = class {
 		return result;
 	}
 	abort() {
-		if (this.state.status !== "pending") return;
+		if (this.activeControllers.size === 0) return;
 		this.generation += 1;
-		this.controller?.abort();
 		this.controller = null;
-		this.setState({
+		if (this.state.status === "pending") this.setState({
 			status: "idle",
 			error: null,
 			result: null
 		});
+		this.cancelActive();
 	}
 	reset() {
 		this.generation += 1;
-		this.controller?.abort();
 		this.controller = null;
 		this.setState({
 			status: "idle",
 			error: null,
 			result: null
 		});
+		this.cancelActive();
+	}
+	rollbackOptimistic(controller) {
+		const rollback = this.rollbacks.get(controller);
+		this.rollbacks.delete(controller);
+		rollback?.();
+	}
+	cancelActive() {
+		const controllers = [...this.activeControllers];
+		this.activeControllers.clear();
+		const errors = [];
+		for (const controller of controllers) {
+			try {
+				this.rollbackOptimistic(controller);
+			} catch (error) {
+				errors.push(error);
+			}
+			controller.abort();
+		}
+		if (errors.length > 0) throw new AggregateError(errors, "Optimistic mutation rollback failed");
 	}
 };
 /**
@@ -187,14 +231,14 @@ var MutationCell = class {
 */
 function createMutation(options) {
 	if (options.key !== void 0 && options.key.length === 0) throw new TypeError("createMutation key must be a non-empty string.");
-	const instance = getCurrentComponentInstance();
+	const instance = currentComponent();
 	const runtimeState = resolveDataRuntimeState(options.runtime);
 	const override = options.key ? runtimeState.mutationTestOverrides.get(options.key) : void 0;
 	if (!instance) {
 		if (override) return override;
 		return new MutationCell(options, runtimeState);
 	}
-	const hookIndex = claimHookIndex(instance, "mutation");
+	const hookIndex = claimHookIndex(instance, "createMutation");
 	ensureMutationCleanup(runtimeState, instance);
 	const slotStore = getMutationSlotStore(runtimeState, instance);
 	if (override) {
@@ -281,19 +325,24 @@ function errorQueryState(data, error) {
 //#region src/data/query-cell.ts
 const RECONCILE_MAX_ATTEMPTS = 3;
 const RECONCILE_RETRY_DELAY_MS = 25;
-var QueryStartWork = class extends ScheduledWork {
+const MAX_GC_TIME_MS = 2147483647;
+const DEFAULT_OWNERLESS_GC_TIME_MS = 3e5;
+function validateGcTime(gcTime) {
+	if (gcTime !== void 0 && (!Number.isFinite(gcTime) || gcTime < 0 || gcTime > MAX_GC_TIME_MS)) throw new RangeError("Query gcTime must be a finite, non-negative timer delay.");
+}
+/** Starts a query fetch in the flush; settles its promise if dropped. */
+var QueryStartWork = class {
 	constructor(run, settle) {
-		super(run);
+		this.run = run;
 		this.settle = settle;
 	}
 	cancel() {
-		super.cancel();
 		this.settle();
 	}
 };
 var QueryCell = class {
 	constructor(options, key, cache) {
-		this.source = createReadableSource();
+		this.source = createSource();
 		this.controller = null;
 		this.generation = 0;
 		this.pendingRefresh = null;
@@ -304,22 +353,36 @@ var QueryCell = class {
 		this.reconcileSequence = 0;
 		this.destroyed = false;
 		this.ownerCount = 0;
+		this.gcTimer = null;
+		this.unownedTimer = null;
 		this.owners = /* @__PURE__ */ new Map();
 		this.warnedDefinitionConflictKeys = /* @__PURE__ */ new Set();
+		this.definitionOwner = null;
+		this.definitionOwnerHook = -1;
+		this.conflictCheck = null;
 		this.state = loadingQueryState();
+		validateGcTime(options.gcTime);
 		this.options = options;
 		this.key = key;
 		this.cache = cache;
 		if (options.initialData !== void 0) this.state = freshQueryState(options.initialData);
 	}
 	attach(generation, hookIndex) {
+		if (this.unownedTimer !== null) {
+			clearTimeout(this.unownedTimer);
+			this.unownedTimer = null;
+		}
+		if (this.gcTimer !== null) {
+			clearTimeout(this.gcTimer);
+			this.gcTimer = null;
+		}
 		let hooks = this.owners.get(generation);
 		if (!hooks) {
-			hooks = /* @__PURE__ */ new Set();
+			hooks = /* @__PURE__ */ new Map();
 			this.owners.set(generation, hooks);
 		}
 		if (hooks.has(hookIndex)) return;
-		hooks.add(hookIndex);
+		hooks.set(hookIndex, null);
 		this.ownerCount += 1;
 	}
 	detach(generation, hookIndex) {
@@ -327,7 +390,51 @@ var QueryCell = class {
 		if (!hooks || !hooks.delete(hookIndex)) return;
 		this.ownerCount -= 1;
 		if (hooks.size === 0) this.owners.delete(generation);
-		if (this.ownerCount <= 0) this.destroy();
+		if (this.ownerCount <= 0) {
+			const gcTime = this.options.gcTime ?? 0;
+			if (gcTime === 0 || this.state.data === null || isServerRender()) this.destroy();
+			else {
+				this.generation += 1;
+				this.controller?.abort();
+				this.controller = null;
+				this.finishPendingRefresh();
+				this.definitionOwner = null;
+				this.definitionOwnerHook = -1;
+				this.gcTimer = setTimeout(() => this.destroy(), gcTime);
+			}
+			return;
+		}
+		if (this.definitionOwner === generation && this.definitionOwnerHook === hookIndex) this.promoteDefinitionOwner();
+	}
+	promoteDefinitionOwner() {
+		this.definitionOwner = null;
+		for (const [generation, hooks] of this.owners) for (const [hookIndex, options] of hooks) if (options) {
+			this.options = options;
+			this.definitionOwner = generation;
+			this.definitionOwnerHook = hookIndex;
+			return;
+		}
+	}
+	/**
+	* Record an attached reader's definition for this key. The owning reader's
+	* renders replace the definition; with no owner, the reader takes over.
+	* Other readers are checked for conflicts once render work settles.
+	*/
+	define(options, generation, hookIndex) {
+		validateGcTime(options.gcTime);
+		const hooks = this.owners.get(generation);
+		if (this.destroyed || !hooks?.has(hookIndex)) return;
+		hooks.set(hookIndex, options);
+		if (this.definitionOwner === null || this.definitionOwner === generation && this.definitionOwnerHook === hookIndex) {
+			this.options = options;
+			this.definitionOwner = generation;
+			this.definitionOwnerHook = hookIndex;
+			return;
+		}
+	}
+	warnOnConflictingReaders() {
+		if (this.destroyed) return;
+		for (const hooks of this.owners.values()) for (const options of hooks.values()) if (options) this.warnOnConflictingDefinition(options);
 	}
 	warnOnConflictingDefinition(options) {
 		const conflicts = this.getDefinitionConflicts(options);
@@ -341,14 +448,45 @@ var QueryCell = class {
 	destroy() {
 		if (this.destroyed) return;
 		this.destroyed = true;
+		if (this.gcTimer !== null) {
+			clearTimeout(this.gcTimer);
+			this.gcTimer = null;
+		}
+		if (this.unownedTimer !== null) {
+			clearTimeout(this.unownedTimer);
+			this.unownedTimer = null;
+		}
 		this.controller?.abort();
 		this.controller = null;
 		this.reconcileAttemptCount = 0;
 		this.ownerCount = 0;
 		this.owners.clear();
-		this.cache.delete(this.key);
+		this.evictFromCache();
 		this.finishPendingRefresh();
 	}
+	evictFromCache() {
+		if (this.cache.get(this.key) === this) this.cache.delete(this.key);
+	}
+	/** A component's inactive definition must not become an ownerless fetcher. */
+	retireInactiveReaderCacheEntry() {
+		if (this.gcTimer === null) return false;
+		this.destroy();
+		return true;
+	}
+	/** Ownerless handles stay usable after their cache lookup window expires. */
+	scheduleUnownedCacheEviction(gcTime) {
+		if (isServerRender() || this.ownerCount > 0 || this.destroyed) return;
+		if (this.unownedTimer !== null) clearTimeout(this.unownedTimer);
+		this.unownedTimer = null;
+		if (gcTime === 0) {
+			this.evictFromCache();
+			return;
+		}
+		this.unownedTimer = setTimeout(() => {
+			this.unownedTimer = null;
+			if (this.ownerCount === 0) this.evictFromCache();
+		}, gcTime);
+	}
 	getDefinitionConflicts(options) {
 		const conflicts = [];
 		if ((this.options.definitionIdentity ?? this.options.fetch) !== (options.definitionIdentity ?? options.fetch)) conflicts.push("fetch");
@@ -357,31 +495,31 @@ var QueryCell = class {
 		return conflicts;
 	}
 	get data() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.data;
 	}
 	get error() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.error;
 	}
 	get loading() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.loading;
 	}
 	get refreshing() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.refreshing;
 	}
 	get stale() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.stale;
 	}
 	get consistency() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.consistency;
 	}
 	get staleReason() {
-		recordReadableRead(this.source);
+		readSource(this.source);
 		return this.state.staleReason;
 	}
 	/** @internal Whether a collection should schedule this cell's first load. */
@@ -394,6 +532,10 @@ var QueryCell = class {
 	}
 	refresh() {
 		if (this.destroyed) return Promise.resolve();
+		if (this.gcTimer !== null) {
+			this.destroy();
+			return Promise.resolve();
+		}
 		if (this.pendingRefresh) {
 			if (this.pendingRefreshKind === "invalidation") {
 				this.controller?.abort();
@@ -404,14 +546,26 @@ var QueryCell = class {
 		this.queueStart(void 0, "manual");
 		return this.pendingRefresh ?? Promise.resolve();
 	}
-	invalidate() {
+	/** @internal Show an invalidation while a collection waits for a fetch slot. */
+	markQueuedInvalidation() {
 		if (this.destroyed) return;
+		this.generation += 1;
+		this.controller?.abort();
+		this.setState(this.state.data === null ? loadingQueryState() : refreshingQueryState(this.state.data, this.state.consistency === "pending-write" ? "pending-write" : "refreshing"));
+	}
+	invalidate() {
+		if (this.destroyed) return Promise.resolve();
+		if (this.gcTimer !== null) {
+			this.destroy();
+			return Promise.resolve();
+		}
 		if (this.pendingRefresh) {
 			this.controller?.abort();
 			this.queueStart(void 0, "invalidation", true);
-			return;
+			return this.pendingRefresh ?? Promise.resolve();
 		}
 		this.queueStart(void 0, "invalidation");
+		return this.pendingRefresh ?? Promise.resolve();
 	}
 	markPendingWrite() {
 		if (this.destroyed) return;
@@ -429,7 +583,7 @@ var QueryCell = class {
 		if (!continuePending || !this.pendingRefresh) this.pendingRefresh = new Promise((resolve) => {
 			this.pendingRefreshResolve = resolve;
 		});
-		requestRuntimeWork("component", new QueryStartWork(() => {
+		schedule(new QueryStartWork(() => {
 			if (token !== this.pendingRefreshToken) return;
 			if (this.destroyed) {
 				this.finishPendingRefresh(token);
@@ -442,7 +596,7 @@ var QueryCell = class {
 			if (token !== this.pendingRefreshToken) return;
 			this.generation += 1;
 			this.finishPendingRefresh(token);
-		}));
+		}), "effect");
 	}
 	finishPendingRefresh(token = this.pendingRefreshToken) {
 		if (token !== this.pendingRefreshToken) return;
@@ -455,7 +609,7 @@ var QueryCell = class {
 	setState(next) {
 		if (this.destroyed) return;
 		this.state = next;
-		notifySource(this.source);
+		notify(this.source);
 	}
 	async start(reconcileSequence) {
 		if (this.destroyed) return;
@@ -466,9 +620,10 @@ var QueryCell = class {
 		this.controller = controller;
 		const hasData = this.state.data !== null;
 		this.setState(hasData ? refreshingQueryState(this.state.data) : loadingQueryState());
+		const { fetch, isConsistent: checkConsistent, reconcile } = this.options;
 		let nextData;
 		try {
-			nextData = await this.options.fetch({ signal: controller.signal });
+			nextData = await fetch({ signal: controller.signal });
 		} catch (error) {
 			if (this.destroyed || !isCurrentAsyncOperation(this.generation, generation, this.controller, controller)) return;
 			if (isAbortError(error, controller.signal)) {
@@ -481,7 +636,7 @@ var QueryCell = class {
 		if (this.destroyed || !isCurrentAsyncOperation(this.generation, generation, this.controller, controller)) return;
 		let isConsistent;
 		try {
-			isConsistent = this.options.isConsistent?.(nextData) ?? true;
+			isConsistent = checkConsistent?.(nextData) ?? true;
 		} catch (error) {
 			this.setState(errorQueryState(this.state.data, normalizeAsyncDataError(error, "Query consistency check failed")));
 			return;
@@ -489,7 +644,7 @@ var QueryCell = class {
 		if (!isConsistent) {
 			this.setState(staleQueryState(nextData, "inconsistent"));
 			try {
-				await this.reconcile(nextData, generation, controller, reconcileSequence);
+				await this.reconcile(reconcile, nextData, generation, controller, reconcileSequence);
 			} catch (error) {
 				if (isCurrentAsyncOperation(this.generation, generation, this.controller, controller)) this.setState(errorQueryState(this.state.data, normalizeAsyncDataError(error, "Query reconciliation failed")));
 			}
@@ -498,8 +653,8 @@ var QueryCell = class {
 		this.reconcileAttemptCount = 0;
 		this.setState(freshQueryState(nextData));
 	}
-	async reconcile(data, generation, controller, reconcileSequence) {
-		if (!await (this.options.reconcile?.(data, { key: this.options.key }) ?? false) || this.destroyed || reconcileSequence !== this.reconcileSequence || !isCurrentAsyncOperation(this.generation, generation, this.controller, controller)) return;
+	async reconcile(reconcile, data, generation, controller, reconcileSequence) {
+		if (!await (reconcile?.(data, { key: this.key }) ?? false) || this.destroyed || reconcileSequence !== this.reconcileSequence || !isCurrentAsyncOperation(this.generation, generation, this.controller, controller)) return;
 		this.reconcileAttemptCount += 1;
 		if (this.reconcileAttemptCount > RECONCILE_MAX_ATTEMPTS) {
 			this.setState(staleQueryState(this.state.data, "inconsistent"));
@@ -511,63 +666,71 @@ var QueryCell = class {
 		this.queueStart(reconcileSequence, "reconcile", true);
 	}
 };
+function isServerRender() {
+	const context = getActiveRenderContext();
+	return context?.mode === "ssr" || context?.mode === void 0 && typeof window === "undefined";
+}
+function createCell(options, cache) {
+	const cell = new QueryCell(options.takeInitialData ? {
+		...options,
+		initialData: options.takeInitialData()
+	} : options, options.key, cache);
+	cache.set(options.key, cell);
+	cell.ensureStarted();
+	return cell;
+}
 function createLegacyQuery(options) {
-	const instance = getCurrentComponentInstance();
+	validateGcTime(options.gcTime);
+	const instance = currentComponent();
 	const runtimeState = resolveDataRuntimeState(options.runtime);
 	const cache = runtimeState.queryCache;
 	const override = runtimeState.queryTestOverrides.get(options.key);
 	if (!instance) {
 		if (override) return override;
 		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);
+		if (cell?.retireInactiveReaderCacheEntry()) cell = void 0;
+		if (!cell) cell = createCell(options, cache);
+		else cell.warnOnConflictingDefinition(options);
+		cell.scheduleUnownedCacheEviction(options.gcTime ?? DEFAULT_OWNERLESS_GC_TIME_MS);
 		return cell;
 	}
-	const hookIndex = claimHookIndex(instance, "query");
+	const hookIndex = claimHookIndex(instance, "createQuery");
 	ensureQueryCleanup(runtimeState, instance);
+	const generation = instance;
 	const slotStore = getQuerySlotStore(runtimeState, instance);
 	const existingSlot = slotStore.get(hookIndex);
 	if (existingSlot && existingSlot.key === options.key) {
-		existingSlot.cell.warnOnConflictingDefinition(options);
+		existingSlot.cell.define(options, generation, hookIndex);
 		return existingSlot.cell;
 	}
-	if (existingSlot) existingSlot.cell.detach(getComponentLifetimeIdentity(instance), hookIndex);
+	if (existingSlot) existingSlot.cell.detach(generation, hookIndex);
 	if (override) return override;
-	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);
+	const cell = cache.get(options.key) ?? createCell(options, cache);
 	slotStore.set(hookIndex, {
 		key: options.key,
 		cell
 	});
-	cell.attach(getComponentLifetimeIdentity(instance), hookIndex);
+	cell.attach(generation, hookIndex);
+	cell.define(options, generation, hookIndex);
+	cell.ensureStarted();
 	return cell;
 }
 function createDefinedQuery(definition, input, options = {}) {
 	const runtime = options.runtime;
-	const context = getActiveRenderContext();
 	const key = definition.key(input);
-	const dataRuntime = runtime ?? getActiveRenderContext()?.dataRuntime ?? getCurrentAppRenderRuntime()?.dataRuntime ?? getDefaultDataRuntime();
-	const initialData = dataRuntime?.queryData.get(key);
+	const dataRuntime = runtime ?? getActiveRenderContext()?.dataRuntime ?? currentAppRuntime()?.dataRuntime ?? getDefaultDataRuntime();
+	const serverRender = isServerRender();
+	const runtimeState = resolveDataRuntimeState(dataRuntime);
 	return createLegacyQuery({
 		...options,
 		key,
 		definitionIdentity: definition,
-		fetch: ({ signal }) => definition.fetch({
-			...input,
-			signal
-		}),
+		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
+		takeInitialData: () => readQueryData(runtimeState, key, !serverRender),
+		skipInitialFetch: serverRender,
+		runtime: dataRuntime
 	});
 }
 function createQuery(optionsOrDefinition, input, options) {
@@ -592,17 +755,13 @@ function getCollectionStore(generation) {
 	}
 	return store;
 }
-function createCellOptions(runtimeState, query, input, queryKey) {
+function createCellOptions(query, input, queryKey) {
 	return {
 		key: queryKey,
 		definitionIdentity: query,
-		fetch: ({ signal }) => query.fetch({
-			...input,
-			signal
-		}),
+		fetch: ({ signal }) => query.fetch(input, { signal }),
 		isConsistent: query.isConsistent,
 		reconcile: query.reconcile,
-		initialData: runtimeState.queryData.get(queryKey),
 		skipInitialFetch: true
 	};
 }
@@ -611,12 +770,25 @@ var QueryCollectionCell = class {
 		this.runtimeState = runtimeState;
 		this.records = /* @__PURE__ */ new Map();
 		this.ordered = [];
+		this.registeredCells = /* @__PURE__ */ new Set();
 		this.tasks = /* @__PURE__ */ new Map();
 		this.queue = [];
 		this.activeCount = 0;
 		this.concurrency = DEFAULT_QUERY_COLLECTION_CONCURRENCY;
 		this.disposed = false;
 	}
+	get invalidationConcurrency() {
+		return this.concurrency;
+	}
+	invalidateCell(cell) {
+		const ownedCell = cell;
+		if (this.tasks.get(ownedCell)?.state === "active") {
+			ownedCell.invalidate();
+			return;
+		}
+		ownedCell.markQueuedInvalidation();
+		this.schedule(ownedCell, "invalidation");
+	}
 	get entries() {
 		return this.ordered;
 	}
@@ -663,12 +835,12 @@ var QueryCollectionCell = class {
 		const startCandidates = /* @__PURE__ */ new Set();
 		const detachedCells = /* @__PURE__ */ new Set();
 		for (const { input, key, queryKey } of desired) {
-			const cellOptions = createCellOptions(this.runtimeState, query, input, queryKey);
+			const cellOptions = createCellOptions(query, input, queryKey);
 			const previous = this.records.get(key);
 			let record;
 			if (previous?.queryKey === queryKey) {
 				previous.input = input;
-				previous.cell.warnOnConflictingDefinition(cellOptions);
+				previous.cell.define(cellOptions, previous.owner, 0);
 				record = previous;
 			} else {
 				if (previous) {
@@ -678,11 +850,16 @@ var QueryCollectionCell = class {
 				const cache = this.runtimeState.queryCache;
 				let cell = cache.get(queryKey);
 				if (!cell) {
-					cell = new QueryCell(cellOptions, queryKey, cache);
+					const initialData = readQueryData(this.runtimeState, queryKey, startInitialFetches);
+					cell = new QueryCell({
+						...cellOptions,
+						initialData
+					}, queryKey, cache);
 					cache.set(queryKey, cell);
-				} else cell.warnOnConflictingDefinition(cellOptions);
+				}
 				const owner = {};
 				cell.attach(owner, 0);
+				cell.define(cellOptions, owner, 0);
 				record = {
 					key,
 					input,
@@ -700,8 +877,12 @@ var QueryCollectionCell = class {
 			this.detach(record);
 			detachedCells.add(record.cell);
 		}
+		const nextCells = new Set(nextOrdered.map((record) => record.cell));
 		this.records = nextRecords;
 		this.ordered = Object.freeze(nextOrdered);
+		for (const cell of this.registeredCells) if (!nextCells.has(cell)) unregisterCollectionCell(cell, this);
+		for (const cell of nextCells) if (!this.registeredCells.has(cell)) registerCollectionCell(cell, this);
+		this.registeredCells = nextCells;
 		for (const cell of detachedCells) this.cancelIfUnused(cell);
 		for (const cell of startCandidates) this.schedule(cell);
 		this.pump();
@@ -709,6 +890,8 @@ var QueryCollectionCell = class {
 	dispose() {
 		if (this.disposed) return;
 		this.disposed = true;
+		for (const cell of this.registeredCells) unregisterCollectionCell(cell, this);
+		this.registeredCells.clear();
 		const cells = /* @__PURE__ */ new Set();
 		for (const record of this.records.values()) {
 			cells.add(record.cell);
@@ -730,15 +913,20 @@ var QueryCollectionCell = class {
 		const task = this.tasks.get(cell);
 		if (!task || task.state === "cancelled" || task.state === "done") return;
 		if (task.state === "active") this.activeCount -= 1;
+		const rescheduleInvalidation = task.state === "queued" && task.kind === "invalidation";
 		task.state = "cancelled";
 		this.tasks.delete(cell);
 		task.resolve();
+		if (rescheduleInvalidation && !invalidateCollectionCell(cell)) cell.invalidate();
 		this.pump();
 	}
-	schedule(cell) {
+	schedule(cell, kind = "refresh") {
 		if (this.disposed) return Promise.resolve();
 		const existing = this.tasks.get(cell);
-		if (existing) return existing.promise;
+		if (existing) {
+			if (kind === "invalidation") existing.kind = kind;
+			return existing.promise;
+		}
 		let resolve;
 		const promise = new Promise((done) => {
 			resolve = done;
@@ -747,7 +935,8 @@ var QueryCollectionCell = class {
 			cell,
 			promise,
 			resolve,
-			state: "queued"
+			state: "queued",
+			kind
 		};
 		this.tasks.set(cell, task);
 		this.queue.push(task);
@@ -762,7 +951,7 @@ var QueryCollectionCell = class {
 			if (task.state !== "queued" || this.tasks.get(task.cell) !== task) continue;
 			task.state = "active";
 			this.activeCount += 1;
-			task.cell.refresh().finally(() => this.finish(task));
+			(task.kind === "invalidation" ? task.cell.invalidate() : task.cell.refresh()).finally(() => this.finish(task));
 		}
 	}
 	finish(task) {
@@ -779,13 +968,13 @@ var QueryCollectionCell = class {
 * reusable query definition, with bounded collection-started fetches.
 */
 function createQueryCollection(options) {
-	const instance = getCurrentComponentInstance();
+	const instance = currentComponent();
 	if (!instance) throw new Error("[Askr] createQueryCollection() must be called during component render execution.");
 	const hookIndex = claimHookIndex(instance, "createQueryCollection");
 	const concurrency = normalizeQueryCollectionConcurrency(options.concurrency);
 	const inputs = options.inputs();
 	if (!Array.isArray(inputs)) throw new Error("[Askr] createQueryCollection() inputs must return a readonly array.");
-	const generation = getComponentLifetimeIdentity(instance);
+	const generation = instance;
 	const runtimeState = resolveDataRuntimeState(options.runtime);
 	const store = getCollectionStore(generation);
 	let slot = store.get(hookIndex);
@@ -800,7 +989,7 @@ function createQueryCollection(options) {
 			collection: new QueryCollectionCell(runtimeState)
 		};
 		store.set(hookIndex, slot);
-		ownComponentCleanup(instance, () => {
+		instance.onCleanup(() => {
 			const current = store.get(hookIndex);
 			try {
 				current?.collection.dispose();