raf-effect-atom 0.0.0-stage → 0.1.0

package/dist/Hydration.mjs

@@ -0,0 +1,134 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { split } from "./internal/pending.mjs";
+import { remember } from "./internal/sources.mjs";
+import * as Atom from "effect/reactivity/Atom";
+import * as EffectHydration from "effect/reactivity/Hydration";
+// src/Hydration.ts
+/**
+* Streams a server registry into the browser's, typed failures intact, and
+* hydrates it without requesting anything again.
+*
+* `dehydrate` encodes the request registry's serializable atoms. Settled
+* results cross as values; results still loading cross as promises that
+* resolve when they settle, carried by the framework's own streaming.
+* `hydrate` applies settled values at once and holds each streamed result
+* until its promise resolves, so `useAtomResult` waits for it instead of
+* starting the atom. `hydrated` keeps a hydrated value on the atom's first
+* read instead of running its effect again.
+*
+* Typed failures survive because a serializable `AsyncResult` atom, such as
+* an `AtomRpc` query with a `serializationKey`, encodes its `Cause` with the
+* procedure's error Schemas: a server-side `IssueNotFound` decodes as an
+* `IssueNotFound` in the browser.
+*
+* @stability unstable
+* @since 0.1.0
+*/
+var Hydration_exports = /* @__PURE__ */ __exportAll({
+	dehydrate: () => dehydrate,
+	hydrate: () => hydrate,
+	hydrated: () => hydrated
+});
+const copies = /* @__PURE__ */ new WeakMap();
+/**
+* Returns a serializable atom that keeps its hydrated value on its first
+* read, instead of running its effect again.
+*
+* **When to use**
+*
+* The loader verbs and `useAtomResult` already read through it. Use it when
+* reading a hydrated atom with `@effect/atom-react`'s own hooks.
+*
+* **Details**
+*
+* The copy shares the atom's serialization key, so both read the same
+* registry node. It sets `skipInitialRun` on the atom's `Serializable`
+* metadata, and is memoized per atom, so every call returns the same copy.
+* An atom that isn't serializable, or already skips its initial run, is
+* returned as it is.
+*
+* **Gotchas**
+*
+* The copy keeps the hydrated value only for the first read: a refresh, or a
+* change to a dependency, runs the effect as usual. An `Initial` value never
+* skips the effect, which is why a result the server was still loading
+* crosses as a promise that `useAtomResult` waits for.
+*
+* **Example**
+*
+* ```ts
+* import { useAtomValue } from "@effect/atom-react"
+* import { Hydration } from "raf-effect-atom"
+*
+* const result = useAtomValue(Hydration.hydrated(issue(1)))
+* ```
+*
+* @see {@link Atom.serializable} for the metadata it copies
+*
+* @stability unstable
+* @category combinators
+* @since 0.1.0
+*/
+const hydrated = (atom) => {
+	if (!Atom.isSerializable(atom) || atom[Atom.SerializableTypeId].skipInitialRun === true) return atom;
+	const cached = copies.get(atom);
+	if (cached !== void 0) return cached;
+	const copy = Object.assign(Object.create(Object.getPrototypeOf(atom)), {
+		...atom,
+		[Atom.SerializableTypeId]: {
+			...atom[Atom.SerializableTypeId],
+			skipInitialRun: true
+		}
+	});
+	copies.set(atom, copy);
+	return copy;
+};
+/**
+* Encodes a request registry's serializable atoms for the browser.
+*
+* **Details**
+*
+* `Hydration.dehydrate` with `encodeInitialAs: "promise"`: a settled result
+* crosses as its encoded value, and a result still loading crosses as a
+* promise of its encoded value, which resolves when it settles. The
+* framework's serializer carries the promises (TanStack Router's dehydrated
+* state, React's server component props, React Router's Single Fetch).
+*
+* **Gotchas**
+*
+* Only atoms in the registry when it's called are included, so call it once
+* the loaders have started theirs.
+*
+* @see {@link hydrate} for the browser side
+*
+* @stability unstable
+* @category dehydration
+* @since 0.1.0
+*/
+const dehydrate = (registry) => remember(EffectHydration.dehydrate(registry, { encodeInitialAs: "promise" }), registry);
+/**
+* Applies dehydrated state to the browser's registry.
+*
+* **When to use**
+*
+* Use outside React, such as in a router's `hydrate` hook, before the app
+* renders. Inside React, use `HydrationBoundary`.
+*
+* **Details**
+*
+* Settled values go through `Hydration.hydrate`. A streamed result is held
+* until its promise resolves, then hydrated; until then `useAtomResult`
+* suspends on it instead of starting the atom, which would request it again.
+* A streamed result that can't be decoded, or whose promise rejects, is
+* dropped, and the atom runs in the browser.
+*
+* @see {@link dehydrate} for the server side
+*
+* @stability unstable
+* @category hydration
+* @since 0.1.0
+*/
+const hydrate = (registry, state) => {
+	EffectHydration.hydrate(registry, split(registry, state));
+};
+export { Hydration_exports, dehydrate, hydrate, hydrated };

package/dist/Loader.d.mts

@@ -0,0 +1,192 @@
+import { ArgsOf, ErrorOf, Handle, LoadedHandle, Source, SuccessOf } from "./Handle.mjs";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+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, SettledResult, ensure, fetch, make, prefetch, result };
+}
+/**
+ * A settled `AsyncResult`: what `ensure` and `fetch` return.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export type SettledResult<A, E> = AsyncResult.Failure<A, E> | AsyncResult.Success<A, E>;
+/**
+ * How long a loader's lease keeps an atom mounted when no component takes it
+ * over. Default 30 seconds.
+ *
+ * **Details**
+ *
+ * A lease ends when `useAtomResult` mounts the atom, or when this time has
+ * passed, after which the registry's idle TTL applies as usual. On a request
+ * registry, leases last until the registry is disposed.
+ *
+ * @stability unstable
+ * @category references
+ * @since 0.1.0
+ */
+export declare const LeaseTTL: Context.Reference<Duration.Duration>;
+/**
+ * Starts a source's atom without waiting for it, and returns its handle.
+ *
+ * **When to use**
+ *
+ * Use for data the route needs but its loader doesn't: it streams in while
+ * the route renders.
+ *
+ * **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.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Loader } from "raf-effect-atom"
+ *
+ * const program = Loader.prefetch(commentPage, issueId, 0)
+ * ```
+ *
+ * @stability unstable
+ * @category verbs
+ * @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, waits only while it has no result, and returns a
+ * handle whose reader renders without suspending.
+ *
+ * **When to use**
+ *
+ * Use when the loader needs the result, such as to redirect on a tag, or
+ * when the route shouldn't render without it.
+ *
+ * **Details**
+ *
+ * An atom with a result returns at once, without refetching. On a request
+ * registry, it also waits out a refresh in flight, so the server never
+ * renders a result that's about to change. A typed failure settles it like
+ * a success: `result` returns it. A defect or an interruption fails the
+ * Effect.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ * import { AsyncResult } from "effect/reactivity"
+ * import { Loader } from "raf-effect-atom"
+ *
+ * const program = Effect.gen(function* () {
+ *   const handle = yield* Loader.ensure(issue, 1)
+ *   const result = Loader.result(handle)
+ *   return AsyncResult.isSuccess(result) ? result.value.title : "missing"
+ * })
+ * ```
+ *
+ * @stability unstable
+ * @category verbs
+ * @since 0.1.0
+ */
+export declare const ensure: <S extends Source>(source: S, ...args: ArgsOf<S>) => Effect.Effect<LoadedHandle<S>, never, AtomRegistry.AtomRegistry>;
+/**
+ * Starts a source's atom, or refreshes it if it has a result, waits for the
+ * new result to settle, and returns a handle whose reader renders without
+ * suspending.
+ *
+ * **When to use**
+ *
+ * Use when the loader must not see a result from before it ran, such as
+ * after a mutation.
+ *
+ * **Details**
+ *
+ * Waits until the result settles and isn't refreshing. A typed failure
+ * settles it like a success: `result` returns it. A defect or an
+ * interruption fails the Effect.
+ *
+ * @stability unstable
+ * @category verbs
+ * @since 0.1.0
+ */
+export declare const fetch: <S extends Source>(source: S, ...args: ArgsOf<S>) => Effect.Effect<LoadedHandle<S>, never, AtomRegistry.AtomRegistry>;
+/**
+ * Returns the settled result `ensure` or `fetch` waited for.
+ *
+ * **When to use**
+ *
+ * Use in the loader that ran the verb, to branch on the result: redirect on
+ * a tag, or build another atom's arguments from it. Components read the
+ * handle with `useAtomResult`, which follows the registry.
+ *
+ * **Gotchas**
+ *
+ * Only the handle object the verb returned has it: a handle that crossed
+ * the network, as loader data or a server component's prop, is a copy, and
+ * this throws for it.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { AsyncResult } from "effect/reactivity"
+ * import { Loader } from "raf-effect-atom"
+ *
+ * const handle = await atoms.ensure(issue, id)
+ * const error = AsyncResult.error(Loader.result(handle))
+ * ```
+ *
+ * @stability unstable
+ * @category getters
+ * @since 0.1.0
+ */
+export declare const result: <S extends Source>(handle: LoadedHandle<S>) => SettledResult<SuccessOf<S>, ErrorOf<S>>;
+/**
+ * The loader verbs as Promises over one registry, as the framework
+ * integrations put them on the router context.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.1.0
+ */
+export interface Loader {
+  /** {@link ensure}, as a Promise that rejects only on a defect. */
+  readonly ensure: <S extends Source>(source: S, ...args: ArgsOf<S>) => Promise<LoadedHandle<S>>;
+  /** {@link fetch}, as a Promise that rejects only on a defect. */
+  readonly fetch: <S extends Source>(source: S, ...args: ArgsOf<S>) => Promise<LoadedHandle<S>>;
+  /** {@link prefetch}, run at once. */
+  readonly prefetch: <S extends Source>(source: S, ...args: ArgsOf<S>) => Handle<S>;
+}
+/**
+ * Creates the Promise verbs over one registry.
+ *
+ * **When to use**
+ *
+ * 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 with the `AtomRegistry` provided.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Loader, RequestRegistry } from "raf-effect-atom"
+ *
+ * const loader = Loader.make(RequestRegistry.make())
+ * const comments = loader.prefetch(commentPage, 1, 0)
+ * const issueHandle = await loader.ensure(issue, 1)
+ * ```
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: (registry: AtomRegistry.AtomRegistry, options?: {
+  readonly leaseTTL?: Duration.Input | undefined;
+}) => Loader;
+export { Loader_d_exports };

package/dist/Loader.mjs

@@ -0,0 +1,286 @@
+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 { isRequestRegistry } from "./RequestRegistry.mjs";
+import * as Atom from "effect/reactivity/Atom";
+import * as Predicate from "effect/Predicate";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+// src/Loader.ts
+/**
+* Starts atoms from route loaders, before anything renders, so nothing
+* waterfalls.
+*
+* Each verb takes a source, an atom family or an `AsyncResult` atom, with its
+* arguments. It starts the atom in the registry, takes a lease on it, so the
+* registry's idle TTL can't evict it before the route renders and
+* `useAtomResult` takes it over, and returns its handle for the component
+* that reads it:
+*
+* | Verb       | Starts the atom                 | Waits                         | Has a value already   |
+* | ---------- | ------------------------------- | ----------------------------- | --------------------- |
+* | `prefetch` | if it isn't in the registry     | never                         | leaves it alone       |
+* | `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 |
+*
+* 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
+* interruptions reject.
+*
+* The verbs are Effects that need the `AtomRegistry`; `make` gives the same
+* verbs as Promises over one registry, for loaders that are async functions.
+*
+* @stability unstable
+* @since 0.1.0
+*/
+var Loader_exports = /* @__PURE__ */ __exportAll({
+	LeaseTTL: () => LeaseTTL,
+	ensure: () => ensure,
+	fetch: () => fetch,
+	make: () => make,
+	prefetch: () => prefetch,
+	result: () => result
+});
+/**
+* How long a loader's lease keeps an atom mounted when no component takes it
+* over. Default 30 seconds.
+*
+* **Details**
+*
+* A lease ends when `useAtomResult` mounts the atom, or when this time has
+* passed, after which the registry's idle TTL applies as usual. On a request
+* registry, leases last until the registry is disposed.
+*
+* @stability unstable
+* @category references
+* @since 0.1.0
+*/
+const LeaseTTL = Context.Reference("raf-effect-atom/Loader/LeaseTTL", { defaultValue: () => Duration.seconds(30) });
+const start = Effect.fnUntraced(function* (atom) {
+	const registry = yield* AtomRegistry.AtomRegistry;
+	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 ttl = request ? void 0 : Duration.toMillis(yield* LeaseTTL);
+	const target = hydrated(atom);
+	const key = keyOf(target);
+	const existed = registry.getNodes().has(key) || Predicate.isString(key) && registry.preloadedSerializable.has(key);
+	take(registry, target, ttl);
+	return {
+		existed,
+		registry,
+		request,
+		target
+	};
+});
+const isSettled = (result) => AsyncResult.isNotInitial(result) && !result.waiting;
+const settled = (registry, atom, isDone) => Effect.callback((resume) => {
+	const current = registry.get(atom);
+	if (isDone(current)) {
+		resume(Effect.succeed(current));
+		return;
+	}
+	const cancel = registry.subscribe(atom, (value) => {
+		if (isDone(value)) {
+			cancel();
+			resume(Effect.succeed(value));
+		}
+	});
+	return Effect.sync(cancel);
+}).pipe(Effect.flatMap(rejectDefects));
+const rejectDefects = (result) => {
+	if (AsyncResult.isFailure(result) && Option.isNone(Cause.findErrorOption(result.cause))) {
+		const defects = result.cause;
+		return Effect.failCause(defects);
+	}
+	return Effect.succeed(result);
+};
+/**
+* Starts a source's atom without waiting for it, and returns its handle.
+*
+* **When to use**
+*
+* Use for data the route needs but its loader doesn't: it streams in while
+* the route renders.
+*
+* **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.
+*
+* **Example**
+*
+* ```ts
+* import { Effect } from "effect"
+* import { Loader } from "raf-effect-atom"
+*
+* const program = Loader.prefetch(commentPage, issueId, 0)
+* ```
+*
+* @stability unstable
+* @category verbs
+* @since 0.1.0
+*/
+const prefetch = (source, ...args) => Effect.gen(function* () {
+	const atom = atomOf(source, args);
+	yield* start(atom);
+	return make$1(args, atom);
+});
+const loaded = (args, atom, result) => {
+	const handle = loaded$1(args, atom);
+	results.set(handle, result);
+	return handle;
+};
+/**
+* Starts a source's atom, waits only while it has no result, and returns a
+* handle whose reader renders without suspending.
+*
+* **When to use**
+*
+* Use when the loader needs the result, such as to redirect on a tag, or
+* when the route shouldn't render without it.
+*
+* **Details**
+*
+* An atom with a result returns at once, without refetching. On a request
+* registry, it also waits out a refresh in flight, so the server never
+* renders a result that's about to change. A typed failure settles it like
+* a success: `result` returns it. A defect or an interruption fails the
+* Effect.
+*
+* **Example**
+*
+* ```ts
+* import { Effect } from "effect"
+* import { AsyncResult } from "effect/reactivity"
+* import { Loader } from "raf-effect-atom"
+*
+* const program = Effect.gen(function* () {
+*   const handle = yield* Loader.ensure(issue, 1)
+*   const result = Loader.result(handle)
+*   return AsyncResult.isSuccess(result) ? result.value.title : "missing"
+* })
+* ```
+*
+* @stability unstable
+* @category verbs
+* @since 0.1.0
+*/
+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);
+	return loaded(args, atom, result);
+});
+/**
+* Starts a source's atom, or refreshes it if it has a result, waits for the
+* new result to settle, and returns a handle whose reader renders without
+* suspending.
+*
+* **When to use**
+*
+* Use when the loader must not see a result from before it ran, such as
+* after a mutation.
+*
+* **Details**
+*
+* Waits until the result settles and isn't refreshing. A typed failure
+* settles it like a success: `result` returns it. A defect or an
+* interruption fails the Effect.
+*
+* @stability unstable
+* @category verbs
+* @since 0.1.0
+*/
+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 node = registry.getNodes().get(keyOf(target));
+		registry.refresh(node?.atom ?? target);
+	}
+	const result = yield* settled(registry, target, isSettled);
+	return loaded(args, atom, result);
+});
+const results = /* @__PURE__ */ new WeakMap();
+/**
+* Returns the settled result `ensure` or `fetch` waited for.
+*
+* **When to use**
+*
+* Use in the loader that ran the verb, to branch on the result: redirect on
+* a tag, or build another atom's arguments from it. Components read the
+* handle with `useAtomResult`, which follows the registry.
+*
+* **Gotchas**
+*
+* Only the handle object the verb returned has it: a handle that crossed
+* the network, as loader data or a server component's prop, is a copy, and
+* this throws for it.
+*
+* **Example**
+*
+* ```ts
+* import { AsyncResult } from "effect/reactivity"
+* import { Loader } from "raf-effect-atom"
+*
+* const handle = await atoms.ensure(issue, id)
+* const error = AsyncResult.error(Loader.result(handle))
+* ```
+*
+* @stability unstable
+* @category getters
+* @since 0.1.0
+*/
+const result = (handle) => {
+	const settledResult = results.get(handle);
+	if (settledResult === void 0) throw new Error("raf-effect-atom: Loader.result got a handle that no ensure or fetch returned here. Only the code that ran the verb has its result: a handle that crossed the network is a copy. Read it with useAtomResult instead.");
+	return settledResult;
+};
+/**
+* Creates the Promise verbs over one registry.
+*
+* **When to use**
+*
+* 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 with the `AtomRegistry` provided.
+*
+* **Example**
+*
+* ```ts
+* import { Loader, RequestRegistry } from "raf-effect-atom"
+*
+* const loader = Loader.make(RequestRegistry.make())
+* const comments = loader.prefetch(commentPage, 1, 0)
+* const issueHandle = await loader.ensure(issue, 1)
+* ```
+*
+* @stability unstable
+* @category constructors
+* @since 0.1.0
+*/
+const make = (registry, options) => {
+	const leaseTTL = options?.leaseTTL === void 0 ? void 0 : Duration.fromInputUnsafe(options.leaseTTL);
+	const provide = (effect) => {
+		const provided = Effect.provideService(effect, AtomRegistry.AtomRegistry, registry);
+		return leaseTTL === void 0 ? provided : Effect.provideService(provided, LeaseTTL, leaseTTL);
+	};
+	return {
+		ensure: (source, ...args) => Effect.runPromise(provide(ensure(source, ...args))),
+		fetch: (source, ...args) => Effect.runPromise(provide(fetch(source, ...args))),
+		prefetch: (source, ...args) => Effect.runSync(provide(prefetch(source, ...args)))
+	};
+};
+export { LeaseTTL, Loader_exports, ensure, fetch, make, prefetch, result };

package/dist/Next.d.mts

@@ -0,0 +1,65 @@
+import { ArgsOf, Handle, LoadedHandle, Source } from "./Handle.mjs";
+import { HydrateAtoms } from "./NextClient.mjs";
+import { RegistryProvider } from "./RegistryProvider.mjs";
+import * as EffectHydration from "effect/reactivity/Hydration";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+/**
+ * Returns the request registry of the server render in progress.
+ *
+ * **Details**
+ *
+ * Made once per request through React's `cache`, and disposed through
+ * `cacheSignal` when React finishes the render, after the last streamed
+ * result has been sent.
+ *
+ * **Gotchas**
+ *
+ * Only server components share it: outside a server component render,
+ * `cache` doesn't cache, so each call makes a new registry.
+ *
+ * @stability unstable
+ * @category registry
+ * @since 0.1.0
+ */
+export declare const getRegistry: () => AtomRegistry.AtomRegistry;
+/**
+ * `Loader.prefetch` on the request's registry: starts a source's atom, to
+ * stream it, and returns its handle.
+ *
+ * @stability unstable
+ * @category verbs
+ * @since 0.1.0
+ */
+export declare const prefetch: <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.
+ *
+ * @stability unstable
+ * @category verbs
+ * @since 0.1.0
+ */
+export declare const ensure: <S extends Source>(source: S, ...args: ArgsOf<S>) => Promise<LoadedHandle<S>>;
+/**
+ * `Loader.fetch` on the request's registry: starts or refreshes a source's
+ * atom, waits for the new result, and returns its handle.
+ *
+ * @stability unstable
+ * @category verbs
+ * @since 0.1.0
+ */
+export declare const fetch: <S extends Source>(source: S, ...args: ArgsOf<S>) => Promise<LoadedHandle<S>>;
+/**
+ * `Hydration.dehydrate` on the request's registry, for `HydrateAtoms`.
+ *
+ * **Gotchas**
+ *
+ * Includes the atoms started so far, so call it after the server component's
+ * verbs. Each `HydrateAtoms` hydrates what its own `dehydrate()` saw.
+ *
+ * @stability unstable
+ * @category dehydration
+ * @since 0.1.0
+ */
+export declare const dehydrate: () => Array<EffectHydration.DehydratedAtom>;
+export { HydrateAtoms, RegistryProvider };