@raf-query/core 0.10.1 → 0.10.3

package/CHANGELOG.md

@@ -1,14 +1,27 @@
 # Changelog
 
+## [0.10.3](https://github.com/KATT/raf-query/compare/0.10.2...0.10.3) (2026-10-16)
+
+### Features
+
+* **core:** add QueryBinding, a framework-free useQuery for bindings ([#197](https://github.com/KATT/raf-query/issues/197)) ([4865802](https://github.com/KATT/raf-query/commit/48658024f4d21d43ce8274de379a19c8898b6173)), references [#194](https://github.com/KATT/raf-query/issues/194)
+
+## [0.10.2](https://github.com/KATT/raf-query/compare/0.10.1...0.10.2) (2026-10-16)
+
+### Features
+
+- **react:** re-render useQuery readers of the thenable's status when the first load settles (2/3) ([#198](https://github.com/KATT/raf-query/issues/198)) ([436d83c](https://github.com/KATT/raf-query/commit/436d83cfd6a3944265eb56d5597c322342c5a6c6))
+- **react:** type useQuery's promise as a Thenable (1/3) ([#200](https://github.com/KATT/raf-query/issues/200)) ([47e5309](https://github.com/KATT/raf-query/commit/47e530957565a2bd345642ae7a4be5d3c501ffb2))
+
 ## [0.10.1](https://github.com/KATT/raf-query/compare/0.10.0...0.10.1) (2026-10-16)
 
 ### Features
 
-* **core:** export QueryClient, dehydrate, hydrate, allKeyed and the useQuery controls from @raf-query/core ([#193](https://github.com/KATT/raf-query/issues/193)) ([54492ab](https://github.com/KATT/raf-query/commit/54492abbe2966a0645e8a4c77f9c5ab31d6e3a20)), references [#194](https://github.com/KATT/raf-query/issues/194)
+- **core:** export QueryClient, dehydrate, hydrate, allKeyed and the useQuery controls from @raf-query/core ([#193](https://github.com/KATT/raf-query/issues/193)) ([54492ab](https://github.com/KATT/raf-query/commit/54492abbe2966a0645e8a4c77f9c5ab31d6e3a20)), references [#194](https://github.com/KATT/raf-query/issues/194)
 
 ### Documentation
 
-* React Router client-only and server sections with one server client per request, Effect under Integrations, official docs links, and ensure waits like fetch in server-only code ([#192](https://github.com/KATT/raf-query/issues/192)) ([841ffcf](https://github.com/KATT/raf-query/commit/841ffcf4d0fa0a40dfc58dc65bfcfadca8948874)), references [#190](https://github.com/KATT/raf-query/issues/190)
+- React Router client-only and server sections with one server client per request, Effect under Integrations, official docs links, and ensure waits like fetch in server-only code ([#192](https://github.com/KATT/raf-query/issues/192)) ([841ffcf](https://github.com/KATT/raf-query/commit/841ffcf4d0fa0a40dfc58dc65bfcfadca8948874)), references [#190](https://github.com/KATT/raf-query/issues/190)
 
 ## [0.10.0](https://github.com/KATT/raf-query/compare/0.9.2...0.10.0) (2026-10-16)
 

package/dist/binding.d.mts

@@ -0,0 +1,92 @@
+import { QueryFactory, QueryHandle } from "./options.mjs";
+import { Query, query_d_exports } from "./query.mjs";
+import { QueryClient } from "./client.mjs";
+import { Options, QueryObserver, observer_d_exports } from "./observer.mjs";
+import { ReadValue, UseQueryControls, UseQueryOptions, UseQueryThrowOptions } from "./controls.mjs";
+declare namespace binding_d_exports {
+  export { Hooks, QueryBinding, ReadOptions, Result, ResultWithData, Source, makeUnsafe, observerOptions, queryFor, subscribeUnsafe, syncUnsafe };
+}
+/** A read's options: the observer's, and `throwOnError` for typed errors. */
+export type ReadOptions<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = UseQueryOptions & UseQueryThrowOptions<TFactory> & {
+  readonly throwOnError?: TThrow;
+};
+/**
+ * What a binding's `useQuery` returns: the query's controls, the `promise`
+ * of the data to show, and that `data` once it's there. Each property is a
+ * getter that calls {@link Hooks.track}, so destructuring reads it once.
+ */
+export type Result<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = UseQueryControls<TFactory> & {
+  /** The promise's data once it has settled, else `undefined`. */
+  readonly data: ReadValue<TFactory, TThrow> | undefined;
+  /**
+   * Settles with the data to show. A new promise per data version, already
+   * settled once the cache has data.
+   */
+  readonly promise: Promise<ReadValue<TFactory, TThrow>>;
+};
+/** {@link Result} for a handle from `ensure` or `fetch`. */
+export type ResultWithData<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = Result<TFactory, TThrow> & {
+  /** The query's data. The handle's `data` until the cache has data again. */
+  readonly data: ReadValue<TFactory, TThrow>;
+};
+/** How a framework plugs into a binding. */
+export interface Hooks {
+  /**
+   * Runs when the result changed: a property something read, or a pending
+   * promise something read settling in place. Typically bumps the version.
+   */
+  readonly notify: () => void;
+  /**
+   * Runs on every read of the result, before the read, so the framework
+   * re-runs whatever read it after {@link Hooks.notify}. Typically reads a
+   * version signal.
+   */
+  readonly track: () => void;
+  /**
+   * Runs cache writes (starting a read can notify observers synchronously)
+   * outside the framework's tracking. Default: runs `f` as is.
+   */
+  readonly untracked?: <A>(f: () => A) => A;
+}
+/** Where a binding reads its handle and options from. */
+export interface Source<TFactory extends QueryFactory> {
+  readonly handle: () => QueryHandle<TFactory>;
+  readonly options: () => UseQueryOptions & {
+    readonly throwOnError?: boolean;
+  };
+}
+/** One component's read of a query. */
+export interface QueryBinding<TFactory extends QueryFactory = QueryFactory> {
+  readonly client: QueryClient<unknown>;
+  readonly observer: QueryObserver<TFactory>;
+  /** The result, the same object for the binding's life. */
+  readonly result: Result<TFactory, boolean>;
+}
+/**
+ * The query a handle points at. Calls the factory, so callers keep it for
+ * as long as the handle is the same.
+ */
+export declare function queryFor<TFactory extends QueryFactory>(client: QueryClient<unknown>, factory: TFactory, handle: QueryHandle<TFactory>): Query<TFactory>;
+/** The observer's part of a read's options. */
+export declare function observerOptions(options: UseQueryOptions): Options;
+/**
+ * Bind `factory` to the handle and options `source` returns. Reads the
+ * query and observes it, but doesn't subscribe: call {@link subscribeUnsafe}
+ * where the framework mounts, in the browser.
+ */
+export declare function makeUnsafe<TFactory extends QueryFactory>(client: QueryClient<unknown>, factory: TFactory, source: Source<TFactory>, hooks: Hooks): QueryBinding<TFactory>;
+/**
+ * Follow the source: switch to a new handle's query, or new options. Reads
+ * call it themselves, so markup that reads before the framework's effects
+ * run still sees the new query. Bindings also call it from an effect, so a
+ * new handle is observed even when nothing reads the result.
+ */
+export declare function syncUnsafe<TFactory extends QueryFactory>(self: QueryBinding<TFactory>): void;
+/**
+ * Notify {@link Hooks.notify} on result changes from now on. A server
+ * render reads once and never unmounts, so bindings call it in the browser
+ * only. Returns the unsubscribe.
+ */
+export declare function subscribeUnsafe<TFactory extends QueryFactory>(self: QueryBinding<TFactory>): () => void;
+//#endregion
+export { binding_d_exports };

package/dist/binding.mjs

@@ -0,0 +1,186 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { hashKey } from "./key.mjs";
+import { readUnsafe } from "./query.mjs";
+import { promiseControls, resultThenable } from "./controls.mjs";
+import { getOptimisticResultUnsafe, getUnsafe, makeUnsafe as makeUnsafe$1, setOptionsUnsafe, subscribeUnsafe as subscribeUnsafe$1, trackProp } from "./observer.mjs";
+import { Result } from "effect";
+//#region src/binding.ts
+/**
+* What a framework's `useQuery` does, without the framework: one observer
+* per component, following the handle and options it reads through
+* getters, and a result of getters over the observer. A binding supplies
+* {@link Hooks}: how a read is tracked, how a change is announced, and how
+* cache writes run outside the framework's tracking. The Vue and Svelte
+* packages are this plus their reactivity and lifecycle.
+*
+* Synchronous throughout, for renders.
+*/
+var binding_exports = /* @__PURE__ */ __exportAll({
+	makeUnsafe: () => makeUnsafe,
+	observerOptions: () => observerOptions,
+	queryFor: () => queryFor,
+	subscribeUnsafe: () => subscribeUnsafe,
+	syncUnsafe: () => syncUnsafe
+});
+/**
+* The query a handle points at. Calls the factory, so callers keep it for
+* as long as the handle is the same.
+*/
+function queryFor(client, factory, handle) {
+	const args = [handle.input];
+	return client.getQuery(factory, ...args);
+}
+/** The observer's part of a read's options. */
+function observerOptions(options) {
+	return {
+		refetchInterval: options.refetchInterval,
+		refetchOnReconnect: options.refetchOnReconnect,
+		refetchOnWindowFocus: options.refetchOnWindowFocus,
+		whilePending: options.whilePending
+	};
+}
+function sameObserverOptions(a, b) {
+	return a.refetchInterval === b.refetchInterval && a.refetchOnReconnect === b.refetchOnReconnect && a.refetchOnWindowFocus === b.refetchOnWindowFocus && a.whilePending === b.whilePending;
+}
+function stateOf(self) {
+	return self;
+}
+const runNow = (f) => f();
+/**
+* Bind `factory` to the handle and options `source` returns. Reads the
+* query and observes it, but doesn't subscribe: call {@link subscribeUnsafe}
+* where the framework mounts, in the browser.
+*/
+function makeUnsafe(client, factory, source, hooks) {
+	return (hooks.untracked ?? runNow)(() => {
+		const handle = source.handle();
+		const query = queryFor(client, factory, handle);
+		const options = observerOptions(source.options());
+		readUnsafe(query);
+		const state = {
+			awaited: /* @__PURE__ */ new WeakSet(),
+			client,
+			factory,
+			handle,
+			hooks,
+			observer: makeUnsafe$1(query, options),
+			options,
+			query,
+			source
+		};
+		return Object.assign(state, { result: resultOf(state) });
+	});
+}
+/**
+* Follow the source: switch to a new handle's query, or new options. Reads
+* call it themselves, so markup that reads before the framework's effects
+* run still sees the new query. Bindings also call it from an effect, so a
+* new handle is observed even when nothing reads the result.
+*/
+function syncUnsafe(self) {
+	sync(stateOf(self));
+}
+function sync(impl) {
+	const handle = impl.source.handle();
+	const options = observerOptions(impl.source.options());
+	const newQuery = handle !== impl.handle && hashKey(handle.key) !== impl.query.hash;
+	impl.handle = handle;
+	if (!newQuery && sameObserverOptions(options, impl.options)) return;
+	(impl.hooks.untracked ?? runNow)(() => {
+		if (newQuery) {
+			impl.query = queryFor(impl.client, impl.factory, handle);
+			readUnsafe(impl.query);
+		}
+		impl.options = options;
+		setOptionsUnsafe(impl.observer, impl.query, options);
+	});
+}
+/**
+* Notify {@link Hooks.notify} on result changes from now on. A server
+* render reads once and never unmounts, so bindings call it in the browser
+* only. Returns the unsubscribe.
+*/
+function subscribeUnsafe(self) {
+	const impl = stateOf(self);
+	return subscribeUnsafe$1(impl.observer, impl.hooks.notify);
+}
+function resultOf(impl) {
+	const { hooks, observer } = impl;
+	function read(name) {
+		sync(impl);
+		hooks.track();
+		trackProp(observer, name);
+		return impl.client.isServer ? getOptimisticResultUnsafe(observer, impl.query, impl.options) : getUnsafe(observer);
+	}
+	function throwOnError() {
+		return impl.source.options().throwOnError ?? impl.client.throwOnError;
+	}
+	function shown() {
+		const promise = read("promise").promise;
+		if (promise.status === "pending" && !impl.awaited.has(promise)) {
+			impl.awaited.add(promise);
+			promise.then(hooks.notify, hooks.notify);
+		}
+		return throwOnError() ? promise : resultThenable(promise);
+	}
+	function controls() {
+		return promiseControls(getUnsafe(observer));
+	}
+	return {
+		get data() {
+			const promise = shown();
+			if (promise.status === "fulfilled") return promise.value;
+			const handle = impl.handle;
+			if (!("data" in handle)) return;
+			const data = handle.data;
+			return throwOnError() ? data : Result.succeed(data);
+		},
+		get error() {
+			return read("error").error;
+		},
+		fetchNextPage: () => controls().fetchNextPage(),
+		fetchPreviousPage: () => controls().fetchPreviousPage(),
+		get hash() {
+			return read("hash").hash;
+		},
+		get hasNextPage() {
+			return read("hasNextPage").hasNextPage;
+		},
+		get hasPreviousPage() {
+			return read("hasPreviousPage").hasPreviousPage;
+		},
+		get input() {
+			return read("input").input;
+		},
+		get isFetching() {
+			return read("isFetching").isFetching;
+		},
+		get isFetchingNextPage() {
+			return read("isFetchingNextPage").isFetchingNextPage;
+		},
+		get isFetchingPreviousPage() {
+			return read("isFetchingPreviousPage").isFetchingPreviousPage;
+		},
+		get isPending() {
+			return read("isPending").isPending;
+		},
+		get isPrevious() {
+			return read("isPrevious").isPrevious;
+		},
+		get isStale() {
+			return read("isStale").isStale;
+		},
+		get key() {
+			return read("key").key;
+		},
+		get promise() {
+			return shown();
+		},
+		refetch: () => controls().refetch(),
+		get updatedAt() {
+			return read("updatedAt").updatedAt;
+		}
+	};
+}
+//#endregion
+export { binding_exports, makeUnsafe, observerOptions, queryFor, subscribeUnsafe, syncUnsafe };

package/dist/index.d.mts

@@ -9,4 +9,5 @@ import { cache_d_exports } from "./cache.mjs";
 import { QueryClient, QueryClientConfig, dehydrate, hydrate } from "./client.mjs";
 import { observer_d_exports } from "./observer.mjs";
 import { HasTypedError, PagingControls, PromiseControls, QueryControls, ReadValue, ThrowsOnError, UseQueryControls, UseQueryOptions, UseQueryThrowOptions, promiseControls, resultThenable } from "./controls.mjs";
-export { type AnyQueryOptions, type DataOf, type DehydrateOptions, type DehydratedQuery, type DehydratedResult, type DehydratedState, type DehydratedStream, type ErrorOf, type HasTypedError, type HydrateOptions, type InfiniteData, type InfiniteQueryOptions, type InfiniteQueryTypes, type InputArgs, type InputOf, type IsPaged, type LoadOptions, type PageFunctionContext, type PageOf, type PagedQueryFactory, type PagingControls, type Pending, platform_d_exports as Platform, type PromiseControls, query_d_exports as Query, type QueryBehavior, cache_d_exports as QueryCache, QueryClient, type QueryClientConfig, type QueryControls, type QueryFactory, type QueryFnResult, type QueryFunctionContext, type QueryHandle, type QueryHandleWithData, type QueryKey, type QueryMeta, observer_d_exports as QueryObserver, type QueryOptions, type QueryTypes, type ReadValue, RedactedError, type Register, type RetryPolicy, type ServicesOf, type Settled, type Thenable, type ThrowsOnError, type UseQueryControls, type UseQueryOptions, type UseQueryThrowOptions, allKeyed, canDehydrate, dehydrate, dehydrateQuery, fulfilled, hashKey, hydrate, infiniteQueryOptions, matchesKey, pending, promiseControls, queryOptions, resultThenable };
+import { binding_d_exports } from "./binding.mjs";
+export { type AnyQueryOptions, type DataOf, type DehydrateOptions, type DehydratedQuery, type DehydratedResult, type DehydratedState, type DehydratedStream, type ErrorOf, type HasTypedError, type HydrateOptions, type InfiniteData, type InfiniteQueryOptions, type InfiniteQueryTypes, type InputArgs, type InputOf, type IsPaged, type LoadOptions, type PageFunctionContext, type PageOf, type PagedQueryFactory, type PagingControls, type Pending, platform_d_exports as Platform, type PromiseControls, query_d_exports as Query, type QueryBehavior, binding_d_exports as QueryBinding, cache_d_exports as QueryCache, QueryClient, type QueryClientConfig, type QueryControls, type QueryFactory, type QueryFnResult, type QueryFunctionContext, type QueryHandle, type QueryHandleWithData, type QueryKey, type QueryMeta, observer_d_exports as QueryObserver, type QueryOptions, type QueryTypes, type ReadValue, RedactedError, type Register, type RetryPolicy, type ServicesOf, type Settled, type Thenable, type ThrowsOnError, type UseQueryControls, type UseQueryOptions, type UseQueryThrowOptions, allKeyed, canDehydrate, dehydrate, dehydrateQuery, fulfilled, hashKey, hydrate, infiniteQueryOptions, matchesKey, pending, promiseControls, queryOptions, resultThenable };

package/dist/index.mjs

@@ -9,4 +9,5 @@ import { cache_exports } from "./cache.mjs";
 import { QueryClient, dehydrate, hydrate } from "./client.mjs";
 import { promiseControls, resultThenable } from "./controls.mjs";
 import { observer_exports } from "./observer.mjs";
-export { platform_exports as Platform, query_exports as Query, cache_exports as QueryCache, QueryClient, observer_exports as QueryObserver, RedactedError, allKeyed, canDehydrate, dehydrate, dehydrateQuery, fulfilled, hashKey, hydrate, infiniteQueryOptions, matchesKey, pending, promiseControls, queryOptions, resultThenable };
+import { binding_exports } from "./binding.mjs";
+export { platform_exports as Platform, query_exports as Query, binding_exports as QueryBinding, cache_exports as QueryCache, QueryClient, observer_exports as QueryObserver, RedactedError, allKeyed, canDehydrate, dehydrate, dehydrateQuery, fulfilled, hashKey, hydrate, infiniteQueryOptions, matchesKey, pending, promiseControls, queryOptions, resultThenable };

package/dist/observer.d.mts

@@ -4,7 +4,7 @@ import { Thenable } from "./thenable.mjs";
 import { Query, query_d_exports } from "./query.mjs";
 import { Effect, Pipeable, Stream } from "effect";
 declare namespace observer_d_exports {
-  export { Options, QueryObserver, Result$1 as Result, ResultKey, TypeId, changes, get, getOptimisticResultUnsafe, getUnsafe, isQueryObserver, make, makeUnsafe, setOptionsUnsafe, subscribeUnsafe, trackProp, trackResult };
+  export { Options, QueryObserver, Result$1 as Result, ResultKey, TypeId, changes, get, getOptimisticResultUnsafe, getUnsafe, isQueryObserver, make, makeUnsafe, setOptionsUnsafe, subscribeUnsafe, trackProp, trackResult, trackThenable };
 }
 export declare const TypeId = "~@raf-query/core/QueryObserver";
 export type TypeId = typeof TypeId;
@@ -96,6 +96,14 @@ export declare function changes<TFactory extends QueryFactory>(self: QueryObserv
  * changes.
  */
 export declare function trackResult<TFactory extends QueryFactory, TResult extends Result$1<DataOf<TFactory>>>(self: QueryObserver<TFactory>, result: TResult): TResult;
+/**
+ * Wrap `promise`, the result's or one derived from it, so that reading its
+ * `status`, `value` or `reason` marks its settling as tracked. A first load
+ * settles its promise in place, without a new promise, so only readers of
+ * those fields need to hear about it. The mark is the wrapper's, shared by
+ * the observers that hand it out.
+ */
+export declare function trackThenable<TFactory extends QueryFactory, TThenable extends Thenable<unknown>>(self: QueryObserver<TFactory>, promise: TThenable): TThenable;
 /** Mark `name` as read, for bindings that track access themselves. */
 export declare function trackProp<TFactory extends QueryFactory>(self: QueryObserver<TFactory>, name: ResultKey): void;
 //#endregion

package/dist/observer.mjs

@@ -10,7 +10,8 @@ import { Effect, Exit, FiberHandle, Pipeable, Predicate, Scope } from "effect";
 * Query's `QueryObserver`: it derives the reader's result from the query's
 * state, keeps a previous query's data for `whilePending: "previous"`, runs
 * `refetchInterval`, and notifies its listeners only when a result property
-* they read changed (see {@link trackResult}). Bindings make one per hook.
+* they read changed (see {@link trackResult}), or a promise whose `status`
+* they read settled (see {@link trackThenable}). Bindings make one per hook.
 *
 * The `*Unsafe` functions read and update synchronously, for renders and
 * external stores. While it has listeners, the observer holds a `Scope` (a
@@ -30,7 +31,8 @@ var observer_exports = /* @__PURE__ */ __exportAll({
 	setOptionsUnsafe: () => setOptionsUnsafe,
 	subscribeUnsafe: () => subscribeUnsafe,
 	trackProp: () => trackProp,
-	trackResult: () => trackResult
+	trackResult: () => trackResult,
+	trackThenable: () => trackThenable
 });
 const TypeId = "~@raf-query/core/QueryObserver";
 const Proto = {
@@ -65,9 +67,16 @@ function implOf(self) {
 function isResultKey(name) {
 	return Predicate.isString(name) && Object.hasOwn(resultKeys, name);
 }
-function shallowEqual(a, b) {
-	for (const name of Object.keys(resultKeys)) if (isResultKey(name) && a[name] !== b[name]) return false;
-	return true;
+/** Whether `next.promise` has a different status than it had in the current result. */
+function settled(self, next) {
+	return self.currentStatus !== next.promise.status;
+}
+function anyChanged(self, next) {
+	return settled(self, next) || Object.keys(resultKeys).some((name) => isResultKey(name) && self.current[name] !== next[name]);
+}
+function setCurrent(self, next) {
+	self.current = next;
+	self.currentStatus = next.promise.status;
 }
 /** The result for `query` with `options`, given the last query that had data. */
 function resultOf(query, options, lastWithData) {
@@ -97,13 +106,16 @@ function resultOf(query, options, lastWithData) {
 }
 /** Observe `query`. Doesn't subscribe to it until the observer has a listener. */
 function makeUnsafe(query, options = {}) {
+	const current = resultOf(query, options, void 0);
 	return Object.assign(Object.create(Proto), {
-		current: resultOf(query, options, void 0),
+		current,
+		currentStatus: current.promise.status,
 		lastWithData: getUnsafe$1(query).hasData ? query : void 0,
 		listeners: /* @__PURE__ */ new Set(),
 		options,
 		query,
 		subscription: void 0,
+		tracked: void 0,
 		trackedProps: /* @__PURE__ */ new Set()
 	});
 }
@@ -126,7 +138,7 @@ function get(self) {
 function getOptimisticResultUnsafe(self, query, options) {
 	const impl = implOf(self);
 	const result = resultOf(query, options, impl.lastWithData);
-	if (!shallowEqual(impl.current, result)) impl.current = result;
+	if (anyChanged(impl, result)) setCurrent(impl, result);
 	return result;
 }
 /** Observe `query` with `options` from now on. */
@@ -185,22 +197,62 @@ function trackResult(self, result) {
 		return Reflect.get(target, name, receiver);
 	} });
 }
+const settledFields = /* @__PURE__ */ new Set([
+	"reason",
+	"status",
+	"value"
+]);
+/**
+* One wrapper per promise, shared by every observer, so its identity is as
+* stable as the promise's: an observer made by a render that suspended
+* before committing is replaced on the next attempt, and `use()` expects
+* the same promise again.
+*/
+const wrappers = /* @__PURE__ */ new WeakMap();
+/** Wrappers whose `status`, `value` or `reason` a reader has read. */
+const settledReads = /* @__PURE__ */ new WeakSet();
+/**
+* Wrap `promise`, the result's or one derived from it, so that reading its
+* `status`, `value` or `reason` marks its settling as tracked. A first load
+* settles its promise in place, without a new promise, so only readers of
+* those fields need to hear about it. The mark is the wrapper's, shared by
+* the observers that hand it out.
+*/
+function trackThenable(self, promise) {
+	let wrapper = wrappers.get(promise);
+	if (!wrapper) {
+		const created = new Proxy(promise, { get: (target, name) => {
+			if (settledFields.has(name)) settledReads.add(created);
+			const value = Reflect.get(target, name, target);
+			return Predicate.isFunction(value) ? value.bind(target) : value;
+		} });
+		wrappers.set(promise, created);
+		wrapper = created;
+	}
+	implOf(self).tracked = wrapper;
+	return wrapper;
+}
+function readsSettled(self) {
+	return self.tracked !== void 0 && settledReads.has(self.tracked);
+}
 /** Mark `name` as read, for bindings that track access themselves. */
 function trackProp(self, name) {
 	implOf(self).trackedProps.add(name);
 }
 /** Recompute the result, and notify listeners if a tracked property changed. */
 function updateResult(self) {
-	const previous = self.current;
 	const next = resultOf(self.query, self.options, self.lastWithData);
 	if (getUnsafe$1(self.query).hasData) self.lastWithData = self.query;
-	if (shallowEqual(previous, next)) return;
-	self.current = next;
-	if (shouldNotify(self, previous, next)) for (const listener of self.listeners) listener();
+	if (!anyChanged(self, next)) return;
+	const notify = shouldNotify(self, next);
+	setCurrent(self, next);
+	if (notify) for (const listener of self.listeners) listener();
 }
-function shouldNotify(self, previous, next) {
-	if (self.trackedProps.size === 0) return true;
-	for (const name of self.trackedProps) if (previous[name] !== next[name]) return true;
+/** Whether something tracked differs in `next` from the current result. */
+function shouldNotify(self, next) {
+	if (self.trackedProps.size === 0 && !readsSettled(self)) return true;
+	if (readsSettled(self) && settled(self, next)) return true;
+	for (const name of self.trackedProps) if (self.current[name] !== next[name]) return true;
 	return false;
 }
 /**
@@ -245,4 +297,4 @@ function poll(query, interval) {
 	}).pipe(Effect.delay(interval), Effect.forever);
 }
 //#endregion
-export { TypeId, changes, get, getOptimisticResultUnsafe, getUnsafe, isQueryObserver, make, makeUnsafe, observer_exports, setOptionsUnsafe, subscribeUnsafe, trackProp, trackResult };
+export { TypeId, changes, get, getOptimisticResultUnsafe, getUnsafe, isQueryObserver, make, makeUnsafe, observer_exports, setOptionsUnsafe, subscribeUnsafe, trackProp, trackResult, trackThenable };

package/package.json

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