raf-effect-atom 0.0.0 → 0.2.0

package/dist/NextClient.d.mts

@@ -1,7 +1,7 @@
 import { HydrationBoundaryProps } from "./ReactHydration.mjs";
 import * as React from "react";
 /**
- * Hydrates the state a server component dehydrated with `dehydrate()`,
+ * Hydrates the state a server component dehydrated with `await dehydrate()`,
  * streamed results included.
  *
  * **Details**
@@ -16,11 +16,10 @@ import * as React from "react";
  * import { dehydrate, ensure, HydrateAtoms } from "raf-effect-atom/next"
  *
  * export default async function IssuePage(props: { params: Promise<{ id: string }> }) {
- *   const id = Number((await props.params).id)
- *   await ensure(issue(id))
+ *   const handle = await ensure(issue, Number((await props.params).id))
  *   return (
- *     <HydrateAtoms state={dehydrate()}>
- *       <Issue id={id} />
+ *     <HydrateAtoms state={await dehydrate()}>
+ *       <Issue issue={handle} />
  *     </HydrateAtoms>
  *   )
  * }

package/dist/NextClient.mjs

@@ -9,7 +9,7 @@ import { jsx } from "react/jsx-runtime";
 * @since 0.1.0
 */
 /**
-* Hydrates the state a server component dehydrated with `dehydrate()`,
+* Hydrates the state a server component dehydrated with `await dehydrate()`,
 * streamed results included.
 *
 * **Details**
@@ -24,11 +24,10 @@ import { jsx } from "react/jsx-runtime";
 * import { dehydrate, ensure, HydrateAtoms } from "raf-effect-atom/next"
 *
 * export default async function IssuePage(props: { params: Promise<{ id: string }> }) {
-*   const id = Number((await props.params).id)
-*   await ensure(issue(id))
+*   const handle = await ensure(issue, Number((await props.params).id))
 *   return (
-*     <HydrateAtoms state={dehydrate()}>
-*       <Issue id={id} />
+*     <HydrateAtoms state={await dehydrate()}>
+*       <Issue issue={handle} />
 *     </HydrateAtoms>
 *   )
 * }

package/dist/ReactHydration.d.mts

@@ -41,7 +41,7 @@ export interface HydrationBoundaryProps {
  * import { HydrationBoundary } from "raf-effect-atom"
  *
  * <HydrationBoundary state={loaderData.atoms}>
- *   <IssuePage id={id} />
+ *   <IssuePage issue={loaderData.issue} />
  * </HydrationBoundary>
  * ```
  *

package/dist/ReactHydration.mjs

@@ -42,7 +42,7 @@ import { jsx } from "react/jsx-runtime";
 * import { HydrationBoundary } from "raf-effect-atom"
 *
 * <HydrationBoundary state={loaderData.atoms}>
-*   <IssuePage id={id} />
+*   <IssuePage issue={loaderData.issue} />
 * </HydrationBoundary>
 * ```
 *

package/dist/ReactRouter.d.mts

@@ -36,6 +36,22 @@ export interface MiddlewareArgs {
   readonly context: {
     readonly set: (context: AtomsContext, value: RequestAtoms) => void;
   };
+  readonly request: Request;
+}
+/**
+ * Options for `atomsMiddleware`.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface AtomsMiddlewareOptions {
+  /**
+   * Runs on each request's registry before the loaders, with the request,
+   * to set what its atoms need, such as its cookie. The middleware waits
+   * for one that returns a promise.
+   */
+  readonly seed?: ((registry: AtomRegistry.AtomRegistry, request: Request) => void | Promise<void>) | undefined;
 }
 /**
  * Creates a root middleware that gives each server request its own
@@ -49,15 +65,30 @@ export interface MiddlewareArgs {
  * then. When `next` doesn't return a `Response`, as Data Mode's
  * `query` can, the registry is left to be collected with the request.
  *
+ * `seed` runs on the new registry before `next`, so every loader's atoms
+ * start with what it sets.
+ *
  * **Gotchas**
  *
  * It's server middleware: export it as the root route's `middleware`, not
  * `clientMiddleware`. In the browser, the root's `RegistryProvider` holds
  * the registry.
  *
+ * **Example**
+ *
+ * ```ts
+ * export const middleware = [
+ *   atomsMiddleware(atomsContext, {
+ *     // In-process RPC calls send the page request's cookie.
+ *     seed: (registry, request) =>
+ *       registry.set(requestCookie, request.headers.get("cookie") ?? undefined)
+ *   })
+ * ]
+ * ```
+ *
  * @stability unstable
  * @category integrations
  * @since 0.1.0
  */
-export declare const atomsMiddleware: (context: AtomsContext) => <Result>(args: MiddlewareArgs, next: () => Promise<Result>) => Promise<Result>;
+export declare const atomsMiddleware: (context: AtomsContext, options?: AtomsMiddlewareOptions) => <Result>(args: MiddlewareArgs, next: () => Promise<Result>) => Promise<Result>;
 export { RegistryProvider };

package/dist/ReactRouter.mjs

@@ -1,5 +1,5 @@
 import { dehydrate } from "./Hydration.mjs";
-import { make } from "./RequestRegistry.mjs";
+import { make, settled } from "./RequestRegistry.mjs";
 import { make as make$1 } from "./Loader.mjs";
 import { RegistryProvider } from "./RegistryProvider.mjs";
 import * as Predicate from "effect/Predicate";
@@ -30,14 +30,14 @@ import * as Predicate from "effect/Predicate";
 * // app/routes/issue.tsx
 * export async function loader(args: Route.LoaderArgs) {
 *   const atoms = args.context.get(atomsContext)
-*   await atoms.ensure(issue(Number(args.params.id)))
-*   return { atoms: atoms.dehydrate() }
+*   const handle = await atoms.ensure(issue, Number(args.params.id))
+*   return { atoms: atoms.dehydrate(), issue: handle }
 * }
 *
 * export default function IssueRoute(props: Route.ComponentProps) {
 *   return (
 *     <HydrationBoundary state={props.loaderData.atoms}>
-*       <Issue id={Number(props.params.id)} />
+*       <Issue issue={props.loaderData.issue} />
 *     </HydrationBoundary>
 *   )
 * }
@@ -58,18 +58,40 @@ import * as Predicate from "effect/Predicate";
 * then. When `next` doesn't return a `Response`, as Data Mode's
 * `query` can, the registry is left to be collected with the request.
 *
+* `seed` runs on the new registry before `next`, so every loader's atoms
+* start with what it sets.
+*
 * **Gotchas**
 *
 * It's server middleware: export it as the root route's `middleware`, not
 * `clientMiddleware`. In the browser, the root's `RegistryProvider` holds
 * the registry.
 *
+* **Example**
+*
+* ```ts
+* export const middleware = [
+*   atomsMiddleware(atomsContext, {
+*     // In-process RPC calls send the page request's cookie.
+*     seed: (registry, request) =>
+*       registry.set(requestCookie, request.headers.get("cookie") ?? undefined)
+*   })
+* ]
+* ```
+*
 * @stability unstable
 * @category integrations
 * @since 0.1.0
 */
-const atomsMiddleware = (context) => async (args, next) => {
-	const registry = make();
+const atomsMiddleware = (context, options) => async (args, next) => {
+	const seed = options?.seed;
+	const registry = make({ seed: seed === void 0 ? void 0 : (created) => seed(created, args.request) });
+	try {
+		await settled(registry);
+	} catch (error) {
+		registry.dispose();
+		throw error;
+	}
 	const loader = make$1(registry);
 	args.context.set(context, {
 		...loader,

package/dist/RequestRegistry.d.mts

@@ -1,32 +1,88 @@
+import { Seed as Seed$1 } from "./internal/seeds.mjs";
 import * as AtomRegistry from "effect/reactivity/AtomRegistry";
 import * as Layer from "effect/Layer";
 declare namespace RequestRegistry_d_exports {
-  export { isRequestRegistry, layer, make };
+  export { Options, Seed, isRequestRegistry, layer, make, settled };
+}
+/**
+ * Prepares a request registry before the loader verbs start atoms in it,
+ * such as by setting an atom to the request's cookie.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export type Seed = Seed$1;
+/**
+ * Options for `make`.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.2.0
+ */
+export interface Options {
+  /**
+   * Runs on the new registry before any verb starts an atom in it. When it
+   * returns a promise, `ensure` and `fetch` wait for it, and `prefetch`
+   * returns its handle at once and starts the atom once it resolves.
+   */
+  readonly seed?: Seed | undefined;
 }
 /**
  * Creates the registry for one server request.
  *
  * **Details**
  *
- * It's an ordinary `AtomRegistry`, marked as a request registry. On a
- * request registry, `ensure` waits like `fetch` does, nothing revalidates in
- * the background, and a loader's lease lasts until the registry is disposed.
- * In development, the loader verbs refuse an atom that isn't serializable,
- * because the browser would request it again.
+ * - It's an ordinary `AtomRegistry`, marked as a request registry. On a
+ *   request registry, `ensure` waits like `fetch` does, nothing revalidates
+ *   in the background, and a loader's lease lasts until the registry is
+ *   disposed. In development, the loader verbs refuse an atom that isn't
+ *   serializable, because the browser would request it again.
+ * - `seed` sets what the request's atoms need before they run, such as the
+ *   page request's cookie for an RPC protocol that forwards it. It can be
+ *   async, for request data only a promise gives, such as Next.js's
+ *   `headers()`.
+ *
+ * **Gotchas**
+ *
+ * With an async seed, a `prefetch` before it settles starts its atom later,
+ * so `Hydration.dehydrate` would miss it: wait for `settled` first, as the
+ * framework integrations do.
  *
  * **Example**
  *
  * ```ts
  * import { RequestRegistry } from "raf-effect-atom"
  *
- * const registry = RequestRegistry.make()
+ * const registry = RequestRegistry.make({
+ *   seed: (registry) => registry.set(requestCookie, request.headers.get("cookie") ?? undefined)
+ * })
  * ```
  *
  * @stability unstable
  * @category constructors
  * @since 0.1.0
  */
-export declare const make: () => AtomRegistry.AtomRegistry;
+export declare const make: (options?: Options) => AtomRegistry.AtomRegistry;
+/**
+ * Waits until a request registry's seed has settled and every atom a verb
+ * started while it ran has started.
+ *
+ * **When to use**
+ *
+ * Use before `Hydration.dehydrate` on a registry with an async seed, outside
+ * the framework integrations, which call it for you.
+ *
+ * **Details**
+ *
+ * Resolves at once for a registry without a seed, or whose seed was
+ * synchronous. Rejects with the seed's error.
+ *
+ * @stability unstable
+ * @category getters
+ * @since 0.2.0
+ */
+export declare const settled: (registry: AtomRegistry.AtomRegistry) => Promise<void>;
 /**
  * A layer that provides a request registry as the `AtomRegistry`, disposed
  * when the layer's scope closes.

package/dist/RequestRegistry.mjs

@@ -1,4 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { run, settled as settled$1 } from "./internal/seeds.mjs";
 import * as Effect from "effect/Effect";
 import * as AtomRegistry from "effect/reactivity/AtomRegistry";
 import * as Layer from "effect/Layer";
@@ -18,7 +19,8 @@ import * as Layer from "effect/Layer";
 var RequestRegistry_exports = /* @__PURE__ */ __exportAll({
 	isRequestRegistry: () => isRequestRegistry,
 	layer: () => layer,
-	make: () => make
+	make: () => make,
+	settled: () => settled
 });
 const requestRegistries = /* @__PURE__ */ new WeakSet();
 /**
@@ -26,30 +28,62 @@ const requestRegistries = /* @__PURE__ */ new WeakSet();
 *
 * **Details**
 *
-* It's an ordinary `AtomRegistry`, marked as a request registry. On a
-* request registry, `ensure` waits like `fetch` does, nothing revalidates in
-* the background, and a loader's lease lasts until the registry is disposed.
-* In development, the loader verbs refuse an atom that isn't serializable,
-* because the browser would request it again.
+* - It's an ordinary `AtomRegistry`, marked as a request registry. On a
+*   request registry, `ensure` waits like `fetch` does, nothing revalidates
+*   in the background, and a loader's lease lasts until the registry is
+*   disposed. In development, the loader verbs refuse an atom that isn't
+*   serializable, because the browser would request it again.
+* - `seed` sets what the request's atoms need before they run, such as the
+*   page request's cookie for an RPC protocol that forwards it. It can be
+*   async, for request data only a promise gives, such as Next.js's
+*   `headers()`.
+*
+* **Gotchas**
+*
+* With an async seed, a `prefetch` before it settles starts its atom later,
+* so `Hydration.dehydrate` would miss it: wait for `settled` first, as the
+* framework integrations do.
 *
 * **Example**
 *
 * ```ts
 * import { RequestRegistry } from "raf-effect-atom"
 *
-* const registry = RequestRegistry.make()
+* const registry = RequestRegistry.make({
+*   seed: (registry) => registry.set(requestCookie, request.headers.get("cookie") ?? undefined)
+* })
 * ```
 *
 * @stability unstable
 * @category constructors
 * @since 0.1.0
 */
-const make = () => {
+const make = (options) => {
 	const registry = AtomRegistry.make();
 	requestRegistries.add(registry);
+	if (options?.seed !== void 0) run(registry, options.seed);
 	return registry;
 };
 /**
+* Waits until a request registry's seed has settled and every atom a verb
+* started while it ran has started.
+*
+* **When to use**
+*
+* Use before `Hydration.dehydrate` on a registry with an async seed, outside
+* the framework integrations, which call it for you.
+*
+* **Details**
+*
+* Resolves at once for a registry without a seed, or whose seed was
+* synchronous. Rejects with the seed's error.
+*
+* @stability unstable
+* @category getters
+* @since 0.2.0
+*/
+const settled = (registry) => settled$1(registry);
+/**
 * A layer that provides a request registry as the `AtomRegistry`, disposed
 * when the layer's scope closes.
 *
@@ -73,4 +107,4 @@ const layer = Layer.effect(AtomRegistry.AtomRegistry, Effect.acquireRelease(Effe
 * @since 0.1.0
 */
 const isRequestRegistry = (registry) => requestRegistries.has(registry);
-export { RequestRegistry_exports, isRequestRegistry, layer, make };
+export { RequestRegistry_exports, isRequestRegistry, layer, make, settled };

package/dist/TanStackRouter.d.mts

@@ -1,3 +1,4 @@
+import { Seed } from "./RequestRegistry.mjs";
 import * as EffectHydration from "effect/reactivity/Hydration";
 import * as AtomRegistry from "effect/reactivity/AtomRegistry";
 import { AnyRouter } from "@tanstack/react-router";
@@ -38,14 +39,23 @@ export interface RouterAtomsOptions<TRouter extends AnyRouter> {
  *   default registry does. An atom's own `Atom.setIdleTTL` or
  *   `Atom.keepAlive` wins. The server's request registry lives for one
  *   request, so it has none.
+ * - `seed` runs on the server's request registry before the loaders start
+ *   atoms in it, as `RequestRegistry.make`'s does: set what the request's
+ *   atoms need, such as its cookie. It can be async. The browser's registry
+ *   isn't seeded.
  *
  * **Example**
  *
  * ```ts
+ * import { getRequestHeader } from "@tanstack/react-start/server"
  * import { makeRegistry } from "raf-effect-atom/tanstack-router"
  *
- * // Keeps an issue the user navigated away from for a minute.
- * const registry = makeRegistry({ defaultIdleTTL: 60_000 })
+ * const registry = makeRegistry({
+ *   // Keeps an issue the user navigated away from for a minute.
+ *   defaultIdleTTL: 60_000,
+ *   // In-process RPC calls send the page request's cookie.
+ *   seed: (registry) => registry.set(requestCookie, getRequestHeader("cookie"))
+ * })
  * ```
  *
  * @stability unstable
@@ -54,6 +64,7 @@ export interface RouterAtomsOptions<TRouter extends AnyRouter> {
  */
 export declare const makeRegistry: (options?: {
   readonly defaultIdleTTL?: number | undefined;
+  readonly seed?: Seed | undefined;
 }) => AtomRegistry.AtomRegistry;
 /**
  * Provides a registry to a TanStack router's app and streams it from the

package/dist/TanStackRouter.mjs

@@ -1,5 +1,5 @@
 import { dehydrate, hydrate } from "./Hydration.mjs";
-import { isRequestRegistry } from "./RequestRegistry.mjs";
+import { isRequestRegistry, settled } from "./RequestRegistry.mjs";
 import { make } from "./internal/registry.mjs";
 import * as Predicate from "effect/Predicate";
 import { RegistryContext } from "@effect/atom-react";
@@ -51,14 +51,23 @@ import { jsx } from "react/jsx-runtime";
 *   default registry does. An atom's own `Atom.setIdleTTL` or
 *   `Atom.keepAlive` wins. The server's request registry lives for one
 *   request, so it has none.
+* - `seed` runs on the server's request registry before the loaders start
+*   atoms in it, as `RequestRegistry.make`'s does: set what the request's
+*   atoms need, such as its cookie. It can be async. The browser's registry
+*   isn't seeded.
 *
 * **Example**
 *
 * ```ts
+* import { getRequestHeader } from "@tanstack/react-start/server"
 * import { makeRegistry } from "raf-effect-atom/tanstack-router"
 *
-* // Keeps an issue the user navigated away from for a minute.
-* const registry = makeRegistry({ defaultIdleTTL: 60_000 })
+* const registry = makeRegistry({
+*   // Keeps an issue the user navigated away from for a minute.
+*   defaultIdleTTL: 60_000,
+*   // In-process RPC calls send the page request's cookie.
+*   seed: (registry) => registry.set(requestCookie, getRequestHeader("cookie"))
+* })
 * ```
 *
 * @stability unstable
@@ -116,6 +125,7 @@ const setupRouterAtoms = (options) => {
 		const dehydrate$1 = router.options.dehydrate;
 		router.options.dehydrate = async () => {
 			const dehydrated = await dehydrate$1?.();
+			await settled(registry);
 			if (disposed) return dehydrated;
 			const atoms = { "raf-effect-atom": dehydrate(registry) };
 			return Predicate.isObject(dehydrated) ? {

package/dist/Waterfalls.d.mts

@@ -1,6 +1,5 @@
+import { ArgsOf, Handle, Source } from "./Handle.mjs";
 import { Mode } from "./internal/waterfalls.mjs";
-import * as Atom from "effect/reactivity/Atom";
-import * as AsyncResult from "effect/reactivity/AsyncResult";
 import * as React from "react";
 /**
  * What `useAtomResult` does in development when a read starts an atom that
@@ -51,8 +50,8 @@ export declare const WaterfallDetection: (props: {
   readonly mode: WaterfallMode;
 }) => React.ReactNode;
 /**
- * Starts an atom during render and returns it, for an input only a render
- * knows, such as a debounced search query.
+ * Starts a source's atom during render and returns its handle, for an input
+ * only a render knows, such as a debounced search query.
  *
  * **When to use**
  *
@@ -71,12 +70,14 @@ export declare const WaterfallDetection: (props: {
  * - A result the server is still streaming is awaited by `useAtomResult`,
  *   not started again.
  * - `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 atom a loader would start, inside an error boundary's `wrap`:
- * `useAtomResult(boundary.wrap(useWaterfall(user(id))))`. The wrapper isn't
- * serializable, so the server couldn't send it to the browser.
+ * 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.
  *
  * **Example**
  *
@@ -84,7 +85,7 @@ export declare const WaterfallDetection: (props: {
  * import { useAtomResult, useWaterfall } from "raf-effect-atom"
  *
  * function Author(props: { readonly userId: UserId }) {
- *   const result = useAtomResult(useWaterfall(user(props.userId)))
+ *   const result = useAtomResult(user, useWaterfall(user, props.userId))
  *   // ...
  * }
  * ```
@@ -95,4 +96,4 @@ export declare const WaterfallDetection: (props: {
  * @category hooks
  * @since 0.1.0
  */
-export declare const useWaterfall: <Self extends Atom.Atom<AsyncResult.AsyncResult<unknown, unknown>>>(atom: Self) => Self;
+export declare const useWaterfall: <S extends Source>(source: S, ...args: ArgsOf<S>) => Handle<S>;

package/dist/Waterfalls.mjs

@@ -2,6 +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 { prefetch } from "./Loader.mjs";
 import { ModeContext, isStarted } from "./internal/waterfalls.mjs";
 import * as Predicate from "effect/Predicate";
@@ -53,8 +54,8 @@ const WaterfallDetection = (props) => process.env.NODE_ENV === "production" ? pr
 	children: props.children
 });
 /**
-* Starts an atom during render and returns it, for an input only a render
-* knows, such as a debounced search query.
+* Starts a source's atom during render and returns its handle, for an input
+* only a render knows, such as a debounced search query.
 *
 * **When to use**
 *
@@ -73,12 +74,14 @@ const WaterfallDetection = (props) => process.env.NODE_ENV === "production" ? pr
 * - A result the server is still streaming is awaited by `useAtomResult`,
 *   not started again.
 * - `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 atom a loader would start, inside an error boundary's `wrap`:
-* `useAtomResult(boundary.wrap(useWaterfall(user(id))))`. The wrapper isn't
-* serializable, so the server couldn't send it to the browser.
+* 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.
 *
 * **Example**
 *
@@ -86,7 +89,7 @@ const WaterfallDetection = (props) => process.env.NODE_ENV === "production" ? pr
 * import { useAtomResult, useWaterfall } from "raf-effect-atom"
 *
 * function Author(props: { readonly userId: UserId }) {
-*   const result = useAtomResult(useWaterfall(user(props.userId)))
+*   const result = useAtomResult(user, useWaterfall(user, props.userId))
 *   // ...
 * }
 * ```
@@ -97,11 +100,12 @@ const WaterfallDetection = (props) => process.env.NODE_ENV === "production" ? pr
 * @category hooks
 * @since 0.1.0
 */
-const useWaterfall = (atom) => {
+const useWaterfall = (source, ...args) => {
 	const registry = React.useContext(RegistryContext);
+	const atom = atomOf(source, args);
 	const target = hydrated(atom);
 	const key = keyOf(target);
-	if (!(Predicate.isString(key) && get(registry, key) !== void 0) && !isStarted(registry, target)) Effect.runSync(Effect.provideService(prefetch(atom), AtomRegistry.AtomRegistry, registry));
-	return atom;
+	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);
 };
 export { WaterfallDetection, useWaterfall };

package/dist/index.d.mts

@@ -1,7 +1,8 @@
+import { ArgsOf, ErrorOf, Handle, HandleKey, LoadedHandle, Source, SuccessOf } from "./Handle.mjs";
 import { Loader_d_exports } from "./Loader.mjs";
+import { RequestRegistry_d_exports } from "./RequestRegistry.mjs";
 import { HydrationBoundary, HydrationBoundaryProps } from "./ReactHydration.mjs";
 import { Hydration_d_exports } from "./Hydration.mjs";
-import { RequestRegistry_d_exports } from "./RequestRegistry.mjs";
 import { useAtomResult } from "./Hooks.mjs";
 import { WaterfallDetection, WaterfallMode, useWaterfall } from "./Waterfalls.mjs";
-export { Hydration_d_exports as Hydration, HydrationBoundary, HydrationBoundaryProps, Loader_d_exports as Loader, RequestRegistry_d_exports as RequestRegistry, WaterfallDetection, WaterfallMode, useAtomResult, useWaterfall };
+export { ArgsOf, ErrorOf, Handle, HandleKey, Hydration_d_exports as Hydration, HydrationBoundary, HydrationBoundaryProps, LoadedHandle, Loader_d_exports as Loader, RequestRegistry_d_exports as RequestRegistry, Source, SuccessOf, WaterfallDetection, WaterfallMode, useAtomResult, useWaterfall };

package/dist/internal/handles.mjs

@@ -0,0 +1,22 @@
+import { keyOf as keyOf$1 } from "./leases.mjs";
+import * as Atom from "effect/reactivity/Atom";
+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. */
+const keyOf = (atom) => {
+	const key = keyOf$1(atom);
+	if (!Predicate.isString(key)) return;
+	return key;
+};
+const make = (args, atom) => ({
+	args,
+	key: keyOf(atom)
+});
+const loaded = (args, atom) => ({
+	args,
+	key: keyOf(atom),
+	loaded: true
+});
+export { atomOf, loaded, make };

package/dist/internal/next.mjs

@@ -1,16 +1,25 @@
-import { dehydrate as dehydrate$1 } from "../Hydration.mjs";
-import { make } from "../RequestRegistry.mjs";
-import { make as make$1 } from "../Loader.mjs";
+import { dehydrate } from "../Hydration.mjs";
+import { make as make$1, settled } from "../RequestRegistry.mjs";
+import { make as make$2 } from "../Loader.mjs";
 import * as React from "react";
 // src/internal/next.ts
-const getRegistry = React.cache(() => {
-	const registry = make();
-	React.cacheSignal()?.addEventListener("abort", () => registry.dispose(), { once: true });
-	return registry;
-});
-const getLoader = React.cache(() => make$1(getRegistry()));
-const prefetch = (atom) => getLoader().prefetch(atom);
-const ensure = (atom) => getLoader().ensure(atom);
-const fetch = (atom) => getLoader().fetch(atom);
-const dehydrate = () => dehydrate$1(getRegistry());
-export { dehydrate, ensure, fetch, getRegistry, prefetch };
+const make = (options) => {
+	const getRegistry = React.cache(() => {
+		const registry = make$1(options);
+		React.cacheSignal()?.addEventListener("abort", () => registry.dispose(), { once: true });
+		return registry;
+	});
+	const getLoader = React.cache(() => make$2(getRegistry()));
+	return {
+		dehydrate: async () => {
+			const registry = getRegistry();
+			await settled(registry);
+			return dehydrate(registry);
+		},
+		ensure: (source, ...args) => getLoader().ensure(source, ...args),
+		fetch: (source, ...args) => getLoader().fetch(source, ...args),
+		getRegistry,
+		prefetch: (source, ...args) => getLoader().prefetch(source, ...args)
+	};
+};
+export { make };

package/dist/internal/registry.mjs

@@ -9,7 +9,7 @@ const defaultIdleTTL = 400;
 * A request registry on the server, and in the browser a registry like
 * `@effect/atom-react`'s `RegistryProvider` makes.
 */
-const make = (options) => isServer() ? make$1() : AtomRegistry.make({
+const make = (options) => isServer() ? make$1({ seed: options?.seed }) : AtomRegistry.make({
 	defaultIdleTTL: options?.defaultIdleTTL ?? defaultIdleTTL,
 	scheduleTask
 });

package/dist/internal/seeds.d.mts

@@ -0,0 +1,3 @@
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+/** Prepares a request registry before any loader verb starts an atom in it. */
+export type Seed = (registry: AtomRegistry.AtomRegistry) => void | Promise<void>;