@systemfsoftware/effect-atom 0.5.3

package/dist/Atom-DGWqaX9a.d.ts

@@ -0,0 +1,1257 @@
+import { L as Result } from "./Result-CAjFdzam.js";
+import * as Arr from "effect/Array";
+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 { LazyArg } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { Scheduler } from "effect/Scheduler";
+import * as Schema from "effect/Schema";
+import * as Scope$1 from "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+import * as KeyValueStore from "effect/unstable/persistence/KeyValueStore";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import { Pipeable } from "effect/Pipeable";
+import { Inspectable } from "effect/Inspectable";
+import { ReadonlyRecord } from "effect/Record";
+import { NoInfer } from "effect/Types";
+//#region src/internal/core.d.ts
+/**
+ * Type-level identifier used to recognize `Atom` values.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+type TypeId$1 = '~effect/reactivity/Atom';
+/**
+ * Runtime identifier attached to `Atom` values and used by `isAtom`.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+declare const TypeId$1: TypeId$1;
+/**
+ * Type-level identifier used to recognize writable atoms.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+type WritableTypeId = '~effect/reactivity/Atom/Writable';
+/**
+ * Runtime identifier attached to writable atoms and used by `isWritable`.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+declare const WritableTypeId: WritableTypeId;
+/**
+ * Returns `true` when a value is an `Atom`.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+declare const isAtom: (u: unknown) => u is Atom<any>;
+/**
+ * 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
+ */
+declare const setIdleTTL: {
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => A;
+  <A extends Atom<any>>(self: A, duration: Duration.Input): A;
+};
+/**
+ * Returns `true` when an atom is writable.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+declare const isWritable: <R, W>(atom: Atom<R>) => atom is Writable<R, W>;
+/**
+ * Creates a read-only atom from a read function and an optional custom refresh registration callback.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare const readable: <A>(read: (get: AtomContext) => A, refresh?: (f: <A_1>(atom: Atom<A_1>) => void) => void) => Atom<A>;
+/**
+ * Creates a writable atom from read and write functions, with an optional custom refresh registration callback.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+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>;
+/**
+ * Creates a derived atom by reading another atom with a custom `AtomContext`
+ * function.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const transform: {
+  <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>;
+  <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>;
+};
+declare namespace Registry_d_exports {
+  export { AtomRegistry, Node, Registry, TypeId, getResult$1 as getResult, isAtomRegistry, layer, layerOptions, make$1 as make, mount$1 as mount, toStream$1 as toStream, toStreamResult$1 as toStreamResult };
+}
+/**
+ * The literal type used to identify `AtomRegistry` services and values.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+type TypeId = '~effect-atom/atom/Registry';
+/**
+ * The runtime type id used to identify `AtomRegistry` services and values.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+declare const TypeId: TypeId;
+/**
+ * Returns `true` when the value has the `AtomRegistry` type id.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+declare const isAtomRegistry: (u: unknown) => u is Registry;
+/**
+ * The runtime registry that stores atom nodes and coordinates reads, writes,
+ * refreshes, subscriptions, and disposal.
+ *
+ * **Details**
+ *
+ * It also manages scheduler configuration, serializable preloaded values, and node
+ * addition/removal callbacks.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface Registry {
+  readonly [TypeId]: TypeId;
+  readonly scheduler: Scheduler;
+  readonly schedulerAsync: Scheduler;
+  readonly getNodes: () => ReadonlyMap<Atom<any> | string, Node<any>>;
+  readonly get: <A>(atom: Atom<A>) => A;
+  readonly mount: <A>(atom: Atom<A>) => () => void;
+  readonly refresh: <A>(atom: Atom<A>) => void;
+  readonly set: <R, W>(atom: Writable<R, W>, value: W) => void;
+  readonly setSerializable: (key: string, encoded: unknown) => void;
+  readonly setInitialValue: <A>(atom: Atom<A>, value: A) => void;
+  readonly modify: <R, W, A>(atom: Writable<R, W>, f: (_: R) => [returnValue: A, nextValue: W]) => A;
+  readonly update: <R, W>(atom: Writable<R, W>, f: (_: R) => W) => void;
+  readonly subscribe: <A>(atom: Atom<A>, f: (_: A) => void, options?: {
+    readonly immediate?: boolean;
+  }) => () => void;
+  readonly reset: () => void;
+  readonly dispose: () => void;
+  onNodeAdded?: ((node: Node<any>) => void) | undefined;
+  onNodeRemoved?: ((node: Node<any>) => void) | undefined;
+}
+/**
+ * A registry node for a single atom.
+ *
+ * **Details**
+ *
+ * Nodes expose the current value, parent and child dependency links, listener set,
+ * and current lifecycle state.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface Node<A> {
+  readonly atom: Atom<A>;
+  readonly value: () => A;
+  parents: Set<Node<any>>;
+  children: Set<Node<any>>;
+  listeners: Set<() => void>;
+  currentState(): 'uninitialized' | 'stale' | 'valid' | 'removed';
+}
+/**
+ * Creates an `AtomRegistry`.
+ *
+ * **Details**
+ *
+ * Options can preload initial atom values, provide a custom task scheduler,
+ * configure timeout bucket resolution, and set a default idle time-to-live for
+ * unused atoms.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare const make$1: (options?: {
+  readonly initialValues?: Iterable<readonly [Atom<any>, any]> | undefined;
+  readonly scheduleTask?: ((f: () => void) => () => void) | undefined;
+  readonly timeoutResolution?: number | undefined;
+  readonly defaultIdleTTL?: number | undefined;
+}) => Registry;
+declare const AtomRegistry_base: Context.ServiceClass<AtomRegistry, "~effect-atom/atom/Registry", Registry>;
+/**
+ * Service tag for the active atom runtime cache.
+ *
+ * **When to use**
+ *
+ * Use to access or provide the registry that stores atom values,
+ * dependencies, subscriptions, and disposal state for a reactive lifetime.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+declare class AtomRegistry extends AtomRegistry_base {}
+/**
+ * Creates a layer that provides an `AtomRegistry` configured with the supplied
+ * options.
+ *
+ * **Details**
+ *
+ * The registry is disposed when the layer scope is finalized.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+declare const layerOptions: (options?: {
+  readonly initialValues?: Iterable<readonly [Atom<any>, any]> | undefined;
+  readonly scheduleTask?: ((f: () => void) => () => void) | undefined;
+  readonly timeoutResolution?: number | undefined;
+  readonly defaultIdleTTL?: number | undefined;
+}) => Layer.Layer<AtomRegistry>;
+/**
+ * The default layer that provides a fresh `AtomRegistry`.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+declare const layer: Layer.Layer<AtomRegistry>;
+/**
+ * Converts an atom in this registry into a stream.
+ *
+ * **Details**
+ *
+ * The stream emits the current value immediately, emits subsequent changes, and
+ * unsubscribes from the registry when the stream scope closes.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+declare const toStream$1: {
+  <A>(atom: Atom<A>): (self: Registry) => Stream.Stream<A>;
+  <A>(self: Registry, atom: Atom<A>): Stream.Stream<A>;
+};
+/**
+ * Converts an `AsyncResult` atom in this registry into a stream of successful
+ * values.
+ *
+ * **Details**
+ *
+ * Initial results are skipped, failures fail the stream with their cause, and
+ * duplicate stream values are dropped with `Stream.changes`.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+declare const toStreamResult$1: {
+  <A, E>(atom: Atom<Result<A, E>>): (self: Registry) => Stream.Stream<A, E>;
+  <A, E>(self: Registry, atom: Atom<Result<A, E>>): Stream.Stream<A, E>;
+};
+/**
+ * Reads an `AsyncResult` atom from this registry as an effect.
+ *
+ * **Details**
+ *
+ * The effect waits for the result to leave `Initial`, and also waits through
+ * waiting results when `suspendOnWaiting` is enabled.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+declare const getResult$1: {
+  <A, E>(atom: Atom<Result<A, E>>, options?: {
+    readonly suspendOnWaiting?: boolean | undefined;
+  }): (self: Registry) => Effect.Effect<A, E>;
+  <A, E>(self: Registry, atom: Atom<Result<A, E>>, options?: {
+    readonly suspendOnWaiting?: boolean | undefined;
+  }): Effect.Effect<A, E>;
+};
+/**
+ * Mounts an atom in this registry for the lifetime of the current scope.
+ *
+ * **Details**
+ *
+ * The atom is subscribed with a no-op listener and the subscription is released
+ * when the scope finalizer runs.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+declare const mount$1: {
+  <A>(atom: Atom<A>): (self: Registry) => Effect.Effect<void, never, Scope$1.Scope>;
+  <A>(self: Registry, atom: Atom<A>): Effect.Effect<void, never, Scope$1.Scope>;
+};
+//#endregion
+//#region src/browser.d.ts
+/**
+ * Creates a browser-only signal atom that increments when the document becomes visible.
+ *
+ * **Details**
+ *
+ * It listens for `visibilitychange` events on `window` and removes the listener
+ * when the atom is disposed.
+ *
+ * @category constants
+ * @since 4.0.0
+ */
+declare const windowFocusSignal: Atom<number>;
+/**
+ * Creates a combinator that refreshes an atom whenever the supplied signal atom
+ * changes.
+ *
+ * **Details**
+ *
+ * The derived atom also subscribes to the source atom so normal source updates are
+ * forwarded to its own value.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare const makeRefreshOnSignal: <_>(signal: Atom<_>) => <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
+/**
+ * Refreshes an atom whenever `windowFocusSignal` changes.
+ *
+ * **Details**
+ *
+ * This helper is browser-only because `windowFocusSignal` depends on `window` and
+ * `document.visibilityState`.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+declare const refreshOnWindowFocus: <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
+/**
+ * Creates an atom that reads and writes a URL search parameter.
+ *
+ * **Gotchas**
+ *
+ * If you pass a schema, it has to be synchronous and have no context.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare function searchParam<S extends Schema.ConstraintCodec<any, string> = never>(name: string, options?: {
+  readonly schema?: S | undefined;
+}): Writable<[S] extends [never] ? string : Option.Option<S['Type']>>;
+//#endregion
+//#region src/server.d.ts
+/**
+ * The type id used to mark atoms with a server-side read override.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+declare const ServerValueTypeId: '~effect-atom/atom/Atom/ServerValue';
+/**
+ * Server-side read override attached to an atom by `withServerValue`.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+type ServerValue<A> = {
+  readonly [ServerValueTypeId]: (get: <A>(atom: Atom<A>) => A) => A;
+};
+/**
+ * Sets the value of an Atom when read on the server.
+ *
+ * @category transforming
+ * @since 4.0.0
+ */
+declare const withServerValue: {
+  <A extends Atom<any>>(read: (get: <A>(atom: Atom<A>) => A) => Type<A>): (self: A) => A;
+  <A extends Atom<any>>(self: A, read: (get: <A>(atom: Atom<A>) => A) => Type<A>): A;
+};
+/**
+ * Sets an `AsyncResult` atom's server-side value to
+ * `AsyncResult.initial(true)`.
+ *
+ * @category transforming
+ * @since 4.0.0
+ */
+declare const withServerValueInitial: <A extends Atom<Result<any, any>>>(self: A) => A;
+/**
+ * Reads an atom from a registry, using its server-side read override when one is
+ * present.
+ *
+ * **Details**
+ *
+ * Nested reads performed by the override are resolved against the same registry.
+ *
+ * @category getters
+ * @since 4.0.0
+ */
+declare const getServerValue: {
+  (registry: Registry): <A>(self: Atom<A>) => A;
+  <A>(self: Atom<A>, registry: Registry): A;
+};
+declare namespace Atom_d_exports {
+  export { Atom, AtomContext, AtomResultFn, AtomRuntime, Failure, FnContext, Interrupt, PullResult, PullSuccess, RegistryRuntimeFactory, Reset, RuntimeFactory, Serializable, SerializableTypeId, ServerValue, ServerValueTypeId, SharedRuntimeFactory, Success, Type, TypeId$1 as TypeId, WithoutSerializable, Writable, WritableTypeId, WriteContext, autoDispose, batch, context, debounce, family, fn, fnSync, get, getResult, getServerValue, initialValue, isAtom, isSerializable, isWritable, keepAlive, kvs, make, makeRefreshOnSignal, map, mapResult, modify, mount, optimistic, optimisticFn, pull, readable, refresh, refreshOnWindowFocus, runtime, searchParam, serializable, set, setIdleTTL, setLazy, subscriptionRef, swr, toStream, toStreamResult, transform, update, windowFocusSignal, withEquality, withFallback, withLabel, withReactivity, withRefresh, withServerValue, withServerValueInitial, writable };
+}
+/**
+ * Reactive value read by an `AtomRegistry`, with metadata controlling caching, laziness, refresh behavior, and initial value targeting.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface Atom<A> extends Pipeable, Inspectable {
+  readonly [TypeId$1]: TypeId$1;
+  readonly keepAlive: boolean;
+  readonly lazy: boolean;
+  readonly read: (get: AtomContext) => A;
+  equals(value: A, next: A): boolean;
+  readonly refresh?: (f: <A>(atom: Atom<A>) => void) => void;
+  readonly label?: readonly [name: string, stack: string];
+  readonly idleTTL?: number;
+  readonly initialValueTarget?: Atom<A>;
+}
+/**
+ * Extracts the value type produced by an `Atom`.
+ *
+ * @category utility types
+ * @since 4.0.0
+ */
+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
+ */
+type Success<T extends Atom<any>> = T extends Atom<Result<infer A, infer _>> ? A : never;
+/**
+ * Extracts the item type from an atom whose value is a `PullResult`.
+ *
+ * @category utility types
+ * @since 4.0.0
+ */
+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
+ */
+type Failure<T extends Atom<any>> = T extends Atom<Result<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
+ */
+type WithoutSerializable<T extends Atom<any>> = T extends Writable<infer R, infer W> ? Writable<R, W> : Atom<Type<T>>;
+/**
+ * Atom that can also be written to, using a `WriteContext` and an input value to update reactive state.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface Writable<R, W = R> extends Atom<R> {
+  readonly [WritableTypeId]: WritableTypeId;
+  readonly write: (ctx: WriteContext<R>, value: W) => void;
+}
+/**
+ * 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
+ */
+interface AtomContext {
+  <A>(atom: Atom<A>): A;
+  get<A>(this: AtomContext, atom: Atom<A>): A;
+  result<A, E>(this: AtomContext, atom: Atom<Result<A, E>>, options?: {
+    readonly suspendOnWaiting?: boolean | undefined;
+  }): Effect.Effect<A, E>;
+  resultOnce<A, E>(this: AtomContext, atom: Atom<Result<A, E>>, options?: {
+    readonly suspendOnWaiting?: boolean | undefined;
+  }): Effect.Effect<A, E>;
+  once<A>(this: AtomContext, atom: Atom<A>): A;
+  addFinalizer(this: AtomContext, f: () => void): void;
+  mount<A>(this: AtomContext, atom: Atom<A>): void;
+  refresh<A>(this: AtomContext, atom: Atom<A>): void;
+  refreshSelf(this: AtomContext): void;
+  self<A>(this: AtomContext): Option.Option<A>;
+  setSelf<A>(this: AtomContext, a: A): void;
+  set<R, W>(this: AtomContext, atom: Writable<R, W>, value: W): void;
+  setResult<A, E, W>(this: AtomContext, atom: Writable<Result<A, E>, W>, value: W): Effect.Effect<A, E>;
+  some<A>(this: AtomContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>;
+  someOnce<A>(this: AtomContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>;
+  stream<A>(this: AtomContext, atom: Atom<A>, options?: {
+    readonly withoutInitialValue?: boolean;
+    readonly bufferSize?: number;
+  }): Stream.Stream<A>;
+  streamResult<A, E>(this: AtomContext, atom: Atom<Result<A, E>>, options?: {
+    readonly withoutInitialValue?: boolean;
+    readonly bufferSize?: number;
+  }): Stream.Stream<A, E>;
+  subscribe<A>(this: AtomContext, atom: Atom<A>, f: (_: A) => void, options?: {
+    readonly immediate?: boolean;
+  }): void;
+  isFn?: boolean | undefined;
+  readonly registry: Registry;
+}
+/**
+ * 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
+ */
+interface WriteContext<A> {
+  get<T>(this: WriteContext<A>, atom: Atom<T>): T;
+  refreshSelf(this: WriteContext<A>): void;
+  setSelf(this: WriteContext<A>, a: A): void;
+  set<R, W>(this: WriteContext<A>, atom: Writable<R, W>, value: W): void;
+}
+/**
+ * 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
+ */
+declare function make<A, E>(create: (get: AtomContext) => Effect.Effect<A, E, Scope$1.Scope | AtomRegistry>, options?: {
+  readonly initialValue?: A | undefined;
+  readonly uninterruptible?: boolean | undefined;
+}): Atom<Result<A, E>>;
+declare function make<A, E>(effect: Effect.Effect<A, E, Scope$1.Scope | AtomRegistry>, options?: {
+  readonly initialValue?: A;
+  readonly uninterruptible?: boolean | undefined;
+}): Atom<Result<A, E>>;
+declare function make<A, E>(create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry>, options?: {
+  readonly initialValue?: A;
+}): Atom<Result<A, E | Cause.NoSuchElementError>>;
+declare function make<A, E>(stream: Stream.Stream<A, E, AtomRegistry>, options?: {
+  readonly initialValue?: A;
+}): Atom<Result<A, E | Cause.NoSuchElementError>>;
+declare function make<A>(create: (get: AtomContext) => A): Atom<A>;
+declare function make<A>(initialValue: A): Writable<A>;
+/**
+ * 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
+ */
+interface AtomRuntime<R, ER = never> extends Atom<Result<Context.Context<R>, ER>> {
+  readonly factory: RuntimeFactory;
+  readonly layer: Atom<Layer.Layer<R, ER>>;
+  readonly atom: {
+    <A, E>(create: (get: AtomContext) => Effect.Effect<A, E, Scope$1.Scope | R | AtomRegistry | Reactivity.Reactivity>, options?: {
+      readonly initialValue?: A;
+      readonly uninterruptible?: boolean | undefined;
+    }): Atom<Result<A, E | ER>>;
+    <A, E>(effect: Effect.Effect<A, E, Scope$1.Scope | R | AtomRegistry | Reactivity.Reactivity>, options?: {
+      readonly initialValue?: A;
+      readonly uninterruptible?: boolean | undefined;
+    }): Atom<Result<A, E | ER>>;
+    <A, E>(create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
+      readonly initialValue?: A;
+    }): Atom<Result<A, E | ER | Cause.NoSuchElementError>>;
+    <A, E>(stream: Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
+      readonly initialValue?: A;
+    }): Atom<Result<A, E | ER | Cause.NoSuchElementError>>;
+  };
+  readonly fn: {
+    <Arg>(): {
+      <E, A>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope$1.Scope | AtomRegistry | Reactivity.Reactivity | R>, options?: {
+        readonly initialValue?: A | undefined;
+        readonly reactivityKeys?: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]> | undefined;
+        readonly concurrent?: boolean | undefined;
+      }): AtomResultFn<Arg, A, E | ER>;
+      <E, A>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
+        readonly initialValue?: A | undefined;
+        readonly reactivityKeys?: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]> | undefined;
+        readonly concurrent?: boolean | undefined;
+      }): AtomResultFn<Arg, A, E | ER | Cause.NoSuchElementError>;
+    };
+    <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope$1.Scope | AtomRegistry | Reactivity.Reactivity | R>, options?: {
+      readonly initialValue?: A | undefined;
+      readonly reactivityKeys?: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]> | undefined;
+      readonly concurrent?: boolean | undefined;
+    }): AtomResultFn<Arg, A, E | ER>;
+    <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
+      readonly initialValue?: A | undefined;
+      readonly reactivityKeys?: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]> | undefined;
+      readonly concurrent?: boolean | undefined;
+    }): AtomResultFn<Arg, A, E | ER | Cause.NoSuchElementError>;
+  };
+  readonly pull: <A, E>(create: ((get: AtomContext) => Stream.Stream<A, E, R | AtomRegistry | Reactivity.Reactivity>) | Stream.Stream<A, E, R | AtomRegistry | Reactivity.Reactivity>, options?: {
+    readonly disableAccumulation?: boolean;
+    readonly initialValue?: readonly A[];
+  }) => Writable<PullResult<A, E | ER>, void>;
+  readonly subscriptionRef: <A, E>(create: Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope$1.Scope | R | AtomRegistry | Reactivity.Reactivity> | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope$1.Scope | R | AtomRegistry | Reactivity.Reactivity>)) => Writable<Result<A, E>, A>;
+}
+/**
+ * Factory for `AtomRuntime` values that share a set of global layers.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface RuntimeFactory {
+  <R, E>(create: Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity> | ((get: AtomContext) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)): AtomRuntime<R, E>;
+  readonly addGlobalLayer: <A, E>(layer: Layer.Layer<A, E, AtomRegistry | Reactivity.Reactivity>) => void;
+  /**
+   * Uses the `Reactivity` service from the runtime to refresh the atom whenever
+   * the keys change.
+   */
+  readonly withReactivity: (keys: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]>) => <A extends Atom<any>>(atom: A) => A;
+}
+/**
+ * A `RuntimeFactory` backed by an atom whose memo map is scoped to each registry.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface RegistryRuntimeFactory extends RuntimeFactory {
+  readonly memoMap: Atom<Layer.MemoMap>;
+}
+/**
+ * A `RuntimeFactory` backed by a concrete memo map shared across registries.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface SharedRuntimeFactory extends RuntimeFactory {
+  readonly memoMap: Layer.MemoMap;
+}
+/**
+ * Creates a `RuntimeFactory` backed by a registry-scoped memo map by default,
+ * or by the supplied atom or concrete `Layer.MemoMap`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare function context(): RegistryRuntimeFactory;
+declare function context(options: {
+  readonly memoMap: Atom<Layer.MemoMap>;
+}): RegistryRuntimeFactory;
+declare function context(options: {
+  readonly memoMap: Layer.MemoMap;
+}): SharedRuntimeFactory;
+/**
+ * Default registry-scoped `RuntimeFactory`.
+ *
+ * @category context
+ * @since 4.0.0
+ */
+declare const runtime: RegistryRuntimeFactory;
+/**
+ * Returns `Rx.runtime.withReactivity` for refreshing an atom whenever the
+ * keys change in the `Reactivity` service.
+ *
+ * **When to use**
+ *
+ * Use to refresh an atom whenever one or more invalidation keys change in the
+ * default reactivity runtime.
+ *
+ * @category reactivity
+ * @since 4.0.0
+ */
+declare const withReactivity: (keys: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]>) => <A extends Atom<any>>(atom: A) => A;
+/**
+ * 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
+ */
+declare const subscriptionRef: {
+  <A>(ref: SubscriptionRef.SubscriptionRef<A> | ((get: AtomContext) => SubscriptionRef.SubscriptionRef<A>)): Writable<A>;
+  <A, E>(effect: Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope$1.Scope | AtomRegistry> | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope$1.Scope | AtomRegistry>)): Writable<Result<A, E>, A>;
+};
+/**
+ * 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
+ */
+interface FnContext {
+  <A>(atom: Atom<A>): A;
+  result<A, E>(this: FnContext, atom: Atom<Result<A, E>>, options?: {
+    readonly suspendOnWaiting?: boolean | undefined;
+  }): Effect.Effect<A, E>;
+  addFinalizer(this: FnContext, f: () => void): void;
+  mount<A>(this: FnContext, atom: Atom<A>): void;
+  refresh<A>(this: FnContext, atom: Atom<A>): void;
+  self<A>(this: FnContext): Option.Option<A>;
+  setSelf<A>(this: FnContext, a: A): void;
+  set<R, W>(this: FnContext, atom: Writable<R, W>, value: W): void;
+  setResult<A, E, W>(this: FnContext, atom: Writable<Result<A, E>, W>, value: W): Effect.Effect<A, E>;
+  some<A>(this: FnContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>;
+  stream<A>(this: FnContext, atom: Atom<A>, options?: {
+    readonly withoutInitialValue?: boolean;
+    readonly bufferSize?: number;
+  }): Stream.Stream<A>;
+  streamResult<A, E>(this: FnContext, atom: Atom<Result<A, E>>, options?: {
+    readonly withoutInitialValue?: boolean;
+    readonly bufferSize?: number;
+  }): Stream.Stream<A, E>;
+  subscribe<A>(this: FnContext, atom: Atom<A>, f: (_: A) => void, options?: {
+    readonly immediate?: boolean;
+  }): void;
+  readonly registry: Registry;
+}
+/**
+ * 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
+ */
+declare function fnSync<Arg>(): {
+  <A>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>;
+  <A>(f: (arg: Arg, get: FnContext) => A, options: {
+    readonly initialValue: A;
+  }): Writable<A, Arg>;
+};
+declare function fnSync<A, Arg = void>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>;
+declare function fnSync<A, Arg = void>(f: (arg: Arg, get: FnContext) => A, options: {
+  readonly initialValue: A;
+}): Writable<A, Arg>;
+/**
+ * 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
+ */
+interface AtomResultFn<Arg, A, E = never> extends Writable<Result<A, E>, Arg | Reset | Interrupt> {}
+/**
+ * Defines the control symbol that can be written to an `AtomResultFn` to reset it to its initial state.
+ *
+ * **When to use**
+ *
+ * Use when you need an `AtomResultFn` write value that clears the current async
+ * result and returns it to the initial state.
+ *
+ * @category symbols
+ * @since 4.0.0
+ */
+declare const Reset: unique symbol;
+/**
+ * Type of the `Reset` control symbol accepted by `AtomResultFn` writes.
+ *
+ * @category symbols
+ * @since 4.0.0
+ */
+type Reset = typeof Reset;
+/**
+ * Defines the control symbol that can be written to an `AtomResultFn` to interrupt the current asynchronous computation.
+ *
+ * **When to use**
+ *
+ * Use when you need an `AtomResultFn` write value that interrupts the currently
+ * running async computation.
+ *
+ * @category symbols
+ * @since 4.0.0
+ */
+declare const Interrupt: unique symbol;
+/**
+ * Type of the `Interrupt` control symbol accepted by `AtomResultFn` writes.
+ *
+ * @category symbols
+ * @since 4.0.0
+ */
+type Interrupt = typeof Interrupt;
+/**
+ * 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
+ */
+declare function fn<Arg>(): <E, A>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope$1.Scope | AtomRegistry>, options?: {
+  readonly initialValue?: A | undefined;
+  readonly concurrent?: boolean | undefined;
+}) => AtomResultFn<Arg, A, E>;
+declare function fn<E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope$1.Scope | AtomRegistry>, options?: {
+  readonly initialValue?: A | undefined;
+  readonly concurrent?: boolean | undefined;
+}): AtomResultFn<Arg, A, E>;
+declare function fn<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>;
+declare function fn<E, A, Arg = void>(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>;
+/**
+ * `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
+ */
+type PullResult<A, E = never> = Result<{
+  readonly done: boolean;
+  readonly items: Arr.NonEmptyArray<A>;
+}, E | Cause.NoSuchElementError>;
+/**
+ * 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
+ */
+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>;
+/**
+ * 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
+ */
+declare const family: <Arg, T extends object>(f: (arg: Arg) => T) => (arg: Arg) => T;
+/**
+ * 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
+ */
+declare const withFallback: {
+  <E2, A2>(fallback: Atom<Result<A2, E2>>): <R extends Atom<Result<any, any>>>(self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<Result<Result.Success<Type<R>> | A2, Result.Failure<Type<R>> | E2>, RW> : Atom<Result<Result.Success<Type<R>> | A2, Result.Failure<Type<R>> | E2>>;
+  <R extends Atom<Result<any, any>>, A2, E2>(self: R, fallback: Atom<Result<A2, E2>>): [R] extends [Writable<infer _, infer RW>] ? Writable<Result<Result.Success<Type<R>> | A2, Result.Failure<Type<R>> | E2>, RW> : Atom<Result<Result.Success<Type<R>> | A2, Result.Failure<Type<R>> | E2>>;
+};
+/**
+ * Returns a copy of an atom that remains cached and mounted even when no subscribers are using it.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+declare const keepAlive: <A extends Atom<any>>(self: A) => A;
+/**
+ * Allows a reactive value to be disposed of when it is not in use.
+ *
+ * **Details**
+ *
+ * Atoms have this behavior by default, so use this to undo `keepAlive` on a copied atom.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+declare const autoDispose: <A extends Atom<any>>(self: A) => A;
+/**
+ * Sets whether an atom should be lazy.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const setLazy: {
+  (lazy: boolean): <A extends Atom<any>>(self: A) => A;
+  <A extends Atom<any>>(self: A, lazy: boolean): A;
+};
+/**
+ * Returns a copy of an atom that uses a custom equality function to detect
+ * value changes.
+ *
+ * **Details**
+ *
+ * When an atom's value is rebuilt or written, the registry compares the new
+ * value against the current one to decide whether dependents and listeners
+ * should be notified. By default the comparison uses `Object.is`, so a
+ * structurally equal but referentially distinct value still triggers
+ * notifications. Providing an equality function lets the atom skip updates
+ * when the new value is equal to the current one.
+ *
+ * **Example** (Comparing values structurally)
+ *
+ * ```ts import.meta.vitest
+ * import { Atom } from "effect/unstable/reactivity"
+ *
+ * const point = Atom.make({ x: 0, y: 0 }).pipe(
+ *   Atom.withEquality<{ x: number; y: number }>((a, b) => a.x === b.x && a.y === b.y)
+ * )
+ * point.equals({ x: 1, y: 2 }, { x: 1, y: 2 }) // => true
+ * ```
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+declare const withEquality: {
+  <A>(equals: (value: A, next: A) => boolean): <T extends Atom<A>>(self: T) => T;
+  <T extends Atom<any>>(self: T, equals: (value: Type<T>, next: Type<T>) => boolean): T;
+};
+/**
+ * Attaches a diagnostic label to an atom.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const withLabel: {
+  (name: string): <A extends Atom<any>>(self: A) => A;
+  <A extends Atom<any>>(self: A, name: string): A;
+};
+/**
+ * Pairs an atom with an initial value for registry initialization.
+ *
+ * **When to use**
+ *
+ * Use to preload an atom value when constructing or seeding a registry.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const initialValue: {
+  <A>(initialValue: A): (self: Atom<A>) => readonly [Atom<A>, A];
+  <A>(self: Atom<A>, initialValue: A): readonly [Atom<A>, A];
+};
+/**
+ * Maps the value of an atom by reading the source atom, applying the function,
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const map: {
+  <R extends Atom<any>, B>(f: (_: Type<R>) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
+  <R extends Atom<any>, B>(self: R, f: (_: Type<R>) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
+};
+/**
+ * Maps the successful value inside an `AsyncResult` atom.
+ *
+ * **Details**
+ *
+ * Initial and failure states are preserved, and writable source atoms keep their
+ * original write input type.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+declare const mapResult: {
+  <R extends Atom<Result<any, any>>, B>(f: (_: Result.Success<Type<R>>) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<Result<B, Result.Failure<Type<R>>>, RW> : Atom<Result<B, Result.Failure<Type<R>>>>;
+  <R extends Atom<Result<any, any>>, B>(self: R, f: (_: Result.Success<Type<R>>) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<Result<B, Result.Failure<Type<R>>>, RW> : Atom<Result<B, Result.Failure<Type<R>>>>;
+};
+/**
+ * Creates an atom that publishes source changes only after the source has stopped
+ * changing for the specified duration.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const debounce: {
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>;
+};
+/**
+ * Creates a derived atom that reads the source and schedules a refresh after the
+ * specified duration.
+ *
+ * **Details**
+ *
+ * The scheduled refresh is canceled when the derived atom's lifetime is disposed.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+declare const withRefresh: {
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>;
+};
+/**
+ * Adds stale-while-revalidate refresh behavior to an async result atom.
+ *
+ * **Details**
+ *
+ * Automatic revalidation during reads is skipped while the current value is
+ * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+ * forward to the wrapped atom. Use `revalidateOnMount` to control whether stale data should trigger a
+ * background refresh on first mount. Use `revalidateOnFocus` to control
+ * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+declare const swr: {
+  (options: {
+    readonly staleTime: Duration.Input;
+    readonly revalidateOnMount?: boolean | undefined;
+    readonly revalidateOnFocus?: boolean | 'always' | undefined;
+    readonly focusSignal?: Atom<any> | undefined;
+  }): <R extends Atom<Result<any, any>>>(self: R) => WithoutSerializable<R>;
+  <R extends Atom<Result<any, any>>>(self: R, options: {
+    readonly staleTime: Duration.Input;
+    readonly revalidateOnMount?: boolean | undefined;
+    readonly revalidateOnFocus?: boolean | 'always' | undefined;
+    readonly focusSignal?: Atom<any> | undefined;
+  }): WithoutSerializable<R>;
+};
+/**
+ * Wraps an atom in a writable optimistic atom.
+ *
+ * **Details**
+ *
+ * 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 constructors
+ * @since 4.0.0
+ */
+declare const optimistic: <A>(self: Atom<A>) => Writable<A, Atom<Result<A, unknown>>>;
+/**
+ * Creates an `AtomResultFn` that applies an optimistic update before running the
+ * underlying mutation.
+ *
+ * **Details**
+ *
+ * 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 combinators
+ * @since 4.0.0
+ */
+declare const optimisticFn: {
+  <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<Result<W, unknown>>>) => AtomResultFn<OW, XA, XE>;
+  <A, W, XA, XE, OW = void>(self: Writable<A, Atom<Result<W, unknown>>>, 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>);
+  }): AtomResultFn<OW, XA, XE>;
+};
+/**
+ * Runs synchronous atom updates as a batch.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const batch: (f: () => void) => void;
+/**
+ * Creates a writable atom backed by a `KeyValueStore` entry.
+ *
+ * **Details**
+ *
+ * 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.
+ *
+ * **Gotchas**
+ *
+ * Error surfacing differs by mode. Async mode reports a failed store read as an
+ * `AsyncResult.failure`; sync mode has no error channel on its bare value, so a
+ * failed read renders the default value instead. Writes are optimistic in both
+ * modes: the value is shown immediately and the store write is fired in the
+ * background, so a write the store later refuses is not reflected in the atom.
+ * Use async mode when store failures must be observable.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare function kvs<S extends Schema.ConstraintCodec<any, any>, const Mode extends 'sync' | 'async' = never>(options: {
+  readonly runtime: AtomRuntime<KeyValueStore.KeyValueStore, any>;
+  readonly key: string;
+  readonly schema: S;
+  readonly defaultValue: LazyArg<S['Type']>;
+  readonly mode?: Mode | undefined;
+}): Writable<'async' extends Mode ? Result<S['Type']> : S['Type'], S['Type']>;
+/**
+ * Converts an atom into a stream using the `AtomRegistry` service.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const toStream: <A>(self: Atom<A>) => Stream.Stream<A, never, AtomRegistry>;
+/**
+ * Converts an `AsyncResult` atom into a stream using the `AtomRegistry` service.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const toStreamResult: <A, E>(self: Atom<Result<A, E>>) => Stream.Stream<A, E, AtomRegistry>;
+/**
+ * Reads an atom's current value from the `AtomRegistry` service.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+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
+ */
+declare const modify: {
+  <R, W, A>(f: (_: R) => [returnValue: A, nextValue: W]): (self: Writable<R, W>) => Effect.Effect<A, never, AtomRegistry>;
+  <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
+ */
+declare const set: {
+  <W>(value: W): <R>(self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>;
+  <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
+ */
+declare const update: {
+  <R, W>(f: (_: R) => W): (self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>;
+  <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.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const getResult: <A, E>(self: Atom<Result<A, E>>, options?: {
+  readonly suspendOnWaiting?: boolean | undefined;
+}) => Effect.Effect<A, E, AtomRegistry>;
+/**
+ * Runs a refresh request for an atom through the `AtomRegistry` service.
+ *
+ * **When to use**
+ *
+ * Use to invalidate and recompute an atom from an Effect that has access to the
+ * active registry.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+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.
+ *
+ * **Details**
+ *
+ * Mounting keeps the atom subscribed with a no-op listener until the scope
+ * finalizer releases it.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+declare const mount: <A>(self: Atom<A>) => Effect.Effect<void, never, AtomRegistry | Scope$1.Scope>;
+/**
+ * The type id used to mark atoms that carry serialization metadata.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+declare const SerializableTypeId: SerializableTypeId;
+/**
+ * The literal type of the serializable atom marker.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+type SerializableTypeId = '~effect-atom/atom/Atom/Serializable';
+/**
+ * Serialization metadata attached to an atom.
+ *
+ * **Details**
+ *
+ * The key identifies the atom in dehydrated state, and the encode/decode
+ * functions convert between the atom value and the schema encoded value.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface Serializable<S extends Schema.Constraint> {
+  readonly [SerializableTypeId]: {
+    readonly key: string;
+    readonly encode: (value: S['Type']) => S['Encoded'];
+    readonly decode: (value: S['Encoded']) => S['Type'];
+  };
+}
+/**
+ * Returns `true` when an atom carries `Serializable` metadata.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+declare const isSerializable: (self: Atom<any>) => self is Atom<any> & Serializable<any>;
+/**
+ * Attaches serialization metadata to an atom using a schema and stable key.
+ *
+ * **Details**
+ *
+ * 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
+ */
+declare const serializable: {
+  <R extends Atom<any>, S extends Schema.ConstraintCodec<Type<R>, any>>(options: {
+    readonly key: string;
+    readonly schema: S;
+  }): (self: R) => R & Serializable<S>;
+  <R extends Atom<any>, S extends Schema.ConstraintCodec<Type<R>, any>>(self: R, options: {
+    readonly key: string;
+    readonly schema: S;
+  }): R & Serializable<S>;
+};
+//#endregion
+export { withEquality as $, getResult as A, readable as At, optimistic as B, batch as C, mount$1 as Ct, fn as D, WritableTypeId as Dt, family as E, TypeId$1 as Et, make as F, serializable as G, pull as H, map as I, subscriptionRef as J, set as K, mapResult as L, isSerializable as M, transform as Mt, keepAlive as N, writable as Nt, fnSync as O, isAtom as Ot, kvs as P, update as Q, modify as R, autoDispose as S, make$1 as St, debounce as T, toStreamResult$1 as Tt, refresh as U, optimisticFn as V, runtime as W, toStream as X, swr as Y, toStreamResult as Z, Success as _, TypeId as _t, Atom_d_exports as a, ServerValueTypeId as at, Writable as b, layer as bt, Interrupt as c, withServerValueInitial as ct, RegistryRuntimeFactory as d, searchParam as dt, withFallback as et, Reset as f, windowFocusSignal as ft, SharedRuntimeFactory as g, Registry_d_exports as gt, SerializableTypeId as h, Registry as ht, AtomRuntime as i, ServerValue as it, initialValue as j, setIdleTTL as jt, get as k, isWritable as kt, PullResult as l, makeRefreshOnSignal as lt, Serializable as m, Node as mt, AtomContext as n, withReactivity as nt, Failure as o, getServerValue as ot, RuntimeFactory as p, AtomRegistry as pt, setLazy as q, AtomResultFn as r, withRefresh as rt, FnContext as s, withServerValue as st, Atom as t, withLabel as tt, PullSuccess as u, refreshOnWindowFocus as ut, Type as v, getResult$1 as vt, context as w, toStream$1 as wt, WriteContext as x, layerOptions as xt, WithoutSerializable as y, isAtomRegistry as yt, mount as z };