@systemfsoftware/effect-atom 0.5.3

package/dist/Registry-BE4aKSZk.mjs

@@ -0,0 +1,823 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { F as isResult, T as toExit, _ as isNotInitial, h as isInitial, m as isFailure, v as isSuccess } from "./Result-rlUvoHzK.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { constVoid, dual } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { MixedScheduler } from "effect/Scheduler";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import { hasProperty } from "effect/Predicate";
+import * as Queue from "effect/Queue";
+import * as Match from "effect/Match";
+//#region src/internal/HostTimer.ts
+/**
+* Host clock and timer primitives for the atom registry.
+*
+* This module is the named host boundary for wall-clock reads and delayed
+* scheduling. It deliberately imports nothing from `effect`: the registry
+* itself is a fiber-free store, and consumers who need deterministic idle
+* eviction pass their own `now` / `scheduleTimer` to `Registry.make` /
+* `Registry.layerOptions`. The defaults here are the plain platform
+* implementations.
+*
+* @since 4.0.0
+*/
+const hostNow = () => Date.now();
+const hostScheduleTimer = (f, delayMillis) => {
+	const id = setTimeout(f, delayMillis);
+	return () => clearTimeout(id);
+};
+//#endregion
+//#region src/internal/NodeLifetime.ts
+const decideNodeFate = (input) => {
+	if (input.keepAlive || input.listenerCount > 0 || input.childCount > 0 || !input.isLive || input.isWaiting) return { _tag: "Alive" };
+	if (input.idleTTL === 0) return { _tag: "RemoveNow" };
+	const ttlMillis = input.idleTTL ?? input.defaultIdleTTL;
+	return ttlMillis === void 0 ? { _tag: "RemoveNow" } : {
+		_tag: "RemoveAfterTtl",
+		ttlMillis
+	};
+};
+//#endregion
+//#region src/internal/Node.ts
+const notifyListener = (listener) => {
+	listener();
+};
+const NodeFlags = {
+	alive: 1,
+	initialized: 2,
+	waitingForValue: 4
+};
+const NodeState = {
+	uninitialized: NodeFlags.alive | NodeFlags.waitingForValue,
+	stale: NodeFlags.alive | NodeFlags.initialized | NodeFlags.waitingForValue,
+	valid: NodeFlags.alive | NodeFlags.initialized,
+	removed: 0
+};
+/** @internal */
+var NodeImpl = class {
+	constructor(registry, atom) {
+		this.registry = registry;
+		this.atom = atom;
+		this.writeContext = new WriteContextImpl(registry, this);
+	}
+	registry;
+	atom;
+	state = NodeState.uninitialized;
+	lifetime;
+	writeContext;
+	preserveInitialValueOnBuild = false;
+	parents = /* @__PURE__ */ new Set();
+	previousParents;
+	children = /* @__PURE__ */ new Set();
+	listeners = /* @__PURE__ */ new Set();
+	skipInvalidation = false;
+	building = false;
+	invalidatedDuringBuild = false;
+	currentState() {
+		switch (this.state) {
+			case NodeState.uninitialized: return "uninitialized";
+			case NodeState.stale: return "stale";
+			case NodeState.valid: return "valid";
+			default: return "removed";
+		}
+	}
+	get canBeRemoved() {
+		const value = this._value;
+		const fate = decideNodeFate({
+			keepAlive: this.atom.keepAlive,
+			listenerCount: this.listeners.size,
+			childCount: this.children.size,
+			isLive: this.state !== 0,
+			isWaiting: isResult(value) && isInitial(value) && value.waiting,
+			idleTTL: this.atom.idleTTL,
+			defaultIdleTTL: this.registry.defaultIdleTTL
+		});
+		return Match.value(fate).pipe(Match.tags({
+			Alive: () => false,
+			RemoveNow: () => true,
+			RemoveAfterTtl: () => true
+		}), Match.exhaustive);
+	}
+	_value;
+	value() {
+		if ((this.state & NodeFlags.waitingForValue) !== 0) {
+			this.lifetime = makeLifetime(this);
+			this.building = true;
+			const value = this.atom.read(this.lifetime);
+			this.building = false;
+			if ((this.state & NodeFlags.waitingForValue) !== 0) {
+				if (this.preserveInitialValueOnBuild) {
+					this.preserveInitialValueOnBuild = false;
+					this.state = NodeState.valid;
+				} else this.setValue(value);
+			}
+			if (this.previousParents) {
+				const parents = this.previousParents;
+				this.previousParents = void 0;
+				for (const parent of parents) {
+					parent.removeChild(this);
+					if (parent.canBeRemoved) this.registry.scheduleNodeRemoval(parent);
+				}
+			}
+		}
+		return this._value;
+	}
+	valueOption() {
+		if ((this.state & NodeFlags.initialized) === 0) return Option.none();
+		return Option.some(this._value);
+	}
+	setInitialValue(value) {
+		if ((this.state & NodeFlags.initialized) === 0) {
+			this.preserveInitialValueOnBuild = true;
+			this.state = NodeState.stale;
+			this._value = value;
+			if (batchState.phase === BatchPhase.collect) batchState.notify.add(this);
+			else this.notify();
+			return;
+		}
+		this.setValue(value);
+	}
+	setValue(value) {
+		if ((this.state & NodeFlags.initialized) === 0) {
+			this.state = NodeState.valid;
+			this._value = value;
+			if (batchState.phase === BatchPhase.collect) batchState.notify.add(this);
+			else this.notify();
+			return;
+		}
+		this.state = NodeState.valid;
+		if (this.atom.equals(this._value, value)) return;
+		this._value = value;
+		if (this.skipInvalidation) this.skipInvalidation = false;
+		else this.invalidateChildren();
+		if (this.listeners.size > 0) {
+			if (batchState.phase === BatchPhase.collect) batchState.notify.add(this);
+			else this.notify();
+		}
+	}
+	addParent(parent) {
+		this.parents.add(parent);
+		if (this.previousParents !== void 0) {
+			this.previousParents.delete(parent);
+			if (this.previousParents.size === 0) this.previousParents = void 0;
+		}
+		if (!parent.children.has(this)) {
+			parent.children.add(this);
+			if (parent.skipInvalidation) parent.skipInvalidation = false;
+		}
+	}
+	removeChild(child) {
+		this.children.delete(child);
+	}
+	invalidate() {
+		if (this.building && batchState.phase === BatchPhase.collect) this.invalidatedDuringBuild = true;
+		if (this.state === NodeState.valid) {
+			this.state = NodeState.stale;
+			this.disposeLifetime();
+		}
+		if (batchState.phase === BatchPhase.collect) batchState.stale.push(this);
+		else if (this.atom.lazy && this.listeners.size === 0 && !childrenAreActive(this.children)) {
+			this.invalidateChildren();
+			this.skipInvalidation = true;
+		} else this.value();
+	}
+	invalidateChildren() {
+		if (this.children.size === 0) return;
+		const children = this.children;
+		this.children = /* @__PURE__ */ new Set();
+		for (const child of children) child.invalidate();
+	}
+	notify() {
+		this.listeners.forEach(notifyListener);
+		if (batchState.phase === BatchPhase.commit) batchState.notify.delete(this);
+	}
+	disposeLifetime() {
+		if (this.lifetime !== void 0) {
+			this.lifetime.dispose();
+			this.lifetime = void 0;
+		}
+		if (this.parents.size !== 0) {
+			this.previousParents = this.parents;
+			this.parents = /* @__PURE__ */ new Set();
+		}
+	}
+	remove() {
+		this.state = NodeState.removed;
+		this.listeners.clear();
+		if (this.lifetime === void 0) return;
+		this.disposeLifetime();
+		if (this.previousParents === void 0) return;
+		const parents = this.previousParents;
+		this.previousParents = void 0;
+		for (const parent of parents) {
+			parent.removeChild(this);
+			if (parent.canBeRemoved) this.registry.removeNode(parent);
+		}
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+};
+function childrenAreActive(children) {
+	if (children.size === 0) return false;
+	let current = children;
+	let stack;
+	let stackIndex = 0;
+	while (current !== void 0) {
+		for (const child of current) if (!child.atom.lazy || child.listeners.size > 0) return true;
+		else if (child.children.size > 0) {
+			if (stack === void 0) stack = [child.children];
+			else stack.push(child.children);
+		}
+		current = stack?.[stackIndex++];
+	}
+	return false;
+}
+const LifetimeProto = {
+	addFinalizer(f) {
+		if (this.disposed) return f();
+		this.finalizers ??= [];
+		this.finalizers.push(f);
+	},
+	get(atom) {
+		if (this.disposed) return this.node.registry.get(atom);
+		const parent = this.node.registry.ensureNode(atom);
+		const value = parent.value();
+		this.node.addParent(parent);
+		return value;
+	},
+	result(atom, options) {
+		if (this.disposed || this.isFn) return this.resultOnce(atom, options);
+		const result = this.get(atom);
+		if (options?.suspendOnWaiting && result.waiting) return Effect.never;
+		if (isInitial(result)) return Effect.never;
+		if (isFailure(result)) return Exit.failCause(result.cause);
+		return Effect.succeed(result.value);
+	},
+	resultOnce(atom, options) {
+		return Effect.callback((resume) => {
+			const result = this.once(atom);
+			if (!isInitial(result) && !(options?.suspendOnWaiting && result.waiting)) return resume(toExit(result));
+			const cancel = this.node.registry.subscribe(atom, (result) => {
+				if (isInitial(result) || options?.suspendOnWaiting && result.waiting) return;
+				cancel();
+				resume(toExit(result));
+			}, { immediate: false });
+			return Effect.sync(cancel);
+		});
+	},
+	setResult(atom, value) {
+		if (this.disposed) return Effect.never;
+		this.node.registry.set(atom, value);
+		return this.resultOnce(atom, { suspendOnWaiting: true });
+	},
+	some(atom) {
+		if (this.disposed || this.isFn) return this.someOnce(atom);
+		const result = this.get(atom);
+		return Option.isNone(result) ? Effect.never : Effect.succeed(result.value);
+	},
+	someOnce(atom) {
+		return Effect.callback((resume) => {
+			const result = this.once(atom);
+			if (Option.isSome(result)) return resume(Effect.succeed(result.value));
+			const cancel = this.node.registry.subscribe(atom, (result) => {
+				if (Option.isNone(result)) return;
+				cancel();
+				resume(Effect.succeed(result.value));
+			}, { immediate: false });
+			return Effect.sync(cancel);
+		});
+	},
+	once(atom) {
+		return this.node.registry.get(atom);
+	},
+	self() {
+		if (this.disposed) return Option.none();
+		return this.node.valueOption();
+	},
+	refresh(atom) {
+		if (this.disposed) return;
+		this.node.registry.refresh(atom);
+	},
+	refreshSelf() {
+		if (this.disposed) return;
+		this.node.invalidate();
+	},
+	mount(atom) {
+		if (this.disposed) return;
+		this.addFinalizer(this.node.registry.mount(atom));
+	},
+	subscribe(atom, f, options) {
+		if (this.disposed) return;
+		this.addFinalizer(this.node.registry.subscribe(atom, f, options));
+	},
+	setSelf(a) {
+		if (this.disposed) return;
+		this.node.setValue(a);
+	},
+	set(atom, value) {
+		if (this.disposed) return;
+		this.node.registry.set(atom, value);
+	},
+	stream(atom, options) {
+		if (this.disposed) return Stream.empty;
+		return Stream.callback((queue) => Effect.sync(() => {
+			this.subscribe(atom, (value) => Queue.offerUnsafe(queue, value), { immediate: !options?.withoutInitialValue });
+		}));
+	},
+	streamResult(atom, options) {
+		return this.stream(atom, options).pipe(Stream.filter(isNotInitial), Stream.mapEffect((result) => {
+			if (isSuccess(result)) return Effect.succeed(result.value);
+			return Effect.failCause(result.cause);
+		}));
+	},
+	dispose() {
+		this.disposed = true;
+		if (this.finalizers === void 0) return;
+		const finalizers = this.finalizers;
+		this.finalizers = void 0;
+		for (let i = finalizers.length - 1; i >= 0; i--) {
+			const finalizer = finalizers[i];
+			if (finalizer !== void 0) finalizer();
+		}
+	}
+};
+const makeLifetime = (node) => {
+	const lifetime = Object.assign(function get(atom) {
+		if (lifetime.disposed) return node.registry.get(atom);
+		else if (lifetime.isFn) return node.registry.get(atom);
+		const parent = node.registry.ensureNode(atom);
+		const value = parent.value();
+		node.addParent(parent);
+		return value;
+	}, LifetimeProto, {
+		isFn: false,
+		disposed: false,
+		finalizers: void 0,
+		node,
+		registry: node.registry
+	});
+	return lifetime;
+};
+var WriteContextImpl = class {
+	constructor(registry, node) {
+		this.registry = registry;
+		this.node = node;
+	}
+	registry;
+	node;
+	get(atom) {
+		return this.registry.get(atom);
+	}
+	set(atom, value) {
+		return this.registry.set(atom, value);
+	}
+	setSelf(value) {
+		return this.node.setValue(value);
+	}
+	refreshSelf() {
+		return this.node.invalidate();
+	}
+};
+/** @internal */
+const BatchPhase = {
+	disabled: 0,
+	collect: 1,
+	commit: 2
+};
+/** @internal */
+const batchState = {
+	phase: BatchPhase.disabled,
+	depth: 0,
+	stale: [],
+	notify: /* @__PURE__ */ new Set()
+};
+/** @internal */
+function batch(f) {
+	batchState.phase = BatchPhase.collect;
+	batchState.depth++;
+	try {
+		f();
+		if (batchState.depth === 1) {
+			for (const node of batchState.stale) batchRebuildNode(node);
+			batchState.phase = BatchPhase.commit;
+			for (const node of batchState.notify) node.notify();
+			batchState.notify.clear();
+		}
+	} finally {
+		batchState.depth--;
+		if (batchState.depth === 0) {
+			batchState.phase = BatchPhase.disabled;
+			batchState.stale = [];
+		}
+	}
+}
+function batchRebuildNode(node) {
+	if (node.state === NodeState.valid) {
+		if (!node.invalidatedDuringBuild) return;
+		node.invalidatedDuringBuild = false;
+		node.state = NodeState.stale;
+		node.disposeLifetime();
+	}
+	for (const parent of node.parents) if (parent.state !== NodeState.valid) batchRebuildNode(parent);
+	if (node.state !== NodeState.valid) node.value();
+}
+//#endregion
+//#region src/Registry.ts
+/**
+* Stores and runs atoms for one reactive runtime.
+*
+* An `AtomRegistry` evaluates atoms, caches their current values, tracks
+* dependencies, applies writes and refreshes, manages subscriptions, and
+* disposes unused nodes. Each registry is independent, so the same atom can hold
+* different values in different registries. Serializable atom values can also be
+* preloaded before the first read.
+*
+* @since 4.0.0
+*/
+var Registry_exports = /* @__PURE__ */ __exportAll({
+	AtomRegistry: () => AtomRegistry,
+	BatchPhase: () => BatchPhase,
+	RegistryImpl: () => RegistryImpl,
+	TypeId: () => TypeId,
+	batch: () => batch,
+	batchState: () => batchState,
+	getResult: () => getResult,
+	isAtomRegistry: () => isAtomRegistry,
+	layer: () => layer,
+	layerOptions: () => layerOptions,
+	make: () => make,
+	mount: () => mount,
+	toStream: () => toStream,
+	toStreamResult: () => toStreamResult
+});
+/**
+* The runtime type id used to identify `AtomRegistry` services and values.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect-atom/atom/Registry";
+/**
+* Returns `true` when the value has the `AtomRegistry` type id.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isAtomRegistry = (u) => hasProperty(u, TypeId);
+/**
+* Creates an `AtomRegistry`.
+*
+* **Details**
+*
+* Options can preload initial atom values, provide a custom task scheduler,
+* configure timeout bucket resolution, and set a default idle time-to-live for
+* unused atoms.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make = (options) => new RegistryImpl(options?.initialValues, options?.scheduleTask, options?.timeoutResolution, options?.defaultIdleTTL, options?.now, options?.scheduleTimer);
+/**
+* Service tag for the active atom runtime cache.
+*
+* **When to use**
+*
+* Use to access or provide the registry that stores atom values,
+* dependencies, subscriptions, and disposal state for a reactive lifetime.
+*
+* @category services
+* @since 4.0.0
+*/
+var AtomRegistry = class extends Context.Service()(TypeId) {};
+/**
+* Creates a layer that provides an `AtomRegistry` configured with the supplied
+* options.
+*
+* **Details**
+*
+* The registry is disposed when the layer scope is finalized.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerOptions = (options) => Layer.effect(AtomRegistry, Effect.gen(function* () {
+	const scope = yield* Effect.scope;
+	const registry = make(options);
+	yield* Scope.addFinalizer(scope, Effect.sync(() => registry.dispose()));
+	return registry;
+}));
+/**
+* The default layer that provides a fresh `AtomRegistry`.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = layerOptions();
+/**
+* Converts an atom in this registry into a stream.
+*
+* **Details**
+*
+* The stream emits the current value immediately, emits subsequent changes, and
+* unsubscribes from the registry when the stream scope closes.
+*
+* @category converting
+* @since 4.0.0
+*/
+const toStream = dual(2, (self, atom) => Stream.callback((queue) => Effect.suspend(() => {
+	const fiber = Fiber.getCurrent();
+	if (fiber === void 0) return Effect.die(/* @__PURE__ */ new Error("Expected a current fiber when converting an atom to a stream"));
+	const scope = Context.getUnsafe(fiber.context, Scope.Scope);
+	const cancel = self.subscribe(atom, (value) => Queue.offerUnsafe(queue, value), { immediate: true });
+	return Scope.addFinalizer(scope, Effect.sync(cancel));
+})));
+/**
+* Converts an `AsyncResult` atom in this registry into a stream of successful
+* values.
+*
+* **Details**
+*
+* Initial results are skipped, failures fail the stream with their cause, and
+* duplicate stream values are dropped with `Stream.changes`.
+*
+* @category converting
+* @since 4.0.0
+*/
+const toStreamResult = dual(2, (self, atom) => toStream(self, atom).pipe(Stream.filter(isNotInitial), Stream.mapEffect((result) => isSuccess(result) ? Effect.succeed(result.value) : Effect.failCause(result.cause)), Stream.changes));
+/**
+* Reads an `AsyncResult` atom from this registry as an effect.
+*
+* **Details**
+*
+* The effect waits for the result to leave `Initial`, and also waits through
+* waiting results when `suspendOnWaiting` is enabled.
+*
+* @category converting
+* @since 4.0.0
+*/
+const getResult = dual((args) => isAtomRegistry(args[0]), (self, atom, options) => {
+	const suspendOnWaiting = options?.suspendOnWaiting ?? false;
+	return Effect.callback((resume) => {
+		const result = self.get(atom);
+		if (!isInitial(result) && !(suspendOnWaiting && result.waiting)) return resume(toExit(result));
+		const cancel = self.subscribe(atom, (value) => {
+			if (!isInitial(value) && !(suspendOnWaiting && value.waiting)) {
+				resume(toExit(value));
+				cancel();
+			}
+		});
+		return Effect.sync(cancel);
+	});
+});
+/**
+* Mounts an atom in this registry for the lifetime of the current scope.
+*
+* **Details**
+*
+* The atom is subscribed with a no-op listener and the subscription is released
+* when the scope finalizer runs.
+*
+* @category converting
+* @since 4.0.0
+*/
+const mount = dual(2, (self, atom) => Effect.acquireRelease(Effect.sync(() => self.mount(atom)), (release) => Effect.sync(release)));
+const constImmediate = { immediate: true };
+const SerializableTypeId = "~effect-atom/atom/Atom/Serializable";
+const isSerializableAtom = (atom) => SerializableTypeId in atom;
+const atomKey = (atom) => isSerializableAtom(atom) ? atom[SerializableTypeId].key : atom;
+/**
+* Nodes are stored in one heterogeneous map keyed by `atomKey`. A node found
+* under an atom's key is that atom's own node, so key equality re-establishes
+* the erased `A` type across the map boundary.
+*/
+const isNodeImplFor = (atom, node) => atomKey(node.atom) === atomKey(atom);
+/**
+* @internal
+*/
+var RegistryImpl = class {
+	[TypeId];
+	timeoutResolution;
+	defaultIdleTTL;
+	scheduler;
+	schedulerAsync;
+	dispatcher;
+	now;
+	scheduleTimer;
+	onNodeAdded;
+	onNodeRemoved;
+	constructor(initialValues, scheduleTask, timeoutResolution, defaultIdleTTL, now, scheduleTimer) {
+		this[TypeId] = TypeId;
+		this.scheduler = new MixedScheduler("sync", scheduleTask);
+		this.schedulerAsync = new MixedScheduler("async", scheduleTask);
+		this.dispatcher = this.schedulerAsync.makeDispatcher();
+		this.defaultIdleTTL = defaultIdleTTL;
+		this.now = now ?? hostNow;
+		this.scheduleTimer = scheduleTimer ?? hostScheduleTimer;
+		if (timeoutResolution === void 0 && defaultIdleTTL !== void 0) this.timeoutResolution = Math.round(defaultIdleTTL / 2);
+		else this.timeoutResolution = timeoutResolution ?? 1e3;
+		if (initialValues !== void 0) for (const [atom, value] of initialValues) this.setInitialValue(atom, value);
+	}
+	setInitialValue(atom, value) {
+		let target = atom;
+		while (target.initialValueTarget) target = target.initialValueTarget;
+		this.ensureNode(target).setInitialValue(value);
+	}
+	nodes = /* @__PURE__ */ new Map();
+	preloadedSerializable = /* @__PURE__ */ new Map();
+	timeoutBuckets = /* @__PURE__ */ new Map();
+	nodeTimeoutBucket = /* @__PURE__ */ new Map();
+	disposed = false;
+	getNodes() {
+		return this.nodes;
+	}
+	get(atom) {
+		return this.ensureNode(atom).value();
+	}
+	getRaw(atom) {
+		const node = this.nodes.get(atomKey(atom));
+		if (node === void 0 || !isNodeImplFor(atom, node)) return Option.none();
+		return node.valueOption();
+	}
+	set(atom, value) {
+		atom.write(this.ensureNode(atom).writeContext, value);
+	}
+	setSerializable(key, encoded) {
+		const node = this.nodes.get(key);
+		if (node === void 0) {
+			this.preloadedSerializable.set(key, encoded);
+			return;
+		}
+		this.applySerializableValue(node, encoded);
+	}
+	applySerializableValue(node, encoded) {
+		const atom = node.atom;
+		if (!isSerializableAtom(atom)) return;
+		let decoded;
+		try {
+			decoded = atom[SerializableTypeId].decode(encoded);
+		} catch {
+			return;
+		}
+		let target = atom;
+		while (target.initialValueTarget) target = target.initialValueTarget;
+		if (target === atom) node.setValue(decoded);
+		else this.ensureNode(target).setInitialValue(decoded);
+	}
+	modify(atom, f) {
+		const node = this.ensureNode(atom);
+		const result = f(node.value());
+		atom.write(node.writeContext, result[1]);
+		return result[0];
+	}
+	update(atom, f) {
+		const node = this.ensureNode(atom);
+		atom.write(node.writeContext, f(node.value()));
+	}
+	refresh = (atom) => {
+		if (atom.refresh !== void 0) atom.refresh(this.refresh);
+		else this.invalidateAtom(atom);
+	};
+	subscribe(atom, f, options) {
+		const node = this.ensureNode(atom);
+		if (options?.immediate) f(node.value());
+		const remove = node.subscribe(function() {
+			f(node._value);
+		});
+		return () => {
+			remove();
+			if (node.canBeRemoved) this.scheduleNodeRemoval(node);
+		};
+	}
+	mount(atom) {
+		return this.subscribe(atom, constVoid, constImmediate);
+	}
+	atomHasTtl(atom) {
+		return !atom.keepAlive && atom.idleTTL !== 0 && (atom.idleTTL !== void 0 || this.defaultIdleTTL !== void 0);
+	}
+	ensureNode(atom) {
+		const key = atomKey(atom);
+		let node;
+		const existing = this.nodes.get(key);
+		if (existing !== void 0 && isNodeImplFor(atom, existing)) {
+			node = existing;
+			if (this.atomHasTtl(atom)) this.removeNodeTimeout(node);
+		} else {
+			node = this.createNode(atom);
+			this.nodes.set(key, node);
+			this.onNodeAdded?.(node);
+		}
+		if (typeof key === "string" && this.preloadedSerializable.has(key)) {
+			const encoded = this.preloadedSerializable.get(key);
+			this.preloadedSerializable.delete(key);
+			this.applySerializableValue(node, encoded);
+		}
+		return node;
+	}
+	createNode(atom) {
+		if (this.disposed) throw new Error(`Cannot access Atom ${atom.label?.[0] ?? "unknown"}: registry is disposed`);
+		if (!atom.keepAlive) this.scheduleAtomRemoval(atom);
+		return new NodeImpl(this, atom);
+	}
+	invalidateAtom = (atom) => {
+		this.ensureNode(atom).invalidate();
+	};
+	scheduleAtomRemoval(atom) {
+		this.dispatcher.scheduleTask(() => {
+			const node = this.nodes.get(atomKey(atom));
+			if (node !== void 0 && node.canBeRemoved) this.removeNode(node);
+		}, 0);
+	}
+	scheduleNodeRemoval(node) {
+		this.dispatcher.scheduleTask(() => {
+			if (node.canBeRemoved) this.removeNode(node);
+		}, 0);
+	}
+	removeNode(node) {
+		if (this.atomHasTtl(node.atom)) this.setNodeTimeout(node);
+		else {
+			this.nodes.delete(atomKey(node.atom));
+			node.remove();
+			this.onNodeRemoved?.(node);
+		}
+	}
+	setNodeTimeout(node) {
+		if (this.nodeTimeoutBucket.has(node)) return;
+		const nodeIdleTTL = node.atom.idleTTL ?? this.defaultIdleTTL;
+		if (nodeIdleTTL === void 0) return;
+		let idleTTL = nodeIdleTTL;
+		if (this.#currentSweepTTL !== null) {
+			idleTTL -= this.#currentSweepTTL;
+			if (idleTTL <= 0) {
+				if (node.canBeRemoved) {
+					this.nodes.delete(atomKey(node.atom));
+					node.remove();
+					this.onNodeRemoved?.(node);
+				}
+				return;
+			}
+		}
+		const ttl = Math.ceil(idleTTL / this.timeoutResolution) * this.timeoutResolution;
+		const timestamp = this.now() + ttl;
+		const bucket = timestamp - timestamp % this.timeoutResolution + this.timeoutResolution;
+		let entry = this.timeoutBuckets.get(bucket);
+		if (entry === void 0) {
+			entry = [/* @__PURE__ */ new Set(), this.scheduleTimer(() => this.sweepBucket(bucket), bucket - this.now())];
+			this.timeoutBuckets.set(bucket, entry);
+		}
+		entry[0].add(node);
+		this.nodeTimeoutBucket.set(node, bucket);
+	}
+	removeNodeTimeout(node) {
+		const bucket = this.nodeTimeoutBucket.get(node);
+		if (bucket === void 0) return;
+		this.nodeTimeoutBucket.delete(node);
+		this.scheduleNodeRemoval(node);
+		const entry = this.timeoutBuckets.get(bucket);
+		if (entry === void 0) return;
+		const [nodes, cancel] = entry;
+		nodes.delete(node);
+		if (nodes.size === 0) {
+			cancel();
+			this.timeoutBuckets.delete(bucket);
+		}
+	}
+	#currentSweepTTL = null;
+	sweepBucket(bucket) {
+		const entry = this.timeoutBuckets.get(bucket);
+		if (entry === void 0) return;
+		this.timeoutBuckets.delete(bucket);
+		entry[0].forEach((node) => {
+			this.nodeTimeoutBucket.delete(node);
+			if (!node.canBeRemoved) return;
+			this.nodes.delete(atomKey(node.atom));
+			this.onNodeRemoved?.(node);
+			const idleTTL = node.atom.idleTTL ?? this.defaultIdleTTL;
+			if (idleTTL !== void 0) this.#currentSweepTTL = idleTTL;
+			node.remove();
+			this.#currentSweepTTL = null;
+		});
+	}
+	reset() {
+		this.timeoutBuckets.forEach(([, cancel]) => cancel());
+		this.timeoutBuckets.clear();
+		this.nodeTimeoutBucket.clear();
+		this.nodes.forEach((node) => {
+			node.remove();
+			this.onNodeRemoved?.(node);
+		});
+		this.nodes.clear();
+	}
+	dispose() {
+		this.disposed = true;
+		this.reset();
+	}
+};
+//#endregion
+export { getResult as a, layerOptions as c, toStream as d, toStreamResult as f, batchState as h, TypeId as i, make as l, batch as m, RegistryImpl as n, isAtomRegistry as o, BatchPhase as p, Registry_exports as r, layer as s, AtomRegistry as t, mount as u };