@raf-query/core 0.0.18 → 0.1.0

package/dist/query.mjs

@@ -1,429 +1,119 @@
-import { scheduleNotify } from "./notify.mjs";
-import { whenOnline } from "./online.mjs";
-import { replaceEqualDeep } from "./share.mjs";
-import { fulfilled, pending } from "./thenable.mjs";
-import { Cause, Effect, Exit, Predicate, Schedule } from "effect";
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { unsafeCast } from "./cast.mjs";
+import { CancelledError as CancelledError$1, TypeId as TypeId$1, changes as changes$1, entryOf, fetch as fetch$1, hasNextPageUnsafe as hasNextPageUnsafe$1, hasPreviousPageUnsafe as hasPreviousPageUnsafe$1, invalidate as invalidate$1, isQuery as isQuery$1, isStaleUnsafe as isStaleUnsafe$1, provide, readUnsafe as readUnsafe$1, reset as reset$1, subscribeUnsafe as subscribeUnsafe$1 } from "./entry.mjs";
+import { Effect } from "effect";
+import { dual } from "effect/Function";
 //#region src/query.ts
-/** Thrown into a request's awaiters when the cache is cleared mid-request. */
-var CancelledError = class extends Error {
-	constructor() {
-		super("The query was cancelled");
-		this.name = "CancelledError";
-	}
-};
-const noop = () => {};
-const identity = (value) => value;
-const defaultObserver = {};
-function isEffectResult(result) {
-	return Effect.isEffect(result);
+/**
+* One cache entry, as a data type: a `Query` carries its key, handle and
+* options, and the functions here read it, subscribe to it and run its
+* requests. Get one from `QueryCache.getQuery(factory, input)`.
+*
+* Requests are Effects. The `*Unsafe` functions read and subscribe
+* synchronously, for renders and external stores that can't run an Effect.
+*/
+var query_exports = /* @__PURE__ */ __exportAll({
+	CancelledError: () => CancelledError,
+	TypeId: () => TypeId,
+	changes: () => changes,
+	fetch: () => fetch,
+	fetchNextPage: () => fetchNextPage,
+	fetchPreviousPage: () => fetchPreviousPage,
+	get: () => get,
+	getUnsafe: () => getUnsafe,
+	hasNextPageUnsafe: () => hasNextPageUnsafe,
+	hasPreviousPageUnsafe: () => hasPreviousPageUnsafe,
+	invalidate: () => invalidate,
+	isQuery: () => isQuery,
+	isStaleUnsafe: () => isStaleUnsafe,
+	observerCountUnsafe: () => observerCountUnsafe,
+	readUnsafe: () => readUnsafe,
+	refetch: () => refetch,
+	reset: () => reset,
+	subscribeUnsafe: () => subscribeUnsafe
+});
+const TypeId = TypeId$1;
+const CancelledError = CancelledError$1;
+const isQuery = isQuery$1;
+function typed(effect) {
+	return unsafeCast(effect);
 }
-function isInfiniteData(data) {
-	return Predicate.hasProperty(data, "pages") && Predicate.hasProperty(data, "pageParams") && Array.isArray(data.pages) && Array.isArray(data.pageParams);
+function typedState(state) {
+	return unsafeCast(state);
 }
-function shouldRetry(retry, failureCount, error) {
-	if (Predicate.isBoolean(retry)) return retry;
-	if (Predicate.isNumber(retry)) return failureCount <= retry;
-	return retry(failureCount, error);
+/**
+* Start a request, or join the one in flight. Fails with the request's
+* error, or a {@link CancelledError} if the entry leaves the cache first.
+* The entry's requests run with this fiber's services from now on, as after
+* a `QueryCache` verb.
+*/
+const fetch = dual((args) => isQuery(args[0]), (self, request) => typed(Effect.contextWith((caller) => {
+	const entry = entryOf(self);
+	provide(entry, caller);
+	return fetch$1(entry, request);
+})));
+/** Refetch now; succeeds when the request settles, whatever its outcome. */
+function refetch(self) {
+	return entryOf(self).commands.refetch;
 }
-function nextPageParam(options, data) {
-	if (data.pages.length === 0) return;
-	return options.getNextPageParam(data.pages.at(-1), data.pages, data.pageParams.at(-1), data.pageParams);
+/** Load the page after the last one; succeeds once it settles. */
+function fetchNextPage(self) {
+	return entryOf(self).commands.fetchNextPage;
 }
-function previousPageParam(options, data) {
-	if (data.pages.length === 0 || !options.getPreviousPageParam) return;
-	return options.getPreviousPageParam(data.pages[0], data.pages, data.pageParams[0], data.pageParams);
+/** Load the page before the first one; succeeds once it settles. */
+function fetchPreviousPage(self) {
+	return entryOf(self).commands.fetchPreviousPage;
 }
-function addPage(data, page, pageParam, direction, maxPages) {
-	const forward = direction === "forward";
-	const pages = forward ? [...data.pages, page] : [page, ...data.pages];
-	const pageParams = forward ? [...data.pageParams, pageParam] : [pageParam, ...data.pageParams];
-	if (maxPages === void 0 || pages.length <= maxPages) return {
-		pageParams,
-		pages
-	};
-	return forward ? {
-		pageParams: pageParams.slice(-maxPages),
-		pages: pages.slice(-maxPages)
-	} : {
-		pageParams: pageParams.slice(0, maxPages),
-		pages: pages.slice(0, maxPages)
-	};
+/** Mark stale, and refetch if read; succeeds once that refetch settles. */
+function invalidate(self) {
+	return invalidate$1(entryOf(self));
+}
+/**
+* Drop data and errors, back to the state of a new entry. Readers suspend
+* and refetch; succeeds when that refetch settles.
+*/
+function reset(self) {
+	return reset$1(entryOf(self));
+}
+/** The entry's current state. */
+function get(self) {
+	return Effect.sync(() => getUnsafe(self));
+}
+/** {@link get}, synchronously. */
+function getUnsafe(self) {
+	return typedState(entryOf(self).state);
+}
+/**
+* The entry's current state, then every change. Counts as a reader while
+* the stream runs, so invalidation and focus refetch it.
+*/
+function changes(self) {
+	return unsafeCast(changes$1(entryOf(self)));
+}
+/**
+* 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(self) {
+	return unsafeCast(readUnsafe$1(entryOf(self)));
+}
+/** Listen for state changes. Subscribed entries count as read. */
+function subscribeUnsafe(self, listener, options) {
+	return subscribeUnsafe$1(entryOf(self), listener, options);
+}
+/** Staleness as of now; `state.isStale` is only kept current while read. */
+function isStaleUnsafe(self) {
+	return isStaleUnsafe$1(entryOf(self));
+}
+function hasNextPageUnsafe(self) {
+	return hasNextPageUnsafe$1(entryOf(self));
+}
+function hasPreviousPageUnsafe(self) {
+	return hasPreviousPageUnsafe$1(entryOf(self));
+}
+/** Readers currently subscribed. */
+function observerCountUnsafe(self) {
+	return entryOf(self).listeners.size;
 }
-var QueryEntry = class {
-	hash;
-	key;
-	#errorShown = false;
-	#errorShownTimer;
-	#gcTimer;
-	#handle;
-	#host;
-	#inFlight;
-	#listeners = /* @__PURE__ */ new Map();
-	#options;
-	#pending;
-	#staleTimer;
-	#state;
-	constructor(host, key, hash) {
-		this.#host = host;
-		this.key = key;
-		this.hash = hash;
-		this.#handle = {
-			input: void 0,
-			key
-		};
-		this.#pending = pending();
-		this.#state = {
-			data: void 0,
-			error: null,
-			failureCount: 0,
-			fetchDirection: void 0,
-			hasData: false,
-			isFetching: false,
-			isInvalidated: false,
-			isStale: true,
-			promise: this.#pending.promise,
-			status: "pending",
-			updatedAt: 0
-		};
-		this.#scheduleGc();
-	}
-	get handle() {
-		return this.#handle;
-	}
-	get options() {
-		return this.#options;
-	}
-	/** Readers are subscribed; `invalidate` and focus refetch only what is read. */
-	get isObserved() {
-		return this.#listeners.size > 0;
-	}
-	get observerCount() {
-		return this.#listeners.size;
-	}
-	getState = () => this.#state;
-	isStaleNow = () => this.#computeStale(this.#state);
-	subscribe = (listener, observer = defaultObserver) => {
-		this.#listeners.set(listener, observer);
-		this.#clearGc();
-		this.#scheduleStale();
-		this.#host.observersChanged(this);
-		return () => {
-			if (!this.#listeners.delete(listener)) return;
-			if (this.#listeners.size === 0) {
-				clearTimeout(this.#staleTimer);
-				this.#scheduleGc();
-			}
-			this.#host.observersChanged(this);
-		};
-	};
-	/** Attach the options and input of the latest factory call. */
-	setOptions(options, input) {
-		this.#options = options;
-		if (this.#handle.input !== input) this.#handle = {
-			input,
-			key: this.key
-		};
-	}
-	read = () => {
-		const state = this.#state;
-		if (!state.hasData && !state.isFetching) {
-			if (state.status !== "error" || this.#errorShown) this.fetch().catch(noop);
-			else this.#markErrorShown();
-		}
-		return this.#state.promise;
-	};
-	fetch = (request = {}) => {
-		const options = this.#options;
-		const inFlight = this.#inFlight;
-		if (inFlight && !(request.restart && options)) {
-			if (request.direction) {
-				const next = () => this.fetch(request);
-				return inFlight.deferred.promise.then(next, next);
-			}
-			return inFlight.deferred.promise;
-		}
-		if (!options) return this.#state.promise;
-		inFlight?.controller.abort();
-		return this.#start(this.#request(options, request), request.direction);
-	};
-	refetch = () => this.fetch().then(noop, noop);
-	fetchNextPage = () => this.fetch({ direction: "forward" }).then(noop, noop);
-	fetchPreviousPage = () => this.fetch({ direction: "backward" }).then(noop, noop);
-	hasNextPage = () => {
-		const options = this.#options;
-		const data = this.#state.data;
-		return options?.kind === "infinite" && isInfiniteData(data) && nextPageParam(options, data) != null;
-	};
-	hasPreviousPage = () => {
-		const options = this.#options;
-		const data = this.#state.data;
-		return options?.kind === "infinite" && isInfiniteData(data) && previousPageParam(options, data) != null;
-	};
-	invalidate = () => {
-		this.#set({ isInvalidated: true });
-		if (!this.isObserved || !this.#options) return Promise.resolve();
-		return this.fetch({ restart: true }).then(noop, noop);
-	};
-	reset = () => {
-		clearTimeout(this.#errorShownTimer);
-		this.#errorShownTimer = void 0;
-		this.#errorShown = false;
-		this.#pending ??= pending();
-		this.#set({
-			data: void 0,
-			error: null,
-			failureCount: 0,
-			hasData: false,
-			isInvalidated: false,
-			promise: this.#pending.promise,
-			status: "pending",
-			updatedAt: 0
-		});
-		if (!this.#options || !this.isObserved && !this.#inFlight) return Promise.resolve();
-		return this.fetch({ restart: true }).then(noop, noop);
-	};
-	/** Write data directly, as if a request had returned it. */
-	setData(data, updatedAt = Date.now()) {
-		this.#succeed(data, updatedAt);
-	}
-	/** Adopt a request started elsewhere (the server's, during hydration). */
-	resume(promise) {
-		if (this.#state.hasData || this.#inFlight) return;
-		this.#start(Effect.tryPromise({
-			catch: identity,
-			try: () => Promise.resolve(promise)
-		}), void 0).catch(noop);
-	}
-	/** Refetch a read, stale entry whose readers want it on this event. */
-	onWindowEvent(event) {
-		const option = event === "focus" ? "refetchOnWindowFocus" : "refetchOnReconnect";
-		const fallback = this.#behavior(option) ?? true;
-		if ([...this.#listeners.values()].some((observer) => observer[option] ?? fallback) && this.#computeStale(this.#state)) this.fetch().catch(noop);
-	}
-	/** Stop timers and abort the in-flight request; the entry is leaving the cache. */
-	destroy() {
-		clearTimeout(this.#gcTimer);
-		clearTimeout(this.#staleTimer);
-		clearTimeout(this.#errorShownTimer);
-		const inFlight = this.#inFlight;
-		this.#inFlight = void 0;
-		if (inFlight) {
-			inFlight.controller.abort();
-			inFlight.deferred.reject(new CancelledError());
-		}
-	}
-	#behavior(name) {
-		return this.#options?.[name] ?? this.#host.defaults[name];
-	}
-	#computeStale(state) {
-		if (state.isInvalidated || !state.hasData) return true;
-		const staleTime = this.#behavior("staleTime") ?? 0;
-		return Date.now() - state.updatedAt >= staleTime;
-	}
-	#set(patch) {
-		const next = {
-			...this.#state,
-			...patch
-		};
-		this.#state = {
-			...next,
-			isStale: this.#computeStale(next)
-		};
-		for (const listener of this.#listeners.keys()) scheduleNotify(listener);
-		this.#host.changed(this);
-		this.#scheduleStale();
-	}
-	#start(request, direction) {
-		const deferred = this.#inFlight?.deferred ?? pending();
-		const run = {
-			controller: new AbortController(),
-			deferred
-		};
-		this.#inFlight = run;
-		this.#clearGc();
-		if (!this.#state.hasData && this.#state.status === "error") {
-			this.#pending = pending();
-			this.#set({
-				error: null,
-				failureCount: 0,
-				fetchDirection: direction,
-				isFetching: true,
-				promise: this.#pending.promise,
-				status: "pending"
-			});
-		} else this.#set({
-			failureCount: 0,
-			fetchDirection: direction,
-			isFetching: true
-		});
-		Effect.runPromiseExit(request, { signal: run.controller.signal }).then((exit) => this.#settle(run, exit), noop);
-		return deferred.promise;
-	}
-	#settle(run, exit) {
-		if (this.#inFlight !== run) return;
-		this.#inFlight = void 0;
-		if (Exit.isSuccess(exit)) run.deferred.resolve(this.#succeed(exit.value, Date.now()));
-		else if (Cause.hasInterruptsOnly(exit.cause)) {
-			this.#set({
-				fetchDirection: void 0,
-				isFetching: false
-			});
-			run.deferred.reject(new CancelledError());
-		} else {
-			const error = Cause.squash(exit.cause);
-			this.#fail(error);
-			run.deferred.reject(error);
-		}
-		this.#scheduleGc();
-	}
-	#succeed(next, updatedAt) {
-		const previous = this.#state;
-		const data = previous.hasData && this.#behavior("structuralSharing") !== false ? replaceEqualDeep(previous.data, next) : next;
-		const firstLoad = this.#pending;
-		this.#pending = void 0;
-		firstLoad?.resolve(data);
-		const unchanged = previous.hasData && data === previous.data;
-		this.#set({
-			data,
-			error: null,
-			failureCount: 0,
-			fetchDirection: void 0,
-			hasData: true,
-			isFetching: false,
-			isInvalidated: false,
-			promise: firstLoad?.promise ?? (unchanged ? previous.promise : fulfilled(data)),
-			status: "success",
-			updatedAt
-		});
-		return data;
-	}
-	#fail(error) {
-		this.#host.reportError(error, this);
-		if (!this.#state.hasData) {
-			const firstLoad = this.#pending;
-			this.#pending = void 0;
-			firstLoad?.reject(error);
-			this.#errorShown = false;
-		}
-		this.#set({
-			error,
-			fetchDirection: void 0,
-			isFetching: false,
-			status: "error"
-		});
-	}
-	/**
-	* 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.
-	*/
-	#markErrorShown() {
-		if (this.#errorShownTimer !== void 0) return;
-		this.#errorShownTimer = setTimeout(() => {
-			this.#errorShownTimer = void 0;
-			this.#errorShown = true;
-		}, 0);
-	}
-	#request(options, request) {
-		if (options.kind === "query") return this.#attempt((signal) => options.queryFn({
-			queryKey: options.queryKey,
-			signal
-		}));
-		return this.#pagedRequest(options, request);
-	}
-	#pagedRequest(options, request) {
-		const current = isInfiniteData(this.#state.data) ? this.#state.data : void 0;
-		const fetchPage = (pageParam, direction) => this.#attempt((signal) => options.queryFn({
-			direction,
-			pageParam,
-			queryKey: options.queryKey,
-			signal
-		}));
-		return Effect.gen(function* () {
-			if (request.direction && current) {
-				const pageParam = request.direction === "forward" ? nextPageParam(options, current) : previousPageParam(options, current);
-				if (pageParam == null) return current;
-				const page = yield* fetchPage(pageParam, request.direction);
-				return addPage(current, page, pageParam, request.direction, options.maxPages);
-			}
-			const count = Math.max(request.pages ?? 1, current?.pages.length ?? 0);
-			let data = {
-				pageParams: [],
-				pages: []
-			};
-			let pageParam = current && current.pageParams.length > 0 ? current.pageParams[0] : options.initialPageParam;
-			for (let index = 0; index < count; index++) {
-				if (index > 0) {
-					const next = nextPageParam(options, data);
-					if (next == null) break;
-					pageParam = next;
-				}
-				const page = yield* fetchPage(pageParam, "forward");
-				data = addPage(data, page, pageParam, "forward", options.maxPages);
-			}
-			return data;
-		});
-	}
-	/** One request: run the `queryFn` with a fresh signal, retrying per policy. */
-	#attempt(call) {
-		const once = Effect.suspend(() => {
-			const controller = new AbortController();
-			return Effect.try({
-				catch: identity,
-				try: () => call(controller.signal)
-			}).pipe(Effect.flatMap((result) => isEffectResult(result) ? result : Effect.tryPromise({
-				catch: identity,
-				try: () => Promise.resolve(result)
-			})), Effect.onInterrupt(() => Effect.sync(() => controller.abort())));
-		});
-		return this.#withRetry(once);
-	}
-	#withRetry(once) {
-		const retry = this.#behavior("retry") ?? (this.#host.isServer ? 0 : 3);
-		const countFailure = Effect.sync(() => this.#set({ failureCount: this.#state.failureCount + 1 }));
-		const counted = once.pipe(Effect.tapError(() => countFailure));
-		const online = this.#host.isServer ? Effect.void : whenOnline;
-		if (Schedule.isSchedule(retry)) return Effect.suspend(() => {
-			let first = true;
-			const each = Effect.suspend(() => {
-				const wait = first ? Effect.void : online;
-				first = false;
-				return wait.pipe(Effect.andThen(counted));
-			});
-			return Effect.retry(each, retry);
-		});
-		const retryDelay = this.#behavior("retryDelay");
-		const delayFor = (failureCount, error) => {
-			if (retryDelay === void 0) return Math.min(1e3 * 2 ** (failureCount - 1), 3e4);
-			return Predicate.isNumber(retryDelay) ? retryDelay : retryDelay(failureCount, error);
-		};
-		const attempt = counted.pipe(Effect.catch((error) => {
-			const failureCount = this.#state.failureCount;
-			if (!shouldRetry(retry, failureCount, error)) return Effect.fail(error);
-			return Effect.sleep(delayFor(failureCount, error)).pipe(Effect.andThen(online), Effect.andThen(Effect.suspend(() => attempt)));
-		}));
-		return attempt;
-	}
-	#clearGc() {
-		clearTimeout(this.#gcTimer);
-		this.#gcTimer = void 0;
-	}
-	#scheduleGc() {
-		this.#clearGc();
-		if (this.isObserved || this.#inFlight) return;
-		const gcTime = this.#behavior("gcTime") ?? (this.#host.isServer ? Infinity : 3e5);
-		if (Number.isFinite(gcTime)) this.#gcTimer = setTimeout(() => this.#host.remove(this), gcTime);
-	}
-	#scheduleStale() {
-		clearTimeout(this.#staleTimer);
-		const state = this.#state;
-		if (this.#host.isServer || !this.isObserved || state.isStale) return;
-		const staleTime = this.#behavior("staleTime") ?? 0;
-		if (!Number.isFinite(staleTime)) return;
-		const remaining = state.updatedAt + staleTime - Date.now();
-		this.#staleTimer = setTimeout(() => this.#set({}), Math.max(remaining, 0) + 1);
-	}
-};
 //#endregion
-export { CancelledError, QueryEntry, isInfiniteData, nextPageParam, previousPageParam };
+export { CancelledError, TypeId, changes, fetch, fetchNextPage, fetchPreviousPage, get, getUnsafe, hasNextPageUnsafe, hasPreviousPageUnsafe, invalidate, isQuery, isStaleUnsafe, observerCountUnsafe, query_exports, readUnsafe, refetch, reset, subscribeUnsafe };

package/dist/request.mjs

@@ -0,0 +1,47 @@
+import { Context, Effect, Scope } from "effect";
+//#region src/request.ts
+function isEffectResult(result) {
+	return Effect.isEffect(result);
+}
+/**
+* One `queryFn` call as an Effect. The signal it gets aborts when the fiber
+* is interrupted; a returned Effect runs in the same fiber, so interrupting
+* the request interrupts it. Plain values settle like promises, a microtask
+* later. A `queryFn` that throws instead of returning is a defect, as in
+* `Effect.sync`.
+*/
+function fromQueryFn(call) {
+	return Effect.callback((resume, signal) => {
+		let result;
+		try {
+			result = call(signal);
+		} catch (error) {
+			resume(Effect.die(error));
+			return;
+		}
+		if (isEffectResult(result)) {
+			resume(result);
+			return;
+		}
+		Promise.resolve(result).then((value) => resume(Effect.succeed(value)), (error) => resume(Effect.fail(error)));
+	});
+}
+/**
+* The services a request runs with: the cache's, under those of the verb
+* that last called for the entry. The caller's `Scope` is left out: a
+* request outlives the call that started it.
+*/
+function requestServices(cache, caller) {
+	return Context.merge(cache, Context.omit(Scope.Scope)(caller));
+}
+/**
+* A request as it runs: in a `raf-query.request` span, with `services`,
+* which hold what its `queryFn` Effect needs (entries erase that type with
+* the data's). Typed failures become the query's error; defects are logged
+* too, since nothing else reports them.
+*/
+function runRequest(request, hash, services) {
+	return request.pipe(Effect.tapDefect((defect) => Effect.logError("raf-query: queryFn died", defect)), Effect.withSpan("raf-query.request", { attributes: { "raf_query.hash": hash } }), Effect.provideContext(services));
+}
+//#endregion
+export { fromQueryFn, requestServices, runRequest };

package/dist/retry.mjs

@@ -0,0 +1,25 @@
+import { Effect, Predicate, Schedule } from "effect";
+//#region src/retry.ts
+/** Doubling from 1 s, at most 30 s. */
+const defaultDelays = Schedule.min([Schedule.exponential("1 second"), Schedule.spaced("30 seconds")]);
+function delays(retryDelay) {
+	if (retryDelay === void 0) return defaultDelays;
+	if (Predicate.isNumber(retryDelay)) return Schedule.spaced(retryDelay);
+	return Schedule.forever.pipe(Schedule.modifyDelay((step) => Effect.succeed(retryDelay(step.attempt, step.input))));
+}
+/**
+* A query's retry options as one `Schedule`, or `undefined` when it doesn't
+* retry. `retryDelay` sets the delays; a count or predicate in `retry` stops
+* the schedule, given the attempt number (1 after the first failure) and the
+* error.
+*/
+function retrySchedule(behavior, isServer) {
+	const retry = behavior.retry ?? (isServer ? 0 : 3);
+	if (Schedule.isSchedule(retry)) return retry;
+	if (retry === false || retry === 0) return;
+	const schedule = delays(behavior.retryDelay);
+	if (retry === true) return schedule;
+	return schedule.pipe(Schedule.while((step) => Predicate.isNumber(retry) ? step.attempt <= retry : retry(step.attempt, step.input)));
+}
+//#endregion
+export { retrySchedule };

package/dist/thenable.d.mts

@@ -0,0 +1,29 @@
+//#region src/thenable.d.ts
+/**
+ * Promises that carry their own result, in the fields React's `use()` reads
+ * before suspending (`status`, `value`, `reason`). A settled one can be read
+ * synchronously, so React renders it without a fallback.
+ */
+interface PendingStatus {
+  readonly status: "pending";
+}
+interface FulfilledStatus<T> {
+  readonly status: "fulfilled";
+  readonly value: T;
+}
+interface RejectedStatus {
+  readonly reason: unknown;
+  readonly status: "rejected";
+}
+/**
+ * A promise that says whether it has settled, and with what. `status` moves
+ * from `"pending"` to `"fulfilled"` (with `value`) or `"rejected"` (with
+ * `reason`) once, when the promise settles.
+ */
+export type Thenable<T> = Promise<T> & (FulfilledStatus<T> | PendingStatus | RejectedStatus);
+export interface Pending<T> {
+  readonly promise: Thenable<T>;
+  reject(reason: unknown): void;
+  resolve(value: T): void;
+}
+//#endregion

package/dist/thenable.mjs

@@ -1,8 +1,8 @@
 //#region src/thenable.ts
 /**
-* Promises that React's `use()` can read synchronously. React checks
-* `status` / `value` / `reason` on a thenable before suspending, so a
-* settled one renders without a fallback.
+* Promises that carry their own result, in the fields React's `use()` reads
+* before suspending (`status`, `value`, `reason`). A settled one can be read
+* synchronously, so React renders it without a fallback.
 */
 const noop = () => {};
 function fulfilled(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/core",
-  "version": "0.0.18",
+  "version": "0.1.0",
   "description": "Framework-agnostic core of raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",

package/dist/all-keyed.d.mts

@@ -1,18 +0,0 @@
-//#region src/all-keyed.d.ts
-/** The resolved form of a record passed to {@link allKeyed}. */
-export type Settled<TRecord> = { -readonly [TKey in keyof TRecord]: Awaited<TRecord[TKey]>; };
-/**
- * Ponyfill of the TC39 `Promise.allKeyed` proposal: a record of promises in,
- * a promise of the same record out, rejecting on the first failure.
- *
- * ```ts
- * const data = await allKeyed({
- *   post: qc.ensure(postQuery, { slug }),
- *   author: qc.ensure(authorQuery, { slug }),
- * });
- * ```
- */
-export declare function allKeyed<TRecord extends {
-  readonly [key: string]: unknown;
-}>(record: TRecord): Promise<Settled<TRecord>>;
-//#endregion