@systemfsoftware/effect-atom 0.5.3

package/dist/Registry-B1ULaW2_.mjs

@@ -0,0 +1,769 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { F as isResult, T as toExit, _ as isNotInitial, h as isInitial } from "./Result-DwtHFH70.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$1 from "effect/Scope";
+import * as Stream from "effect/Stream";
+import { hasProperty } from "effect/Predicate";
+import * as Queue from "effect/Queue";
+import { Schema } from "effect";
+Schema.Union([
+	Schema.TaggedStruct("Alive", {}),
+	Schema.TaggedStruct("RemoveNow", {}),
+	Schema.TaggedStruct("RemoveAfterTtl", { ttlMillis: Schema.Finite })
+]);
+const decideNodeFate = (input) => input.keepAlive || input.listenerCount > 0 || input.childCount > 0 || !input.isLive || input.isWaiting ? { _tag: "Alive" } : input.idleTTL !== 0 && (input.idleTTL !== void 0 || input.defaultIdleTTL !== void 0) ? {
+	_tag: "RemoveAfterTtl",
+	ttlMillis: input.idleTTL ?? input.defaultIdleTTL
+} : { _tag: "RemoveNow" };
+//#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;
+		return 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
+		})._tag !== "Alive";
+	}
+	_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 = {
+	get registry() {
+		return this.node.registry;
+	},
+	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;
+		switch (result._tag) {
+			case "Initial": return Effect.never;
+			case "Failure": return Exit.failCause(result.cause);
+			case "Success": return Effect.succeed(result.value);
+		}
+	},
+	resultOnce(atom, options) {
+		return Effect.callback((resume) => {
+			const result = this.once(atom);
+			if (result._tag !== "Initial" && !(options?.suspendOnWaiting && result.waiting)) return resume(toExit(result));
+			const cancel = this.node.registry.subscribe(atom, (result) => {
+				if (result._tag === "Initial" || 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 result._tag === "None" ? 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) => result._tag === "Success" ? Effect.succeed(result.value) : 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--) finalizers[i]();
+	}
+};
+const makeLifetime = (node) => {
+	function get(atom) {
+		if (get.disposed) return node.registry.get(atom);
+		else if (get.isFn) return node.registry.get(atom);
+		const parent = node.registry.ensureNode(atom);
+		const value = parent.value();
+		node.addParent(parent);
+		return value;
+	}
+	Object.setPrototypeOf(get, LifetimeProto);
+	get.isFn = false;
+	get.disposed = false;
+	get.finalizers = void 0;
+	get.node = node;
+	return get;
+};
+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 (let i = 0; i < batchState.stale.length; i++) batchRebuildNode(batchState.stale[i]);
+			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);
+/**
+* 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$1.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();
+	const scope = Context.getUnsafe(fiber.context, Scope$1.Scope);
+	const cancel = self.subscribe(atom, (value) => Queue.offerUnsafe(queue, value), { immediate: true });
+	return Scope$1.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) => result._tag === "Success" ? 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 (result._tag !== "Initial" && !(suspendOnWaiting && result.waiting)) return resume(toExit(result));
+		const cancel = self.subscribe(atom, (value) => {
+			if (value._tag !== "Initial" && !(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 atomKey = (atom) => SerializableTypeId in atom ? atom[SerializableTypeId].key : atom;
+/**
+* @internal
+*/
+var RegistryImpl = class {
+	[TypeId];
+	timeoutResolution;
+	defaultIdleTTL;
+	scheduler;
+	schedulerAsync;
+	dispatcher;
+	onNodeAdded;
+	onNodeRemoved;
+	constructor(initialValues, scheduleTask, timeoutResolution, defaultIdleTTL) {
+		this[TypeId] = TypeId;
+		this.scheduler = new MixedScheduler("sync", scheduleTask);
+		this.schedulerAsync = new MixedScheduler("async", scheduleTask);
+		this.dispatcher = this.schedulerAsync.makeDispatcher();
+		this.defaultIdleTTL = defaultIdleTTL;
+		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();
+	}
+	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 (!(SerializableTypeId in 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 = this.nodes.get(key);
+		if (node === void 0) {
+			node = this.createNode(atom);
+			this.nodes.set(key, node);
+			this.onNodeAdded?.(node);
+		} else if (this.atomHasTtl(atom)) this.removeNodeTimeout(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;
+		let idleTTL = node.atom.idleTTL ?? this.defaultIdleTTL;
+		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 = Date.now() + ttl;
+		const bucket = timestamp - timestamp % this.timeoutResolution + this.timeoutResolution;
+		let entry = this.timeoutBuckets.get(bucket);
+		if (entry === void 0) {
+			entry = [/* @__PURE__ */ new Set(), setTimeout(() => this.sweepBucket(bucket), bucket - Date.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 [nodes, handle] = this.timeoutBuckets.get(bucket);
+		nodes.delete(node);
+		if (nodes.size === 0) {
+			clearTimeout(handle);
+			this.timeoutBuckets.delete(bucket);
+		}
+	}
+	#currentSweepTTL = null;
+	sweepBucket(bucket) {
+		const nodes = this.timeoutBuckets.get(bucket)[0];
+		this.timeoutBuckets.delete(bucket);
+		nodes.forEach((node) => {
+			this.nodeTimeoutBucket.delete(node);
+			if (!node.canBeRemoved) return;
+			this.nodes.delete(atomKey(node.atom));
+			this.onNodeRemoved?.(node);
+			this.#currentSweepTTL = node.atom.idleTTL ?? this.defaultIdleTTL;
+			node.remove();
+			this.#currentSweepTTL = null;
+		});
+	}
+	reset() {
+		this.timeoutBuckets.forEach(([, handle]) => clearTimeout(handle));
+		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 };