@raf-query/core 0.11.0 → 0.12.0

package/dist/entry.mjs

@@ -1,526 +1,355 @@
-import { replaceEqualDeep } from "./share.mjs";
-import { fetchPages, isInfiniteData, nextPageParam, previousPageParam } from "./infinite.mjs";
-import { listen } from "./listen.mjs";
-import { scheduleNotify } from "./notify.mjs";
-import { whenOnline } from "./platform.mjs";
-import { fromQueryFn, requestServices, runRequest } from "./request.mjs";
-import { retrySchedule } from "./retry.mjs";
+import { listeners } from "./subscribe.mjs";
+import { isObject } from "./guards.mjs";
+import { hashKey } from "./keys/keys.mjs";
+import { matches } from "./keys/targets.mjs";
+import { optionsOf } from "./options.mjs";
+import { replaceEqualDeep } from "./structural-sharing/structural-sharing.mjs";
 import { fulfilled, pending } from "./thenable.mjs";
-import { Cause, Data, Deferred, Effect, Exit, FiberMap, Pipeable, Predicate, Schedule, Scope } from "effect";
 //#region src/entry.ts
-const TypeId = "~@raf-query/core/Query";
-/**
-* The failure of a request that was interrupted rather than settled: its
-* entry was removed or cleared, or an Effect `queryFn` was interrupted.
-*/
-var CancelledError = class extends Data.TaggedError("CancelledError") {
-	message = "The query was cancelled";
+const initialState = {
+	data: void 0,
+	error: void 0,
+	fetchingDirection: void 0,
+	hasData: false,
+	isFetching: false,
+	status: "pending",
+	updatedAt: 0
 };
-/**
-* Why a query with `enabled: false` has no data: `ensure` / `fetch` die
-* with it, and on a server its promise rejects with it.
-*/
-var DisabledError = class extends Data.TaggedError("DisabledError") {
-	get message() {
-		return `Query ${this.hash} is disabled (enabled: false)`;
-	}
-};
-const Proto = {
-	...Pipeable.Prototype,
-	[TypeId]: {
-		_A: (value) => value,
-		_E: (value) => value
-	}
-};
-const defaultSubscribeOptions = {};
-function isQuery(value) {
-	return Predicate.hasProperty(value, TypeId);
+const fiveMinutes = 3e5;
+function abortError() {
+	return new DOMException("The query was cancelled", "AbortError");
+}
+function notify(entry) {
+	const client = entry.client;
+	const changed = client["~changed"];
+	if (changed.size === 0) queueMicrotask(() => {
+		const batch = [...changed];
+		changed.clear();
+		for (const item of batch) {
+			item.readers.emit(item.state);
+			client["~events"].emit({
+				entry: item,
+				type: "updated"
+			});
+		}
+	});
+	changed.add(entry);
+}
+function setState(entry, patch) {
+	entry.state = {
+		...entry.state,
+		...patch
+	};
+	notify(entry);
 }
-function entryOf(query) {
-	return query;
+function newPending(entry) {
+	const next = pending();
+	entry.pendingThenable = next;
+	entry.thenable = next.promise;
 }
-function emit(cache, event) {
-	for (const listener of cache.listeners) listener(event);
+function gcTime(entry) {
+	return entry.options?.gcTime ?? entry.client.config.gcTime ?? fiveMinutes;
 }
-/** Fibers keyed by task: forking a task interrupts its previous fiber. */
-function makeTasks(cache, scope) {
-	const runSync = Effect.runSyncWith(cache.services);
-	const runFork = Effect.runForkWith(cache.services);
-	const fibers = runSync(FiberMap.make().pipe(Scope.provide(scope)));
-	const run = runSync(FiberMap.runtime(fibers)());
-	return {
-		cancel(task) {
-			if (FiberMap.hasUnsafe(fibers, task)) runFork(FiberMap.remove(fibers, task));
-		},
-		fork(task, effect, options) {
-			run(task, effect, options);
+function scheduleGc(entry) {
+	const client = entry.client;
+	client.clock.clearTimeout(entry.gcTimer);
+	entry.gcTimer = void 0;
+	const time = gcTime(entry);
+	if (client.isServer || entry.readers.size > 0 || !Number.isFinite(time)) return;
+	entry.gcTimer = client.clock.setTimeout(() => {
+		entry.gcTimer = void 0;
+		if (entry.run) {
+			entry.run.done.promise.then(() => scheduleGc(entry));
+			return;
 		}
-	};
+		remove(entry);
+	}, time);
 }
-function make(cache, key, hash) {
-	const scope = Scope.forkUnsafe(cache.scope);
+function create(client, key, hash) {
 	const first = pending();
-	const entry = Object.assign(Object.create(Proto), {
-		cache,
-		errorShown: false,
-		failureCountBefore: 0,
-		handle: {
-			input: void 0,
-			key
-		},
+	const entry = {
+		client,
+		factory: void 0,
+		gcTimer: void 0,
 		hash,
-		hydratedMeta: void 0,
-		inFlight: void 0,
+		input: void 0,
 		key,
-		listeners: /* @__PURE__ */ new Map(),
 		options: void 0,
-		pending: first,
-		retriesStopped: false,
-		returnsEffect: void 0,
-		scope,
-		services: cache.services,
-		signalRead: false,
-		state: {
-			data: void 0,
-			error: null,
-			failureCount: 0,
-			fetchDirection: void 0,
-			hasData: false,
-			isFetching: false,
-			isInvalidated: false,
-			isStale: true,
-			promise: first.promise,
-			status: "pending",
-			updatedAt: 0
-		},
-		tasks: makeTasks(cache, scope)
-	});
-	const command = (request) => Effect.suspend(() => isDisabled(entry) ? Effect.void : Effect.ignore(fetch(entry, request)));
-	const commands = {
-		fetchNextPage: command({ direction: "forward" }),
-		fetchPreviousPage: command({ direction: "backward" }),
-		refetch: command()
+		pendingThenable: first,
+		readers: listeners((size) => {
+			client["~events"].emit({
+				entry,
+				type: "readers"
+			});
+			if (size === 0) scheduleGc(entry);
+			else {
+				client.clock.clearTimeout(entry.gcTimer);
+				entry.gcTimer = void 0;
+			}
+		}),
+		requestedAt: client["~seq"],
+		run: void 0,
+		state: initialState,
+		thenable: first.promise
 	};
-	Object.assign(entry, { commands });
+	client["~entries"].set(hash, entry);
+	client["~events"].emit({
+		entry,
+		type: "added"
+	});
 	scheduleGc(entry);
 	return entry;
 }
-function now(entry) {
-	return entry.cache.clock.currentTimeMillisUnsafe();
-}
-/** Readers are subscribed; `invalidate` and focus refetch only what is read. */
-function isObserved(entry) {
-	return entry.listeners.size > 0;
-}
-function behavior(entry, name) {
-	return entry.options?.[name] ?? entry.cache.defaults[name];
-}
-/** The entry's latest factory call returned `enabled: false`: it doesn't run. */
-function isDisabled(entry) {
-	return behavior(entry, "enabled") === false;
-}
-/** Until a factory call attaches options, `meta` comes from hydration. */
-function metaOf(entry) {
-	return entry.options ? behavior(entry, "meta") : entry.hydratedMeta ?? entry.cache.defaults.meta;
-}
-function computeStale(entry, state) {
-	if (state.isInvalidated || !state.hasData) return true;
-	const staleTime = behavior(entry, "staleTime") ?? 0;
-	return now(entry) - state.updatedAt >= staleTime;
-}
-function isStaleUnsafe(entry) {
-	return computeStale(entry, entry.state);
-}
-function hasNextPageUnsafe(entry) {
-	const options = entry.options;
-	const data = entry.state.data;
-	return options?.kind === "infinite" && isInfiniteData(data) && nextPageParam(options, data) != null;
-}
-function hasPreviousPageUnsafe(entry) {
-	const options = entry.options;
-	const data = entry.state.data;
-	return options?.kind === "infinite" && isInfiniteData(data) && previousPageParam(options, data) != null;
-}
-function subscribeUnsafe(entry, listener, options = defaultSubscribeOptions) {
-	entry.listeners.set(listener, options);
-	entry.retriesStopped = false;
-	entry.tasks.cancel("gc");
-	scheduleStale(entry);
-	emit(entry.cache, {
-		query: entry,
-		type: "observers"
-	});
-	return () => {
-		if (!entry.listeners.delete(listener)) return;
-		if (entry.listeners.size === 0) {
-			entry.tasks.cancel("stale");
-			scheduleGc(entry);
-			const inFlight = entry.inFlight;
-			if (inFlight) scheduleNotify(() => unobserved(entry, inFlight));
-		}
-		emit(entry.cache, {
-			query: entry,
-			type: "observers"
-		});
-	};
-}
-function changes(entry) {
-	return listen((push) => {
-		push(entry.state);
-		return subscribeUnsafe(entry, () => push(entry.state));
-	});
+/** The entry for a key, created if missing. Hydration uses it. */
+function entryForKey(client, key) {
+	const hash = hashKey(key);
+	return client["~entries"].get(hash) ?? create(client, key, hash);
 }
 /**
-* Run this entry's requests with the services of `caller`, a verb's fiber
-* context, over the cache's: every request from now on, including ones a
-* render, a refetch or `invalidate` starts.
+* The entry for a factory's input, created if missing, with the factory's
+* current options. Every read goes through here, which links an entry that
+* was only hydrated to its factory.
 */
-function provide(entry, caller) {
-	entry.services = requestServices(entry.cache.services, caller);
-}
-/** Attach the options and input of the latest factory call. */
-function setOptions(entry, options, input) {
+function entryOf(client, factory, input) {
+	const options = optionsOf(factory, input);
+	const entry = entryForKey(client, options.queryKey);
+	entry.factory = factory;
+	entry.input = input;
 	entry.options = options;
-	if (entry.handle.input !== input) entry.handle = {
-		input,
-		key: entry.key
-	};
-}
-/**
-* The promise a render should unwrap. Starts the first request if nothing
-* has, and retries a failed first load once its error has been shown.
-*/
-function readUnsafe(entry) {
-	const state = entry.state;
-	if (!state.hasData && !state.isFetching) {
-		if (state.status !== "error" || entry.errorShown) begin(entry, {});
-		else markErrorShown(entry);
-	}
-	return entry.state.promise;
-}
-/** Start a request unless one is in flight, without waiting for it. */
-function start(entry) {
-	begin(entry, {});
+	scheduleGc(entry);
+	return entry;
 }
-/**
-* Whether cached data that was asked for again should be refetched. A server
-* cache renders once, so a refetch there could only duplicate a request whose
-* result is never shown; it refetches only what `invalidate` marked.
-*/
-function needsRefetch(entry) {
-	return entry.cache.isServer ? entry.state.isInvalidated : isStaleUnsafe(entry);
+/** Whether an invalidation newer than the entry's data covers it. */
+function isInvalidated(entry) {
+	return entry.client["~stamps"].some((stamp) => stamp.at > entry.requestedAt && matches(entry, stamp));
 }
-/** Background refetch of cached data that was asked for again. */
-function revalidate(entry) {
+/** Whether the entry's data should be refetched before it's trusted. */
+function isStale(entry) {
 	const state = entry.state;
-	if (state.hasData && !state.isFetching && needsRefetch(entry)) start(entry);
-}
-function fetch(entry, request = {}) {
-	return Effect.suspend(() => {
-		const inFlight = entry.inFlight;
-		if (inFlight && request.direction && !request.restart) return Deferred.await(inFlight).pipe(Effect.exit, Effect.andThen(fetch(entry, request)));
-		return begin(entry, request);
-	});
+	if (!state.hasData) return true;
+	const staleTime = entry.options?.staleTime ?? entry.client.config.staleTime ?? 0;
+	return entry.client.clock.now() - state.updatedAt >= staleTime || isInvalidated(entry);
 }
-function invalidate(entry) {
-	return Effect.suspend(() => {
-		set(entry, { isInvalidated: true });
-		if (!isObserved(entry) || !entry.options || isDisabled(entry)) return Effect.void;
-		return Effect.ignore(begin(entry, { restart: true }));
-	});
-}
-function reset(entry) {
-	return Effect.suspend(() => {
-		entry.tasks.cancel("errorShown");
-		entry.errorShown = false;
-		entry.pending ??= pending();
-		set(entry, {
-			data: void 0,
-			error: null,
-			failureCount: 0,
-			hasData: false,
-			isInvalidated: false,
-			promise: entry.pending.promise,
-			status: "pending",
-			updatedAt: 0
-		});
-		if (!entry.options || isDisabled(entry) || !isObserved(entry) && !entry.inFlight) return Effect.void;
-		return Effect.ignore(begin(entry, { restart: true }));
-	});
-}
-/** Write data directly, as if a request had returned it. */
-function setData(entry, data, updatedAt = now(entry)) {
-	succeed(entry, data, updatedAt);
-}
-/**
-* Adopt a request started elsewhere (the server's, during hydration). Its
-* data counts as fetched when the sender got it, not when it arrived.
-*/
-function resume(entry, promise) {
-	if (entry.state.hasData || entry.inFlight) return;
-	let updatedAt;
-	startRequest(entry, Effect.promise(async () => {
-		const result = await promise;
-		updatedAt = result.updatedAt;
-		return result.data;
-	}), void 0, () => updatedAt);
-}
-/** Refetch a read, stale entry whose readers want it on this event. */
-function onPlatformEvent(entry, event) {
-	const option = event === "focus" ? "refetchOnWindowFocus" : "refetchOnReconnect";
-	const fallback = behavior(entry, option) ?? true;
-	if ([...entry.listeners.values()].some((options) => options[option] ?? fallback) && isStaleUnsafe(entry)) start(entry);
-}
-/** Take `entry` out of its cache: interrupt its fibers and fail its awaiters. */
-function remove(entry) {
-	const cache = entry.cache;
-	if (cache.entries.get(entry.hash) !== entry) return;
-	cache.entries.delete(entry.hash);
-	const inFlight = entry.inFlight;
-	entry.inFlight = void 0;
-	Effect.runForkWith(cache.services)(Scope.close(entry.scope, Exit.void));
-	if (inFlight) Deferred.doneUnsafe(inFlight, Exit.fail(new CancelledError()));
-	emit(cache, {
-		query: entry,
-		type: "removed"
+/** Write data. `startedAt` orders it against invalidations. */
+function write(entry, data, updatedAt, startedAt) {
+	const previous = entry.state;
+	const next = (entry.options?.structuralSharing ?? entry.client.config.structuralSharing ?? true) && previous.hasData ? replaceEqualDeep(previous.data, data) : data;
+	entry.requestedAt = Math.max(entry.requestedAt, startedAt);
+	if (entry.pendingThenable) {
+		entry.pendingThenable.resolve(next);
+		entry.pendingThenable = void 0;
+	} else if (!previous.hasData || next !== previous.data) entry.thenable = fulfilled(next);
+	setState(entry, {
+		data: next,
+		error: void 0,
+		hasData: true,
+		status: "success",
+		updatedAt
 	});
+	scheduleGc(entry);
 }
 /**
-* Start a request now, or join the one in flight. The returned Effect
-* waits for its result.
+* Record a failed request. Data the entry had stays readable. Without data,
+* the request in flight has a pending thenable for readers: it rejects.
 */
-function begin(entry, request) {
-	if (Predicate.isTagged(entry.scope.state, "Closed")) return Effect.fail(new CancelledError());
-	if (isDisabled(entry)) {
-		const error = new DisabledError({ hash: entry.hash });
-		if (entry.cache.isServer) {
-			const firstLoad = entry.pending;
-			entry.pending = void 0;
-			firstLoad?.reject(error);
-		}
-		return Effect.die(error);
-	}
-	const options = entry.options;
-	const inFlight = entry.inFlight;
-	if (inFlight && !(request.restart && options)) return Deferred.await(inFlight);
-	if (!options) {
-		const promise = entry.state.promise;
-		return Effect.promise(() => promise);
+function failWith(entry, error) {
+	if (!entry.state.hasData) {
+		entry.pendingThenable?.reject(error);
+		entry.pendingThenable = void 0;
 	}
-	entry.tasks.cancel("request");
-	return Deferred.await(startRequest(entry, runRequest(requestEffect(entry, options, request), entry.hash, entry.services), request.direction));
-}
-function set(entry, patch) {
-	const next = {
-		...entry.state,
-		...patch
-	};
-	entry.state = {
-		...next,
-		isStale: computeStale(entry, next)
-	};
-	for (const listener of entry.listeners.keys()) scheduleNotify(listener);
-	emit(entry.cache, {
-		query: entry,
-		type: "updated"
+	setState(entry, {
+		error,
+		status: "error"
 	});
-	scheduleStale(entry);
 }
-/** Run `request` as the entry's request fiber, settling into its awaiter. */
-function startRequest(entry, request, direction, updatedAt) {
-	if (!entry.inFlight) entry.failureCountBefore = entry.state.failureCount;
-	const awaiter = entry.inFlight ?? Deferred.makeUnsafe();
-	entry.inFlight = awaiter;
-	entry.retriesStopped = false;
-	entry.signalRead = false;
-	entry.tasks.cancel("gc");
-	if (!entry.state.hasData && !entry.pending) {
-		entry.pending = pending();
-		set(entry, {
-			error: null,
-			failureCount: 0,
-			fetchDirection: direction,
-			isFetching: true,
-			promise: entry.pending.promise,
-			status: "pending"
-		});
-	} else set(entry, {
-		failureCount: 0,
-		fetchDirection: direction,
-		isFetching: true
+function finish(entry, run, outcome) {
+	entry.run = void 0;
+	setState(entry, {
+		fetchingDirection: void 0,
+		isFetching: false
 	});
-	entry.tasks.fork("request", Effect.exit(request).pipe(Effect.flatMap((exit) => Effect.sync(() => settle(entry, awaiter, exit, updatedAt?.() ?? now(entry))))));
-	return awaiter;
-}
-function settle(entry, awaiter, exit, updatedAt) {
-	if (entry.inFlight !== awaiter) return;
-	entry.inFlight = void 0;
-	if (Exit.isSuccess(exit)) {
-		const data = succeed(entry, exit.value, updatedAt);
-		Deferred.doneUnsafe(awaiter, Exit.succeed(data));
-	} else if (Cause.hasInterruptsOnly(exit.cause)) {
-		set(entry, {
-			fetchDirection: void 0,
-			isFetching: false
-		});
-		Deferred.doneUnsafe(awaiter, Exit.fail(new CancelledError()));
-	} else {
-		fail(entry, Cause.squash(exit.cause));
-		Deferred.doneUnsafe(awaiter, exit);
-	}
+	run.done.resolve(outcome);
 	scheduleGc(entry);
 }
-/**
-* The last reader left while `awaiter`'s request was in flight. A refetch
-* whose work an interrupt cancels (`signalRead`) is interrupted, and the
-* entry goes back to its state before the request; its awaiters get the
-* cached data. Any other request finishes, so its result is cached, but
-* runs no more retries.
-*/
-function unobserved(entry, awaiter) {
-	if (isObserved(entry) || entry.inFlight !== awaiter) return;
-	if (!entry.signalRead || !entry.state.hasData) {
-		entry.retriesStopped = true;
+function isAsyncIterable(value) {
+	return isObject(value) && Symbol.asyncIterator in value;
+}
+async function pump(entry, run, chunks, stream) {
+	let data = stream.initial;
+	try {
+		for await (const chunk of chunks) {
+			if (entry.run !== run) return;
+			data = stream.reduce(data, chunk);
+			write(entry, data, entry.client.clock.now(), run.startedAt);
+			if (!run.settled) {
+				run.settled = true;
+				run.done.resolve({ ok: true });
+			}
+		}
+	} catch (error) {
+		if (entry.run === run) {
+			failWith(entry, error);
+			finish(entry, run, {
+				error,
+				ok: false
+			});
+		}
 		return;
 	}
-	entry.inFlight = void 0;
-	entry.tasks.cancel("request");
-	set(entry, {
-		failureCount: entry.failureCountBefore,
-		fetchDirection: void 0,
-		isFetching: false
-	});
-	Deferred.doneUnsafe(awaiter, Exit.succeed(entry.state.data));
-	scheduleGc(entry);
+	if (entry.run === run) {
+		if (!run.settled) write(entry, data, entry.client.clock.now(), run.startedAt);
+		finish(entry, run, { ok: true });
+	}
 }
-function succeed(entry, next, updatedAt) {
-	const previous = entry.state;
-	const data = previous.hasData && behavior(entry, "structuralSharing") !== false ? replaceEqualDeep(previous.data, next) : next;
-	const firstLoad = entry.pending;
-	entry.pending = void 0;
-	firstLoad?.resolve(data);
-	const unchanged = previous.hasData && data === previous.data;
-	const isFetching = entry.inFlight !== void 0;
-	set(entry, {
-		data,
-		error: null,
-		failureCount: 0,
-		fetchDirection: isFetching ? previous.fetchDirection : void 0,
-		hasData: true,
-		isFetching,
-		isInvalidated: false,
-		promise: firstLoad?.promise ?? (unchanged ? previous.promise : fulfilled(data)),
-		status: "success",
-		updatedAt
+function terminal(op) {
+	return new Promise((resolve) => {
+		const options = op.options;
+		const paged = options["~run"];
+		resolve(paged ? paged(op) : options.queryFn({
+			meta: op.meta,
+			queryKey: op.queryKey,
+			signal: op.signal
+		}));
 	});
-	return data;
 }
-function fail(entry, error) {
-	emit(entry.cache, {
-		error,
-		query: entry,
-		type: "failed"
-	});
-	if (!entry.state.hasData) {
-		const firstLoad = entry.pending;
-		entry.pending = void 0;
-		firstLoad?.reject(error);
-		entry.errorShown = false;
-	}
-	set(entry, {
-		error,
-		fetchDirection: void 0,
-		isFetching: false,
-		status: "error"
-	});
+function chain(op) {
+	const links = op.client.config.links ?? [];
+	const call = (index, current) => {
+		const link = links[index];
+		return link ? link(current, (next) => call(index + 1, next)) : terminal(current);
+	};
+	return call(0, op);
 }
 /**
-* A failed first load rejects its promise, so the reader throws to an error
-* boundary. Every read in that same task (React retries a throwing render
-* once, StrictMode renders twice) gets the rejection too; a read in a later
-* task — the boundary was reset — starts a new request.
+* Run the entry's request, or join the one in flight. Resolves with how it
+* ended, never rejects: a removed entry's request ends with an `AbortError`.
+* Whoever waited on a restarted request gets the new one's outcome.
 */
-function markErrorShown(entry) {
-	entry.tasks.fork("errorShown", Effect.yieldNow.pipe(Effect.andThen(Effect.sync(() => {
-		entry.errorShown = true;
-	}))), { onlyIfMissing: true });
-}
-function requestEffect(entry, options, request) {
-	const meta = metaOf(entry);
-	const queryKey = options.queryKey;
-	if (options.kind === "query") return attempt(entry, (readSignal) => options.queryFn({
-		meta,
-		queryKey,
-		get signal() {
-			return readSignal();
+function fetchEntry(entry, request = {}) {
+	const current = entry.run;
+	if (current && !request.restart && request.direction === void 0) return current.done.promise;
+	const options = entry.options;
+	if (!options) return Promise.resolve({ ok: true });
+	current?.controller.abort();
+	const client = entry.client;
+	const run = {
+		controller: new AbortController(),
+		done: current && !current.settled ? current.done : Promise.withResolvers(),
+		settled: false,
+		startedAt: ++client["~seq"]
+	};
+	entry.run = run;
+	if (!entry.state.hasData && !entry.pendingThenable) newPending(entry);
+	setState(entry, {
+		fetchingDirection: request.direction,
+		isFetching: true
+	});
+	const state = entry.state;
+	chain({
+		client,
+		data: state.data,
+		direction: request.direction,
+		hasData: state.hasData,
+		hash: entry.hash,
+		input: entry.input,
+		meta: options.meta ?? {},
+		options,
+		pages: request.pages,
+		queryKey: entry.key,
+		signal: run.controller.signal
+	}).then((result) => {
+		if (entry.run !== run) return;
+		if (options.stream && isAsyncIterable(result)) {
+			pump(entry, run, result, options.stream);
+			return;
+		}
+		write(entry, result, client.clock.now(), run.startedAt);
+		finish(entry, run, { ok: true });
+	}, (error) => {
+		if (entry.run !== run) return;
+		failWith(entry, error);
+		finish(entry, run, {
+			error,
+			ok: false
+		});
+	});
+	return run.done.promise;
+}
+/** Take over a request started elsewhere (hydration of a pending entry). */
+function adopt(entry, promise) {
+	const run = {
+		controller: new AbortController(),
+		done: Promise.withResolvers(),
+		settled: false,
+		startedAt: entry.client["~seq"]
+	};
+	entry.run = run;
+	if (!entry.state.hasData && !entry.pendingThenable) newPending(entry);
+	setState(entry, { isFetching: true });
+	Promise.resolve(promise).then((sent) => {
+		if (entry.run === run) {
+			write(entry, sent.data, sent.updatedAt, run.startedAt);
+			finish(entry, run, { ok: true });
 		}
-	}));
-	const pagesOf = () => isInfiniteData(entry.state.data) ? entry.state.data : void 0;
-	return fetchPages(options, pagesOf(), request, (pageParam, direction) => attempt(entry, (readSignal) => options.queryFn({
-		direction,
-		meta,
-		pageParam,
-		queryKey,
-		get signal() {
-			return readSignal();
+	}, (error) => {
+		if (entry.run === run) {
+			failWith(entry, error);
+			finish(entry, run, {
+				error,
+				ok: false
+			});
 		}
-	})), pagesOf);
+	});
 }
-/**
-* One `queryFn` call, retried per the query's policy. Every failure counts.
-* `call` reads the signal through `readSignal`, which marks the entry's
-* `signalRead`. Its services are erased with its data type; `runRequest`
-* provides them.
-*/
-function attempt(entry, call) {
-	const once = fromQueryFn((signal) => {
-		const result = call(() => {
-			entry.signalRead = true;
-			return signal;
+/** Subscribe to an entry's state. Subscribers are its readers: an entry with none can be gc'd. */
+function subscribeEntry(entry, listener, options) {
+	return entry.readers.subscribe(listener, options);
+}
+/** Drop the entry, aborting its request. Waiters get an `AbortError`. */
+function remove(entry) {
+	const client = entry.client;
+	if (client["~entries"].get(entry.hash) !== entry) return;
+	client["~entries"].delete(entry.hash);
+	client.clock.clearTimeout(entry.gcTimer);
+	const run = entry.run;
+	entry.run = void 0;
+	if (run) {
+		run.controller.abort();
+		run.done.resolve({
+			error: abortError(),
+			ok: false
 		});
-		entry.returnsEffect = Effect.isEffect(result);
-		if (entry.returnsEffect) entry.signalRead = true;
-		return result;
-	}).pipe(Effect.tapError(() => Effect.sync(() => set(entry, { failureCount: entry.state.failureCount + 1 }))));
-	const schedule = retrySchedule({
-		retry: behavior(entry, "retry"),
-		retryDelay: behavior(entry, "retryDelay")
-	}, entry.cache.isServer);
-	if (!schedule) return once;
-	const online = entry.cache.isServer ? Effect.void : whenOnline;
-	return Effect.suspend(() => {
-		let retrying = false;
-		let lastError;
-		const unlessStopped = (next) => Effect.suspend(() => entry.retriesStopped ? Effect.fail(lastError) : next);
-		const gated = Effect.suspend(() => {
-			if (!retrying) {
-				retrying = true;
-				return once;
-			}
-			return unlessStopped(Effect.andThen(online, unlessStopped(once)));
-		}).pipe(Effect.tapError((error) => Effect.sync(() => {
-			lastError = error;
-		})));
-		return Effect.retry(gated, Schedule.while(schedule, () => !entry.retriesStopped));
+	}
+	client["~events"].emit({
+		entry,
+		type: "removed"
 	});
 }
-function scheduleGc(entry) {
-	const gcTime = behavior(entry, "gcTime") ?? (entry.cache.isServer ? Infinity : 3e5);
-	if (isObserved(entry) || entry.inFlight || !Number.isFinite(gcTime)) {
-		entry.tasks.cancel("gc");
-		return;
-	}
-	entry.tasks.fork("gc", Effect.sleep(gcTime).pipe(Effect.andThen(Effect.sync(() => remove(entry)))));
+/** Drop data and errors. Read entries (or ones loading) refetch; resolves when they settle. */
+function reset(entry) {
+	entry.state = initialState;
+	newPending(entry);
+	notify(entry);
+	if (entry.readers.size > 0 || entry.run) return fetchEntry(entry, { restart: true });
+	return Promise.resolve({ ok: true });
 }
-function scheduleStale(entry) {
-	const state = entry.state;
-	const staleTime = behavior(entry, "staleTime") ?? 0;
-	if (entry.cache.isServer || !isObserved(entry) || state.isStale || !Number.isFinite(staleTime)) {
-		entry.tasks.cancel("stale");
-		return;
+/**
+* Record an invalidation: one stamp per target, all at one point in the
+* sequence. Entries they cover that have readers refetch now, once however
+* many stamps cover them; the rest find out when they are next read.
+* Resolves when the refetches settle.
+*/
+function invalidate(client, makeStamps) {
+	const stamps = makeStamps(++client["~seq"]);
+	const entries = [...client["~entries"].values()];
+	const oldest = Math.min(...entries.map((entry) => entry.requestedAt));
+	client["~stamps"] = [...client["~stamps"].filter((kept) => kept.at > oldest), ...stamps];
+	const refetches = [];
+	for (const entry of entries) if (stamps.some((stamp) => matches(entry, stamp))) {
+		notify(entry);
+		if (entry.readers.size > 0) refetches.push(fetchEntry(entry, { restart: true }));
 	}
-	const remaining = state.updatedAt + staleTime - now(entry);
-	entry.tasks.fork("stale", Effect.sleep(Math.max(remaining, 0) + 1).pipe(Effect.andThen(Effect.sync(() => set(entry, {})))));
+	return Promise.all(refetches).then(() => {});
 }
 //#endregion
-export { CancelledError, DisabledError, TypeId, changes, emit, entryOf, fetch, hasNextPageUnsafe, hasPreviousPageUnsafe, invalidate, isDisabled, isObserved, isQuery, isStaleUnsafe, make, metaOf, needsRefetch, onPlatformEvent, provide, readUnsafe, remove, reset, resume, revalidate, setData, setOptions, start, subscribeUnsafe };
+export { abortError, adopt, entryForKey, entryOf, fetchEntry, invalidate, isInvalidated, isStale, remove, reset, subscribeEntry, write };