effect 4.0.0-beta.66 → 4.0.0-beta.68

package/dist/unstable/reactivity/Atom.d.ts

@@ -1,4 +1,27 @@
 /**
+ * The `Atom` module defines reactive values and the helpers for constructing,
+ * composing, running, and persisting them with an `AtomRegistry`. Atoms are
+ * small read functions whose regular `get` reads form a dependency graph, so
+ * derived values are cached by the registry and invalidated when their
+ * dependencies, writable state, refresh hooks, or subscriptions change.
+ *
+ * Use atoms for application and UI state, derived data, `Effect` or `Stream`
+ * queries exposed as `AsyncResult`, writable function atoms for commands,
+ * subscription refs, pull-based streams, optimistic updates, URL search
+ * parameters, `KeyValueStore` entries, and serializable or server-specific
+ * hydration.
+ *
+ * The cache belongs to the registry, not the atom object: the same atom can have
+ * different values in different registries, and serializable atoms are keyed by
+ * their serialization key. Stable atom identity matters for dependency tracking
+ * and cache reuse, so use `family` for parameterized atoms. Unobserved atoms are
+ * disposed unless kept alive or retained by an idle TTL, which can cause derived
+ * state, effects, streams, and finalizers to be rebuilt later. Runtime-backed
+ * atoms run effects and streams with the registry scheduler, scope, and
+ * `AtomRuntime` layer context; `runtime.withReactivity` only refreshes after
+ * explicit `Reactivity` invalidations, while one-shot reads such as `once` do
+ * not create dependency edges.
+ *
  * @since 4.0.0
  */
 import * as Arr from "../../Array.ts";
@@ -23,18 +46,24 @@ import { AtomRegistry } from "./AtomRegistry.ts";
 import * as Registry from "./AtomRegistry.ts";
 import * as Reactivity from "./Reactivity.ts";
 /**
+ * Type-level identifier used to recognize `Atom` values.
+ *
+ * @category type IDs
  * @since 4.0.0
- * @category type ids
  */
 export type TypeId = "~effect/reactivity/Atom";
 /**
+ * Runtime identifier attached to `Atom` values and used by `isAtom`.
+ *
+ * @category type IDs
  * @since 4.0.0
- * @category type ids
  */
 export declare const TypeId: TypeId;
 /**
- * @since 4.0.0
+ * Reactive value read by an `AtomRegistry`, with metadata controlling caching, laziness, refresh behavior, and initial value targeting.
+ *
  * @category models
+ * @since 4.0.0
  */
 export interface Atom<A> extends Pipeable, Inspectable.Inspectable {
     readonly [TypeId]: TypeId;
@@ -47,51 +76,76 @@ export interface Atom<A> extends Pipeable, Inspectable.Inspectable {
     readonly initialValueTarget?: Atom<A>;
 }
 /**
+ * Returns `true` when a value is an `Atom`.
+ *
+ * @category guards
  * @since 4.0.0
- * @category Guards
  */
 export declare const isAtom: (u: unknown) => u is Atom<any>;
 /**
+ * Extracts the value type produced by an `Atom`.
+ *
+ * @category utility types
  * @since 4.0.0
  */
 export type Type<T extends Atom<any>> = T extends Atom<infer A> ? A : never;
 /**
+ * Extracts the success value type from an atom whose value is an `AsyncResult`.
+ *
+ * @category utility types
  * @since 4.0.0
  */
 export type Success<T extends Atom<any>> = T extends Atom<AsyncResult.AsyncResult<infer A, infer _>> ? A : never;
 /**
+ * Extracts the item type from an atom whose value is a `PullResult`.
+ *
+ * @category utility types
  * @since 4.0.0
  */
 export type PullSuccess<T extends Atom<any>> = T extends Atom<PullResult<infer A, infer _>> ? A : never;
 /**
+ * Extracts the failure error type from an atom whose value is an `AsyncResult`.
+ *
+ * @category utility types
  * @since 4.0.0
  */
 export type Failure<T extends Atom<any>> = T extends Atom<AsyncResult.AsyncResult<infer _, infer E>> ? E : never;
 /**
+ * Returns an atom type without serializable metadata, preserving `Writable` read and write types when the input atom is writable.
+ *
+ * @category utility types
  * @since 4.0.0
  */
 export type WithoutSerializable<T extends Atom<any>> = T extends Writable<infer R, infer W> ? Writable<R, W> : Atom<Type<T>>;
 /**
+ * Runtime identifier attached to writable atoms and used by `isWritable`.
+ *
+ * @category type IDs
  * @since 4.0.0
- * @category type ids
  */
 export declare const WritableTypeId: WritableTypeId;
 /**
+ * Type-level identifier used to recognize writable atoms.
+ *
+ * @category type IDs
  * @since 4.0.0
- * @category type ids
  */
 export type WritableTypeId = "~effect/reactivity/Atom/Writable";
 /**
- * @since 4.0.0
+ * Atom that can also be written to, using a `WriteContext` and an input value to update reactive state.
+ *
  * @category models
+ * @since 4.0.0
  */
 export interface Writable<R, W = R> extends Atom<R> {
     readonly [WritableTypeId]: WritableTypeId;
     readonly write: (ctx: WriteContext<R>, value: W) => void;
 }
 /**
- * @since 4.0.0
+ * Context passed to atom read functions for reading dependencies, awaiting `AsyncResult` or `Option` values, managing subscriptions and finalizers, refreshing atoms, and updating writable atoms.
+ *
  * @category context
+ * @since 4.0.0
  */
 export interface AtomContext {
     <A>(atom: Atom<A>): A;
@@ -127,8 +181,10 @@ export interface AtomContext {
     readonly registry: Registry.AtomRegistry;
 }
 /**
- * @since 4.0.0
+ * Context passed to writable atom write functions for reading atoms, refreshing or setting the current atom, and writing to other writable atoms.
+ *
  * @category context
+ * @since 4.0.0
  */
 export interface WriteContext<A> {
     get<T>(this: WriteContext<A>, atom: Atom<T>): T;
@@ -137,85 +193,113 @@ export interface WriteContext<A> {
     set<R, W>(this: WriteContext<A>, atom: Writable<R, W>, value: W): void;
 }
 /**
- * @since 4.0.0
+ * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const setIdleTTL: {
     /**
-     * @since 4.0.0
+     * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     (duration: Duration.Input): <A extends Atom<any>>(self: A) => A;
     /**
-     * @since 4.0.0
+     * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <A extends Atom<any>>(self: A, duration: Duration.Input): A;
 };
 /**
- * @since 4.0.0
+ * Returns `true` when an atom is writable.
+ *
  * @category refinements
+ * @since 4.0.0
  */
 export declare const isWritable: <R, W>(atom: Atom<R>) => atom is Writable<R, W>;
 /**
- * @since 4.0.0
+ * Creates a read-only atom from a read function and an optional custom refresh registration callback.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export declare const readable: <A>(read: (get: AtomContext) => A, refresh?: (f: <A_1>(atom: Atom<A_1>) => void) => void) => Atom<A>;
 /**
- * @since 4.0.0
+ * Creates a writable atom from read and write functions, with an optional custom refresh registration callback.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export declare const writable: <R, W>(read: (get: AtomContext) => R, write: (ctx: WriteContext<R>, value: W) => void, refresh?: (f: <A>(atom: Atom<A>) => void) => void) => Writable<R, W>;
 /**
- * @since 4.0.0
+ * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export declare const make: {
     /**
-     * @since 4.0.0
+     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A, E>(create: (get: AtomContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
         readonly initialValue?: A | undefined;
         readonly uninterruptible?: boolean | undefined;
     }): Atom<AsyncResult.AsyncResult<A, E>>;
     /**
-     * @since 4.0.0
+     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A, E>(effect: Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
         readonly initialValue?: A;
         readonly uninterruptible?: boolean | undefined;
     }): Atom<AsyncResult.AsyncResult<A, E>>;
     /**
-     * @since 4.0.0
+     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A, E>(create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry>, options?: {
         readonly initialValue?: A;
     }): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>;
     /**
-     * @since 4.0.0
+     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A, E>(stream: Stream.Stream<A, E, AtomRegistry>, options?: {
         readonly initialValue?: A;
     }): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>;
     /**
-     * @since 4.0.0
+     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A>(create: (get: AtomContext) => A): Atom<A>;
     /**
-     * @since 4.0.0
+     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A>(initialValue: A): Writable<A>;
 };
 /**
- * @since 4.0.0
+ * Atom that builds a `Context` from a `Layer` and exposes constructors for atoms, functions, pulls, and subscription refs that run with that context.
+ *
  * @category models
+ * @since 4.0.0
  */
 export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult<Context.Context<R>, ER>> {
     readonly factory: RuntimeFactory;
@@ -267,8 +351,10 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
     readonly subscriptionRef: <A, E>(create: Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity> | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>)) => Writable<AsyncResult.AsyncResult<A, E>, A>;
 }
 /**
- * @since 4.0.0
+ * Factory for `AtomRuntime` values that share a `Layer.MemoMap` and a set of global layers.
+ *
  * @category models
+ * @since 4.0.0
  */
 export interface RuntimeFactory {
     <R, E>(create: Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity> | ((get: AtomContext) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)): AtomRuntime<R, E>;
@@ -281,49 +367,63 @@ export interface RuntimeFactory {
     readonly withReactivity: (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) => <A extends Atom<any>>(atom: A) => A;
 }
 /**
- * @since 4.0.0
+ * Creates a `RuntimeFactory` backed by the supplied `Layer.MemoMap`.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export declare const context: (options: {
     readonly memoMap: Layer.MemoMap;
 }) => RuntimeFactory;
 /**
- * @since 4.0.0
+ * Default `Layer.MemoMap` used by the module-level `runtime` factory.
+ *
  * @category context
+ * @since 4.0.0
  */
 export declare const defaultMemoMap: Layer.MemoMap;
 /**
- * @since 4.0.0
+ * Default `RuntimeFactory` created with `defaultMemoMap`.
+ *
  * @category context
+ * @since 4.0.0
  */
 export declare const runtime: RuntimeFactory;
 /**
  * An alias to `Rx.runtime.withReactivity`, for refreshing an atom whenever the
  * keys change in the `Reactivity` service.
  *
- * @since 4.0.0
  * @category Reactivity
+ * @since 4.0.0
  */
 export declare const withReactivity: (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) => <A extends Atom<any>>(atom: A) => A;
 /**
- * @since 4.0.0
+ * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export declare const subscriptionRef: {
     /**
-     * @since 4.0.0
+     * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A>(ref: SubscriptionRef.SubscriptionRef<A> | ((get: AtomContext) => SubscriptionRef.SubscriptionRef<A>)): Writable<A>;
     /**
-     * @since 4.0.0
+     * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A, E>(effect: Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry> | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry>)): Writable<AsyncResult.AsyncResult<A, E>, A>;
 };
 /**
- * @since 4.0.0
+ * Context passed to `fn` and `fnSync` computations for reading atoms, awaiting results, registering finalizers, refreshing atoms, subscribing to changes, and writing updates.
+ *
  * @category models
+ * @since 4.0.0
  */
 export interface FnContext {
     <A>(atom: Atom<A>): A;
@@ -352,99 +452,131 @@ export interface FnContext {
     readonly registry: Registry.AtomRegistry;
 }
 /**
- * @since 4.0.0
+ * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export declare const fnSync: {
     /**
-     * @since 4.0.0
+     * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <Arg>(): {
         /**
-         * @since 4.0.0
+         * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
+         *
          * @category constructors
+         * @since 4.0.0
          */
         <A>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>;
         /**
-         * @since 4.0.0
+         * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
+         *
          * @category constructors
+         * @since 4.0.0
          */
         <A>(f: (arg: Arg, get: FnContext) => A, options: {
             readonly initialValue: A;
         }): Writable<A, Arg>;
     };
     /**
-     * @since 4.0.0
+     * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A, Arg = void>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>;
     /**
-     * @since 4.0.0
+     * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <A, Arg = void>(f: (arg: Arg, get: FnContext) => A, options: {
         readonly initialValue: A;
     }): Writable<A, Arg>;
 };
 /**
- * @since 4.0.0
+ * Writable async function atom whose value is an `AsyncResult` and whose writes accept function arguments plus `Reset` and `Interrupt` controls.
+ *
  * @category models
+ * @since 4.0.0
  */
 export interface AtomResultFn<Arg, A, E = never> extends Writable<AsyncResult.AsyncResult<A, E>, Arg | Reset | Interrupt> {
 }
 /**
- * @since 4.0.0
+ * Control symbol that can be written to an `AtomResultFn` to reset it to its initial state.
+ *
  * @category symbols
+ * @since 4.0.0
  */
 export declare const Reset: unique symbol;
 /**
- * @since 4.0.0
+ * Type of the `Reset` control symbol accepted by `AtomResultFn` writes.
+ *
  * @category symbols
+ * @since 4.0.0
  */
 export type Reset = typeof Reset;
 /**
- * @since 4.0.0
+ * Control symbol that can be written to an `AtomResultFn` to interrupt the current asynchronous computation.
+ *
  * @category symbols
+ * @since 4.0.0
  */
 export declare const Interrupt: unique symbol;
 /**
- * @since 4.0.0
+ * Type of the `Interrupt` control symbol accepted by `AtomResultFn` writes.
+ *
  * @category symbols
+ * @since 4.0.0
  */
 export type Interrupt = typeof Interrupt;
 /**
- * @since 4.0.0
+ * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export declare const fn: {
     /**
-     * @since 4.0.0
+     * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <Arg>(): <E, A>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
         readonly initialValue?: A | undefined;
         readonly concurrent?: boolean | undefined;
     }) => AtomResultFn<Arg, A, E>;
     /**
-     * @since 4.0.0
+     * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
         readonly initialValue?: A | undefined;
         readonly concurrent?: boolean | undefined;
     }): AtomResultFn<Arg, A, E>;
     /**
-     * @since 4.0.0
+     * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <Arg>(): <E, A>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry>, options?: {
         readonly initialValue?: A | undefined;
         readonly concurrent?: boolean | undefined;
     }) => AtomResultFn<Arg, A, E | Cause.NoSuchElementError>;
     /**
-     * @since 4.0.0
+     * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
+     *
      * @category constructors
+     * @since 4.0.0
      */
     <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry>, options?: {
         readonly initialValue?: A | undefined;
@@ -452,44 +584,58 @@ export declare const fn: {
     }): AtomResultFn<Arg, A, E | Cause.NoSuchElementError>;
 };
 /**
- * @since 4.0.0
+ * `AsyncResult` produced by `pull`, containing a non-empty batch of pulled items and a `done` flag, or `NoSuchElementError` when the stream completes without items.
+ *
  * @category models
+ * @since 4.0.0
  */
 export type PullResult<A, E = never> = AsyncResult.AsyncResult<{
     readonly done: boolean;
     readonly items: Arr.NonEmptyArray<A>;
 }, E | Cause.NoSuchElementError>;
 /**
- * @since 4.0.0
+ * Creates a writable atom that pulls an initial chunk from a stream and then pulls the next chunk whenever it is written to, accumulating items unless `disableAccumulation` is enabled.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export declare const pull: <A, E>(create: ((get: AtomContext) => Stream.Stream<A, E, AtomRegistry>) | Stream.Stream<A, E, AtomRegistry>, options?: {
     readonly disableAccumulation?: boolean | undefined;
 }) => Writable<PullResult<A, E>, void>;
 /**
- * @since 4.0.0
+ * Creates a memoized atom factory that returns the same object for the same argument, using weak references for cached values when the platform supports them.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export declare const family: <Arg, T extends object>(f: (arg: Arg) => T) => (arg: Arg) => T;
 /**
- * @since 4.0.0
+ * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const withFallback: {
     /**
-     * @since 4.0.0
+     * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <E2, A2>(fallback: Atom<AsyncResult.AsyncResult<A2, E2>>): <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>, RW> : Atom<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>>;
     /**
-     * @since 4.0.0
+     * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<AsyncResult.AsyncResult<any, any>>, A2, E2>(self: R, fallback: Atom<AsyncResult.AsyncResult<A2, E2>>): [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>, RW> : Atom<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>>;
 };
 /**
- * @since 4.0.0
+ * Returns a copy of an atom that remains cached and mounted even when no subscribers are using it.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const keepAlive: <A extends Atom<any>>(self: A) => A;
 /**
@@ -498,148 +644,268 @@ export declare const keepAlive: <A extends Atom<any>>(self: A) => A;
  *
  * Note that Atom's have this behavior by default.
  *
- * @since 4.0.0
  * @category combinators
+ * @since 4.0.0
  */
 export declare const autoDispose: <A extends Atom<any>>(self: A) => A;
 /**
- * @since 4.0.0
+ * Sets whether an atom should be lazy.
+ *
+ * Lazy atoms defer recomputation while they have no active listeners or active
+ * non-lazy dependents, rebuilding the next time their value is observed.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const setLazy: {
     /**
-     * @since 4.0.0
+     * Sets whether an atom should be lazy.
+     *
+     * Lazy atoms defer recomputation while they have no active listeners or active
+     * non-lazy dependents, rebuilding the next time their value is observed.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     (lazy: boolean): <A extends Atom<any>>(self: A) => A;
     /**
-     * @since 4.0.0
+     * Sets whether an atom should be lazy.
+     *
+     * Lazy atoms defer recomputation while they have no active listeners or active
+     * non-lazy dependents, rebuilding the next time their value is observed.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <A extends Atom<any>>(self: A, lazy: boolean): A;
 };
 /**
- * @since 4.0.0
+ * Attaches a diagnostic label to an atom.
+ *
+ * The label is used for inspection and debugging metadata and does not change the
+ * atom's read or write behavior.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const withLabel: {
     /**
-     * @since 4.0.0
+     * Attaches a diagnostic label to an atom.
+     *
+     * The label is used for inspection and debugging metadata and does not change the
+     * atom's read or write behavior.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     (name: string): <A extends Atom<any>>(self: A) => A;
     /**
-     * @since 4.0.0
+     * Attaches a diagnostic label to an atom.
+     *
+     * The label is used for inspection and debugging metadata and does not change the
+     * atom's read or write behavior.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <A extends Atom<any>>(self: A, name: string): A;
 };
 /**
- * @since 4.0.0
+ * Pairs an atom with an initial value for registry initialization.
+ *
+ * The returned tuple can be supplied to `AtomRegistry` initial values so the atom
+ * starts with the provided value before it is first rebuilt.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const initialValue: {
     /**
-     * @since 4.0.0
+     * Pairs an atom with an initial value for registry initialization.
+     *
+     * The returned tuple can be supplied to `AtomRegistry` initial values so the atom
+     * starts with the provided value before it is first rebuilt.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <A>(initialValue: A): (self: Atom<A>) => readonly [Atom<A>, A];
     /**
-     * @since 4.0.0
+     * Pairs an atom with an initial value for registry initialization.
+     *
+     * The returned tuple can be supplied to `AtomRegistry` initial values so the atom
+     * starts with the provided value before it is first rebuilt.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <A>(self: Atom<A>, initialValue: A): readonly [Atom<A>, A];
 };
 /**
- * @since 4.0.0
+ * Creates a derived atom by reading another atom with a custom `AtomContext`
+ * function.
+ *
+ * If the source is writable, the derived atom keeps the source write input and
+ * forwards writes to the source. `initialValueTarget` controls which atom receives
+ * preloaded initial values for the derived atom.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const transform: {
     /**
-     * @since 4.0.0
+     * Creates a derived atom by reading another atom with a custom `AtomContext`
+     * function.
+     *
+     * If the source is writable, the derived atom keeps the source write input and
+     * forwards writes to the source. `initialValueTarget` controls which atom receives
+     * preloaded initial values for the derived atom.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<any>, B>(f: (get: AtomContext, atom: R) => B, options?: {
         readonly initialValueTarget?: Atom<B> | undefined;
     }): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
     /**
-     * @since 4.0.0
+     * Creates a derived atom by reading another atom with a custom `AtomContext`
+     * function.
+     *
+     * If the source is writable, the derived atom keeps the source write input and
+     * forwards writes to the source. `initialValueTarget` controls which atom receives
+     * preloaded initial values for the derived atom.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<any>, B>(self: R, f: (get: AtomContext, atom: R) => B, options?: {
         readonly initialValueTarget?: Atom<B> | undefined;
     }): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
 };
 /**
- * @since 4.0.0
+ * Maps the current value of an atom with a pure function.
+ *
+ * When the source atom is writable, the returned atom remains writable and keeps
+ * the source atom's write input type.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const map: {
     /**
-     * @since 4.0.0
+     * Maps the current value of an atom with a pure function.
+     *
+     * When the source atom is writable, the returned atom remains writable and keeps
+     * the source atom's write input type.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<any>, B>(f: (_: Type<R>) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
     /**
-     * @since 4.0.0
+     * Maps the current value of an atom with a pure function.
+     *
+     * When the source atom is writable, the returned atom remains writable and keeps
+     * the source atom's write input type.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<any>, B>(self: R, f: (_: Type<R>) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
 };
 /**
- * @since 4.0.0
+ * Maps the successful value inside an `AsyncResult` atom.
+ *
+ * Initial and failure states are preserved, and writable source atoms keep their
+ * original write input type.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const mapResult: {
     /**
-     * @since 4.0.0
+     * Maps the successful value inside an `AsyncResult` atom.
+     *
+     * Initial and failure states are preserved, and writable source atoms keep their
+     * original write input type.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<AsyncResult.AsyncResult<any, any>>, B>(f: (_: AsyncResult.AsyncResult.Success<Type<R>>) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>, RW> : Atom<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>>;
     /**
-     * @since 4.0.0
+     * Maps the successful value inside an `AsyncResult` atom.
+     *
+     * Initial and failure states are preserved, and writable source atoms keep their
+     * original write input type.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<AsyncResult.AsyncResult<any, any>>, B>(self: R, f: (_: AsyncResult.AsyncResult.Success<Type<R>>) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>, RW> : Atom<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>>;
 };
 /**
- * @since 4.0.0
+ * Creates an atom that publishes source changes only after the source has stopped
+ * changing for the specified duration.
+ *
+ * The current source value is used immediately, and any pending debounce timer is
+ * cleared when the derived atom is disposed.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const debounce: {
     /**
-     * @since 4.0.0
+     * Creates an atom that publishes source changes only after the source has stopped
+     * changing for the specified duration.
+     *
+     * The current source value is used immediately, and any pending debounce timer is
+     * cleared when the derived atom is disposed.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
     /**
-     * @since 4.0.0
+     * Creates an atom that publishes source changes only after the source has stopped
+     * changing for the specified duration.
+     *
+     * The current source value is used immediately, and any pending debounce timer is
+     * cleared when the derived atom is disposed.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>;
 };
 /**
- * Ensures that the value of the atom is refreshed at most once per specified
- * duration.
+ * Creates a derived atom that reads the source and schedules a refresh after the
+ * specified duration.
+ *
+ * The scheduled refresh is canceled when the derived atom's lifetime is disposed.
  *
- * @since 4.0.0
  * @category combinators
+ * @since 4.0.0
  */
 export declare const withRefresh: {
     /**
-     * Ensures that the value of the atom is refreshed at most once per specified
-     * duration.
+     * Creates a derived atom that reads the source and schedules a refresh after the
+     * specified duration.
+     *
+     * The scheduled refresh is canceled when the derived atom's lifetime is disposed.
      *
-     * @since 4.0.0
      * @category combinators
+     * @since 4.0.0
      */
     (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
     /**
-     * Ensures that the value of the atom is refreshed at most once per specified
-     * duration.
+     * Creates a derived atom that reads the source and schedules a refresh after the
+     * specified duration.
+     *
+     * The scheduled refresh is canceled when the derived atom's lifetime is disposed.
      *
-     * @since 4.0.0
      * @category combinators
+     * @since 4.0.0
      */
     <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>;
 };
@@ -654,8 +920,8 @@ export declare const withRefresh: {
  * background refresh on first mount. Use `revalidateOnFocus` to control
  * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
  *
- * @since 4.0.0
  * @category combinators
+ * @since 4.0.0
  */
 export declare const swr: {
     /**
@@ -669,8 +935,8 @@ export declare const swr: {
      * background refresh on first mount. Use `revalidateOnFocus` to control
      * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
      *
-     * @since 4.0.0
      * @category combinators
+     * @since 4.0.0
      */
     (options: {
         readonly staleTime: Duration.Input;
@@ -689,8 +955,8 @@ export declare const swr: {
      * background refresh on first mount. Use `revalidateOnFocus` to control
      * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
      *
-     * @since 4.0.0
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R, options: {
         readonly staleTime: Duration.Input;
@@ -700,26 +966,54 @@ export declare const swr: {
     }): WithoutSerializable<R>;
 };
 /**
- * @since 4.0.0
+ * Wraps an atom in a writable optimistic atom.
+ *
+ * Writes accept transition atoms containing `AsyncResult` values. Waiting
+ * successes are shown optimistically while transitions run; when successful
+ * transitions finish, the source atom is refreshed, and failures roll the value
+ * back to the latest source value.
+ *
  * @category Optimistic
+ * @since 4.0.0
  */
 export declare const optimistic: <A>(self: Atom<A>) => Writable<A, Atom<AsyncResult.AsyncResult<A, unknown>>>;
 /**
- * @since 4.0.0
+ * Creates an `AtomResultFn` that applies an optimistic update before running the
+ * underlying mutation.
+ *
+ * The reducer computes the provisional value from the current value and mutation
+ * input. The wrapped function result then completes the transition or updates the
+ * optimistic value through the provided setter callback.
+ *
  * @category Optimistic
+ * @since 4.0.0
  */
 export declare const optimisticFn: {
     /**
-     * @since 4.0.0
+     * Creates an `AtomResultFn` that applies an optimistic update before running the
+     * underlying mutation.
+     *
+     * The reducer computes the provisional value from the current value and mutation
+     * input. The wrapped function result then completes the transition or updates the
+     * optimistic value through the provided setter callback.
+     *
      * @category Optimistic
+     * @since 4.0.0
      */
     <A, W, XA, XE, OW = void>(options: {
         readonly reducer: (current: NoInfer<A>, update: OW) => NoInfer<W>;
         readonly fn: AtomResultFn<OW, XA, XE> | ((set: (result: NoInfer<W>) => void) => AtomResultFn<OW, XA, XE>);
     }): (self: Writable<A, Atom<AsyncResult.AsyncResult<W, unknown>>>) => AtomResultFn<OW, XA, XE>;
     /**
-     * @since 4.0.0
+     * Creates an `AtomResultFn` that applies an optimistic update before running the
+     * underlying mutation.
+     *
+     * The reducer computes the provisional value from the current value and mutation
+     * input. The wrapped function result then completes the transition or updates the
+     * optimistic value through the provided setter callback.
+     *
      * @category Optimistic
+     * @since 4.0.0
      */
     <A, W, XA, XE, OW = void>(self: Writable<A, Atom<AsyncResult.AsyncResult<W, unknown>>>, options: {
         readonly reducer: (current: NoInfer<A>, update: OW) => NoInfer<W>;
@@ -727,28 +1021,55 @@ export declare const optimisticFn: {
     }): AtomResultFn<OW, XA, XE>;
 };
 /**
- * @since 4.0.0
+ * Runs synchronous atom updates as a batch.
+ *
+ * Stale nodes are rebuilt and listeners are notified after the callback completes,
+ * so dependent updates observe the final batched state.
+ *
  * @category batching
+ * @since 4.0.0
  */
 export declare const batch: (f: () => void) => void;
 /**
- * @since 4.0.0
+ * A browser-only signal atom that increments when the document becomes visible.
+ *
+ * It listens for `visibilitychange` events on `window` and removes the listener
+ * when the atom is disposed.
+ *
  * @category Focus
+ * @since 4.0.0
  */
 export declare const windowFocusSignal: Atom<number>;
 /**
- * @since 4.0.0
+ * Creates a combinator that refreshes an atom whenever the supplied signal atom
+ * changes.
+ *
+ * The derived atom also subscribes to the source atom so normal source updates are
+ * forwarded to its own value.
+ *
  * @category Focus
+ * @since 4.0.0
  */
 export declare const makeRefreshOnSignal: <_>(signal: Atom<_>) => <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
 /**
- * @since 4.0.0
+ * Refreshes an atom whenever `windowFocusSignal` changes.
+ *
+ * This helper is browser-only because `windowFocusSignal` depends on `window` and
+ * `document.visibilityState`.
+ *
  * @category Focus
+ * @since 4.0.0
  */
 export declare const refreshOnWindowFocus: <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
 /**
- * @since 4.0.0
+ * Creates a writable atom backed by a `KeyValueStore` entry.
+ *
+ * Values are encoded and decoded with the supplied schema. In sync mode the atom
+ * exposes the decoded value and writes the default value when the key is missing;
+ * in async mode it exposes an `AsyncResult` of the decoded value.
+ *
  * @category KeyValueStore
+ * @since 4.0.0
  */
 export declare const kvs: <S extends Schema.Codec<any, any>, const Mode extends "sync" | "async" = never>(options: {
     readonly runtime: AtomRuntime<KeyValueStore.KeyValueStore, any>;
@@ -762,105 +1083,163 @@ export declare const kvs: <S extends Schema.Codec<any, any>, const Mode extends
  *
  * Note: If you pass a schema, it has to be synchronous and have no context.
  *
- * @since 4.0.0
  * @category URL search params
+ * @since 4.0.0
  */
 export declare const searchParam: <S extends Schema.Codec<any, string> = never>(name: string, options?: {
     readonly schema?: S | undefined;
 }) => Writable<[S] extends [never] ? string : Option.Option<S["Type"]>>;
 /**
+ * Converts an atom into a stream using the `AtomRegistry` service.
+ *
+ * The stream emits the atom's current value immediately and then emits subsequent
+ * changes until the stream scope is closed.
+ *
+ * @category converting
  * @since 4.0.0
- * @category Conversions
  */
 export declare const toStream: <A>(self: Atom<A>) => Stream.Stream<A, never, AtomRegistry>;
 /**
+ * Converts an `AsyncResult` atom into a stream using the `AtomRegistry` service.
+ *
+ * Initial results are skipped, successes are emitted as stream values, and
+ * failures fail the stream with the result cause.
+ *
+ * @category converting
  * @since 4.0.0
- * @category Conversions
  */
 export declare const toStreamResult: <A, E>(self: Atom<AsyncResult.AsyncResult<A, E>>) => Stream.Stream<A, E, AtomRegistry>;
 /**
+ * Reads an atom's current value from the `AtomRegistry` service.
+ *
+ * @category converting
  * @since 4.0.0
- * @category Conversions
  */
 export declare const get: <A>(self: Atom<A>) => Effect.Effect<A, never, AtomRegistry>;
 /**
+ * Reads a writable atom, computes a return value and next write value, writes the
+ * next value, and returns the computed result.
+ *
+ * @category converting
  * @since 4.0.0
- * @category Conversions
  */
 export declare const modify: {
     /**
+     * Reads a writable atom, computes a return value and next write value, writes the
+     * next value, and returns the computed result.
+     *
+     * @category converting
      * @since 4.0.0
-     * @category Conversions
      */
     <R, W, A>(f: (_: R) => [returnValue: A, nextValue: W]): (self: Writable<R, W>) => Effect.Effect<A, never, AtomRegistry>;
     /**
+     * Reads a writable atom, computes a return value and next write value, writes the
+     * next value, and returns the computed result.
+     *
+     * @category converting
      * @since 4.0.0
-     * @category Conversions
      */
     <R, W, A>(self: Writable<R, W>, f: (_: R) => [returnValue: A, nextValue: W]): Effect.Effect<A, never, AtomRegistry>;
 };
 /**
+ * Writes a value to a writable atom through the `AtomRegistry` service.
+ *
+ * @category converting
  * @since 4.0.0
- * @category Conversions
  */
 export declare const set: {
     /**
+     * Writes a value to a writable atom through the `AtomRegistry` service.
+     *
+     * @category converting
      * @since 4.0.0
-     * @category Conversions
      */
     <W>(value: W): <R>(self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>;
     /**
+     * Writes a value to a writable atom through the `AtomRegistry` service.
+     *
+     * @category converting
      * @since 4.0.0
-     * @category Conversions
      */
     <R, W>(self: Writable<R, W>, value: W): Effect.Effect<void, never, AtomRegistry>;
 };
 /**
+ * Updates a writable atom by reading its current value from the registry and
+ * writing the value returned by the update function.
+ *
+ * @category converting
  * @since 4.0.0
- * @category Conversions
  */
 export declare const update: {
     /**
+     * Updates a writable atom by reading its current value from the registry and
+     * writing the value returned by the update function.
+     *
+     * @category converting
      * @since 4.0.0
-     * @category Conversions
      */
     <R, W>(f: (_: R) => W): (self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>;
     /**
+     * Updates a writable atom by reading its current value from the registry and
+     * writing the value returned by the update function.
+     *
+     * @category converting
      * @since 4.0.0
-     * @category Conversions
      */
     <R, W>(self: Writable<R, W>, f: (_: R) => W): Effect.Effect<void, never, AtomRegistry>;
 };
 /**
+ * Reads an `AsyncResult` atom as an effect through the `AtomRegistry` service.
+ *
+ * The effect waits while the result is `Initial`, and also while it is waiting
+ * when `suspendOnWaiting` is enabled. Successes succeed with the value and
+ * failures fail with the result cause.
+ *
+ * @category converting
  * @since 4.0.0
- * @category Conversions
  */
 export declare const getResult: <A, E>(self: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
     readonly suspendOnWaiting?: boolean | undefined;
 }) => Effect.Effect<A, E, AtomRegistry>;
 /**
+ * Requests a refresh of an atom through the `AtomRegistry` service.
+ *
+ * @category converting
  * @since 4.0.0
- * @category Conversions
  */
 export declare const refresh: <A>(self: Atom<A>) => Effect.Effect<void, never, AtomRegistry>;
 /**
+ * Mounts an atom in the `AtomRegistry` for the lifetime of the current scope.
+ *
+ * Mounting keeps the atom subscribed with a no-op listener until the scope
+ * finalizer releases it.
+ *
+ * @category converting
  * @since 4.0.0
- * @category Conversions
  */
 export declare const mount: <A>(self: Atom<A>) => Effect.Effect<void, never, AtomRegistry | Scope.Scope>;
 /**
- * @since 4.0.0
+ * The type id used to mark atoms that carry serialization metadata.
+ *
  * @category Serializable
+ * @since 4.0.0
  */
 export declare const SerializableTypeId: SerializableTypeId;
 /**
- * @since 4.0.0
+ * The literal type of the serializable atom marker.
+ *
  * @category Serializable
+ * @since 4.0.0
  */
 export type SerializableTypeId = "~effect-atom/atom/Atom/Serializable";
 /**
- * @since 4.0.0
+ * Serialization metadata attached to an atom.
+ *
+ * The key identifies the atom in dehydrated state, and the encode/decode
+ * functions convert between the atom value and the schema encoded value.
+ *
  * @category Serializable
+ * @since 4.0.0
  */
 export interface Serializable<S extends Schema.Top> {
     readonly [SerializableTypeId]: {
@@ -870,26 +1249,43 @@ export interface Serializable<S extends Schema.Top> {
     };
 }
 /**
- * @since 4.0.0
+ * Returns `true` when an atom carries `Serializable` metadata.
+ *
  * @category Serializable
+ * @since 4.0.0
  */
 export declare const isSerializable: (self: Atom<any>) => self is Atom<any> & Serializable<any>;
 /**
- * @since 4.0.0
+ * Attaches serialization metadata to an atom using a schema and stable key.
+ *
+ * The schema is converted to a JSON codec for synchronous encode/decode, and the
+ * key is also used as the atom label when the atom does not already have one.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export declare const serializable: {
     /**
-     * @since 4.0.0
+     * Attaches serialization metadata to an atom using a schema and stable key.
+     *
+     * The schema is converted to a JSON codec for synchronous encode/decode, and the
+     * key is also used as the atom label when the atom does not already have one.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<any>, S extends Schema.Codec<Type<R>, any>>(options: {
         readonly key: string;
         readonly schema: S;
     }): (self: R) => R & Serializable<S>;
     /**
-     * @since 4.0.0
+     * Attaches serialization metadata to an atom using a schema and stable key.
+     *
+     * The schema is converted to a JSON codec for synchronous encode/decode, and the
+     * key is also used as the atom label when the atom does not already have one.
+     *
      * @category combinators
+     * @since 4.0.0
      */
     <R extends Atom<any>, S extends Schema.Codec<Type<R>, any>>(self: R, options: {
         readonly key: string;
@@ -897,52 +1293,70 @@ export declare const serializable: {
     }): R & Serializable<S>;
 };
 /**
- * @since 4.0.0
+ * The type id used to mark atoms with a server-side read override.
+ *
  * @category ServerValue
+ * @since 4.0.0
  */
 export declare const ServerValueTypeId: "~effect-atom/atom/Atom/ServerValue";
 /**
  * Overrides the value of an Atom when read on the server.
  *
- * @since 4.0.0
  * @category ServerValue
+ * @since 4.0.0
  */
 export declare const withServerValue: {
     /**
      * Overrides the value of an Atom when read on the server.
      *
-     * @since 4.0.0
      * @category ServerValue
+     * @since 4.0.0
      */
     <A extends Atom<any>>(read: (get: <A>(atom: Atom<A>) => A) => Type<A>): (self: A) => A;
     /**
      * Overrides the value of an Atom when read on the server.
      *
-     * @since 4.0.0
      * @category ServerValue
+     * @since 4.0.0
      */
     <A extends Atom<any>>(self: A, read: (get: <A>(atom: Atom<A>) => A) => Type<A>): A;
 };
 /**
- * Sets the Atom's server value to `Result.initial(true)`.
+ * Sets an `AsyncResult` atom's server-side value to
+ * `AsyncResult.initial(true)`.
  *
- * @since 4.0.0
  * @category ServerValue
+ * @since 4.0.0
  */
 export declare const withServerValueInitial: <A extends Atom<AsyncResult.AsyncResult<any, any>>>(self: A) => A;
 /**
- * @since 4.0.0
+ * Reads an atom from a registry, using its server-side read override when one is
+ * present.
+ *
+ * Nested reads performed by the override are resolved against the same registry.
+ *
  * @category ServerValue
+ * @since 4.0.0
  */
 export declare const getServerValue: {
     /**
-     * @since 4.0.0
+     * Reads an atom from a registry, using its server-side read override when one is
+     * present.
+     *
+     * Nested reads performed by the override are resolved against the same registry.
+     *
      * @category ServerValue
+     * @since 4.0.0
      */
     (registry: Registry.AtomRegistry): <A>(self: Atom<A>) => A;
     /**
-     * @since 4.0.0
+     * Reads an atom from a registry, using its server-side read override when one is
+     * present.
+     *
+     * Nested reads performed by the override are resolved against the same registry.
+     *
      * @category ServerValue
+     * @since 4.0.0
      */
     <A>(self: Atom<A>, registry: Registry.AtomRegistry): A;
 };