@systemfsoftware/effect-atom 0.5.3

package/dist/Atom-DVWTGeoV.mjs

@@ -0,0 +1,1449 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as getResult$1, d as toStream$1, f as toStreamResult$1, m as batch$1, t as AtomRegistry, u as mount$1 } from "./Registry-BE4aKSZk.mjs";
+import { D as value, F as isResult, I as success, N as failure, O as waiting, P as initial, T as toExit, b as map$1, c as failureWithPrevious, d as fromExitWithPrevious, h as isInitial, k as waitingFrom, m as isFailure, p as getOrThrow, s as failWithPrevious, v as isSuccess, w as replacePrevious } from "./Result-rlUvoHzK.mjs";
+import * as Arr from "effect/Array";
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { constTrue, constVoid, constant, dual, pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
+import * as Pull from "effect/Pull";
+import * as Scheduler$1 from "effect/Scheduler";
+import * as Schema from "effect/Schema";
+import * as Scope 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 { NodeInspectSymbol } from "effect/Inspectable";
+import { pipeArguments } from "effect/Pipeable";
+import { hasProperty } from "effect/Predicate";
+import * as Result from "effect/Result";
+//#region src/internal/Core.ts
+/** @internal */
+const PipeInspectableProto = { pipe() {
+	return pipeArguments(this, arguments);
+} };
+/**
+* Runtime identifier attached to `Atom` values and used by `isAtom`.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect/reactivity/Atom";
+/**
+* Runtime identifier attached to writable atoms and used by `isWritable`.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const WritableTypeId = "~effect/reactivity/Atom/Writable";
+/**
+* Returns `true` when a value is an `Atom`.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isAtom = (u) => hasProperty(u, TypeId);
+/**
+* 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
+*/
+const setIdleTTL = dual(2, (self, durationInput) => {
+	const duration = Duration.fromInputUnsafe(durationInput);
+	const isFinite = Duration.isFinite(duration);
+	const copy = {
+		...self,
+		keepAlive: !isFinite,
+		idleTTL: isFinite ? Duration.toMillis(duration) : void 0
+	};
+	Reflect.setPrototypeOf(copy, Reflect.getPrototypeOf(self));
+	return copy;
+});
+/** @internal */
+const removeTtl = setIdleTTL(0);
+/** @internal */
+const AtomProto = {
+	[TypeId]: TypeId,
+	equals: Object.is,
+	...PipeInspectableProto,
+	[NodeInspectSymbol]() {
+		return this;
+	},
+	toJSON() {
+		return {
+			_id: "Atom",
+			keepAlive: this.keepAlive,
+			lazy: this.lazy,
+			label: this.label
+		};
+	}
+};
+/** @internal */
+const WritableProto = {
+	...AtomProto,
+	[WritableTypeId]: WritableTypeId
+};
+/**
+* Returns `true` when an atom is writable.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isWritable = (atom) => WritableTypeId in atom;
+/**
+* Creates a read-only atom from a read function and an optional custom refresh registration callback.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const readable = (read, refresh) => {
+	return {
+		...AtomProto,
+		keepAlive: false,
+		lazy: true,
+		read,
+		...refresh === void 0 ? {} : { refresh }
+	};
+};
+/**
+* Creates a writable atom from read and write functions, with an optional custom refresh registration callback.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const writable = (read, write, refresh) => {
+	return {
+		...WritableProto,
+		keepAlive: false,
+		lazy: true,
+		read,
+		write,
+		...refresh === void 0 ? {} : { refresh }
+	};
+};
+const getInitialValueTarget = (atom) => {
+	let target = atom;
+	while (target.initialValueTarget) target = target.initialValueTarget;
+	return target;
+};
+/**
+* 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
+*/
+const transform = dual((args) => isAtom(args[0]), (self, f, options) => {
+	const atom = removeTtl(isWritable(self) ? writable((get) => f(get, self), function(ctx, value) {
+		ctx.set(self, value);
+	}, self.refresh ?? function(refresh) {
+		refresh(self);
+	}) : readable((get) => f(get, self), self.refresh ?? function(refresh) {
+		refresh(self);
+	}));
+	if (options?.initialValueTarget) {
+		const mutable = atom;
+		mutable.initialValueTarget = getInitialValueTarget(options.initialValueTarget);
+	}
+	return atom;
+});
+//#endregion
+//#region src/Browser.ts
+/**
+* Browser-only `Atom` helpers.
+*
+* This module holds the parts of `Atom` that touch `window`, `history`, or
+* `document`: window focus tracking and URL search parameter atoms. All
+* exports are re-exported from `Atom` so consumers keep importing everything
+* from there.
+*
+* @since 4.0.0
+*/
+/**
+* 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
+*/
+const windowFocusSignal = readable((get) => {
+	let count = 0;
+	function update() {
+		if (document.visibilityState === "visible") get.setSelf(++count);
+	}
+	window.addEventListener("visibilitychange", update);
+	get.addFinalizer(() => {
+		window.removeEventListener("visibilitychange", update);
+	});
+	return count;
+});
+/**
+* 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
+*/
+const makeRefreshOnSignal = (signal) => {
+	function refreshOnSignal(self) {
+		return transform(self, (get) => {
+			get.once(signal);
+			get.subscribe(signal, () => get.refresh(self));
+			get.subscribe(self, (value) => get.setSelf(value));
+			return get.once(self);
+		}, { initialValueTarget: self });
+	}
+	return refreshOnSignal;
+};
+/**
+* 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
+*/
+const refreshOnWindowFocus = makeRefreshOnSignal(windowFocusSignal);
+function searchParam(name, options) {
+	const decode = options?.schema && Schema.decodeExit(options.schema);
+	const encode = options?.schema && Schema.encodeExit(options.schema);
+	return writable((get) => {
+		if (typeof window === "undefined") return decode ? Option.none() : "";
+		const handleUpdate = () => {
+			if (searchParamState.updating) return;
+			const newValue = new URLSearchParams(window.location.search).get(name) || "";
+			if (decode) get.setSelf(Exit.getSuccess(decode(newValue)));
+			else if (newValue !== Option.getOrUndefined(get.self())) get.setSelf(newValue);
+		};
+		window.addEventListener("popstate", handleUpdate);
+		window.addEventListener("pushstate", handleUpdate);
+		get.addFinalizer(() => {
+			window.removeEventListener("popstate", handleUpdate);
+			window.removeEventListener("pushstate", handleUpdate);
+		});
+		const value = new URLSearchParams(window.location.search).get(name) || "";
+		return decode ? Exit.getSuccess(decode(value)) : value;
+	}, (ctx, value) => {
+		if (typeof window === "undefined") {
+			ctx.setSelf(value);
+			return;
+		}
+		if (encode) {
+			const encoded = Option.flatMap(Option.isOption(value) ? value : Option.none(), (v) => Exit.getSuccess(encode(v)));
+			searchParamState.updates.set(name, Option.getOrElse(encoded, () => ""));
+			if (Option.isOption(value)) ctx.setSelf(Option.zipRight(encoded, value));
+		} else if (typeof value === "string") {
+			searchParamState.updates.set(name, value);
+			ctx.setSelf(value);
+		}
+		const generation = ++searchParamState.generation;
+		Effect.runFork(Effect.sleep("500 millis").pipe(Effect.andThen(Effect.sync(() => {
+			if (searchParamState.generation === generation) updateSearchParams();
+		}))));
+	});
+}
+const searchParamState = {
+	generation: 0,
+	updates: /* @__PURE__ */ new Map(),
+	updating: false
+};
+function updateSearchParams() {
+	searchParamState.updating = true;
+	const searchParams = new URLSearchParams(window.location.search);
+	for (const [key, value] of searchParamState.updates.entries()) if (value.length > 0) searchParams.set(key, value);
+	else searchParams.delete(key);
+	searchParamState.updates.clear();
+	const newUrl = `${window.location.pathname}?${searchParams.toString()}`;
+	window.history.pushState({}, "", newUrl);
+	searchParamState.updating = false;
+}
+//#endregion
+//#region src/Server.ts
+/**
+* Server-side `Atom` helpers.
+*
+* This module holds the parts of `Atom` that describe how to read atom values
+* on the server: the server-value type id, the read-override combinators, and
+* the registry getter that honors them. All exports are re-exported from
+* `Atom` so consumers keep importing everything from there.
+*
+* @since 4.0.0
+*/
+/**
+* The type id used to mark atoms with a server-side read override.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const ServerValueTypeId = "~effect-atom/atom/Atom/ServerValue";
+const isServerValue = (self) => ServerValueTypeId in self;
+/**
+* Sets the value of an Atom when read on the server.
+*
+* @category transforming
+* @since 4.0.0
+*/
+const withServerValue = dual(2, (self, read) => {
+	const copy = {
+		...self,
+		[ServerValueTypeId]: read
+	};
+	Reflect.setPrototypeOf(copy, Reflect.getPrototypeOf(self));
+	return copy;
+});
+/**
+* Sets an `AsyncResult` atom's server-side value to
+* `AsyncResult.initial(true)`.
+*
+* @category transforming
+* @since 4.0.0
+*/
+const withServerValueInitial = (self) => {
+	const copy = {
+		...self,
+		[ServerValueTypeId]: constant(initial(true))
+	};
+	Reflect.setPrototypeOf(copy, Reflect.getPrototypeOf(self));
+	return copy;
+};
+/**
+* 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
+*/
+const getServerValue = dual(2, (self, registry) => isServerValue(self) ? self[ServerValueTypeId]((atom) => registry.get(atom)) : registry.get(self));
+//#endregion
+//#region src/Atom.ts
+/**
+* Reactive state primitives for values managed by an `AtomRegistry`.
+*
+* An `Atom` describes how to produce or update one piece of reactive state. The
+* registry runs atom reads, remembers current values, tracks dependencies
+* between atoms, starts effects and streams, and cleans up atoms that are no
+* longer used. This module includes the atom constructors and update helpers
+* used for cached values, effect-backed values, streams, browser state, stored
+* values, and server-rendered values.
+*
+* @since 4.0.0
+*/
+var Atom_exports = /* @__PURE__ */ __exportAll({
+	Interrupt: () => Interrupt,
+	Reset: () => Reset,
+	SerializableTypeId: () => SerializableTypeId,
+	ServerValueTypeId: () => ServerValueTypeId,
+	TypeId: () => TypeId,
+	WritableTypeId: () => WritableTypeId,
+	autoDispose: () => autoDispose,
+	batch: () => batch,
+	context: () => context,
+	debounce: () => debounce,
+	family: () => family,
+	fn: () => fn,
+	fnSync: () => fnSync,
+	get: () => get,
+	getResult: () => getResult,
+	getServerValue: () => getServerValue,
+	initialValue: () => initialValue,
+	isAtom: () => isAtom,
+	isSerializable: () => isSerializable,
+	isWritable: () => isWritable,
+	keepAlive: () => keepAlive,
+	kvs: () => kvs,
+	make: () => make,
+	makeRead: () => makeRead,
+	makeRefreshOnSignal: () => makeRefreshOnSignal,
+	map: () => map,
+	mapResult: () => mapResult,
+	modify: () => modify,
+	mount: () => mount,
+	optimistic: () => optimistic,
+	optimisticFn: () => optimisticFn,
+	pull: () => pull,
+	readable: () => readable,
+	refresh: () => refresh,
+	refreshOnWindowFocus: () => refreshOnWindowFocus,
+	runtime: () => runtime,
+	searchParam: () => searchParam,
+	serializable: () => serializable,
+	set: () => set,
+	setIdleTTL: () => setIdleTTL,
+	setLazy: () => setLazy,
+	subscriptionRef: () => subscriptionRef,
+	swr: () => swr,
+	toStream: () => toStream,
+	toStreamResult: () => toStreamResult,
+	transform: () => transform,
+	update: () => update,
+	windowFocusSignal: () => windowFocusSignal,
+	withEquality: () => withEquality,
+	withFallback: () => withFallback,
+	withLabel: () => withLabel,
+	withReactivity: () => withReactivity,
+	withRefresh: () => withRefresh,
+	withServerValue: () => withServerValue,
+	withServerValueInitial: () => withServerValueInitial,
+	writable: () => writable
+});
+function runtimeFn(arg, options) {
+	if (arguments.length === 0) return (arg, options) => makeFnRuntime(this, arg, options);
+	return makeFnRuntime(this, arg, options);
+}
+const RuntimeProto = {
+	...AtomProto,
+	atom(arg, options) {
+		return readable((get) => {
+			const previous = get.self();
+			const runtimeResult = get(this);
+			if (isSuccess(runtimeResult)) {
+				const services = runtimeResult.value;
+				const value = typeof arg === "function" ? arg(get) : arg;
+				if (Effect.isEffect(value)) return effect(get, value, options, services);
+				return stream(get, value, options, services);
+			}
+			return replacePrevious(runtimeResult, previous);
+		});
+	},
+	fn: runtimeFn,
+	pull(create, options) {
+		const pullSignal = removeTtl(state(0));
+		const pullAtom = readable((get) => {
+			const previous = get.self();
+			const runtime = get(this);
+			if (isSuccess(runtime)) {
+				const services = runtime.value;
+				const value = typeof create === "function" ? create(get) : create;
+				return makeEffect(get, makeStreamPullEffect(get, pullSignal, value, options), initial(true), services, false);
+			}
+			return replacePrevious(runtime, previous);
+		});
+		return makeStreamPull(pullSignal, pullAtom);
+	},
+	subscriptionRef(create) {
+		const refAtom = removeTtl(readable((get) => {
+			const previous = get.self();
+			const runtimeResult = get(this);
+			if (isSuccess(runtimeResult)) {
+				const services = runtimeResult.value;
+				return makeEffect(get, typeof create === "function" ? create(get) : create, initial(true), services, false);
+			}
+			return replacePrevious(runtimeResult, previous);
+		}));
+		return makeSubRef(refAtom, (get, ref) => {
+			if (isResult(ref) && !isSuccess(ref)) return readRefResult(get, ref);
+			const runtime = getOrThrow(get(this));
+			return isResult(ref) ? readRefResult(get, ref, runtime) : success(readRefDirect(get, ref, runtime));
+		});
+	}
+};
+const makeFnRuntime = (self, arg, options) => {
+	const isFnArg = (u) => typeof u === "function";
+	const f = (a, get) => {
+		if (!isFnArg(arg)) throw new Error("AtomRuntime.fn expects a function argument");
+		return arg(a, get);
+	};
+	const [read, write, argAtom] = makeResultFn(options?.reactivityKeys ? (a, get) => {
+		const eff = f(a, get);
+		return Effect.isEffect(eff) ? Reactivity.mutation(eff, options.reactivityKeys ?? []) : Stream.ensuring(eff, Reactivity.invalidate(options.reactivityKeys ?? []));
+	} : f, options);
+	return writable((get) => {
+		const previous = get.self();
+		get.get(argAtom);
+		const runtimeResult = get.get(self);
+		if (isSuccess(runtimeResult)) return read(get, runtimeResult.value);
+		return replacePrevious(runtimeResult, previous);
+	}, write);
+};
+function constSetSelf(ctx, value) {
+	ctx.setSelf(value);
+}
+function make(arg, options) {
+	let readOrAtom;
+	if (Effect.isEffect(arg)) readOrAtom = function(get, providedServices) {
+		return effect(get, arg, options, providedServices);
+	};
+	else if (Stream.isStream(arg)) readOrAtom = function(get, providedServices) {
+		return stream(get, arg, options, providedServices);
+	};
+	else if (typeof arg === "function") readOrAtom = function(get, providedServices) {
+		const value = Reflect.apply(arg, void 0, [get, providedServices]);
+		if (Effect.isEffect(value)) return effect(get, value, options, providedServices);
+		else if (Stream.isStream(value)) return stream(get, value, options, providedServices);
+		return value;
+	};
+	else readOrAtom = state(arg);
+	if (isAtom(readOrAtom)) return readOrAtom;
+	return readable(readOrAtom);
+}
+function makeRead(arg, options) {
+	if (Effect.isEffect(arg)) return function(get, providedServices) {
+		return effect(get, arg, options, providedServices);
+	};
+	else if (Stream.isStream(arg)) return function(get, providedServices) {
+		return stream(get, arg, options, providedServices);
+	};
+	else if (typeof arg === "function") return function(get, providedServices) {
+		const value = Reflect.apply(arg, void 0, [get, providedServices]);
+		if (Effect.isEffect(value)) return effect(get, value, options, providedServices);
+		else if (Stream.isStream(value)) return stream(get, value, options, providedServices);
+		return value;
+	};
+	return state(arg);
+}
+const state = (initialValue) => writable(function(_get) {
+	return initialValue;
+}, constSetSelf);
+const effect = (get, effect, options, services) => {
+	return makeEffect(get, effect, options?.initialValue !== void 0 ? success(options.initialValue) : initial(), services, options?.uninterruptible);
+};
+function makeEffect(ctx, effect, initialValue, services = Context.empty(), uninterruptible = false) {
+	const previous = ctx.self();
+	const scope = Scope.makeUnsafe();
+	ctx.addFinalizer(() => {
+		Effect.runForkWith(services)(Scope.close(scope, Exit.void));
+	});
+	const servicesMap = new Map(services.mapUnsafe);
+	servicesMap.set(Scope.Scope.key, scope);
+	servicesMap.set(AtomRegistry.key, ctx.registry);
+	servicesMap.set(Scheduler$1.Scheduler.key, ctx.registry.scheduler);
+	let syncResult;
+	let isAsync = false;
+	const cancel = runCallbackSync(Context.makeUnsafe(servicesMap), effect, function(exit) {
+		syncResult = fromExitWithPrevious(exit, previous);
+		if (isAsync) ctx.setSelf(syncResult);
+	}, uninterruptible);
+	isAsync = true;
+	if (cancel !== void 0) ctx.addFinalizer(cancel);
+	if (syncResult !== void 0) return syncResult;
+	else if (Option.isSome(previous)) return waitingFrom(previous);
+	return waiting(initialValue);
+}
+function runCallbackSync(services, effect, onExit, uninterruptible = false) {
+	if (Exit.isExit(effect)) {
+		onExit(effect);
+		return;
+	}
+	const fiber = Effect.runForkWith(services)(effect);
+	fiber.currentDispatcher?.flush();
+	const result = fiber.pollUnsafe();
+	if (result) {
+		onExit(result);
+		return;
+	}
+	const remove = fiber.addObserver(onExit);
+	function cancel() {
+		remove();
+		if (!uninterruptible) fiber.interruptUnsafe();
+	}
+	return cancel;
+}
+function context(options) {
+	const memoMap = options?.memoMap ?? removeTtl(make(() => Layer.makeMemoMapUnsafe()));
+	const resolveMemoMap = (get) => isAtom(memoMap) ? get(memoMap) : memoMap;
+	let globalLayer = Reactivity.layer;
+	const addGlobalLayer = (layer) => {
+		globalLayer = Layer.provideMerge(globalLayer, Layer.orDie(Layer.provide(layer, Reactivity.layer)));
+	};
+	const reactivityAtom = removeTtl(make((get) => Effect.contextWith((services) => Layer.buildWithMemoMap(Reactivity.layer, resolveMemoMap(get), Context.get(services, Scope.Scope))).pipe(Effect.map(Context.get(Reactivity.Reactivity)))));
+	const withReactivity = (keys) => (atom) => {
+		const read = (get) => {
+			const store = getOrThrow(get(reactivityAtom));
+			get.addFinalizer(store.registerUnsafe(keys, () => {
+				get.refresh(atom);
+			}));
+			get.subscribe(atom, (value) => get.setSelf(value));
+			return atom.read(get);
+		};
+		return {
+			...atom,
+			read
+		};
+	};
+	const factoryFn = function makeRuntime(create) {
+		const layerAtom = keepAlive(typeof create === "function" ? readable((get) => Layer.provideMerge(create(get), globalLayer)) : readable(() => Layer.provideMerge(create, globalLayer)));
+		return {
+			...AtomProto,
+			...RuntimeProto,
+			keepAlive: false,
+			lazy: true,
+			refresh: void 0,
+			factory,
+			layer: layerAtom,
+			read(get) {
+				const layer = get(layerAtom);
+				const built = Effect.flatMap(Effect.scope, (scope) => Layer.buildWithMemoMap(layer, resolveMemoMap(get), scope));
+				return effect(get, built, { uninterruptible: true });
+			}
+		};
+	};
+	const factory = isAtom(memoMap) ? Object.assign(factoryFn, {
+		memoMap,
+		addGlobalLayer,
+		withReactivity
+	}) : Object.assign(factoryFn, {
+		memoMap,
+		addGlobalLayer,
+		withReactivity
+	});
+	return factory;
+}
+/**
+* Default registry-scoped `RuntimeFactory`.
+*
+* @category context
+* @since 4.0.0
+*/
+const runtime = context();
+/**
+* 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
+*/
+const withReactivity = runtime.withReactivity;
+const stream = (get, stream, options, services) => {
+	return makeStream(get, stream, options?.initialValue !== void 0 ? success(options.initialValue) : initial(), services);
+};
+function makeStream(ctx, stream, initialValue, services = Context.empty()) {
+	const previous = ctx.self();
+	services = Context.add(services, AtomRegistry, ctx.registry);
+	let latest = Option.none();
+	const run = Effect.scopedWith((scope) => Effect.flatMap(Channel.toPullScoped(stream.channel, scope), (pull) => Effect.whileLoop({
+		while: constTrue,
+		body: () => pull,
+		step(arr) {
+			const last = Arr.lastNonEmpty(arr);
+			latest = Option.some(last);
+			ctx.setSelf(success(last, { waiting: true }));
+		}
+	}))).pipe(Effect.catchCause((cause) => {
+		if (Pull.isDoneCause(cause)) pipe(Option.orElse(latest, () => Option.flatMap(previous, value)), Option.match({
+			onNone: () => ctx.setSelf(failWithPrevious(new Cause.NoSuchElementError(), { previous })),
+			onSome: (a) => ctx.setSelf(success(a))
+		}));
+		else {
+			const mapFail = (e) => Cause.isDone(e) ? new Cause.NoSuchElementError() : e;
+			const stripped = Cause.map(cause, mapFail);
+			ctx.setSelf(failureWithPrevious(stripped, { previous }));
+		}
+		return Effect.void;
+	}));
+	const servicesMap = new Map(services.mapUnsafe);
+	servicesMap.set(AtomRegistry.key, ctx.registry);
+	servicesMap.set(Scheduler$1.Scheduler.key, ctx.registry.scheduler);
+	const cancel = runCallbackSync(Context.makeUnsafe(servicesMap), run, constVoid, false);
+	if (cancel !== void 0) ctx.addFinalizer(cancel);
+	if (Option.isSome(previous)) return waitingFrom(previous);
+	return waiting(initialValue);
+}
+/**
+* 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
+*/
+const subscriptionRef = (ref) => makeSubRef(readable((get) => {
+	const value = typeof ref === "function" ? ref(get) : ref;
+	return SubscriptionRef.isSubscriptionRef(value) ? value : makeEffect(get, value, initial(true));
+}), (get, source) => isResult(source) ? readRefResult(get, source) : readRefDirect(get, source));
+/** The ref a source carries, when it has produced one. */
+const refOf = (source) => {
+	if (!isResult(source)) return Option.some(source);
+	if (!isSuccess(source)) return Option.none();
+	const value = source.value;
+	return Context.isContext(value) ? Option.none() : Option.some(value);
+};
+/**
+* Reads a ref the caller already holds: subscribes to its changes for the
+* lifetime of the read and yields its current value. A ref handed over outright
+* has nothing to await, so this reports the value itself, never a result.
+*/
+const readRefDirect = (get, ref, services = Context.empty()) => {
+	get.addFinalizer(SubscriptionRef.changes(ref).pipe(Stream.runForEachArray((arr) => {
+		for (let i = 0; i < arr.length; i++) get.setSelf(arr[i]);
+		return Effect.void;
+	}), Effect.runCallbackWith(services)));
+	return Effect.runSyncWith(services)(SubscriptionRef.get(ref));
+};
+/**
+* Reads a ref that is still being produced, so the value reports every state the
+* producer reaches rather than only its outcome.
+*/
+const readRefResult = (get, source, services = Context.empty()) => {
+	if (isSuccess(source)) {
+		const value = source.value;
+		if (Context.isContext(value)) return success(value);
+		return makeStream(get, SubscriptionRef.changes(value), initial(true), services);
+	}
+	return isFailure(source) ? failure(source.cause, { waiting: source.waiting }) : initial(source.waiting);
+};
+const makeSubRef = (refAtom, read) => {
+	function write(ctx, value) {
+		const ref = refOf(ctx.get(refAtom));
+		if (Option.isSome(ref)) Effect.runSync(SubscriptionRef.set(ref.value, value));
+	}
+	return writable((get) => read(get, get(refAtom)), write);
+};
+function fnSync(...args) {
+	if (args.length === 0) return makeFnSync;
+	const f = args[0];
+	if (f === void 0) throw new TypeError("fnSync expects a function argument");
+	return makeFnSync(f, args[1]);
+}
+const makeFnSync = (f, options) => {
+	const argAtom = removeTtl(state([0, void 0]));
+	const hasInitialValue = options?.initialValue !== void 0;
+	return writable(function(get) {
+		get.isFn = true;
+		const [counter, arg] = get.get(argAtom);
+		if (counter === 0) return hasInitialValue ? options.initialValue : Option.none();
+		const argValue = Option.getOrThrowWith(Option.fromUndefinedOr(arg), () => /* @__PURE__ */ new Error("fnSync: function atom read without an argument"));
+		return hasInitialValue ? f(argValue, get) : Option.some(f(argValue, get));
+	}, function(ctx, arg) {
+		batch(() => {
+			ctx.set(argAtom, [ctx.get(argAtom)[0] + 1, arg]);
+			ctx.refreshSelf();
+		});
+	});
+};
+/**
+* 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
+*/
+const Reset = Symbol.for("effect/reactivity/atom/Atom/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
+*/
+const Interrupt = Symbol.for("effect/reactivity/atom/Atom/Interrupt");
+function fn(...args) {
+	if (args.length === 0) return makeFn;
+	const f = args[0];
+	if (f === void 0) throw new TypeError("fn expects a function argument");
+	return makeFn(f, args[1]);
+}
+function makeFn(f, options) {
+	const [read, write] = makeResultFn(f, options);
+	return writable(read, write);
+}
+function makeResultFn(f, options) {
+	const argAtom = removeTtl(state([0, Option.none()]));
+	const initialValue = options?.initialValue !== void 0 ? success(options.initialValue) : initial();
+	const fibersAtom = options?.concurrent ? removeTtl(readable((get) => {
+		const fibers = /* @__PURE__ */ new Set();
+		get.addFinalizer(() => fibers.forEach((f) => f.interruptUnsafe()));
+		return fibers;
+	})) : void 0;
+	function read(get, services) {
+		const fibers = fibersAtom ? get(fibersAtom) : void 0;
+		get.isFn = true;
+		const [counter, arg] = get.get(argAtom);
+		if (counter === 0) return initialValue;
+		else {
+			const argValue = Option.getOrThrow(arg);
+			if (argValue === Interrupt) return failureWithPrevious(Cause.interrupt(), { previous: Option.none() });
+			const value = f(argValue, get);
+			if (Effect.isEffect(value)) {
+				if (fibers) {
+					const eff = value;
+					return makeEffect(get, Effect.flatMap(Effect.forkDetach(eff, { startImmediately: true }), (fiber) => {
+						fibers.add(fiber);
+						fiber.addObserver(() => fibers.delete(fiber));
+						return Effect.map(Fiber.joinAll(fibers), (arr) => Option.getOrThrow(Arr.head(arr)));
+					}), initialValue, services, false);
+				}
+				return makeEffect(get, value, initialValue, services, false);
+			}
+			return makeStream(get, value, initialValue, services);
+		}
+	}
+	function write(ctx, arg) {
+		batch(() => {
+			if (arg === Reset) ctx.set(argAtom, [0, Option.none()]);
+			else if (arg === Interrupt) ctx.set(argAtom, [ctx.get(argAtom)[0] + 1, Option.some(Interrupt)]);
+			else ctx.set(argAtom, [ctx.get(argAtom)[0] + 1, Option.some(arg)]);
+			ctx.refreshSelf();
+		});
+	}
+	return [
+		read,
+		write,
+		argAtom
+	];
+}
+/**
+* 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
+*/
+const pull = (create, options) => {
+	const pullSignal = removeTtl(state(0));
+	const pullAtom = readable(makeRead((get) => makeStreamPullEffect(get, pullSignal, create, options)));
+	return makeStreamPull(pullSignal, pullAtom);
+};
+const makeStreamPullEffect = (get, pullSignal, create, options) => Effect.flatMap(Stream.toPull(typeof create === "function" ? create(get) : create), (pullChunk) => {
+	const fiber = Fiber.getCurrent();
+	if (fiber === void 0) return Effect.die(/* @__PURE__ */ new Error("Atom.pull: no fiber in scope"));
+	const services = Context.empty().pipe(Context.add(Scope.Scope, Context.getUnsafe(fiber.context, Scope.Scope)), Context.add(AtomRegistry, Context.getUnsafe(fiber.context, AtomRegistry)));
+	let acc = Arr.empty();
+	const pull = Effect.matchCauseEffect(pullChunk, {
+		onFailure(cause) {
+			const filtered = Pull.filterDone(cause);
+			if (Result.isSuccess(filtered)) {
+				if (!Arr.isReadonlyArrayNonEmpty(acc)) return Effect.fail(new Cause.NoSuchElementError(`Atom.pull: no items`));
+				return Effect.succeed({
+					done: true,
+					items: acc
+				});
+			}
+			return Effect.failCause(filtered.failure);
+		},
+		onSuccess(chunk) {
+			let items;
+			if (options?.disableAccumulation) items = Arr.fromIterable(chunk);
+			else {
+				items = Arr.appendAll(acc, chunk);
+				acc = items;
+			}
+			if (!Arr.isReadonlyArrayNonEmpty(items)) return pull;
+			return Effect.succeed({
+				done: false,
+				items
+			});
+		}
+	});
+	const cancels = /* @__PURE__ */ new Set();
+	get.addFinalizer(() => {
+		for (const cancel of cancels) cancel();
+	});
+	get.once(pullSignal);
+	get.subscribe(pullSignal, () => {
+		get.setSelf(waitingFrom(Option.none()));
+		let cancel;
+		cancel = runCallbackSync(services, pull, (exit) => {
+			if (cancel) cancels.delete(cancel);
+			const result = fromExitWithPrevious(exit, Option.none());
+			const pending = cancels.size > 0;
+			get.setSelf(pending ? waiting(result) : result);
+		});
+		if (cancel) cancels.add(cancel);
+	});
+	return pull;
+});
+const makeStreamPull = (pullSignal, pullAtom) => writable(pullAtom.read, function(ctx, _) {
+	ctx.set(pullSignal, ctx.get(pullSignal) + 1);
+});
+/**
+* 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
+*/
+const family = typeof WeakRef === "undefined" || typeof FinalizationRegistry === "undefined" ? (f) => {
+	const atoms = MutableHashMap.empty();
+	return function(arg) {
+		const atomEntry = MutableHashMap.get(atoms, arg);
+		if (Option.isSome(atomEntry)) return atomEntry.value;
+		const newAtom = f(arg);
+		MutableHashMap.set(atoms, arg, newAtom);
+		return newAtom;
+	};
+} : (f) => {
+	const atoms = MutableHashMap.empty();
+	const registry = new FinalizationRegistry((arg) => {
+		MutableHashMap.remove(atoms, arg);
+	});
+	return function(arg) {
+		const atomEntry = MutableHashMap.get(atoms, arg).pipe(Option.flatMapNullishOr((ref) => ref.deref()));
+		if (Option.isSome(atomEntry)) return atomEntry.value;
+		const newAtom = f(arg);
+		MutableHashMap.set(atoms, arg, new WeakRef(newAtom));
+		registry.register(newAtom, arg);
+		return newAtom;
+	};
+};
+/**
+* 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
+*/
+const withFallback = dual(2, (self, fallback) => {
+	function withFallback(get) {
+		const result = get(self);
+		return isInitial(result) ? waiting(get(fallback)) : result;
+	}
+	return isWritable(self) ? writable(withFallback, self.write, self.refresh ?? function(refresh) {
+		refresh(self);
+	}) : readable(withFallback, self.refresh ?? function(refresh) {
+		refresh(self);
+	});
+});
+const copyAtomWithProto = (self, patch) => {
+	const copy = Object.assign({}, self, patch);
+	const prototype = Reflect.getPrototypeOf(self);
+	if (prototype !== null && prototype !== Object.prototype) Object.setPrototypeOf(copy, prototype);
+	return copy;
+};
+/**
+* Returns a copy of an atom that remains cached and mounted even when no subscribers are using it.
+*
+* @category combinators
+* @since 4.0.0
+*/
+const keepAlive = (self) => copyAtomWithProto(self, { keepAlive: true });
+/**
+* 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
+*/
+const autoDispose = (self) => copyAtomWithProto(self, { keepAlive: false });
+/**
+* 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
+*/
+const setLazy = dual(2, (self, lazy) => copyAtomWithProto(self, { lazy }));
+/**
+* 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
+*/
+const withEquality = dual(2, (self, equals) => copyAtomWithProto(self, { equals }));
+/**
+* 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
+*/
+const withLabel = dual(2, (self, name) => copyAtomWithProto(self, { label: [name, (/* @__PURE__ */ new Error()).stack?.split("\n")[5] ?? ""] }));
+/**
+* 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
+*/
+const initialValue = dual(2, (self, initialValue) => [self, initialValue]);
+/**
+* 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
+*/
+const map = dual(2, (self, f) => transform(self, (get) => f(get(self))));
+/**
+* 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
+*/
+const mapResultImpl = (self, f) => transform(self, (get) => {
+	const value = get(self);
+	if (!isResult(value)) throw new TypeError("mapResult: expected an AsyncResult atom");
+	if (isSuccess(value)) return success(f(value.value));
+	return value;
+});
+const isMapResultMapper = (arg) => typeof arg === "function";
+function mapResult(selfOrF, f) {
+	if (arguments.length >= 2) {
+		if (!isAtom(selfOrF) || !isMapResultMapper(f)) throw new TypeError("mapResult expects an atom and a function argument");
+		return mapResultImpl(selfOrF, f);
+	}
+	return (self) => {
+		if (!isMapResultMapper(selfOrF)) throw new TypeError("mapResult expects a function argument");
+		return mapResultImpl(self, selfOrF);
+	};
+}
+/**
+* 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
+*/
+const debounce = dual(2, (self, duration) => {
+	const millis = Duration.toMillis(Duration.fromInputUnsafe(duration));
+	return transform(self, function(get) {
+		let timeout;
+		let value = get.once(self);
+		function update() {
+			timeout = void 0;
+			get.setSelf(value);
+		}
+		get.addFinalizer(function() {
+			if (timeout) timeout();
+		});
+		get.subscribe(self, function(val) {
+			value = val;
+			timeout?.();
+			timeout = get.registry.scheduleTimer(update, millis);
+		});
+		return value;
+	}, { initialValueTarget: self });
+});
+/**
+* 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
+*/
+const withRefresh = dual(2, (self, duration) => {
+	const millis = Duration.toMillis(Duration.fromInputUnsafe(duration));
+	return transform(self, function(get) {
+		const fiber = Effect.runFork(Effect.sleep(millis).pipe(Effect.andThen(Effect.sync(() => get.refresh(self)))));
+		get.addFinalizer(() => fiber.interruptUnsafe());
+		return get(self);
+	}, { initialValueTarget: self });
+});
+/**
+* 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
+*/
+const swr = dual(2, (self, options) => {
+	const staleTime = Duration.toMillis(Duration.fromInputUnsafe(options.staleTime));
+	return transform(self, (get) => {
+		const current = get.once(self);
+		get.subscribe(self, (value) => {
+			get.setSelf(value);
+		});
+		if (options.revalidateOnFocus && options.focusSignal) {
+			get.once(options.focusSignal);
+			get.subscribe(options.focusSignal, options.revalidateOnFocus === "always" ? () => get.refresh(self) : () => {
+				const current = get.once(self);
+				if (shouldRevalidateSWR(current, staleTime, get.registry.now())) get.refresh(self);
+			});
+		}
+		if (Option.isNone(get.self()) && options.revalidateOnMount === false) return current;
+		if (shouldRevalidateSWR(current, staleTime, get.registry.now())) get.refresh(self);
+		return current;
+	}, { initialValueTarget: self });
+});
+const swrTimestamp = (result) => {
+	if (isSuccess(result)) return Option.some(result.timestamp);
+	if (isFailure(result)) return Option.map(result.previousSuccess, (success) => success.timestamp);
+	return Option.none();
+};
+const isFreshWithin = (timestamp, staleTime, now) => now - timestamp < staleTime;
+const shouldRevalidateSWR = (result, staleTime, now) => {
+	if (result.waiting) return false;
+	const timestamp = Option.getOrUndefined(swrTimestamp(result));
+	if (timestamp === void 0) return !isInitial(result);
+	return !isFreshWithin(timestamp, staleTime, now);
+};
+/**
+* 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
+*/
+const optimistic = (self) => {
+	let counter = 0;
+	const writeAtom = removeTtl(state([counter, void 0]));
+	return writable((get) => {
+		let lastValue = get.once(self);
+		let needsRefresh = false;
+		get.subscribe(self, (value) => {
+			lastValue = value;
+			if (transitions.size > 0) return;
+			needsRefresh = false;
+			if (!isResult(value)) return get.setSelf(value);
+			const current = Option.getOrUndefined(get.self());
+			if (isInitial(value)) {
+				if (isResult(current) && isInitial(current)) get.setSelf(value);
+				return;
+			}
+			if (isSuccess(value)) {
+				if (isResult(current) && isSuccess(current)) {
+					if (!value.waiting && value.timestamp >= current.timestamp) get.setSelf(value);
+				} else get.setSelf(value);
+				return;
+			}
+			get.setSelf(value);
+		});
+		const transitions = /* @__PURE__ */ new Set();
+		const cancels = /* @__PURE__ */ new Set();
+		get.subscribe(writeAtom, ([, atom]) => {
+			if (atom === void 0) return;
+			if (transitions.has(atom)) return;
+			transitions.add(atom);
+			let cancel;
+			cancel = get.registry.subscribe(atom, (result) => {
+				if (isSuccess(result) && result.waiting) return get.setSelf(result.value);
+				transitions.delete(atom);
+				if (cancel) {
+					cancels.delete(cancel);
+					cancel();
+				}
+				if (!needsRefresh && !isFailure(result)) needsRefresh = true;
+				if (transitions.size === 0) {
+					if (needsRefresh) {
+						needsRefresh = false;
+						get.refresh(self);
+					} else get.setSelf(lastValue);
+				}
+			}, { immediate: true });
+			if (transitions.has(atom)) cancels.add(cancel);
+			else cancel();
+		});
+		get.addFinalizer(() => {
+			for (const cancel of cancels) cancel();
+			transitions.clear();
+			cancels.clear();
+		});
+		return lastValue;
+	}, (ctx, atom) => ctx.set(writeAtom, [++counter, atom]), (refresh) => refresh(self));
+};
+/**
+* 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
+*/
+const optimisticFn = dual(2, (self, options) => {
+	const transition = removeTtl(state(initial()));
+	return fn((arg, get) => {
+		let value = options.reducer(get(self), arg);
+		if (isResult(value)) value = waiting(value, { touch: true });
+		get.set(transition, success(value, { waiting: true }));
+		get.set(self, transition);
+		const fn = typeof options.fn === "function" ? autoDispose(options.fn((value) => get.set(transition, success(isResult(value) ? waiting(value) : value, { waiting: true })))) : options.fn;
+		get.set(fn, arg);
+		return Effect.callback((resume) => {
+			get.subscribe(fn, (result) => {
+				if (isInitial(result) || result.waiting) return;
+				get.set(transition, map$1(result, () => value));
+				resume(toExit(result));
+			}, { immediate: true });
+		});
+	});
+});
+/**
+* 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
+*/
+const batch = batch$1;
+function kvs(options) {
+	const setAtom = options.runtime.fn((value) => KeyValueStore.KeyValueStore.use((store) => KeyValueStore.toSchemaStore(store, options.schema).set(options.key, value)));
+	const resultAtom = options.runtime.atom(KeyValueStore.KeyValueStore.use((store) => KeyValueStore.toSchemaStore(store, options.schema).get(options.key)));
+	let written = false;
+	return writable((get) => {
+		if (options.mode === "async") {
+			written = false;
+			get.mount(setAtom);
+			const readValue = () => {
+				const result = get.once(resultAtom);
+				if (!isSuccess(result) || !Option.isOption(result.value)) return initial();
+				return Option.isSome(result.value) ? success(result.value.value) : success(options.defaultValue());
+			};
+			get.subscribe(resultAtom, (result) => {
+				if (written) return;
+				if (!isSuccess(result) || !Option.isOption(result.value)) return;
+				if (Option.isSome(result.value)) get.setSelf(success(result.value.value));
+				else {
+					const value = options.defaultValue();
+					get.set(setAtom, value);
+					get.setSelf(success(value));
+				}
+			});
+			return readValue();
+		}
+		written = false;
+		get.mount(setAtom);
+		get.subscribe(resultAtom, (result) => {
+			if (!isSuccess(result) || !Option.isOption(result.value)) return;
+			if (written) return;
+			if (Option.isSome(result.value)) get.setSelf(result.value.value);
+			else {
+				const value = Option.getOrElse(get.self(), options.defaultValue);
+				get.setSelf(value);
+				get.set(setAtom, value);
+			}
+		}, { immediate: true });
+		return Option.getOrElse(get.self(), options.defaultValue);
+	}, (ctx, value) => {
+		written = true;
+		ctx.set(setAtom, value);
+		const next = options.mode === "async" ? success(value) : value;
+		ctx.setSelf(next);
+	});
+}
+/**
+* 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
+*/
+const toStream = (self) => Stream.unwrap(AtomRegistry.use((r) => Effect.succeed(toStream$1(r, self))));
+/**
+* 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
+*/
+const toStreamResult = (self) => Stream.unwrap(AtomRegistry.use((r) => Effect.succeed(toStreamResult$1(r, self))));
+/**
+* Reads an atom's current value from the `AtomRegistry` service.
+*
+* @category converting
+* @since 4.0.0
+*/
+const get = (self) => AtomRegistry.use((r) => Effect.succeed(r.get(self)));
+/**
+* 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
+*/
+const modify = dual(2, (self, f) => Effect.map(AtomRegistry, (_) => _.modify(self, f)));
+/**
+* Writes a value to a writable atom through the `AtomRegistry` service.
+*
+* @category converting
+* @since 4.0.0
+*/
+const set = dual(2, (self, value) => Effect.map(AtomRegistry, (_) => _.set(self, value)));
+/**
+* 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
+*/
+const update = dual(2, (self, f) => Effect.map(AtomRegistry, (_) => _.update(self, f)));
+/**
+* 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
+*/
+const getResult = (self, options) => AtomRegistry.use(getResult$1(self, options));
+/**
+* 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
+*/
+const refresh = (self) => Effect.map(AtomRegistry, (_) => _.refresh(self));
+/**
+* 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
+*/
+const mount = (self) => AtomRegistry.use((r) => mount$1(r, self));
+/**
+* The type id used to mark atoms that carry serialization metadata.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const SerializableTypeId = "~effect-atom/atom/Atom/Serializable";
+/**
+* Returns `true` when an atom carries `Serializable` metadata.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isSerializable = (self) => SerializableTypeId in self;
+/**
+* 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
+*/
+const serializable = dual(2, (self, options) => {
+	const codecJson = Schema.toCodecJson(options.schema);
+	return copyAtomWithProto(self, {
+		label: self.label ?? [options.key, (/* @__PURE__ */ new Error()).stack?.split("\n")[5] ?? ""],
+		[SerializableTypeId]: {
+			key: options.key,
+			encode: Schema.encodeSync(codecJson),
+			decode: Schema.decodeSync(codecJson)
+		}
+	});
+});
+//#endregion
+export { isWritable as $, set as A, withReactivity as B, mount as C, refresh as D, pull as E, toStreamResult as F, withServerValueInitial as G, ServerValueTypeId as H, update as I, searchParam as J, makeRefreshOnSignal as K, withEquality as L, subscriptionRef as M, swr as N, runtime as O, toStream as P, isAtom as Q, withFallback as R, modify as S, optimisticFn as T, getServerValue as U, withRefresh as V, withServerValue as W, TypeId as X, windowFocusSignal as Y, WritableTypeId as Z, kvs as _, autoDispose as a, map as b, debounce as c, fnSync as d, readable as et, get as f, keepAlive as g, isSerializable as h, SerializableTypeId as i, setLazy as j, serializable as k, family as l, initialValue as m, Interrupt as n, transform as nt, batch as o, getResult as p, refreshOnWindowFocus as q, Reset as r, writable as rt, context as s, Atom_exports as t, setIdleTTL as tt, fn as u, make as v, optimistic as w, mapResult as x, makeRead as y, withLabel as z };