raf-effect-atom 0.2.4 → 0.2.6

package/CHANGELOG.md

@@ -1,14 +1,35 @@
 # Changelog
 
+## [0.2.6](https://github.com/KATT/raf-effect-atom/compare/raf-effect-atom%400.2.5...raf-effect-atom%400.2.6) (2026-10-23)
+
+### Features
+
+* **raf-effect-atom:** start browser-only reads with prefetchInBrowser ([65f783a](https://github.com/KATT/raf-effect-atom/commit/65f783a0014e44a8aa11ce5e8fa34ab863063403))
+
+### Documentation
+
+* **www:** keep a search box's text in the URL, and drop the debounce sample ([a3949bf](https://github.com/KATT/raf-effect-atom/commit/a3949bfca4b64e478132f983033b2776e50ba949))
+
+### Tests
+
+* **raf-effect-atom:** start a browser-only read from a client-only TanStack route ([69a8bd8](https://github.com/KATT/raf-effect-atom/commit/69a8bd887c34a7aeef51fdd20057ac30aa9e1fbc))
+* **raf-effect-atom:** type a derived atom's handle through it and its wrappers ([a16b587](https://github.com/KATT/raf-effect-atom/commit/a16b587a59dc4827dd18ecb3a3d5bb8f6fdedf0b))
+
+## [0.2.5](https://github.com/KATT/raf-effect-atom/compare/raf-effect-atom%400.2.4...raf-effect-atom%400.2.5) (2026-10-23)
+
+### Features
+
+- **raf-effect-atom:** start a derived atom's source from the loader verbs, following initialValueTarget ([00a9760](https://github.com/KATT/raf-effect-atom/commit/00a97602068cabf085fa9cfe41e88bf853b6af32))
+
 ## [0.2.4](https://github.com/KATT/raf-effect-atom/compare/raf-effect-atom%400.2.3...raf-effect-atom%400.2.4) (2026-10-23)
 
 ### Features
 
-* **raf-effect-atom:** start a request registry with initialValues, readable atoms included ([67cf767](https://github.com/KATT/raf-effect-atom/commit/67cf767e121e76b385ff0808a087efc6662aed89))
+- **raf-effect-atom:** start a request registry with initialValues, readable atoms included ([67cf767](https://github.com/KATT/raf-effect-atom/commit/67cf767e121e76b385ff0808a087efc6662aed89))
 
 ### Documentation
 
-* correct the generated changelogs' cut-off breaking change and bogus issue links ([c21f64c](https://github.com/KATT/raf-effect-atom/commit/c21f64cad3b4638f2341968aa2e10af5a19904c1))
+- correct the generated changelogs' cut-off breaking change and bogus issue links ([c21f64c](https://github.com/KATT/raf-effect-atom/commit/c21f64cad3b4638f2341968aa2e10af5a19904c1))
 
 ## [0.2.3](https://github.com/KATT/raf-effect-atom/compare/raf-effect-atom%400.2.2...raf-effect-atom%400.2.3) (2026-10-23)
 

package/dist/Handle.d.mts

@@ -67,6 +67,11 @@ export type HandleKey<S> = string & {
  */
 export interface Handle<S> {
   readonly args: ArgsOf<S>;
+  /**
+   * `true` when `Loader.prefetchInBrowser` ran on the server and left the
+   * atom to the browser: the browser's read starts it.
+   */
+  readonly inBrowser?: true;
   /** The atom's serialization key; `undefined` for an atom without one. */
   readonly key: HandleKey<S> | undefined;
 }

package/dist/Hooks.mjs

@@ -2,10 +2,10 @@
 import { stream } from "./internal/pending.mjs";
 import { hydrated } from "./Hydration.mjs";
 import { keyOf, release } from "./internal/leases.mjs";
-import { atomOf } from "./internal/handles.mjs";
+import { atomOf, sourceOf } from "./internal/handles.mjs";
+import { isRequestRegistry } from "./RequestRegistry.mjs";
 import { requireRequestRegistry } from "./internal/registry.mjs";
 import { ModeContext, check } from "./internal/waterfalls.mjs";
-import * as Atom from "effect/reactivity/Atom";
 import * as Predicate from "effect/Predicate";
 import * as Cause from "effect/Cause";
 import * as Option from "effect/Option";
@@ -20,15 +20,6 @@ import * as React from "react";
 * @since 0.1.0
 */
 /**
-* The atom the loader started and the server sent: the first serializable
-* atom in `atom`'s `initialValueTarget` chain, starting with `atom`. An
-* AtomRpc query is serializable itself, though it points at an inner atom.
-*/
-const sourceOf = (atom) => {
-	for (let target = atom; target !== void 0; target = target.initialValueTarget) if (Atom.isSerializable(target)) return target;
-	return atom;
-};
-/**
 * Reads a handle through React Suspense, through the source that made it: a
 * result streamed from the server, a hydrated one, or one a loader started.
 *
@@ -109,6 +100,7 @@ const useAtomResult = (source, handle) => {
 	const registry = React.useContext(RegistryContext);
 	const atom = atomOf(source, handle.args);
 	requireRequestRegistry(registry, "useAtomResult");
+	if (handle.inBrowser === true && isRequestRegistry(registry)) throw new Error(`raf-effect-atom: ${String(atom)} starts in the browser (Loader.prefetchInBrowser), so the server renders the nearest Suspense boundary's fallback, and the browser renders the boundary.`);
 	const target = sourceOf(atom);
 	const started = hydrated(target);
 	const read = target === atom ? hydrated(atom) : atom;
@@ -116,7 +108,7 @@ const useAtomResult = (source, handle) => {
 	if (process.env.NODE_ENV !== "production" && handle.key !== void 0 && Predicate.isString(key) && handle.key !== key) throw new Error(`raf-effect-atom: useAtomResult read the handle of ${handle.key} through a source that makes ${key}. Read a handle through the source that made it.`);
 	const streamed = Predicate.isString(key) ? stream(registry, key) : void 0;
 	if (streamed !== void 0) React.use(streamed);
-	if (process.env.NODE_ENV !== "production") check(registry, started, React.use(ModeContext));
+	if (process.env.NODE_ENV !== "production" && handle.inBrowser !== true) check(registry, started, React.use(ModeContext));
 	if (read !== started) registry.get(started);
 	const current = registry.get(read);
 	const result = useAtomSuspense(read, {

package/dist/Loader.d.mts

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
 import * as AsyncResult from "effect/reactivity/AsyncResult";
 import * as AtomRegistry from "effect/reactivity/AtomRegistry";
 declare namespace Loader_d_exports {
-  export { LeaseTTL, Loader, MakeOptions, SettledResult, ensure, fetch, make, prefetch, result };
+  export { LeaseTTL, Loader, MakeOptions, SettledResult, ensure, fetch, make, prefetch, prefetchInBrowser, result };
 }
 /**
  * A settled `AsyncResult`: what `ensure` and `fetch` return.
@@ -40,10 +40,24 @@ export declare const LeaseTTL: Context.Reference<Duration.Duration>;
  *
  * **Details**
  *
- * Starts the atom if it isn't in the registry, and leaves it alone if it is.
- * Takes a lease either way. The component that reads the handle suspends
- * until the result settles. On a request registry whose async seed is still
- * running, it waits for the seed first.
+ * - Starts the atom if it isn't in the registry, and leaves it alone if it
+ *   is. Takes a lease either way. The component that reads the handle
+ *   suspends until the result settles. On a request registry whose async
+ *   seed is still running, it waits for the seed first.
+ * - A derived atom that isn't serializable, such as an error boundary's
+ *   `wrap(source)`, starts the first serializable atom its
+ *   `initialValueTarget` chain points at, the one `useAtomResult` reads it
+ *   through: the lease, the handle's key and what the server sends are
+ *   that atom's. `ensure` and `fetch` wait for the derived atom's own
+ *   result.
+ *
+ * **Gotchas**
+ *
+ * The server sends a result still loading as a promise only when the atom
+ * it sends holds an `AsyncResult`. A derived atom whose serializable atom
+ * holds another value, such as an `Option` snapshot, crosses with the value
+ * it has when the registry is dehydrated: point it at an `AsyncResult`
+ * atom, or `ensure` it.
  *
  * **Example**
  *
@@ -59,6 +73,49 @@ export declare const LeaseTTL: Context.Reference<Duration.Duration>;
  * @since 0.1.0
  */
 export declare const prefetch: <S extends Source>(source: S, ...args: ArgsOf<S>) => Effect.Effect<Handle<S>, never, AtomRegistry.AtomRegistry>;
+/**
+ * Starts a source's atom in the browser, and returns its handle: on the
+ * server, it starts nothing, and the browser's read starts the atom.
+ *
+ * **When to use**
+ *
+ * Use for data only the browser can load: an input the server never sees,
+ * such as a token in the URL's fragment or a permission, or a request the
+ * server can't make. The rest of the page still renders on the server.
+ *
+ * **Details**
+ *
+ * - In the browser, it's `prefetch`: a loader that runs there, such as on a
+ *   client navigation, starts the atom and takes a lease.
+ * - On a request registry, it returns a handle marked `inBrowser` without
+ *   starting the atom, so the atom needs no serialization key. On the
+ *   server, `useAtomResult` throws for that handle, so React renders the
+ *   nearest Suspense boundary's fallback there and renders the boundary in
+ *   the browser. There, the read starts the atom, and the waterfall check
+ *   skips it, since a loader asked for it.
+ *
+ * **Gotchas**
+ *
+ * - Read the handle under a Suspense boundary: on the server, a read
+ *   outside one fails the whole render. React reports the boundary it
+ *   renders in the browser to `onRecoverableError`.
+ * - On a page the server rendered, the request starts when the browser
+ *   renders the read, after hydration's JavaScript has loaded: start the
+ *   data the server can load with `prefetch` or `ensure`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Loader } from "raf-effect-atom"
+ *
+ * const program = Loader.prefetchInBrowser(pushSubscription)
+ * ```
+ *
+ * @stability unstable
+ * @category verbs
+ * @since 0.2.6
+ */
+export declare const prefetchInBrowser: <S extends Source>(source: S, ...args: ArgsOf<S>) => Effect.Effect<Handle<S>, never, AtomRegistry.AtomRegistry>;
 /**
  * Starts a source's atom, waits only while it has no result, and returns a
  * handle whose reader renders without suspending.
@@ -165,6 +222,8 @@ export interface Loader {
    * the seed resolves.
    */
   readonly prefetch: <S extends Source>(source: S, ...args: ArgsOf<S>) => Handle<S>;
+  /** {@link prefetchInBrowser}, run at once. */
+  readonly prefetchInBrowser: <S extends Source>(source: S, ...args: ArgsOf<S>) => Handle<S>;
   /**
    * Runs an Effect that needs the registry, such as the Effect verbs in an
    * `Effect.gen`, as a Promise that rejects with its squashed cause.
@@ -199,8 +258,8 @@ export interface MakeOptions {
  *
  * Use in a framework integration, in loaders that are async functions, or
  * in an event handler that starts an atom before the state change that
- * renders its reader, for state that can't be in the URL, such as a
- * search-as-you-type query. In Effect code, use the verbs directly, and run
+ * renders its reader, for a choice a click or a submit makes that doesn't
+ * belong in the URL. In Effect code, use the verbs directly, and run
  * the Effect on the registry with `run`.
  *
  * **Details**

package/dist/Loader.mjs

@@ -2,7 +2,7 @@ import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { hydrated } from "./Hydration.mjs";
 import { isDevelopment } from "./internal/development.mjs";
 import { keyOf, take } from "./internal/leases.mjs";
-import { atomOf, loaded as loaded$1, make as make$1 } from "./internal/handles.mjs";
+import { atomOf, inBrowser, loaded as loaded$1, make as make$1, sourceOf } from "./internal/handles.mjs";
 import { afterSeed, pending } from "./internal/seeds.mjs";
 import { isRequestRegistry } from "./RequestRegistry.mjs";
 import * as Atom from "effect/reactivity/Atom";
@@ -31,6 +31,9 @@ import * as AtomRegistry from "effect/reactivity/AtomRegistry";
 * | `ensure`   | if it isn't in the registry     | only while it's `Initial`     | returns it at once    |
 * | `fetch`    | if it isn't, or refreshes it    | until the new result settles  | refreshes, then waits |
 *
+* `prefetchInBrowser` is `prefetch` in the browser. On the server, it
+* starts nothing, and the browser's read starts the atom.
+*
 * Typed failures don't reject: `ensure` and `fetch` settle on them, and
 * `result` returns the settled `AsyncResult`, so a loader can redirect on a
 * tag and otherwise let a boundary render the failure. Only defects and
@@ -48,6 +51,7 @@ var Loader_exports = /* @__PURE__ */ __exportAll({
 	fetch: () => fetch,
 	make: () => make,
 	prefetch: () => prefetch,
+	prefetchInBrowser: () => prefetchInBrowser,
 	result: () => result
 });
 /**
@@ -70,14 +74,16 @@ const start = Effect.fnUntraced(function* (atom) {
 	const seed = pending(registry);
 	if (seed !== void 0) yield* Effect.promise(() => seed);
 	const request = isRequestRegistry(registry);
-	if (request && !Atom.isSerializable(atom) && (yield* isDevelopment)) return yield* Effect.die(/* @__PURE__ */ new Error(`raf-effect-atom: a loader started ${String(atom)}, which isn't serializable, so the browser would request it again. Give it a serialization key, such as AtomRpc's serializationKey option.`));
+	const source = sourceOf(atom);
+	if (request && !Atom.isSerializable(source) && (yield* isDevelopment)) return yield* Effect.die(/* @__PURE__ */ new Error(`raf-effect-atom: a loader started ${String(atom)}, which isn't serializable and doesn't point at a serializable atom with initialValueTarget, so the browser would request it again. Give it a serialization key, such as AtomRpc's serializationKey option.`));
 	const ttl = request ? void 0 : Duration.toMillis(yield* LeaseTTL);
-	const target = hydrated(atom);
+	const target = hydrated(source);
 	const key = keyOf(target);
 	const existed = registry.getNodes().has(key) || Predicate.isString(key) && registry.preloadedSerializable.has(key);
 	take(registry, target, ttl);
 	return {
 		existed,
+		read: source === atom ? hydrated(atom) : atom,
 		registry,
 		request,
 		target
@@ -115,10 +121,24 @@ const rejectDefects = (result) => {
 *
 * **Details**
 *
-* Starts the atom if it isn't in the registry, and leaves it alone if it is.
-* Takes a lease either way. The component that reads the handle suspends
-* until the result settles. On a request registry whose async seed is still
-* running, it waits for the seed first.
+* - Starts the atom if it isn't in the registry, and leaves it alone if it
+*   is. Takes a lease either way. The component that reads the handle
+*   suspends until the result settles. On a request registry whose async
+*   seed is still running, it waits for the seed first.
+* - A derived atom that isn't serializable, such as an error boundary's
+*   `wrap(source)`, starts the first serializable atom its
+*   `initialValueTarget` chain points at, the one `useAtomResult` reads it
+*   through: the lease, the handle's key and what the server sends are
+*   that atom's. `ensure` and `fetch` wait for the derived atom's own
+*   result.
+*
+* **Gotchas**
+*
+* The server sends a result still loading as a promise only when the atom
+* it sends holds an `AsyncResult`. A derived atom whose serializable atom
+* holds another value, such as an `Option` snapshot, crosses with the value
+* it has when the registry is dehydrated: point it at an `AsyncResult`
+* atom, or `ensure` it.
 *
 * **Example**
 *
@@ -138,6 +158,54 @@ const prefetch = (source, ...args) => Effect.gen(function* () {
 	yield* start(atom);
 	return make$1(args, atom);
 });
+/**
+* Starts a source's atom in the browser, and returns its handle: on the
+* server, it starts nothing, and the browser's read starts the atom.
+*
+* **When to use**
+*
+* Use for data only the browser can load: an input the server never sees,
+* such as a token in the URL's fragment or a permission, or a request the
+* server can't make. The rest of the page still renders on the server.
+*
+* **Details**
+*
+* - In the browser, it's `prefetch`: a loader that runs there, such as on a
+*   client navigation, starts the atom and takes a lease.
+* - On a request registry, it returns a handle marked `inBrowser` without
+*   starting the atom, so the atom needs no serialization key. On the
+*   server, `useAtomResult` throws for that handle, so React renders the
+*   nearest Suspense boundary's fallback there and renders the boundary in
+*   the browser. There, the read starts the atom, and the waterfall check
+*   skips it, since a loader asked for it.
+*
+* **Gotchas**
+*
+* - Read the handle under a Suspense boundary: on the server, a read
+*   outside one fails the whole render. React reports the boundary it
+*   renders in the browser to `onRecoverableError`.
+* - On a page the server rendered, the request starts when the browser
+*   renders the read, after hydration's JavaScript has loaded: start the
+*   data the server can load with `prefetch` or `ensure`.
+*
+* **Example**
+*
+* ```ts
+* import { Loader } from "raf-effect-atom"
+*
+* const program = Loader.prefetchInBrowser(pushSubscription)
+* ```
+*
+* @stability unstable
+* @category verbs
+* @since 0.2.6
+*/
+const prefetchInBrowser = (source, ...args) => Effect.gen(function* () {
+	const atom = atomOf(source, args);
+	if (isRequestRegistry(yield* AtomRegistry.AtomRegistry)) return inBrowser(args, atom);
+	yield* start(atom);
+	return make$1(args, atom);
+});
 const loaded = (args, atom, result) => {
 	const handle = loaded$1(args, atom);
 	results.set(handle, result);
@@ -181,7 +249,7 @@ const loaded = (args, atom, result) => {
 const ensure = (source, ...args) => Effect.gen(function* () {
 	const atom = atomOf(source, args);
 	const started = yield* start(atom);
-	const result = yield* settled(started.registry, started.target, started.request ? isSettled : AsyncResult.isNotInitial);
+	const result = yield* settled(started.registry, started.read, started.request ? isSettled : AsyncResult.isNotInitial);
 	return loaded(args, atom, result);
 });
 /**
@@ -207,12 +275,12 @@ const ensure = (source, ...args) => Effect.gen(function* () {
 const fetch = (source, ...args) => Effect.gen(function* () {
 	const atom = atomOf(source, args);
 	const started = yield* start(atom);
-	const { registry, target } = started;
-	if (started.existed && isSettled(registry.get(target))) {
+	const { read, registry, target } = started;
+	if (started.existed && isSettled(registry.get(read))) {
 		const node = registry.getNodes().get(keyOf(target));
-		registry.refresh(node?.atom ?? target);
+		registry.refresh(read === target ? node?.atom ?? target : read);
 	}
-	const result = yield* settled(registry, target, isSettled);
+	const result = yield* settled(registry, read, isSettled);
 	return loaded(args, atom, result);
 });
 const results = /* @__PURE__ */ new WeakMap();
@@ -261,8 +329,8 @@ const either = (first, second) => first === void 0 || second === void 0 ? first
 *
 * Use in a framework integration, in loaders that are async functions, or
 * in an event handler that starts an atom before the state change that
-* renders its reader, for state that can't be in the URL, such as a
-* search-as-you-type query. In Effect code, use the verbs directly, and run
+* renders its reader, for a choice a click or a submit makes that doesn't
+* belong in the URL. In Effect code, use the verbs directly, and run
 * the Effect on the registry with `run`.
 *
 * **Details**
@@ -303,7 +371,15 @@ const make = (registry, options) => {
 			});
 			return make$1(args, atom);
 		},
+		prefetchInBrowser: (source, ...args) => {
+			const atom = atomOf(source, args);
+			if (isRequestRegistry(registry)) return inBrowser(args, atom);
+			afterSeed(registry, () => {
+				Effect.runSync(provide(start(atom)));
+			});
+			return make$1(args, atom);
+		},
 		run: (effect, runOptions) => runPromise(provide(effect), either(signal, runOptions?.signal))
 	};
 };
-export { LeaseTTL, Loader_exports, ensure, fetch, make, prefetch, result };
+export { LeaseTTL, Loader_exports, ensure, fetch, make, prefetch, prefetchInBrowser, result };

package/dist/Next.d.mts

@@ -90,6 +90,15 @@ export declare const getRegistry: () => AtomRegistry.AtomRegistry;
  * @since 0.1.0
  */
 export declare const prefetch: <S extends Source>(source: S, ...args: ArgsOf<S>) => Handle<S>;
+/**
+ * `Loader.prefetchInBrowser` on the request's registry: returns a handle
+ * whose atom the browser's read starts, without starting it on the server.
+ *
+ * @stability unstable
+ * @category verbs
+ * @since 0.2.6
+ */
+export declare const prefetchInBrowser: <S extends Source>(source: S, ...args: ArgsOf<S>) => Handle<S>;
 /**
  * `Loader.ensure` on the request's registry: starts a source's atom, waits
  * for its result, and returns its handle.

package/dist/Next.mjs

@@ -72,6 +72,15 @@ const getRegistry = atoms.getRegistry;
 */
 const prefetch = atoms.prefetch;
 /**
+* `Loader.prefetchInBrowser` on the request's registry: returns a handle
+* whose atom the browser's read starts, without starting it on the server.
+*
+* @stability unstable
+* @category verbs
+* @since 0.2.6
+*/
+const prefetchInBrowser = atoms.prefetchInBrowser;
+/**
 * `Loader.ensure` on the request's registry: starts a source's atom, waits
 * for its result, and returns its handle.
 *
@@ -130,4 +139,4 @@ const run = atoms.run;
 * @since 0.1.0
 */
 const dehydrate = atoms.dehydrate;
-export { HydrateAtoms, RegistryProvider, dehydrate, ensure, fetch, getRegistry, makeRequestAtoms, prefetch, run };
+export { HydrateAtoms, RegistryProvider, dehydrate, ensure, fetch, getRegistry, makeRequestAtoms, prefetch, prefetchInBrowser, run };

package/dist/Waterfalls.d.mts

@@ -51,7 +51,7 @@ export declare const WaterfallDetection: (props: {
 }) => React.ReactNode;
 /**
  * Starts a source's atom during render and returns its handle, for an input
- * only a render knows, such as a debounced search query.
+ * only a render knows, such as an id read from another atom's result.
  *
  * **When to use**
  *
@@ -72,12 +72,9 @@ export declare const WaterfallDetection: (props: {
  * - `useAtomResult` doesn't report an atom started this way.
  * - The handle is a prefetched one: its reader suspends until the result
  *   settles, as for a handle from a loader's `prefetch`.
- *
- * **Gotchas**
- *
- * Pass it the source a loader would start, not an error boundary's
- * `wrap(source)`: the wrapper's atoms aren't serializable, so the server
- * couldn't send them to the browser. Read the handle through the wrapper.
+ * - A derived source, such as an error boundary's `wrap(source)`, starts
+ *   the serializable atom its `initialValueTarget` chain points at, as
+ *   `Loader.prefetch` does.
  *
  * **Example**
  *

package/dist/Waterfalls.mjs

@@ -2,7 +2,7 @@
 import { get } from "./internal/pending.mjs";
 import { hydrated } from "./Hydration.mjs";
 import { keyOf } from "./internal/leases.mjs";
-import { atomOf, make } from "./internal/handles.mjs";
+import { atomOf, make, sourceOf } from "./internal/handles.mjs";
 import { prefetch } from "./Loader.mjs";
 import { ModeContext, isStarted } from "./internal/waterfalls.mjs";
 import * as Predicate from "effect/Predicate";
@@ -55,7 +55,7 @@ const WaterfallDetection = (props) => process.env.NODE_ENV === "production" ? pr
 });
 /**
 * Starts a source's atom during render and returns its handle, for an input
-* only a render knows, such as a debounced search query.
+* only a render knows, such as an id read from another atom's result.
 *
 * **When to use**
 *
@@ -76,12 +76,9 @@ const WaterfallDetection = (props) => process.env.NODE_ENV === "production" ? pr
 * - `useAtomResult` doesn't report an atom started this way.
 * - The handle is a prefetched one: its reader suspends until the result
 *   settles, as for a handle from a loader's `prefetch`.
-*
-* **Gotchas**
-*
-* Pass it the source a loader would start, not an error boundary's
-* `wrap(source)`: the wrapper's atoms aren't serializable, so the server
-* couldn't send them to the browser. Read the handle through the wrapper.
+* - A derived source, such as an error boundary's `wrap(source)`, starts
+*   the serializable atom its `initialValueTarget` chain points at, as
+*   `Loader.prefetch` does.
 *
 * **Example**
 *
@@ -103,7 +100,7 @@ const WaterfallDetection = (props) => process.env.NODE_ENV === "production" ? pr
 const useWaterfall = (source, ...args) => {
 	const registry = React.useContext(RegistryContext);
 	const atom = atomOf(source, args);
-	const target = hydrated(atom);
+	const target = hydrated(sourceOf(atom));
 	const key = keyOf(target);
 	if (!(Predicate.isString(key) && get(registry, key) !== void 0) && !isStarted(registry, target)) return Effect.runSync(Effect.provideService(prefetch(source, ...args), AtomRegistry.AtomRegistry, registry));
 	return make(args, atom);

package/dist/internal/handles.mjs

@@ -4,9 +4,18 @@ import * as Predicate from "effect/Predicate";
 // src/internal/handles.ts
 /** The atom a source makes for its arguments. */
 const atomOf = (source, args) => Atom.isAtom(source) ? source : source(...args);
-/** The registry key a handle records: the atom's serialization key. */
+/**
+* The atom the loader starts and the server sends for `atom`: the first
+* serializable atom in its `initialValueTarget` chain, starting with `atom`.
+* An AtomRpc query is serializable itself, though it points at an inner atom.
+*/
+const sourceOf = (atom) => {
+	for (let target = atom; target !== void 0; target = target.initialValueTarget) if (Atom.isSerializable(target)) return target;
+	return atom;
+};
+/** The registry key a handle records: its source atom's serialization key. */
 const keyOf = (atom) => {
-	const key = keyOf$1(atom);
+	const key = keyOf$1(sourceOf(atom));
 	if (!Predicate.isString(key)) return;
 	return key;
 };
@@ -14,9 +23,14 @@ const make = (args, atom) => ({
 	args,
 	key: keyOf(atom)
 });
+const inBrowser = (args, atom) => ({
+	args,
+	inBrowser: true,
+	key: keyOf(atom)
+});
 const loaded = (args, atom) => ({
 	args,
 	key: keyOf(atom),
 	loaded: true
 });
-export { atomOf, loaded, make };
+export { atomOf, inBrowser, loaded, make, sourceOf };

package/dist/internal/next.mjs

@@ -23,6 +23,7 @@ const make = (options) => {
 		fetch: (source, ...args) => getLoader().fetch(source, ...args),
 		getRegistry,
 		prefetch: (source, ...args) => getLoader().prefetch(source, ...args),
+		prefetchInBrowser: (source, ...args) => getLoader().prefetchInBrowser(source, ...args),
 		run: (effect, runOptions) => getLoader().run(effect, runOptions)
 	};
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raf-effect-atom",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Render-as-you-fetch for Effect Atom: start atoms from route loaders and stream them into the browser, typed failures intact",
   "keywords": [
     "effect",
@@ -58,7 +58,7 @@
     "@types/react-dom": "19.3.0",
     "@vitest/coverage-v8": "5.0.5",
     "effect": "4.0.6",
-    "effect-atom-boundary": "0.1.1",
+    "effect-atom-boundary": "0.1.2",
     "happy-dom": "21.0.4",
     "react": "19.3.1",
     "react-dom": "19.3.1",