@systemfsoftware/effect-atom 0.5.3

package/dist/Atom-NsW01Gu1.mjs

@@ -0,0 +1,1348 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { A as toExit, M as value, N as waiting, O as replacePrevious, P as waitingFrom, S as isSuccess, _ as isFailure, c as failWithPrevious, g as initial, h as getOrThrow, k as success, p as fromExitWithPrevious, u as failureWithPrevious, v as isInitial, w as map$1, x as isResult } from "./Result-D8FNEzuX.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-DhP1TSer.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$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 { pipeArguments } from "effect/Pipeable";
+import { hasProperty } from "effect/Predicate";
+//#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);
+	return Object.assign(Object.create(Object.getPrototypeOf(self)), {
+		...self,
+		keepAlive: !isFinite,
+		idleTTL: isFinite ? Duration.toMillis(duration) : void 0
+	});
+});
+/** @internal */
+const removeTtl = setIdleTTL(0);
+/** @internal */
+const AtomProto = {
+	[TypeId]: TypeId,
+	equals: Object.is,
+	...PipeInspectableProto,
+	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) => {
+	const self = Object.create(AtomProto);
+	self.keepAlive = false;
+	self.lazy = true;
+	self.read = read;
+	self.refresh = refresh;
+	return self;
+};
+/**
+* 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) => {
+	const self = Object.create(WritableProto);
+	self.keepAlive = false;
+	self.lazy = true;
+	self.read = read;
+	self.write = write;
+	self.refresh = refresh;
+	return self;
+};
+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) atom.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(value, (v) => Exit.getSuccess(encode(v)));
+			searchParamState.updates.set(name, Option.getOrElse(encoded, () => ""));
+			value = Option.zipRight(encoded, value);
+		} else searchParamState.updates.set(name, value);
+		ctx.setSelf(value);
+		if (searchParamState.timeout) clearTimeout(searchParamState.timeout);
+		searchParamState.timeout = setTimeout(updateSearchParams, 500);
+	});
+}
+const searchParamState = {
+	timeout: void 0,
+	updates: /* @__PURE__ */ new Map(),
+	updating: false
+};
+function updateSearchParams() {
+	searchParamState.timeout = void 0;
+	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) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+	...self,
+	[ServerValueTypeId]: read
+}));
+/**
+* Sets an `AsyncResult` atom's server-side value to
+* `AsyncResult.initial(true)`.
+*
+* @category transforming
+* @since 4.0.0
+*/
+const withServerValueInitial = (self) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+	...self,
+	[ServerValueTypeId]: constant(initial(true))
+});
+/**
+* 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,
+	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
+});
+const RuntimeProto = {
+	...AtomProto,
+	atom(arg, options) {
+		const read = makeRead(arg, options);
+		return readable((get) => {
+			const previous = get.self();
+			const runtimeResult = get(this);
+			if (runtimeResult._tag !== "Success") return replacePrevious(runtimeResult, previous);
+			return read(get, runtimeResult.value);
+		});
+	},
+	fn(arg, options) {
+		if (arguments.length === 0) return (arg, options) => makeFnRuntime(this, arg, options);
+		return makeFnRuntime(this, arg, options);
+	},
+	pull(arg, options) {
+		const pullSignal = removeTtl(state(0));
+		const pullAtom = readable((get) => {
+			const previous = get.self();
+			const runtimeResult = get(this);
+			if (runtimeResult._tag !== "Success") return replacePrevious(runtimeResult, previous);
+			return makeEffect(get, makeStreamPullEffect(get, pullSignal, arg, options), initial(true), runtimeResult.value);
+		});
+		return makeStreamPull(pullSignal, pullAtom);
+	},
+	subscriptionRef(ref) {
+		return makeSubRef(removeTtl(readable((get) => {
+			const previous = get.self();
+			const runtimeResult = get(this);
+			if (runtimeResult._tag !== "Success") return replacePrevious(runtimeResult, previous);
+			const value = typeof ref === "function" ? ref(get) : ref;
+			return SubscriptionRef.isSubscriptionRef(value) ? value : makeEffect(get, value, initial(true), runtimeResult.value);
+		})), (get, ref) => {
+			const runtime = getOrThrow(get(this));
+			return readSubscriptionRef(get, ref, runtime);
+		});
+	}
+};
+const makeFnRuntime = (self, arg, options) => {
+	const [read, write, argAtom] = makeResultFn(options?.reactivityKeys ? ((a, get) => {
+		const effect = arg(a, get);
+		return Effect.isEffect(effect) ? Reactivity.mutation(effect, options.reactivityKeys) : Stream.ensuring(effect, Reactivity.invalidate(options.reactivityKeys));
+	}) : arg, options);
+	return writable((get) => {
+		get.get(argAtom);
+		const previous = get.self();
+		const runtimeResult = get.get(self);
+		if (runtimeResult._tag !== "Success") return replacePrevious(runtimeResult, previous);
+		return read(get, runtimeResult.value);
+	}, write);
+};
+function constSetSelf(ctx, value) {
+	ctx.setSelf(value);
+}
+function make(arg, options) {
+	const readOrAtom = makeRead(arg, options);
+	if (isAtom(readOrAtom)) return readOrAtom;
+	return readable(readOrAtom);
+}
+function makeRead(arg, options) {
+	if (typeof arg === "function" && !Effect.isEffect(arg) && !Stream.isStream(arg)) {
+		const create = arg;
+		return function(get, providedServices) {
+			const value = create(get);
+			switch (typeof value) {
+				case "function":
+				case "object":
+					if (value === null) return value;
+					else if (EffectTypeId in value) return effect(get, value, options, providedServices);
+					else if (StreamTypeId in value) return stream(get, value, options, providedServices);
+					return value;
+				default: return value;
+			}
+		};
+	} else 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);
+	};
+	return state(arg);
+}
+const EffectTypeId = "~effect/Effect";
+const StreamTypeId = "~effect/Stream";
+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$1.makeUnsafe();
+	ctx.addFinalizer(() => {
+		Effect.runForkWith(services)(Scope$1.close(scope, Exit.void));
+	});
+	const servicesMap = new Map(services.mapUnsafe);
+	servicesMap.set(Scope$1.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 (previous._tag === "Some") 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;
+	function factory(create) {
+		const self = Object.create(RuntimeProto);
+		self.keepAlive = false;
+		self.lazy = true;
+		self.refresh = void 0;
+		self.factory = factory;
+		const layerAtom = keepAlive(typeof create === "function" ? readable((get) => Layer.provideMerge(create(get), globalLayer)) : readable(() => Layer.provideMerge(create, globalLayer)));
+		self.layer = layerAtom;
+		self.read = function read(get) {
+			const layer = get(layerAtom);
+			const build = Effect.flatMap(Effect.scope, (scope) => Layer.buildWithMemoMap(layer, resolveMemoMap(get), scope));
+			return effect(get, build, { uninterruptible: true });
+		};
+		return self;
+	}
+	factory.memoMap = memoMap;
+	factory.addGlobalLayer = (layer) => {
+		globalLayer = Layer.provideMerge(globalLayer, Layer.provide(layer, Reactivity.layer));
+	};
+	const reactivityAtom = removeTtl(make((get) => Effect.contextWith((services) => Layer.buildWithMemoMap(Reactivity.layer, resolveMemoMap(get), Context.get(services, Scope$1.Scope))).pipe(Effect.map(Context.get(Reactivity.Reactivity)))));
+	factory.withReactivity = (keys) => {
+		function withReactivityKeys(atom) {
+			return transform(atom, (get) => {
+				const reactivity = getOrThrow(get(reactivityAtom));
+				get.addFinalizer(reactivity.registerUnsafe(keys, () => {
+					get.refresh(atom);
+				}));
+				get.subscribe(atom, (value) => get.setSelf(value));
+				return get.once(atom);
+			}, { initialValueTarget: atom });
+		}
+		return withReactivityKeys;
+	};
+	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);
+	const run = Effect.scopedWith((scope) => Effect.flatMap(Channel.toPullScoped(stream.channel, scope), (pull) => Effect.whileLoop({
+		while: constTrue,
+		body: () => pull,
+		step(arr) {
+			ctx.setSelf(success(Arr.lastNonEmpty(arr), { waiting: true }));
+		}
+	}))).pipe(Effect.catchCause((cause) => {
+		if (Pull.isDoneCause(cause)) pipe(ctx.self(), Option.flatMap(value), Option.match({
+			onNone: () => ctx.setSelf(failWithPrevious(new Cause.NoSuchElementError(), { previous: ctx.self() })),
+			onSome: (a) => ctx.setSelf(success(a))
+		}));
+		else ctx.setSelf(failureWithPrevious(cause, { previous: ctx.self() }));
+		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 (previous._tag === "Some") 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));
+}), readSubscriptionRef);
+const readSubscriptionRef = (get, sub, services = Context.empty()) => {
+	if (SubscriptionRef.isSubscriptionRef(sub)) {
+		get.addFinalizer(SubscriptionRef.changes(sub).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(sub));
+	} else if (sub._tag !== "Success") return sub;
+	return makeStream(get, SubscriptionRef.changes(sub.value), initial(true), services);
+};
+const makeSubRef = (refAtom, read) => {
+	function write(ctx, value) {
+		const ref = ctx.get(refAtom);
+		if (SubscriptionRef.isSubscriptionRef(ref)) Effect.runSync(SubscriptionRef.set(ref, value));
+		else if (isSuccess(ref)) Effect.runSync(SubscriptionRef.set(ref.value, value));
+	}
+	return writable((get) => {
+		const ref = get(refAtom);
+		if (SubscriptionRef.isSubscriptionRef(ref)) return read(get, ref);
+		else if (isSuccess(ref)) return read(get, ref);
+		return ref;
+	}, write);
+};
+function fnSync(...args) {
+	if (args.length === 0) return makeFnSync;
+	return makeFnSync(...args);
+}
+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();
+		return hasInitialValue ? f(arg, get) : Option.some(f(arg, 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;
+	return makeFn(...args);
+}
+function makeFn(f, options) {
+	const [read, write] = makeResultFn(f, options);
+	return writable(read, write);
+}
+function makeResultFn(f, options) {
+	const argAtom = removeTtl(state([0, void 0]));
+	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 if (arg === Interrupt) return failureWithPrevious(Cause.interrupt(), { previous: get.self() });
+		let value = f(arg, get);
+		if (Effect.isEffect(value)) {
+			if (fibers) {
+				const eff = value;
+				value = Effect.flatMap(Effect.forkDetach(eff, { startImmediately: true }), (fiber) => {
+					fibers.add(fiber);
+					fiber.addObserver(() => fibers.delete(fiber));
+					return Effect.map(Fiber.joinAll(fibers), (arr) => arr[0]);
+				});
+			}
+			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, void 0]);
+			else if (arg === Interrupt) ctx.set(argAtom, [ctx.get(argAtom)[0] + 1, Interrupt]);
+			else ctx.set(argAtom, [ctx.get(argAtom)[0] + 1, 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(function(get) {
+		return 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 services = Fiber.getCurrent().context;
+	let acc = Arr.empty();
+	const pull = Effect.matchCauseEffect(pullChunk, {
+		onFailure(cause) {
+			if (Pull.isDoneCause(cause)) {
+				if (!Arr.isReadonlyArrayNonEmpty(acc)) return Effect.fail(new Cause.NoSuchElementError(`Atom.pull: no items`));
+				return Effect.succeed({
+					done: true,
+					items: acc
+				});
+			}
+			return Effect.failCause(cause);
+		},
+		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(get.self()));
+		let cancel;
+		cancel = runCallbackSync(services, pull, (exit) => {
+			if (cancel) cancels.delete(cancel);
+			const result = fromExitWithPrevious(exit, get.self());
+			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 (atomEntry._tag === "Some") 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 (atomEntry._tag === "Some") 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);
+		if (result._tag === "Initial") return waiting(get(fallback));
+		return result;
+	}
+	return isWritable(self) ? writable(withFallback, self.write, self.refresh ?? function(refresh) {
+		refresh(self);
+	}) : readable(withFallback, self.refresh ?? function(refresh) {
+		refresh(self);
+	});
+});
+/**
+* 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) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+	...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) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+	...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) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+	...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) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+	...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) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+	...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 mapResult = dual(2, (self, f) => map(self, map$1(f)));
+/**
+* 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) clearTimeout(timeout);
+		});
+		get.subscribe(self, function(val) {
+			value = val;
+			if (timeout) clearTimeout(timeout);
+			timeout = setTimeout(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.refresh(self);
+			});
+		}
+		if (Option.isNone(get.self()) && options.revalidateOnMount === false) return current;
+		if (shouldRevalidateSWR(current, staleTime)) get.refresh(self);
+		return current;
+	}, { initialValueTarget: self });
+});
+const swrTimestamp = (result) => {
+	if (result._tag === "Success") return Option.some(result.timestamp);
+	if (result._tag === "Failure") return Option.map(result.previousSuccess, (success) => success.timestamp);
+	return Option.none();
+};
+const isFreshWithin = (timestamp, staleTime, now) => now - timestamp < staleTime;
+const shouldRevalidateSWR = (result, staleTime) => {
+	if (result.waiting) return false;
+	const timestamp = Option.getOrUndefined(swrTimestamp(result));
+	if (timestamp === void 0) return result._tag !== "Initial";
+	return !isFreshWithin(timestamp, staleTime, Date.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());
+			switch (value._tag) {
+				case "Initial":
+					if (isInitial(current)) get.setSelf(value);
+					return;
+				case "Success":
+					if (isSuccess(current)) {
+						if (!value.waiting && value.timestamp >= current.timestamp) get.setSelf(value);
+					} else get.setSelf(value);
+					return;
+				case "Failure": return get.setSelf(value);
+			}
+		});
+		const transitions = /* @__PURE__ */ new Set();
+		const cancels = /* @__PURE__ */ new Set();
+		get.subscribe(writeAtom, ([, atom]) => {
+			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 (result._tag === "Initial" || 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(options.mode === "async" ? (get) => {
+		written = false;
+		get.mount(setAtom);
+		const mapper = map$1(Option.getOrElse(() => {
+			const value = options.defaultValue();
+			get.set(setAtom, value);
+			return value;
+		}));
+		get.subscribe(resultAtom, (result) => {
+			if (written) return;
+			get.setSelf(mapper(result));
+		});
+		return mapper(get.once(resultAtom));
+	} : (get) => {
+		written = false;
+		get.mount(setAtom);
+		get.subscribe(resultAtom, (result) => {
+			if (!isSuccess(result)) 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);
+		ctx.setSelf(options.mode === "async" ? success(value) : value);
+	});
+}
+/**
+* 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 Object.assign(Object.create(Object.getPrototypeOf(self)), {
+		...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 { readable as $, setLazy as A, withRefresh as B, optimistic as C, runtime as D, refresh as E, update as F, makeRefreshOnSignal as G, getServerValue as H, withEquality as I, windowFocusSignal as J, refreshOnWindowFocus as K, withFallback as L, swr as M, toStream as N, serializable as O, toStreamResult as P, isWritable as Q, withLabel as R, mount as S, pull as T, withServerValue as U, ServerValueTypeId as V, withServerValueInitial as W, WritableTypeId as X, TypeId as Y, isAtom as Z, kvs as _, autoDispose as a, mapResult as b, debounce as c, fnSync as d, setIdleTTL as et, get as f, keepAlive as g, isSerializable as h, SerializableTypeId as i, subscriptionRef as j, set as k, family as l, initialValue as m, Interrupt as n, writable as nt, batch as o, getResult as p, searchParam as q, Reset as r, context as s, Atom_exports as t, transform as tt, fn as u, make as v, optimisticFn as w, modify as x, map as y, withReactivity as z };