raf-effect-atom 0.0.0-stage → 0.1.0

package/dist/TanStackRouter.d.mts

@@ -0,0 +1,84 @@
+import * as EffectHydration from "effect/reactivity/Hydration";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { AnyRouter } from "@tanstack/react-router";
+/**
+ * The key `setupRouterAtoms` adds to the router's dehydrated state.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface DehydratedRouterAtoms {
+  readonly "raf-effect-atom": ReadonlyArray<EffectHydration.DehydratedAtom>;
+}
+/**
+ * Options for `setupRouterAtoms`.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface RouterAtomsOptions<TRouter extends AnyRouter> {
+  /** The registry the router context's loader verbs run on. */
+  readonly registry: AtomRegistry.AtomRegistry;
+  readonly router: TRouter;
+}
+/**
+ * Creates the registry for one `getRouter` call: a request registry on the
+ * server, and in the browser a registry like `@effect/atom-react`'s
+ * `RegistryProvider` makes.
+ *
+ * **Details**
+ *
+ * - The server is anywhere without a `window`. To decide otherwise, make
+ *   the registry with `RequestRegistry.make` on the server and
+ *   `AtomRegistry.make` in the browser.
+ * - `defaultIdleTTL` is how many milliseconds the browser's registry keeps
+ *   an atom no component reads, 400 by default, as `@effect/atom-react`'s
+ *   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.
+ *
+ * **Example**
+ *
+ * ```ts
+ * 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 })
+ * ```
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeRegistry: (options?: {
+  readonly defaultIdleTTL?: number | undefined;
+}) => AtomRegistry.AtomRegistry;
+/**
+ * Provides a registry to a TanStack router's app and streams it from the
+ * server to the browser.
+ *
+ * **Details**
+ *
+ * - Wraps the app in `RegistryContext.Provider` through the router's `Wrap`
+ *   option, inside any `Wrap` it has already.
+ * - On the server, adds `Hydration.dehydrate(registry)` to the router's
+ *   dehydrated state once the loaders have run, so results still loading
+ *   cross as promises on the router's stream, and disposes the registry when
+ *   the response finishes.
+ * - In the browser, hydrates the registry from that state before the app
+ *   renders.
+ *
+ * **Gotchas**
+ *
+ * The server's registry must be a request registry and the browser's must
+ * not, so it throws otherwise: a registry shared between requests would send
+ * one user's results to another. Only atoms in the registry when the loaders
+ * finish are sent; one first read while rendering runs again in the browser.
+ *
+ * @stability unstable
+ * @category integrations
+ * @since 0.1.0
+ */
+export declare const setupRouterAtoms: <TRouter extends AnyRouter>(options: RouterAtomsOptions<TRouter>) => void;

package/dist/TanStackRouter.mjs

@@ -0,0 +1,134 @@
+import { dehydrate, hydrate } from "./Hydration.mjs";
+import { isRequestRegistry } from "./RequestRegistry.mjs";
+import { make } from "./internal/registry.mjs";
+import * as Predicate from "effect/Predicate";
+import { RegistryContext } from "@effect/atom-react";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+// src/TanStackRouter.tsx
+/**
+* Connects the loader verbs to TanStack Router and TanStack Start.
+*
+* `getRouter` runs once per request on the server and once in the browser.
+* It makes the registry with `makeRegistry`, puts `Loader.make(registry)` on
+* the router context for the loaders, and calls `setupRouterAtoms`, which
+* provides the registry to the app and sends it from the server to the
+* browser through the router's own dehydration.
+*
+* **Example**
+*
+* ```tsx
+* import { createRouter } from "@tanstack/react-router"
+* import { Loader } from "raf-effect-atom"
+* import { makeRegistry, setupRouterAtoms } from "raf-effect-atom/tanstack-router"
+*
+* export function getRouter() {
+*   const registry = makeRegistry()
+*   const router = createRouter({
+*     routeTree,
+*     context: { atoms: Loader.make(registry) }
+*   })
+*   setupRouterAtoms({ router, registry })
+*   return router
+* }
+* ```
+*
+* @stability unstable
+* @since 0.1.0
+*/
+/**
+* Creates the registry for one `getRouter` call: a request registry on the
+* server, and in the browser a registry like `@effect/atom-react`'s
+* `RegistryProvider` makes.
+*
+* **Details**
+*
+* - The server is anywhere without a `window`. To decide otherwise, make
+*   the registry with `RequestRegistry.make` on the server and
+*   `AtomRegistry.make` in the browser.
+* - `defaultIdleTTL` is how many milliseconds the browser's registry keeps
+*   an atom no component reads, 400 by default, as `@effect/atom-react`'s
+*   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.
+*
+* **Example**
+*
+* ```ts
+* 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 })
+* ```
+*
+* @stability unstable
+* @category constructors
+* @since 0.1.0
+*/
+const makeRegistry = (options) => make(options);
+const hasRouterAtoms = (value) => Predicate.hasProperty(value, "raf-effect-atom") && Array.isArray(value["raf-effect-atom"]);
+/**
+* Provides a registry to a TanStack router's app and streams it from the
+* server to the browser.
+*
+* **Details**
+*
+* - Wraps the app in `RegistryContext.Provider` through the router's `Wrap`
+*   option, inside any `Wrap` it has already.
+* - On the server, adds `Hydration.dehydrate(registry)` to the router's
+*   dehydrated state once the loaders have run, so results still loading
+*   cross as promises on the router's stream, and disposes the registry when
+*   the response finishes.
+* - In the browser, hydrates the registry from that state before the app
+*   renders.
+*
+* **Gotchas**
+*
+* The server's registry must be a request registry and the browser's must
+* not, so it throws otherwise: a registry shared between requests would send
+* one user's results to another. Only atoms in the registry when the loaders
+* finish are sent; one first read while rendering runs again in the browser.
+*
+* @stability unstable
+* @category integrations
+* @since 0.1.0
+*/
+const setupRouterAtoms = (options) => {
+	const router = options.router;
+	const registry = options.registry;
+	if (router.isServer !== isRequestRegistry(registry)) throw new Error(router.isServer ? "raf-effect-atom: setupRouterAtoms got a server router without a request registry, which would share results between requests. Make it with makeRegistry or RequestRegistry.make." : "raf-effect-atom: setupRouterAtoms got a browser router with a request registry. Make it with makeRegistry or AtomRegistry.make.");
+	const Wrap = router.options.Wrap ?? React.Fragment;
+	router.options.Wrap = (props) => /* @__PURE__ */ jsx(RegistryContext.Provider, {
+		value: registry,
+		children: /* @__PURE__ */ jsx(Wrap, { children: props.children })
+	});
+	if (router.isServer) {
+		let disposed = false;
+		router.serverSsrLifecycle = {
+			...router.serverSsrLifecycle,
+			onServerSsrAttach: [...router.serverSsrLifecycle?.onServerSsrAttach ?? [], (serverSsr) => {
+				serverSsr.onCleanup(() => {
+					disposed = true;
+					registry.dispose();
+				});
+			}]
+		};
+		const dehydrate$1 = router.options.dehydrate;
+		router.options.dehydrate = async () => {
+			const dehydrated = await dehydrate$1?.();
+			if (disposed) return dehydrated;
+			const atoms = { "raf-effect-atom": dehydrate(registry) };
+			return Predicate.isObject(dehydrated) ? {
+				...dehydrated,
+				...atoms
+			} : atoms;
+		};
+	} else {
+		const hydrate$1 = router.options.hydrate;
+		router.options.hydrate = async (dehydrated) => {
+			await hydrate$1?.(dehydrated);
+			if (hasRouterAtoms(dehydrated)) hydrate(registry, dehydrated["raf-effect-atom"]);
+		};
+	}
+};
+export { makeRegistry, setupRouterAtoms };

package/dist/Waterfalls.d.mts

@@ -0,0 +1,99 @@
+import { ArgsOf, Handle, Source } from "./Handle.mjs";
+import { Mode } from "./internal/waterfalls.mjs";
+import * as React from "react";
+/**
+ * What `useAtomResult` does in development when a read starts an atom that
+ * no loader, server component, event handler or `useWaterfall` started.
+ *
+ * - `"warn"`: `console.warn` once per atom, naming it. The default.
+ * - `"throw"`: throw to the nearest error boundary, so the page can't be
+ *   used until the atom starts before render.
+ * - `"off"`: don't check.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export type WaterfallMode = Mode;
+/**
+ * Sets how `useAtomResult` reports request waterfalls in the tree below.
+ *
+ * **When to use**
+ *
+ * Put it in the root layout, around the app. `"throw"` turns every atom a
+ * component starts on its own into an error in development, which a person
+ * or a coding agent can't miss.
+ *
+ * **Details**
+ *
+ * Production builds don't check: the check sits behind
+ * `process.env.NODE_ENV !== "production"`, which bundlers replace at build
+ * time, so it's left out of the bundle, and this component renders only its
+ * children.
+ *
+ * **Example**
+ *
+ * ```tsx
+ * import { WaterfallDetection } from "raf-effect-atom"
+ *
+ * function App(props: { readonly children: React.ReactNode }) {
+ *   return <WaterfallDetection mode="throw">{props.children}</WaterfallDetection>
+ * }
+ * ```
+ *
+ * @stability unstable
+ * @category components
+ * @since 0.1.0
+ */
+export declare const WaterfallDetection: (props: {
+  readonly children?: React.ReactNode | undefined;
+  readonly mode: WaterfallMode;
+}) => 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.
+ *
+ * **When to use**
+ *
+ * As an escape hatch, when no loader, server component or event handler can
+ * start the atom: each call is a request waterfall, a round trip after the
+ * render that found the input. Prefer putting the state that picks the data
+ * in the URL, where a loader reads it, or a procedure that resolves the input
+ * on the server. Searching a codebase for `useWaterfall` lists its
+ * waterfalls.
+ *
+ * **Details**
+ *
+ * - Starts the atom like `Loader.prefetch`, with a lease that
+ *   `useAtomResult` takes over when the component mounts, and only if
+ *   nothing started it yet: re-renders start nothing.
+ * - 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 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**
+ *
+ * ```tsx
+ * import { useAtomResult, useWaterfall } from "raf-effect-atom"
+ *
+ * function Author(props: { readonly userId: UserId }) {
+ *   const result = useAtomResult(user, useWaterfall(user, props.userId))
+ *   // ...
+ * }
+ * ```
+ *
+ * @see {@link WaterfallDetection} for the development check it opts out of
+ *
+ * @stability unstable
+ * @category hooks
+ * @since 0.1.0
+ */
+export declare const useWaterfall: <S extends Source>(source: S, ...args: ArgsOf<S>) => Handle<S>;

package/dist/Waterfalls.mjs

@@ -0,0 +1,111 @@
+"use client";
+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";
+import * as Effect from "effect/Effect";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { RegistryContext } from "@effect/atom-react";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+// src/Waterfalls.tsx
+/**
+* Request waterfalls: the escape hatch for atoms only a render can start,
+* and the development check that finds the others.
+*
+* @stability unstable
+* @since 0.1.0
+*/
+/**
+* Sets how `useAtomResult` reports request waterfalls in the tree below.
+*
+* **When to use**
+*
+* Put it in the root layout, around the app. `"throw"` turns every atom a
+* component starts on its own into an error in development, which a person
+* or a coding agent can't miss.
+*
+* **Details**
+*
+* Production builds don't check: the check sits behind
+* `process.env.NODE_ENV !== "production"`, which bundlers replace at build
+* time, so it's left out of the bundle, and this component renders only its
+* children.
+*
+* **Example**
+*
+* ```tsx
+* import { WaterfallDetection } from "raf-effect-atom"
+*
+* function App(props: { readonly children: React.ReactNode }) {
+*   return <WaterfallDetection mode="throw">{props.children}</WaterfallDetection>
+* }
+* ```
+*
+* @stability unstable
+* @category components
+* @since 0.1.0
+*/
+const WaterfallDetection = (props) => process.env.NODE_ENV === "production" ? props.children : /* @__PURE__ */ jsx(ModeContext, {
+	value: props.mode,
+	children: props.children
+});
+/**
+* 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**
+*
+* As an escape hatch, when no loader, server component or event handler can
+* start the atom: each call is a request waterfall, a round trip after the
+* render that found the input. Prefer putting the state that picks the data
+* in the URL, where a loader reads it, or a procedure that resolves the input
+* on the server. Searching a codebase for `useWaterfall` lists its
+* waterfalls.
+*
+* **Details**
+*
+* - Starts the atom like `Loader.prefetch`, with a lease that
+*   `useAtomResult` takes over when the component mounts, and only if
+*   nothing started it yet: re-renders start nothing.
+* - 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 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**
+*
+* ```tsx
+* import { useAtomResult, useWaterfall } from "raf-effect-atom"
+*
+* function Author(props: { readonly userId: UserId }) {
+*   const result = useAtomResult(user, useWaterfall(user, props.userId))
+*   // ...
+* }
+* ```
+*
+* @see {@link WaterfallDetection} for the development check it opts out of
+*
+* @stability unstable
+* @category hooks
+* @since 0.1.0
+*/
+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)) return Effect.runSync(Effect.provideService(prefetch(source, ...args), AtomRegistry.AtomRegistry, registry));
+	return make(args, atom);
+};
+export { WaterfallDetection, useWaterfall };

package/dist/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,12 @@
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+export { __exportAll };

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+import { ArgsOf, ErrorOf, Handle, HandleKey, LoadedHandle, Source, SuccessOf } from "./Handle.mjs";
+import { HydrationBoundary, HydrationBoundaryProps } from "./ReactHydration.mjs";
+import { Loader_d_exports } from "./Loader.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 { 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/index.mjs

@@ -0,0 +1,7 @@
+import { Hydration_exports } from "./Hydration.mjs";
+import { RequestRegistry_exports } from "./RequestRegistry.mjs";
+import { Loader_exports } from "./Loader.mjs";
+import { useAtomResult } from "./Hooks.mjs";
+import { HydrationBoundary } from "./ReactHydration.mjs";
+import { WaterfallDetection, useWaterfall } from "./Waterfalls.mjs";
+export { Hydration_exports as Hydration, HydrationBoundary, Loader_exports as Loader, RequestRegistry_exports as RequestRegistry, WaterfallDetection, useAtomResult, useWaterfall };

package/dist/internal/development.mjs

@@ -0,0 +1,6 @@
+import * as Effect from "effect/Effect";
+import * as Config from "effect/Config";
+// src/internal/development.ts
+/** Whether `NODE_ENV` isn't `production`, read through `Config`. */
+const isDevelopment = Config.String("NODE_ENV").pipe(Config.withDefault("development"), Effect.map((env) => env !== "production"), Effect.orElseSucceed(() => true));
+export { isDevelopment };

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/leases.mjs

@@ -0,0 +1,39 @@
+import * as Atom from "effect/reactivity/Atom";
+// src/internal/leases.ts
+const leases = /* @__PURE__ */ new WeakMap();
+/** The registry's key for an atom: its serialization key, or the atom. */
+const keyOf = (atom) => Atom.isSerializable(atom) ? atom[Atom.SerializableTypeId].key : atom;
+/**
+* Mounts `atom` until `release`, or until `ttl` milliseconds pass. Taking a
+* lease the atom already has restarts its timer.
+*/
+const take = (registry, atom, ttl) => {
+	let byKey = leases.get(registry);
+	if (byKey === void 0) {
+		byKey = /* @__PURE__ */ new Map();
+		leases.set(registry, byKey);
+	}
+	const key = keyOf(atom);
+	let lease = byKey.get(key);
+	if (lease === void 0) {
+		const unmount = registry.mount(atom);
+		const owner = byKey;
+		const created = {
+			release: () => {
+				clearTimeout(created.timer);
+				owner.delete(key);
+				unmount();
+			},
+			timer: void 0
+		};
+		byKey.set(key, created);
+		lease = created;
+	}
+	clearTimeout(lease.timer);
+	lease.timer = ttl === void 0 ? void 0 : setTimeout(lease.release, ttl);
+};
+/** Releases `atom`'s lease, if it has one. */
+const release = (registry, atom) => {
+	leases.get(registry)?.get(keyOf(atom))?.release();
+};
+export { keyOf, release, take };

package/dist/internal/next.mjs

@@ -0,0 +1,16 @@
+import { dehydrate as dehydrate$1 } from "../Hydration.mjs";
+import { make } from "../RequestRegistry.mjs";
+import { make as make$1 } 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 = (source, ...args) => getLoader().prefetch(source, ...args);
+const ensure = (source, ...args) => getLoader().ensure(source, ...args);
+const fetch = (source, ...args) => getLoader().fetch(source, ...args);
+const dehydrate = () => dehydrate$1(getRegistry());
+export { dehydrate, ensure, fetch, getRegistry, prefetch };

package/dist/internal/pending.mjs

@@ -0,0 +1,75 @@
+import * as Hydration from "effect/reactivity/Hydration";
+import * as Predicate from "effect/Predicate";
+// src/internal/pending.ts
+const held = /* @__PURE__ */ new WeakMap();
+const pending = /* @__PURE__ */ new WeakMap();
+/** Each key's latest stream, kept once it settles. */
+const streams = /* @__PURE__ */ new WeakMap();
+/** The promise of a streamed result still on its way, if there is one. */
+const get = (registry, key) => pending.get(registry)?.get(key);
+/**
+* The promise of a key's streamed result, settled or not. A component that
+* suspended on it with `React.use` must call `React.use` again when React
+* retries it, or React reports a conditional `use`. Once settled, it's
+* marked fulfilled the way React marks the thenables it tracks, so `use`
+* returns at once instead of suspending again.
+*/
+const stream = (registry, key) => streams.get(registry)?.get(key);
+const hold = (registry, entry, result) => {
+	let entries = held.get(registry);
+	if (entries === void 0) {
+		entries = /* @__PURE__ */ new WeakSet();
+		held.set(registry, entries);
+	}
+	if (entries.has(entry)) return;
+	entries.add(entry);
+	let byKey = pending.get(registry);
+	if (byKey === void 0) {
+		byKey = /* @__PURE__ */ new Map();
+		pending.set(registry, byKey);
+	}
+	if (byKey.has(entry.key)) return;
+	let latest = streams.get(registry);
+	if (latest === void 0) {
+		latest = /* @__PURE__ */ new Map();
+		streams.set(registry, latest);
+	}
+	const owner = byKey;
+	const done = () => {
+		owner.delete(entry.key);
+	};
+	const fulfilled = () => {
+		Object.assign(promise, {
+			status: "fulfilled",
+			value: void 0
+		});
+	};
+	const promise = Promise.resolve(result).then((value) => {
+		done();
+		if (!Predicate.isSymbol(value)) {
+			const resolved = {
+				...entry,
+				resultPromise: void 0,
+				value
+			};
+			Hydration.hydrate(registry, [resolved]);
+		}
+		fulfilled();
+	}, () => {
+		done();
+		fulfilled();
+	});
+	owner.set(entry.key, promise);
+	latest.set(entry.key, promise);
+};
+/**
+* Holds back each streamed entry of `state` until its promise resolves, and
+* returns the settled ones.
+*/
+const split = (registry, state) => {
+	const settled = [];
+	for (const entry of Hydration.toValues(Array.from(state))) if (entry.resultPromise === void 0) settled.push(entry);
+	else hold(registry, entry, entry.resultPromise);
+	return settled;
+};
+export { get, split, stream };

package/dist/internal/registry.mjs

@@ -0,0 +1,16 @@
+import { make as make$1 } from "../RequestRegistry.mjs";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { scheduleTask } from "@effect/atom-react";
+// src/internal/registry.ts
+const isServer = () => !("window" in globalThis);
+/** `@effect/atom-react`'s default registry keeps an unused atom this long. */
+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({
+	defaultIdleTTL: options?.defaultIdleTTL ?? defaultIdleTTL,
+	scheduleTask
+});
+export { isServer, make };

package/dist/internal/sources.mjs

@@ -0,0 +1,14 @@
+// src/internal/sources.ts
+/** The registry each `dehydrate` result came from, while it's referenced. */
+const sources = /* @__PURE__ */ new WeakMap();
+const remember = (state, registry) => {
+	sources.set(state, registry);
+	return state;
+};
+/**
+* The registry `state` was dehydrated from, when it's the same object
+* `dehydrate` returned: during server rendering by a framework that passes
+* loader data to components without serializing it, such as React Router.
+*/
+const sourceOf = (state) => state === void 0 ? void 0 : sources.get(state);
+export { remember, sourceOf };

package/dist/internal/waterfalls.d.mts

@@ -0,0 +1,5 @@
+import "effect/reactivity/Atom";
+import "effect/reactivity/AtomRegistry";
+import "react";
+/** What a development read does when it starts an atom nothing started. */
+export type Mode = "off" | "throw" | "warn";