@xaendar/signals 0.4.5 → 0.4.6

package/dist/xaendar-signals.es.js

@@ -1,280 +1,1007 @@
-import { Stack as e } from "@xaendar/common";
+import { Stack } from "@xaendar/common";
 //#region ../packages/signals/src/lib/utils/globals/globals.ts
-var t = {
+/**
+* Global state for the signals runtime.
+* Tracks the currently computing `Computed` instance, whether the state is frozen,
+* and the current generation counter.
+*
+* @internal
+*/
+var GLOBAL_STATE = {
 	computing: null,
-	frozen: !1
-}, n = new e();
-function r(e) {
-	n.push(e), t.computing = e;
+	frozen: false
+};
+var computingStack = new Stack();
+/**
+* Pushes a `Computed` instance onto the computing stack and sets it as the
+* currently active computation in `GLOBAL_STATE`.
+*
+* Should be called before executing a computed function to register
+* dependency tracking.
+*
+* @param computed - The `Computed` instance entering the computation phase.
+* @internal
+*/
+function pushComputed(computed) {
+	computingStack.push(computed);
+	GLOBAL_STATE.computing = computed;
 }
-function i() {
-	n.pop(), t.computing = n[n.length - 1] ?? null;
+/**
+* Pops the most recent `Computed` instance from the computing stack and
+* restores the previous one as the active computation in `GLOBAL_STATE`.
+*
+* Should be called after a computed function finishes executing.
+*
+* @internal
+*/
+function popComputed() {
+	computingStack.pop();
+	GLOBAL_STATE.computing = computingStack[computingStack.length - 1] ?? null;
 }
 //#endregion
 //#region ../packages/signals/src/lib/utils/private-symbol/private-symbol.ts
-var a = Symbol("signals-private");
-function o(e) {
-	if (e !== a) throw Error("Invalid symbol");
+/**
+* Symbol not available in public API,
+* used to call internal methods of `State` and `Computed` from `Watcher` without exposing them in the public API.
+*
+* @internal
+*/
+var PRIVATE = Symbol("signals-private");
+/**
+* Asserts that the provided symbol matches the internal {@link PRIVATE} symbol,
+* ensuring the caller has access to internal APIs.
+*
+* Throws if the symbol does not match, preventing external code from
+* invoking methods intended for internal use only.
+*
+* @param symbol - The symbol to validate against {@link PRIVATE}.
+* @throws {Error} If `symbol` does not match {@link PRIVATE}.
+* @internal
+*/
+function assertPrivateContext(symbol) {
+	if (symbol !== PRIVATE) throw new Error("Invalid symbol");
 }
 //#endregion
 //#region ../packages/signals/src/lib/utils/dev-mode/dev-mode.ts
-var s = !1;
-function c(e) {
-	s = e;
+/** 
+* Whether the library is runnign in development mode
+* Used to log extra information for example
+* - Invalid transition states for {@link Computed} or {@link Watcher}  
+*/
+var devMode = false;
+/**
+* Sets the development mode flag.
+* @param mode - `true` to enable dev mode, `false` to disable it.
+*/
+function setDevMode(mode) {
+	devMode = mode;
 }
-function l() {
-	return s;
+/**
+* Returns the current development mode state.
+* @returns `true` if dev mode is enabled, `false` otherwise.
+*/
+function isDevMode() {
+	return devMode;
 }
 //#endregion
 //#region ../packages/signals/src/lib/models/computed/computed.ts
-var u = class e {
-	#e;
-	#t;
-	#n;
-	getSources(e) {
-		return o(e), [...this.#n];
+/**
+* A read-only Signal whose value is derived lazily from other Signals.
+*
+* The value is recomputed only when explicitly read and only if one or more
+* of its (recursive) dependencies have changed since the last evaluation.
+* The result is cached and reused until the Signal becomes stale again.
+*
+* @template T The type of the computed value.
+*
+* @see Signal algorithms — "The Signal.Computed class"
+*/
+var Computed = class Computed {
+	/**
+	* The current value of the signal.
+	*
+	* Uninitialised (`!`) until the first evaluation. After that, holds either
+	* the return value of `#callback` or a boxed error
+	* `{ isError: true; value: Error }` if the last evaluation threw.
+	*
+	* @internalSlot
+	* @see Signal algorithms — "Signal.Computed internal slots"
+	*/
+	#value;
+	/**
+	* The current evaluation state of this Signal.
+	*
+	* - `~dirty~`     — value is known to be stale or has never been evaluated.
+	* - `~checked~`   — an indirect source changed; may or may not be stale.
+	* - `~computing~` — `#callback` is currently executing; guards against cycles.
+	* - `~clean~`     — cached value is up-to-date.
+	*
+	* @internalSlot
+	* @see Signal algorithms — "Signal.Computed State machine"
+	*/
+	#state;
+	/**
+	* The ordered set of Signals read during the last evaluation of
+	* `#callback`. Cleared and rebuilt on every re-evaluation so that
+	* conditional branches that are no longer taken stop being tracked.
+	*
+	* May contain both `State` and `Computed` instances.
+	*
+	* @internalSlot
+	* @see Signal algorithms — "Signal.Computed internal slots"
+	*/
+	#sources;
+	/**
+	* Returns a snapshot of the current sources set for introspection.
+	*
+	* @param symbol - Private access symbol; rejects calls from outside the library.
+	* @returns An array of `State` and `Computed` instances that this Signal depends on.
+	* @internal
+	*/
+	getSources(symbol) {
+		assertPrivateContext(symbol);
+		return [...this.#sources];
 	}
-	#r;
-	getSinks(e) {
-		return o(e), [...this.#r];
+	/**
+	* The set of Signals and Watchers that directly depend on this Signal.
+	*
+	* Populated only when this Signal is reachable from at least one active
+	* `Watcher`. An un-watched `Computed` has an empty sinks set, which allows
+	* it to be garbage-collected independently from the rest of the graph.
+	*
+	* @internalSlot
+	* @see Signal algorithms — "Signal.Computed internal slots"
+	* @see Method — `Signal.Computed.prototype.get` (NOTE on sinks)
+	*/
+	#sinks;
+	/**
+	* Returns a snapshot of the current sinks set for introspection.
+	*
+	* @param symbol - Private access symbol; rejects calls from outside the library.
+	* @returns An array of `Computed` and `Watcher` instances that depend on this Signal.
+	* @internal
+	*/
+	getSinks(symbol) {
+		assertPrivateContext(symbol);
+		return [...this.#sinks];
 	}
-	#i;
-	#a;
-	constructor(e, t) {
-		this.#a = e, this.#i = t?.equals ?? Object.is, this.#n = /* @__PURE__ */ new Set(), this.#r = /* @__PURE__ */ new Set(), this.#t = "dirty";
+	/**
+	* The equality function used to determine whether a newly computed value
+	* is meaningfully different from the previously cached one.
+	*
+	* Called as `equals.call(computed, oldValue, newValue)`. Returns `true` if
+	* the values are considered equal, in which case no downstream propagation
+	* occurs. Defaults to `Object.is` when not provided via options.
+	*
+	* If this function throws, the exception is cached as the Signal's value
+	* and the outcome is treated as `~dirty~`.
+	*
+	* @internalSlot
+	* @see Signal algorithms — "Signal.Computed internal slots"
+	* @see Algorithm — "Set Signal value"
+	*/
+	#equals;
+	/**
+	* The pure function that produces this Signal's value. Evaluated lazily
+	* whenever the Signal is read while in a `~dirty~` or `~checked~` state.
+	*
+	* Called with `this` bound to the `Computed` instance itself so that
+	* internal methods (e.g. `addSource`) are accessible if needed.
+	* Any exception thrown by this function is caught and cached.
+	*
+	* @internalSlot
+	* @see Signal algorithms — "Signal.Computed internal slots"
+	*/
+	#callback;
+	/**
+	* Creates a new `Computed` signal.
+	*
+	* The Signal starts in the `~dirty~` state with an uninitialised value, so
+	* `#callback` will be invoked on the first `get()`.
+	*
+	* @param cb - Pure function evaluated lazily to produce the value.
+	*   Receives the `Computed` instance as `this`.
+	* @param options - Optional configuration:
+	*   - `equals` — custom equality function; defaults to `Object.is`.
+	*
+	* @see Signal algorithms — "Signal.Computed Constructor"
+	*/
+	constructor(cb, options) {
+		this.#callback = cb;
+		this.#equals = options?.equals ?? Object.is;
+		this.#sources = /* @__PURE__ */ new Set();
+		this.#sinks = /* @__PURE__ */ new Set();
+		this.#state = "dirty";
 	}
+	/**
+	* Returns the current value of this Signal, re-evaluating `#callback` if
+	* the cached value may be stale.
+	*
+	* Registers this Signal as a source of any outer `Computed` currently
+	* being evaluated (automatic dependency tracking).
+	*
+	* If the state is `~dirty~` or `~checked~`, walks the source graph
+	* depth-first to find and recalculate the deepest stale `Computed` first,
+	* then re-checks upward until this Signal is `~clean~`.
+	*
+	* @returns The current computed value, or a boxed error object if the last
+	*   evaluation threw.
+	* @throws If `frozen` is `true`.
+	* @throws If the Signal is in the `~computing~` state (cyclic dependency).
+	*
+	* @see Signal algorithms — "Method: Signal.Computed.prototype.get"
+	*/
 	get() {
-		if (t.frozen) throw Error("Cannot get value of a Computed signal while the global state is frozen");
-		if (this.#t === "computing") throw Error("Circular dependency detected while computing a Computed signal");
-		if (t.computing?.addSource(this, a), this.#r.size === 0) this.#s();
-		else if (this.#t === "dirty" || this.#t === "checked") for (; this.#t === "dirty" || this.#t === "checked";) this.#o().#s();
-		return this.#e;
+		if (GLOBAL_STATE.frozen) throw new Error("Cannot get value of a Computed signal while the global state is frozen");
+		if (this.#state === "computing") throw new Error("Circular dependency detected while computing a Computed signal");
+		GLOBAL_STATE.computing?.addSource(this, PRIVATE);
+		if (this.#sinks.size === 0) this.#computeValue();
+		else if (this.#state === "dirty" || this.#state === "checked") while (this.#state === "dirty" || this.#state === "checked") this.#findDeepestStale().#computeValue();
+		return this.#value;
 	}
-	addSource(e, t) {
-		o(t), this.#n.add(e), e.addSink(this, a);
+	/**
+	* Registers a Signal as a source of this `Computed`, discovered during the
+	* execution of `#callback`.
+	*
+	* If this `Computed` is currently being watched (has at least one sink),
+	* the source is also informed of this Signal as a new sink, building the
+	* live push-notification chain upward.
+	*
+	* @param source - The Signal read during evaluation.
+	* @param symbol - Private access symbol; rejects calls from outside the library.
+	* @internal
+	*/
+	addSource(source, symbol) {
+		assertPrivateContext(symbol);
+		this.#sources.add(source);
+		source.addSink(this, PRIVATE);
 	}
-	getState(e) {
-		return o(e), this.#t;
+	/**
+	* Returns the current evaluation state of this Signal.
+	*
+	* @param symbol - Private access symbol; rejects calls from outside the library.
+	* @internal
+	* @see Signal algorithms — "Signal.Computed State machine"
+	*/
+	getState(symbol) {
+		assertPrivateContext(symbol);
+		return this.#state;
 	}
-	setState(t, n) {
-		if (o(n), this.#t !== t) {
-			if (!this.#d(this.#t, t)) {
-				l() && (console.warn(`Invalid state transition from ${this.#t} to ${t} in Computed Signal`), console.warn((/* @__PURE__ */ Error()).stack));
-				return;
+	/**
+	* Transitions this Signal to a new evaluation state.
+	*
+	* Only valid transitions (as defined by the state machine) are allowed.
+	* Invalid transitions throw an error.
+	*
+	* @param newState - The target state.
+	* @param symbol - Private access symbol; rejects calls from outside the library.
+	* @throws If the transition from the current state to `newState` is not allowed.
+	* @internal
+	* @see Signal algorithms — "Signal.Computed State machine"
+	*/
+	setState(newState, symbol) {
+		assertPrivateContext(symbol);
+		if (this.#state === newState) return;
+		if (!this.#isValidTransition(this.#state, newState)) {
+			if (isDevMode()) {
+				console.warn(`Invalid state transition from ${this.#state} to ${newState} in Computed Signal`);
+				console.warn((/* @__PURE__ */ new Error()).stack);
 			}
-			this.#t = t, (this.#t === "dirty" || this.#t === "checked") && this.#r.forEach((t) => t instanceof e ? t.setState("checked", a) : t.notify(a));
+			return;
 		}
+		this.#state = newState;
+		if (this.#state === "dirty" || this.#state === "checked") this.#sinks.forEach((sink) => sink instanceof Computed ? sink.setState("checked", PRIVATE) : sink.notify(PRIVATE));
 	}
-	addSink(e, t) {
-		o(t), this.#r.size === 0 && this.#n.forEach((e) => e.addSink(this, a)), this.#r.add(e);
+	/**
+	* Registers a new sink (a `Computed` or `Watcher` that directly depends on
+	* this Signal) in the internal sinks set.
+	*
+	* If this is the first sink, propagates the sink registration recursively
+	* up through `#sources`, building the live dependency chain that enables
+	* push-based invalidation.
+	*
+	* @param sink - The dependent node to register.
+	* @param symbol - Private access symbol; rejects calls from outside the library.
+	* @internal
+	*/
+	addSink(sink, symbol) {
+		assertPrivateContext(symbol);
+		if (this.#sinks.size === 0) this.#sources.forEach((source) => source.addSink(this, PRIVATE));
+		this.#sinks.add(sink);
 	}
-	removeSink(e, t) {
-		o(t), this.#r.delete(e), this.#r.size === 0 && this.#n.forEach((e) => e.removeSink(this, a));
+	/**
+	* Removes a sink from the internal sinks set.
+	*
+	* If the sinks set becomes empty after removal, propagates the removal
+	* recursively up through `#sources`, tearing down the live dependency
+	* chain and allowing garbage collection of un-watched nodes.
+	*
+	* @param sink - The dependent node to remove.
+	* @param symbol - Private access symbol; rejects calls from outside the library.
+	* @internal
+	*/
+	removeSink(sink, symbol) {
+		assertPrivateContext(symbol);
+		this.#sinks.delete(sink);
+		if (this.#sinks.size === 0) this.#sources.forEach((source) => source.removeSink(this, PRIVATE));
 	}
-	#o() {
-		let t = [...this.#n].find((t) => t instanceof e && (t.#t === "dirty" || t.#t === "checked"));
-		return t ? t.#o() : this;
+	/**
+	* Recursively walks the source graph depth-first to find the deepest,
+	* left-most `Computed` node that is in a `~dirty~` or `~checked~` state.
+	*
+	* This ensures that recalculation always starts from the bottom of the
+	* dependency graph, so every node sees already-updated dependencies —
+	* the core of glitch-free evaluation.
+	*
+	* Cuts off the search when hitting a `~clean~` `Computed` source, since
+	* its subtree is guaranteed to be up-to-date.
+	*
+	* @returns The deepest stale `Computed` found, or `node` itself if none of
+	*   its sources are stale.
+	*/
+	#findDeepestStale() {
+		const unclearNode = [...this.#sources].find((source) => source instanceof Computed && (source.#state === "dirty" || source.#state === "checked"));
+		return unclearNode ? unclearNode.#findDeepestStale() : this;
 	}
-	#s() {
-		this.#n.forEach((e) => e.removeSink(this, a)), this.#n.clear(), r(this), this.setState("computing", a);
-		let t;
+	/**
+	* Executes `#callback` to recompute this Signal's value.
+	*
+	* Implements the "recalculate dirty computed Signal" algorithm:
+	* 1. Clears stale sources and removes this Signal from their sinks.
+	* 2. Sets `computing` to this Signal for automatic dependency tracking.
+	* 3. Runs the callback, caching the return value or any thrown exception.
+	* 4. Restores the previous `computing` value.
+	* 5. Runs the "set Signal value" algorithm to detect value changes.
+	* 6. Transitions state to `~clean~`.
+	* 7. Propagates `~dirty~` to sinks (or attempts `~clean~` if value unchanged).
+	*
+	* @see Signal algorithms — "Algorithm: recalculate dirty computed Signal"
+	*/
+	#computeValue() {
+		this.#sources.forEach((source) => source.removeSink(this, PRIVATE));
+		this.#sources.clear();
+		pushComputed(this);
+		this.setState("computing", PRIVATE);
+		let newValue;
 		try {
-			t = this.#a.call(this);
-		} catch (e) {
-			t = {
-				isError: !0,
-				value: e
+			newValue = this.#callback.call(this);
+		} catch (error) {
+			newValue = {
+				isError: true,
+				value: error
 			};
 		} finally {
-			i();
+			popComputed();
 		}
-		let n = this.#c(t);
-		this.setState("clean", a), n === "dirty" ? this.#r.forEach((t) => t instanceof e ? t.setState("dirty", a) : t.notify(a)) : this.#l();
+		const outcome = this.#setValue(newValue);
+		this.setState("clean", PRIVATE);
+		outcome === "dirty" ? this.#sinks.forEach((sink) => sink instanceof Computed ? sink.setState("dirty", PRIVATE) : sink.notify(PRIVATE)) : this.#propagateClean();
 	}
-	#c(e) {
-		let t = this.#e;
-		if (this.#u(e)) return this.#e = e, "dirty";
+	/**
+	* Implements the "set Signal value" algorithm.
+	*
+	* Compares the new value against the cached one using `#equals`. If equal,
+	* returns `~clean~` and leaves `#value` untouched. Otherwise updates
+	* `#value` and returns `~dirty~`.
+	*
+	* Special cases:
+	* - If `newValue` is a boxed error, `#equals` is skipped and the error is
+	*   cached directly.
+	* - If `#equals` itself throws, the exception is cached as a boxed error
+	*   and the outcome is `~dirty~`.
+	*
+	* @param newValue - The value (or boxed error) produced by `#callback`.
+	* @returns `~clean~` if the value is unchanged, `~dirty~` otherwise.
+	*
+	* @see Signal algorithms — "Set Signal value algorithm"
+	*/
+	#setValue(newValue) {
+		const oldValue = this.#value;
+		if (this.#isErrorValue(newValue)) {
+			this.#value = newValue;
+			return "dirty";
+		}
 		try {
-			if (!this.#u(t) && this.#i.call(this, t, e)) return "clean";
-		} catch (e) {
-			return this.#e = {
-				isError: !0,
-				value: e
-			}, "dirty";
+			if (!this.#isErrorValue(oldValue) && this.#equals.call(this, oldValue, newValue)) return "clean";
+		} catch (equalsError) {
+			this.#value = {
+				isError: true,
+				value: equalsError
+			};
+			return "dirty";
 		}
-		return this.#e = e, "dirty";
+		this.#value = newValue;
+		return "dirty";
 	}
-	#l() {
-		[...this.#r].filter((t) => t instanceof e && t.#t === "checked").forEach((t) => {
-			[...t.#n].every((t) => !(t instanceof e) || t.#t === "clean") && (t.#t = "clean", t.#l());
+	/**
+	* Recursively marks `~checked~` sinks as `~clean~` when all of their
+	* immediate sources are already `~clean~`.
+	*
+	* Called after a recalculation that produced an unchanged value (`~clean~`
+	* outcome from `#setValue`). Propagates the clean signal upward through
+	* the graph so that Computed nodes that were only transitively dirty — and
+	* whose dependencies have not actually changed — are not needlessly
+	* re-evaluated on the next read.
+	*
+	* @see Signal algorithms — "Algorithm: recalculate dirty computed Signal"
+	*/
+	#propagateClean() {
+		[...this.#sinks].filter((sink) => sink instanceof Computed && sink.#state === "checked").forEach((sink) => {
+			if ([...sink.#sources].every((source) => !(source instanceof Computed) || source.#state === "clean")) {
+				sink.#state = "clean";
+				sink.#propagateClean();
+			}
 		});
 	}
-	#u(e) {
-		return typeof e == "object" && !!e && "isError" in e;
+	/**
+	* Type guard that checks whether a value is a boxed error object.
+	*
+	* Used to distinguish a legitimately computed value from a cached
+	* exception produced by `#callback` or `#equals`.
+	*
+	* @param value - The value to inspect.
+	* @returns `true` if `value` is `{ isError: true; value: Error }`.
+	*/
+	#isErrorValue(value) {
+		return typeof value === "object" && !!value && "isError" in value;
 	}
-	#d(e, t) {
-		switch (e) {
-			case "checked": return t === "clean" || t === "dirty";
-			case "clean": return t === "checked" || t === "dirty";
-			case "dirty": return t === "computing";
-			case "computing": return t === "clean";
+	#isValidTransition(from, to) {
+		switch (from) {
+			case "checked": return to === "clean" || to === "dirty";
+			case "clean": return to === "checked" || to === "dirty";
+			case "dirty": return to === "computing";
+			case "computing": return to === "clean";
 		}
 	}
-}, d = class {
-	#e;
-	#t;
-	#n;
-	#r;
-	#i;
-	getSinks(e) {
-		return o(e), [...this.#i];
+};
+//#endregion
+//#region ../packages/signals/src/lib/models/state/state.ts
+var State = class {
+	/**
+	* The current value of the signal.
+	*
+	* Initialised to `initialValue` in the constructor and updated by `set`
+	* whenever the new value is not equal to the current one according to
+	* `#equals`.
+	*
+	* @internalSlot
+	* @see Signal algorithms — 'Signal.State internal slots'
+	*/
+	#value;
+	/**
+	* The equality function used to determine whether a new value is
+	* meaningfully different from the current one.
+	*
+	* Called as `equals.call(signal, oldValue, newValue)`. If it returns
+	* `true` the signal is considered unchanged and no propagation occurs.
+	* Defaults to `Object.is` when not provided via options.
+	*
+	* @internalSlot
+	* @see Signal algorithms — 'Signal.State internal slots'
+	* @see Algorithm — 'Set Signal value'
+	*/
+	#equals;
+	/**
+	* Optional callback invoked (with `frozen = true`) the first time this
+	* Signal gains a sink — i.e. when it transitions from un-observed to
+	* observed by at least one `Watcher` (directly or transitively).
+	*
+	* @internalSlot
+	* @see Signal algorithms — 'Signal.State internal slots'
+	* @see Method — `Signal.subtle.Watcher.prototype.watch`
+	*/
+	#watched;
+	/**
+	* Optional callback invoked (with `frozen = true`) when this Signal loses
+	* its last sink — i.e. when it transitions from observed back to
+	* un-observed.
+	*
+	* @internalSlot
+	* @see Signal algorithms — 'Signal.State internal slots'
+	* @see Method — `Signal.subtle.Watcher.prototype.unwatch`
+	*/
+	#unwatched;
+	/**
+	* The set of watched signals that directly depend on this one.
+	*
+	* Populated only when this Signal is reachable from at least one active
+	* `Watcher` — un-watched Signals have an empty sinks set, which allows
+	* them to be garbage-collected independently from the rest of the graph.
+	*
+	* Should contain both `Computed` and `Watcher` instances, as both can be
+	* direct dependents of a `State`.
+	*
+	* @internalSlot
+	* @see Signal algorithms — 'Signal.State internal slots'
+	* @see Method — `Signal.State.prototype.get` (NOTE on sinks)
+	*/
+	#sinks;
+	/**
+	* Returns a snapshot of the current sinks set for introspection.
+	*
+	* @param symbol - Private access symbol; rejects calls from outside the library.
+	* @returns An array of `Computed` and `Watcher` instances that depend on this Signal.
+	* @internal
+	*/
+	getSinks(symbol) {
+		assertPrivateContext(symbol);
+		return [...this.#sinks];
 	}
-	constructor(e, t) {
-		this.#e = e, this.#t = t?.equals ?? Object.is, this.#n = t?.watched, this.#r = t?.unwatched, this.#i = /* @__PURE__ */ new Set();
+	/**
+	* Creates a new `State` signal.
+	*
+	* @param initialValue - The initial value of the signal.
+	* @param options - Optional configuration:
+	*   - `equals` — custom equality function; defaults to `Object.is`.
+	*   - `watched` — called when the signal gains its first sink.
+	*   - `unwatched` — called when the signal loses its last sink.
+	*
+	* @see Signal algorithms — 'Constructor: Signal.State(initialValue, options)'
+	*/
+	constructor(initialValue, options) {
+		this.#value = initialValue;
+		this.#equals = options?.equals ?? Object.is;
+		this.#watched = options?.watched;
+		this.#unwatched = options?.unwatched;
+		this.#sinks = /* @__PURE__ */ new Set();
 	}
+	/**
+	* Returns the current value of the signal, registering this Signal as a
+	* source of the innermost `Computed` currently being evaluated (if any).
+	*
+	* @throws If `frozen` is `true` — reads are forbidden while a protected
+	* callback (`notify`, `watched`, `unwatched`) is executing.
+	*
+	* @see Signal algorithms — 'Method: Signal.State.prototype.get()'
+	*/
 	get() {
-		if (t.frozen) throw Error("Cannot get value while signals are frozen");
-		return t.computing?.addSource(this, a), this.#e;
+		if (GLOBAL_STATE.frozen) throw new Error("Cannot get value while signals are frozen");
+		GLOBAL_STATE.computing?.addSource(this, PRIVATE);
+		return this.#value;
 	}
-	set(e) {
-		if (t.frozen) throw Error("Cannot set value while signals are frozen");
-		this.#t.call(this, this.#e, e) || (this.#e = e, this.#i.forEach((e) => e instanceof u ? e.setState("dirty", a) : e.notify(a)));
+	/**
+	* Updates the signal's value and propagates changes to all dependent
+	* sinks.
+	*
+	* If `equals(currentValue, newValue)` returns `true` the call is a no-op
+	* and no propagation occurs. Otherwise `#value` is updated, all direct
+	* `Computed` sinks are marked `~dirty~`, indirect ones `~checked~`, and
+	* each reachable `Watcher` has its `notify` callback invoked synchronously
+	* (with `frozen = true`).
+	*
+	* @param newValue - The new value to set.
+	* @throws If `frozen` is `true` — writes are forbidden while a protected
+	* callback is executing.
+	*
+	* @see Signal algorithms — 'Method: Signal.State.prototype.set(newValue)'
+	* @see Algorithm — 'Set Signal value'
+	*/
+	set(newValue) {
+		if (GLOBAL_STATE.frozen) throw new Error("Cannot set value while signals are frozen");
+		if (!this.#equals.call(this, this.#value, newValue)) {
+			this.#value = newValue;
+			this.#sinks.forEach((sink) => sink instanceof Computed ? sink.setState("dirty", PRIVATE) : sink.notify(PRIVATE));
+		}
 	}
-	addSink(e, n) {
-		o(n);
-		let r = this.#i.size === 0;
-		if (this.#i.add(e), r && this.#n) {
-			t.frozen = !0;
+	/**
+	* Registers a new sink (a `Computed` or `Watcher` that depends on this
+	* Signal) in the internal sinks set.
+	*
+	* Called by `Watcher.prototype.watch` when building the live dependency
+	* chain, and by `Computed` when propagating sink registration up through
+	* its sources.
+	*
+	* @param sink - The dependent node to register.
+	* @param symbol - The private symbol for validation.
+	* @internal
+	*/
+	addSink(sink, symbol) {
+		assertPrivateContext(symbol);
+		const empty = this.#sinks.size === 0;
+		this.#sinks.add(sink);
+		if (empty && this.#watched) {
+			GLOBAL_STATE.frozen = true;
 			try {
-				this.#n();
+				this.#watched();
 			} finally {
-				t.frozen = !1;
+				GLOBAL_STATE.frozen = false;
 			}
 		}
 	}
-	removeSink(e, n) {
-		if (o(n), this.#i.delete(e), this.#i.size === 0 && this.#r) {
-			t.frozen = !0;
+	/**
+	* Removes a sink from the internal sinks set.
+	*
+	* Called by `Watcher.prototype.unwatch` when tearing down the live
+	* dependency chain. If the sinks set becomes empty after removal, the
+	* caller is responsible for propagating the removal up through this
+	* Signal's sources.
+	*
+	* @param sink - The dependent node to remove.
+	* @param symbol - The private symbol for validation.
+	* @internal
+	*/
+	removeSink(sink, symbol) {
+		assertPrivateContext(symbol);
+		this.#sinks.delete(sink);
+		if (this.#sinks.size === 0 && this.#unwatched) {
+			GLOBAL_STATE.frozen = true;
 			try {
-				this.#r();
+				this.#unwatched();
 			} finally {
-				t.frozen = !1;
+				GLOBAL_STATE.frozen = false;
 			}
 		}
 	}
-}, f = class {
-	#e;
-	#t;
-	getSources(e) {
-		return o(e), [...this.#t];
+};
+//#endregion
+//#region ../packages/signals/src/lib/models/watcher/watcher.ts
+/**
+* A `Watcher` observes a set of Signals and fires a `notify` callback
+* synchronously when any of their (recursive) dependencies change.
+*
+* It is the low-level primitive on top of which frameworks implement
+* effects and scheduling. It does not hold a value and has no generic
+* type parameter.
+*
+* @see Signal algorithms — 'The `Signal.subtle.Watcher` class'
+*/
+var Watcher = class {
+	/**
+	* The current state of the Watcher.
+	*
+	* - `~waiting~`  — newly created, or `notify` has already been called since
+	*                  the last `watch` call. Not actively observing changes.
+	* - `~watching~` — actively watching; no dependency has changed yet.
+	* - `~pending~`  — a dependency has changed but `notify` has not yet run.
+	*
+	* @internalSlot
+	* @see Signal algorithms — 'Signal.subtle.Watcher State machine'
+	*/
+	#state;
+	/**
+	* The ordered set of Signals this Watcher is currently watching.
+	* May contain both `State` and `Computed` instances.
+	*
+	* @internalSlot
+	* @see Signal algorithms — 'Signal.subtle.Watcher internal slots'
+	*/
+	#signals;
+	/**
+	* Returns a snapshot of the current watched signals set for introspection.
+	*
+	* @param symbol - Private access symbol; rejects calls from outside the library.
+	* @returns An array of `State` and `Computed` instances that this Watcher is watching.
+	* @internal
+	*/
+	getSources(symbol) {
+		assertPrivateContext(symbol);
+		return [...this.#signals];
 	}
-	#n;
-	constructor(e) {
-		this.#e = "waiting", this.#t = /* @__PURE__ */ new Set(), this.#n = e;
+	/**
+	* The callback invoked synchronously when a watched Signal (or one of its
+	* recursive dependencies) changes for the first time since the last
+	* `watch` call.
+	*
+	* Receives the Watcher itself as `this`. No Signals may be read or written
+	* during its execution (`frozen` is `true` for its entire duration).
+	*
+	* @internalSlot
+	* @see Signal algorithms — 'Signal.subtle.Watcher internal slots'
+	*/
+	#notifyCallback;
+	/**
+	* Creates a new Watcher.
+	*
+	* The Watcher starts in the `~waiting~` state with an empty signals set.
+	*
+	* @param notifyCallback - Called synchronously (with `frozen = true`) the
+	* first time a watched dependency changes after each `watch` call. No
+	* Signals may be read or written inside this callback.
+	*
+	* @see Signal algorithms — 'Constructor: new Signal.subtle.Watcher(callback)'
+	*/
+	constructor(notifyCallback) {
+		this.#state = "waiting";
+		this.#signals = /* @__PURE__ */ new Set();
+		this.#notifyCallback = notifyCallback;
 	}
+	/**
+	* Returns the subset of watched Signals that are `Computed` instances
+	* currently in a `~dirty~` or `~checked~` state, meaning they may have a
+	* stale value that has not yet been re-evaluated.
+	*
+	* Typically called inside the microtask scheduled by the `notify` callback
+	* to know which Signals need to be pulled.
+	*
+	* @returns An array of `Computed` signals that are dirty or checked.
+	*
+	* @see Signal algorithms — 'Method: Signal.subtle.Watcher.prototype.getPending()'
+	*/
 	getPending() {
-		return [...this.#t].filter((e) => {
-			if (!(e instanceof u)) return !1;
-			let t = e.getState(a);
-			return t === "dirty" || t === "checked";
+		return [...this.#signals].filter((signal) => {
+			if (!(signal instanceof Computed)) return false;
+			const state = signal.getState(PRIVATE);
+			return state === "dirty" || state === "checked";
 		});
 	}
-	watch(...e) {
-		if (t.frozen) throw Error("Cannot watch signals while frozen");
-		e.forEach((e) => {
-			if (this.#t.has(e)) throw Error("Cannot watch a signal that is already being watched");
-			this.#t.add(e), e.addSink(this, a);
-		}), this.setState("watching", a);
+	/**
+	* Adds the given Signals to the watched set and transitions the Watcher to
+	* the `~watching~` state.
+	*
+	* For each newly-watched Signal, the Watcher is registered as a sink and —
+	* if it is the first sink — the sink registration is propagated recursively
+	* up through the Signal's sources, building the live dependency chain.
+	*
+	* The `watched` callback of each Signal (if any) is called with
+	* `frozen = true`.
+	*
+	* @param signals - One or more `State` signals to start watching.
+	* @throws If `frozen` is `true` at the time of the call.
+	*
+	* @see Signal algorithms — 'Method: Signal.subtle.Watcher.prototype.watch(...signals)'
+	*/
+	watch(...signals) {
+		if (GLOBAL_STATE.frozen) throw new Error("Cannot watch signals while frozen");
+		signals.forEach((signal) => {
+			if (this.#signals.has(signal)) throw new Error("Cannot watch a signal that is already being watched");
+			this.#signals.add(signal);
+			signal.addSink(this, PRIVATE);
+		});
+		this.setState("watching", PRIVATE);
 	}
-	unwatch(...e) {
-		if (t.frozen) throw Error("Cannot unwatch signals while frozen");
-		e.forEach((e) => {
-			if (!this.#t.has(e)) throw Error("Cannot unwatch a signal that is not being watched");
-			this.#t.delete(e), e.removeSink(this, a);
-		}), this.#t.size || this.setState("waiting", a);
+	/**
+	* Removes the given Signals from the watched set.
+	*
+	* For each removed Signal, the Watcher is unregistered as a sink. If the
+	* Signal's sink set becomes empty as a result, the removal is propagated
+	* recursively up through its sources, tearing down the live dependency
+	* chain and allowing garbage collection of unwatched nodes.
+	*
+	* The `unwatched` callback of each Signal (if any) is called with
+	* `frozen = true`.
+	*
+	* If no Signals remain in the watched set, the Watcher transitions back to
+	* the `~waiting~` state.
+	*
+	* @param signals - One or more `State` signals to stop watching.
+	* @throws If `frozen` is `true` at the time of the call.
+	* @throws If any of the given Signals is not currently being watched.
+	*
+	* @see Signal algorithms — 'Method: Signal.subtle.Watcher.prototype.unwatch(...signals)'
+	*/
+	unwatch(...signals) {
+		if (GLOBAL_STATE.frozen) throw new Error("Cannot unwatch signals while frozen");
+		signals.forEach((signal) => {
+			if (!this.#signals.has(signal)) throw new Error("Cannot unwatch a signal that is not being watched");
+			this.#signals.delete(signal);
+			signal.removeSink(this, PRIVATE);
+		});
+		if (!this.#signals.size) this.setState("waiting", PRIVATE);
 	}
-	getState(e) {
-		return o(e), this.#e;
+	/**
+	* Get the current state of the Watcher.
+	* @param symbol - The private symbol for prevent external calls.
+	*/
+	getState(symbol) {
+		assertPrivateContext(symbol);
+		return this.#state;
 	}
-	setState(e, t) {
-		if (o(t), this.#e !== e) {
-			if (!this.#r(this.#e, e)) {
-				l() && (console.warn(`Invalid state transition from ${this.#e} to ${e} in Watcher`), console.warn((/* @__PURE__ */ Error()).stack));
-				return;
+	/**
+	* Set the current state of the Watcher.
+	* @param newState - The new state to set.
+	* @param symbol - The private symbol for prevent external calls.
+	* @throws If the transition from `pending` to `watching` is attempted.
+	*/
+	setState(newState, symbol) {
+		assertPrivateContext(symbol);
+		if (this.#state === newState) return;
+		if (!this.#isValidTransition(this.#state, newState)) {
+			if (isDevMode()) {
+				console.warn(`Invalid state transition from ${this.#state} to ${newState} in Watcher`);
+				console.warn((/* @__PURE__ */ new Error()).stack);
 			}
-			this.#e = e;
+			return;
 		}
+		this.#state = newState;
 	}
-	notify(e) {
-		o(e), t.frozen = !0;
+	/**
+	* Invoce the notify callback when a watched dependency changes
+	* @param symbol - The private symbol for prevent external calls.
+	*/
+	notify(symbol) {
+		assertPrivateContext(symbol);
+		GLOBAL_STATE.frozen = true;
 		try {
-			this.setState("pending", a), this.#n.call(this);
+			this.setState("pending", PRIVATE);
+			this.#notifyCallback.call(this);
 		} finally {
-			this.setState("waiting", a), t.frozen = !1;
+			this.setState("waiting", PRIVATE);
+			GLOBAL_STATE.frozen = false;
 		}
 	}
-	#r(e, t) {
-		switch (e) {
-			case "waiting": return t === "watching";
-			case "watching": return t === "pending" || t === "waiting";
-			case "pending": return t === "waiting";
+	#isValidTransition(from, to) {
+		switch (from) {
+			case "waiting": return to === "watching";
+			case "watching": return to === "pending" || to === "waiting";
+			case "pending": return to === "waiting";
 		}
 	}
 };
 //#endregion
 //#region ../packages/signals/src/lib/subtle.ts
-function p(e) {
-	let n = t.computing;
-	t.computing = null;
+/**
+* Executes a function without tracking any dependencies.
+* @param fn - The function to execute without tracking.
+* @returns The result of the function execution.
+*/
+function untrack(fn) {
+	const prevComputing = GLOBAL_STATE.computing;
+	GLOBAL_STATE.computing = null;
 	try {
-		return e();
+		return fn();
 	} finally {
-		t.computing = n;
+		GLOBAL_STATE.computing = prevComputing;
 	}
 }
-function m() {
-	return t.computing;
+/**
+* Returns the currently active `Computed` instance being evaluated, or `null`
+* @returns The currently active `Computed` instance, or `null` if none is being evaluated.
+*/
+function currentComputed() {
+	return GLOBAL_STATE.computing;
 }
-function h(e) {
-	return e.getSources(a);
+/**
+* Returns the ordered list of all Signals which the given `Computed` or
+* `Watcher` referenced during its last evaluation.
+*
+* - For a `Computed`, these are the Signals read inside its callback.
+* - For a `Watcher`, these are the Signals it is currently watching.
+*
+* @param signal - The `Computed` or `Watcher` to introspect.
+* @returns An array of `State` and `Computed` instances.
+*/
+function introspectSources(signal) {
+	return signal.getSources(PRIVATE);
 }
-function g(e) {
-	return e.getSinks(a);
+/**
+* Returns the direct dependents of the given Signal — Watchers that contain
+* it, plus any `Computed` Signals which read it during their last evaluation
+* (if that `Computed` is recursively watched).
+*
+* @param signal - The `State` or `Computed` Signal to introspect.
+* @returns An array of `Computed` and `Watcher` instances.
+*/
+function introspectSinks(signal) {
+	return signal.getSinks(PRIVATE);
 }
-function _(e) {
-	return e.getSinks(a).length > 0;
+/**
+* Returns `true` if the given Signal is 'live' — i.e. it is watched by a
+* `Watcher`, or it is read by a `Computed` Signal which is (recursively)
+* live.
+*
+* @param signal - The `State` or `Computed` Signal to check.
+* @returns `true` if the Signal has at least one sink.
+*/
+function hasSinks(signal) {
+	return signal.getSinks(PRIVATE).length > 0;
 }
-function v(e) {
-	return e.getSources(a).length > 0;
+/**
+* Returns `true` if the given node is 'reactive' — i.e. it depends on some
+* other Signal. A `Computed` where `hasSources` is `false` will always
+* return the same constant.
+*
+* @param signal - The `Computed` or `Watcher` to check.
+* @returns `true` if the node has at least one source.
+*/
+function hasSources(signal) {
+	return signal.getSources(PRIVATE).length > 0;
 }
 //#endregion
 //#region ../packages/signals/src/lib/load-signals.ts
-function y(e) {
-	c(e?.devMode ?? !1), globalThis.Signal ??= {
-		State: d,
-		Computed: u,
+/**
+* Loads the Signals library by defining the `Signal` global object with the following properties:
+* - `State`: The `State` class for creating reactive state variables.
+* - `Computed`: The `Computed` class for creating derived reactive values.
+* - `Watcher`: The `Watcher` class for observing changes in signals.
+* - `subtle`: An object containing internal utility functions for working with signals, including:
+*  - `untrack`: Executes a function without tracking dependencies.
+*  - `currentComputed`: Returns the currently active `Computed` instance being evaluated, or `null` if none.
+*  - `introspectSources`: Returns the list of sources for a given `Computed` or `Watcher`.
+*  - `introspectSinks`: Returns the list of sinks for a given `State` or `Computed`.
+*  - `hasSinks`: Returns `true` if a given `State` or `Computed` has at least one sink.
+*  - `hasSources`: Returns `true` if a given `Computed` or `Watcher` has at least one source.
+*  - `Watcher`: The `Watcher` class for observing changes in signals.
+* 
+* This function should be called once to initialize the Signals library and make its API available globally.
+*/
+function loadSignals(options) {
+	setDevMode(options?.devMode ?? false);
+	globalThis.Signal ??= {
+		State,
+		Computed,
 		subtle: {
-			untrack: p,
-			currentComputed: m,
-			introspectSources: h,
-			introspectSinks: g,
-			hasSinks: _,
-			hasSources: v,
-			Watcher: f
+			untrack,
+			currentComputed,
+			introspectSources,
+			introspectSinks,
+			hasSinks,
+			hasSources,
+			Watcher
 		}
 	};
 }
 //#endregion
 //#region ../packages/signals/src/lib/models/effect/effect.ts
-function b(e) {
-	let t = new Signal.Computed(() => e()), n = !0, r = new Signal.subtle.Watcher(() => {
-		n && (n = !1, queueMicrotask(() => {
-			n = !0, r.getPending().forEach((e) => e.get()), r.watch();
-		}));
+/**
+* Runs a side-effectful function and automatically re-runs it whenever any
+* Signal read during its execution changes.
+*
+* Internally, `effect` wraps the user callback inside a `Computed` node
+* (for dependency tracking) and observes it with a `Watcher` (for push
+* notifications). When any tracked dependency changes, the `Watcher`
+* schedules a microtask that re-evaluates the `Computed`, which in turn
+* re-runs the user callback and re-registers the new set of dependencies.
+*
+* The returned disposer function stops the effect: it unwatches the internal
+* `Computed` from the `Watcher`, severing all dependency subscriptions so
+* the callback is never called again and the graph nodes can be
+* garbage-collected.
+*
+* @example
+* ```ts
+* const count = new State(0);
+*
+* const stop = effect(() => {
+*   console.log('count is', count.get());
+* });
+* // logs: "count is 0"
+*
+* count.set(1); // logs: "count is 1"
+* count.set(2); // logs: "count is 2"
+*
+* stop();       // no more logs
+* count.set(3); // silent
+* ```
+*
+* @param fn - The side-effectful function to run. Any Signal read inside it
+*   is tracked as a dependency.
+* @returns A disposer function that, when called, permanently stops the effect.
+*/
+function effect(fn) {
+	/**
+	* Wrap the user callback in a Computed so that automatic dependency
+	* tracking (via pushComputed / popComputed) works for free.
+	* The Computed always returns `undefined` — we only care about the
+	* side-effects and the tracked sources, not the value.
+	*/
+	const computed = new Signal.Computed(() => fn());
+	let needsEnqueue = true;
+	/**
+	* The Watcher is notified synchronously as soon as any tracked dependency
+	* changes. Its job is purely to schedule the re-execution; the actual
+	* re-evaluation happens asynchronously in a microtask so that multiple
+	* synchronous signal updates are batched into a single re-run.
+	*/
+	const watcher = new Signal.subtle.Watcher(() => {
+		if (needsEnqueue) {
+			needsEnqueue = false;
+			queueMicrotask(() => {
+				needsEnqueue = true;
+				watcher.getPending().forEach((computed) => computed.get());
+				watcher.watch();
+			});
+		}
 	});
-	return r.watch(t), t.get(), () => r.unwatch(t);
+	watcher.watch(computed);
+	computed.get();
+	/**
+	* Disposer — call this to permanently stop the effect.
+	*
+	* Unwatching the Computed tears down the entire live dependency chain
+	* (Watcher → Computed → all sources), preventing any further
+	* notifications and allowing GC.
+	*/
+	return () => watcher.unwatch(computed);
 }
 //#endregion
-export { b as effect, y as loadSignals };
-
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"xaendar-signals.es.js","names":["#sources","#sinks","#callback","#equals","#state","#computeValue","#findDeepestStale","#value","#isValidTransition","#setValue","#propagateClean","#isErrorValue","#sinks","#value","#equals","#watched","#unwatched","#signals","#state","#notifyCallback","#isValidTransition"],"sources":["../../../../packages/signals/src/lib/utils/globals/globals.ts","../../../../packages/signals/src/lib/utils/private-symbol/private-symbol.ts","../../../../packages/signals/src/lib/utils/dev-mode/dev-mode.ts","../../../../packages/signals/src/lib/models/computed/computed.ts","../../../../packages/signals/src/lib/models/state/state.ts","../../../../packages/signals/src/lib/models/watcher/watcher.ts","../../../../packages/signals/src/lib/subtle.ts","../../../../packages/signals/src/lib/load-signals.ts","../../../../packages/signals/src/lib/models/effect/effect.ts"],"sourcesContent":["import { Stack } from '@xaendar/common';\r\nimport { Computed } from '../../models/computed/computed';\r\nimport { GlobalState } from '../../types/global-state.type';\r\n\r\n/**\r\n * Global state for the signals runtime.\r\n * Tracks the currently computing `Computed` instance, whether the state is frozen,\r\n * and the current generation counter.\r\n *\r\n * @internal\r\n */\r\nexport const GLOBAL_STATE: GlobalState = {\r\n  computing: null,\r\n  frozen: false\r\n};\r\n\r\nconst computingStack = new Stack<Computed>;\r\n\r\n/**\r\n * Pushes a `Computed` instance onto the computing stack and sets it as the\r\n * currently active computation in `GLOBAL_STATE`.\r\n *\r\n * Should be called before executing a computed function to register\r\n * dependency tracking.\r\n *\r\n * @param computed - The `Computed` instance entering the computation phase.\r\n * @internal\r\n */\r\nexport function pushComputed(computed: Computed): void {\r\n  computingStack.push(computed);\r\n  GLOBAL_STATE.computing = computed;\r\n}\r\n\r\n/**\r\n * Pops the most recent `Computed` instance from the computing stack and\r\n * restores the previous one as the active computation in `GLOBAL_STATE`.\r\n *\r\n * Should be called after a computed function finishes executing.\r\n *\r\n * @internal\r\n */\r\nexport function popComputed(): void {\r\n  computingStack.pop();\r\n  GLOBAL_STATE.computing = computingStack[computingStack.length - 1] ?? null;\r\n}","/**\r\n * Symbol not available in public API,\r\n * used to call internal methods of `State` and `Computed` from `Watcher` without exposing them in the public API.\r\n *\r\n * @internal\r\n */\r\nexport const PRIVATE = Symbol('signals-private');\r\n\r\n/**\r\n * Asserts that the provided symbol matches the internal {@link PRIVATE} symbol,\r\n * ensuring the caller has access to internal APIs.\r\n *\r\n * Throws if the symbol does not match, preventing external code from\r\n * invoking methods intended for internal use only.\r\n *\r\n * @param symbol - The symbol to validate against {@link PRIVATE}.\r\n * @throws {Error} If `symbol` does not match {@link PRIVATE}.\r\n * @internal\r\n */\r\nexport function assertPrivateContext(symbol: symbol): void {\r\n  if (symbol !== PRIVATE) {\r\n    throw new Error('Invalid symbol');\r\n  }\r\n}","/** \r\n * Whether the library is runnign in development mode\r\n * Used to log extra information for example\r\n * - Invalid transition states for {@link Computed} or {@link Watcher}  \r\n */\r\nlet devMode = false;\r\n\r\n/**\r\n * Sets the development mode flag.\r\n * @param mode - `true` to enable dev mode, `false` to disable it.\r\n */\r\nexport function setDevMode(mode: boolean): void {\r\n  devMode = mode;\r\n}\r\n\r\n/**\r\n * Returns the current development mode state.\r\n * @returns `true` if dev mode is enabled, `false` otherwise.\r\n */\r\nexport function isDevMode(): boolean {\r\n  return devMode;\r\n}","\r\nimport { GLOBAL_STATE, popComputed, pushComputed } from '../../utils/globals/globals';\r\nimport { PRIVATE, assertPrivateContext } from '../../utils/private-symbol/private-symbol';\r\nimport { ComputedState } from '../../types/computed-state.type';\r\nimport { SignalEqual } from '../../types/signal-equal.type';\r\nimport { SignalOptions } from '../../types/signal-options.type';\r\nimport { State } from '../state/state';\r\nimport { Watcher } from '../watcher/watcher';\r\nimport { isDevMode } from '../../utils/dev-mode/dev-mode';\r\n\r\n/**\r\n * A read-only Signal whose value is derived lazily from other Signals.\r\n *\r\n * The value is recomputed only when explicitly read and only if one or more\r\n * of its (recursive) dependencies have changed since the last evaluation.\r\n * The result is cached and reused until the Signal becomes stale again.\r\n *\r\n * @template T The type of the computed value.\r\n *\r\n * @see Signal algorithms — \"The Signal.Computed class\"\r\n */\r\nexport class Computed<T = any> {\r\n  /**\r\n   * The current value of the signal.\r\n   *\r\n   * Uninitialised (`!`) until the first evaluation. After that, holds either\r\n   * the return value of `#callback` or a boxed error\r\n   * `{ isError: true; value: Error }` if the last evaluation threw.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — \"Signal.Computed internal slots\"\r\n   */\r\n  #value!: T | { isError: true; value: Error };\r\n  /**\r\n   * The current evaluation state of this Signal.\r\n   *\r\n   * - `~dirty~`     — value is known to be stale or has never been evaluated.\r\n   * - `~checked~`   — an indirect source changed; may or may not be stale.\r\n   * - `~computing~` — `#callback` is currently executing; guards against cycles.\r\n   * - `~clean~`     — cached value is up-to-date.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — \"Signal.Computed State machine\"\r\n   */\r\n  #state: ComputedState;\r\n  /**\r\n   * The ordered set of Signals read during the last evaluation of\r\n   * `#callback`. Cleared and rebuilt on every re-evaluation so that\r\n   * conditional branches that are no longer taken stop being tracked.\r\n   *\r\n   * May contain both `State` and `Computed` instances.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — \"Signal.Computed internal slots\"\r\n   */\r\n  #sources: Set<State<unknown> | Computed<unknown>>;\r\n  /**\r\n * Returns a snapshot of the current sources set for introspection.\r\n *\r\n * @param symbol - Private access symbol; rejects calls from outside the library.\r\n * @returns An array of `State` and `Computed` instances that this Signal depends on.\r\n * @internal\r\n */\r\n  public getSources(symbol: symbol): (State<unknown> | Computed<unknown>)[] {\r\n    assertPrivateContext(symbol);\r\n    return [...this.#sources];\r\n  }\r\n  /**\r\n   * The set of Signals and Watchers that directly depend on this Signal.\r\n   *\r\n   * Populated only when this Signal is reachable from at least one active\r\n   * `Watcher`. An un-watched `Computed` has an empty sinks set, which allows\r\n   * it to be garbage-collected independently from the rest of the graph.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — \"Signal.Computed internal slots\"\r\n   * @see Method — `Signal.Computed.prototype.get` (NOTE on sinks)\r\n   */\r\n  #sinks: Set<Computed<unknown> | Watcher>;\r\n  /**\r\n   * Returns a snapshot of the current sinks set for introspection.\r\n   *\r\n   * @param symbol - Private access symbol; rejects calls from outside the library.\r\n   * @returns An array of `Computed` and `Watcher` instances that depend on this Signal.\r\n   * @internal\r\n   */\r\n  public getSinks(symbol: symbol): (Computed<unknown> | Watcher)[] {\r\n    assertPrivateContext(symbol);\r\n    return [...this.#sinks];\r\n  }\r\n  /**\r\n   * The equality function used to determine whether a newly computed value\r\n   * is meaningfully different from the previously cached one.\r\n   *\r\n   * Called as `equals.call(computed, oldValue, newValue)`. Returns `true` if\r\n   * the values are considered equal, in which case no downstream propagation\r\n   * occurs. Defaults to `Object.is` when not provided via options.\r\n   *\r\n   * If this function throws, the exception is cached as the Signal's value\r\n   * and the outcome is treated as `~dirty~`.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — \"Signal.Computed internal slots\"\r\n   * @see Algorithm — \"Set Signal value\"\r\n   */\r\n  #equals: SignalEqual<T>;\r\n  /**\r\n   * The pure function that produces this Signal's value. Evaluated lazily\r\n   * whenever the Signal is read while in a `~dirty~` or `~checked~` state.\r\n   *\r\n   * Called with `this` bound to the `Computed` instance itself so that\r\n   * internal methods (e.g. `addSource`) are accessible if needed.\r\n   * Any exception thrown by this function is caught and cached.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — \"Signal.Computed internal slots\"\r\n   */\r\n  #callback: (this: Computed<T>) => T;\r\n\r\n  /**\r\n   * Creates a new `Computed` signal.\r\n   *\r\n   * The Signal starts in the `~dirty~` state with an uninitialised value, so\r\n   * `#callback` will be invoked on the first `get()`.\r\n   *\r\n   * @param cb - Pure function evaluated lazily to produce the value.\r\n   *   Receives the `Computed` instance as `this`.\r\n   * @param options - Optional configuration:\r\n   *   - `equals` — custom equality function; defaults to `Object.is`.\r\n   *\r\n   * @see Signal algorithms — \"Signal.Computed Constructor\"\r\n   */\r\n  constructor(cb: (this: Computed<T>) => T, options?: SignalOptions<T>) {\r\n    this.#callback = cb;\r\n    this.#equals = options?.equals ?? Object.is;\r\n    this.#sources = new Set;\r\n    this.#sinks = new Set;\r\n    this.#state = 'dirty';\r\n  }\r\n\r\n  /**\r\n   * Returns the current value of this Signal, re-evaluating `#callback` if\r\n   * the cached value may be stale.\r\n   *\r\n   * Registers this Signal as a source of any outer `Computed` currently\r\n   * being evaluated (automatic dependency tracking).\r\n   *\r\n   * If the state is `~dirty~` or `~checked~`, walks the source graph\r\n   * depth-first to find and recalculate the deepest stale `Computed` first,\r\n   * then re-checks upward until this Signal is `~clean~`.\r\n   *\r\n   * @returns The current computed value, or a boxed error object if the last\r\n   *   evaluation threw.\r\n   * @throws If `frozen` is `true`.\r\n   * @throws If the Signal is in the `~computing~` state (cyclic dependency).\r\n   *\r\n   * @see Signal algorithms — \"Method: Signal.Computed.prototype.get\"\r\n   */\r\n  public get(): T | { isError: true; value: Error } {\r\n    if (GLOBAL_STATE.frozen) {\r\n      throw new Error('Cannot get value of a Computed signal while the global state is frozen');\r\n    }\r\n\r\n    if (this.#state === 'computing') {\r\n      throw new Error('Circular dependency detected while computing a Computed signal');\r\n    }\r\n\r\n    GLOBAL_STATE.computing?.addSource(this, PRIVATE);\r\n\r\n    if (this.#sinks.size === 0) {\r\n      this.#computeValue();\r\n    } else if (this.#state === 'dirty' || this.#state === 'checked') {\r\n      while (this.#state === 'dirty' || this.#state === 'checked') {\r\n        const deepest = this.#findDeepestStale();\r\n        deepest.#computeValue();\r\n      }\r\n    }\r\n\r\n    return this.#value;\r\n  }\r\n\r\n  /**\r\n   * Registers a Signal as a source of this `Computed`, discovered during the\r\n   * execution of `#callback`.\r\n   *\r\n   * If this `Computed` is currently being watched (has at least one sink),\r\n   * the source is also informed of this Signal as a new sink, building the\r\n   * live push-notification chain upward.\r\n   *\r\n   * @param source - The Signal read during evaluation.\r\n   * @param symbol - Private access symbol; rejects calls from outside the library.\r\n   * @internal\r\n   */\r\n  public addSource(source: State | Computed, symbol: symbol) {\r\n    assertPrivateContext(symbol);\r\n    this.#sources.add(source);\r\n    source.addSink(this, PRIVATE)\r\n  }\r\n\r\n  /**\r\n   * Returns the current evaluation state of this Signal.\r\n   *\r\n   * @param symbol - Private access symbol; rejects calls from outside the library.\r\n   * @internal\r\n   * @see Signal algorithms — \"Signal.Computed State machine\"\r\n   */\r\n  public getState(symbol: symbol): ComputedState {\r\n    assertPrivateContext(symbol);\r\n    return this.#state;\r\n  }\r\n\r\n  /**\r\n   * Transitions this Signal to a new evaluation state.\r\n   *\r\n   * Only valid transitions (as defined by the state machine) are allowed.\r\n   * Invalid transitions throw an error.\r\n   *\r\n   * @param newState - The target state.\r\n   * @param symbol - Private access symbol; rejects calls from outside the library.\r\n   * @throws If the transition from the current state to `newState` is not allowed.\r\n   * @internal\r\n   * @see Signal algorithms — \"Signal.Computed State machine\"\r\n   */\r\n  public setState(newState: ComputedState, symbol: symbol): void {\r\n    assertPrivateContext(symbol);\r\n\r\n    if (this.#state === newState) {\r\n      return;\r\n    }\r\n\r\n    if (!this.#isValidTransition(this.#state, newState)) {\r\n      if (isDevMode()) {\r\n        console.warn(`Invalid state transition from ${this.#state} to ${newState} in Computed Signal`);\r\n        console.warn(new Error().stack)\r\n      }\r\n      return;\r\n    }\r\n\r\n    this.#state = newState;\r\n\r\n    if (this.#state === 'dirty' || this.#state === 'checked') {\r\n      this.#sinks.forEach(sink => sink instanceof Computed ? sink.setState('checked', PRIVATE) : sink.notify(PRIVATE))\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Registers a new sink (a `Computed` or `Watcher` that directly depends on\r\n   * this Signal) in the internal sinks set.\r\n   *\r\n   * If this is the first sink, propagates the sink registration recursively\r\n   * up through `#sources`, building the live dependency chain that enables\r\n   * push-based invalidation.\r\n   *\r\n   * @param sink - The dependent node to register.\r\n   * @param symbol - Private access symbol; rejects calls from outside the library.\r\n   * @internal\r\n   */\r\n  public addSink(sink: Computed<unknown> | Watcher, symbol: symbol) {\r\n    assertPrivateContext(symbol);\r\n    if (this.#sinks.size === 0) {\r\n      this.#sources.forEach(source => source.addSink(this, PRIVATE));\r\n    }\r\n    this.#sinks.add(sink);\r\n  }\r\n\r\n  /**\r\n   * Removes a sink from the internal sinks set.\r\n   *\r\n   * If the sinks set becomes empty after removal, propagates the removal\r\n   * recursively up through `#sources`, tearing down the live dependency\r\n   * chain and allowing garbage collection of un-watched nodes.\r\n   *\r\n   * @param sink - The dependent node to remove.\r\n   * @param symbol - Private access symbol; rejects calls from outside the library.\r\n   * @internal\r\n   */\r\n  public removeSink(sink: Computed | Watcher, symbol: symbol) {\r\n    assertPrivateContext(symbol);\r\n    this.#sinks.delete(sink);\r\n\r\n    if (this.#sinks.size === 0) {\r\n      this.#sources.forEach(source => source.removeSink(this, PRIVATE));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Recursively walks the source graph depth-first to find the deepest,\r\n   * left-most `Computed` node that is in a `~dirty~` or `~checked~` state.\r\n   *\r\n   * This ensures that recalculation always starts from the bottom of the\r\n   * dependency graph, so every node sees already-updated dependencies —\r\n   * the core of glitch-free evaluation.\r\n   *\r\n   * Cuts off the search when hitting a `~clean~` `Computed` source, since\r\n   * its subtree is guaranteed to be up-to-date.\r\n   *\r\n   * @returns The deepest stale `Computed` found, or `node` itself if none of\r\n   *   its sources are stale.\r\n   */\r\n  #findDeepestStale(): Computed {\r\n    const unclearNode = [...this.#sources].find((source): source is Computed => source instanceof Computed && (source.#state === 'dirty' || source.#state === 'checked'));\r\n    return unclearNode ? unclearNode.#findDeepestStale() : this;\r\n  }\r\n\r\n  /**\r\n   * Executes `#callback` to recompute this Signal's value.\r\n   *\r\n   * Implements the \"recalculate dirty computed Signal\" algorithm:\r\n   * 1. Clears stale sources and removes this Signal from their sinks.\r\n   * 2. Sets `computing` to this Signal for automatic dependency tracking.\r\n   * 3. Runs the callback, caching the return value or any thrown exception.\r\n   * 4. Restores the previous `computing` value.\r\n   * 5. Runs the \"set Signal value\" algorithm to detect value changes.\r\n   * 6. Transitions state to `~clean~`.\r\n   * 7. Propagates `~dirty~` to sinks (or attempts `~clean~` if value unchanged).\r\n   *\r\n   * @see Signal algorithms — \"Algorithm: recalculate dirty computed Signal\"\r\n   */\r\n  #computeValue(): void {\r\n    this.#sources.forEach(source => source.removeSink(this, PRIVATE));\r\n    this.#sources.clear();\r\n\r\n    pushComputed(this);\r\n    this.setState('computing', PRIVATE);\r\n\r\n    let newValue: T | { isError: true; value: Error };\r\n\r\n    try {\r\n      newValue = this.#callback.call(this);\r\n    } catch (error) {\r\n      newValue = { isError: true, value: error as Error };\r\n    } finally {\r\n      popComputed();\r\n    }\r\n\r\n    const outcome = this.#setValue(newValue);\r\n\r\n    this.setState('clean', PRIVATE);\r\n\r\n    outcome === 'dirty'\r\n      ? this.#sinks.forEach(sink => sink instanceof Computed ? sink.setState('dirty', PRIVATE) : sink.notify(PRIVATE))\r\n      : this.#propagateClean();\r\n  }\r\n\r\n  /**\r\n   * Implements the \"set Signal value\" algorithm.\r\n   *\r\n   * Compares the new value against the cached one using `#equals`. If equal,\r\n   * returns `~clean~` and leaves `#value` untouched. Otherwise updates\r\n   * `#value` and returns `~dirty~`.\r\n   *\r\n   * Special cases:\r\n   * - If `newValue` is a boxed error, `#equals` is skipped and the error is\r\n   *   cached directly.\r\n   * - If `#equals` itself throws, the exception is cached as a boxed error\r\n   *   and the outcome is `~dirty~`.\r\n   *\r\n   * @param newValue - The value (or boxed error) produced by `#callback`.\r\n   * @returns `~clean~` if the value is unchanged, `~dirty~` otherwise.\r\n   *\r\n   * @see Signal algorithms — \"Set Signal value algorithm\"\r\n   */\r\n  #setValue(newValue: T | { isError: true; value: Error }): 'clean' | 'dirty' {\r\n    const oldValue = this.#value;\r\n\r\n    /*\r\n      If new value is an error we always update without calling equals\r\n    */\r\n    if (this.#isErrorValue(newValue)) {\r\n      this.#value = newValue;\r\n      return 'dirty';\r\n    }\r\n\r\n    try {\r\n      if (!this.#isErrorValue(oldValue) && this.#equals.call(this, oldValue, newValue)) {\r\n        return 'clean';\r\n      }\r\n    } catch (equalsError) {\r\n      this.#value = { isError: true, value: equalsError as Error };\r\n      return 'dirty';\r\n    }\r\n\r\n    this.#value = newValue;\r\n    return 'dirty';\r\n  }\r\n\r\n  /**\r\n   * Recursively marks `~checked~` sinks as `~clean~` when all of their\r\n   * immediate sources are already `~clean~`.\r\n   *\r\n   * Called after a recalculation that produced an unchanged value (`~clean~`\r\n   * outcome from `#setValue`). Propagates the clean signal upward through\r\n   * the graph so that Computed nodes that were only transitively dirty — and\r\n   * whose dependencies have not actually changed — are not needlessly\r\n   * re-evaluated on the next read.\r\n   *\r\n   * @see Signal algorithms — \"Algorithm: recalculate dirty computed Signal\"\r\n   */\r\n  #propagateClean(): void {\r\n    [...this.#sinks]\r\n      .filter((sink): sink is Computed<unknown> => sink instanceof Computed && sink.#state === 'checked')\r\n      .forEach(sink => {\r\n        const allSourcesClean = [...sink.#sources].every(source => !(source instanceof Computed) || source.#state === 'clean');\r\n        if (allSourcesClean) {\r\n          sink.#state = 'clean';\r\n          sink.#propagateClean();\r\n        }\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Type guard that checks whether a value is a boxed error object.\r\n   *\r\n   * Used to distinguish a legitimately computed value from a cached\r\n   * exception produced by `#callback` or `#equals`.\r\n   *\r\n   * @param value - The value to inspect.\r\n   * @returns `true` if `value` is `{ isError: true; value: Error }`.\r\n   */\r\n  #isErrorValue(value: unknown): value is { isError: true; value: Error } {\r\n    return typeof value === 'object' && !!value && 'isError' in value;\r\n  }\r\n\r\n  #isValidTransition(from: ComputedState, to: ComputedState): boolean {\r\n    switch (from) {\r\n      case 'checked':\r\n        return to === 'clean' || to === 'dirty';\r\n      case 'clean':\r\n        return to === 'checked' || to === 'dirty';\r\n      case 'dirty':\r\n        return to === 'computing';\r\n      case 'computing':\r\n        return to === 'clean';\r\n    }\r\n  }\r\n}","import { NoArgsVoidFunction } from '@xaendar/types';\r\nimport { GLOBAL_STATE } from '../../utils/globals/globals';\r\nimport { PRIVATE, assertPrivateContext } from '../../utils/private-symbol/private-symbol';\r\nimport { SignalEqual } from '../../types/signal-equal.type';\r\nimport { SignalOptions } from '../../types/signal-options.type';\r\nimport { Computed } from '../computed/computed';\r\nimport { Watcher } from '../watcher/watcher';\r\n\r\nexport class State<T = any> {\r\n  /**\r\n   * The current value of the signal.\r\n   *\r\n   * Initialised to `initialValue` in the constructor and updated by `set`\r\n   * whenever the new value is not equal to the current one according to\r\n   * `#equals`.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — 'Signal.State internal slots'\r\n   */\r\n  #value: T;\r\n  /**\r\n   * The equality function used to determine whether a new value is\r\n   * meaningfully different from the current one.\r\n   *\r\n   * Called as `equals.call(signal, oldValue, newValue)`. If it returns\r\n   * `true` the signal is considered unchanged and no propagation occurs.\r\n   * Defaults to `Object.is` when not provided via options.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — 'Signal.State internal slots'\r\n   * @see Algorithm — 'Set Signal value'\r\n   */\r\n  #equals: SignalEqual<T>\r\n  /**\r\n   * Optional callback invoked (with `frozen = true`) the first time this\r\n   * Signal gains a sink — i.e. when it transitions from un-observed to\r\n   * observed by at least one `Watcher` (directly or transitively).\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — 'Signal.State internal slots'\r\n   * @see Method — `Signal.subtle.Watcher.prototype.watch`\r\n   */\r\n  #watched?: NoArgsVoidFunction;\r\n  /**\r\n   * Optional callback invoked (with `frozen = true`) when this Signal loses\r\n   * its last sink — i.e. when it transitions from observed back to\r\n   * un-observed.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — 'Signal.State internal slots'\r\n   * @see Method — `Signal.subtle.Watcher.prototype.unwatch`\r\n   */\r\n  #unwatched?: NoArgsVoidFunction;\r\n  /**\r\n   * The set of watched signals that directly depend on this one.\r\n   *\r\n   * Populated only when this Signal is reachable from at least one active\r\n   * `Watcher` — un-watched Signals have an empty sinks set, which allows\r\n   * them to be garbage-collected independently from the rest of the graph.\r\n   *\r\n   * Should contain both `Computed` and `Watcher` instances, as both can be\r\n   * direct dependents of a `State`.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — 'Signal.State internal slots'\r\n   * @see Method — `Signal.State.prototype.get` (NOTE on sinks)\r\n   */\r\n  #sinks: Set<Computed<unknown> | Watcher>;\r\n  /**\r\n   * Returns a snapshot of the current sinks set for introspection.\r\n   *\r\n   * @param symbol - Private access symbol; rejects calls from outside the library.\r\n   * @returns An array of `Computed` and `Watcher` instances that depend on this Signal.\r\n   * @internal\r\n   */\r\n  public getSinks(symbol: symbol): (Computed<unknown> | Watcher)[] {\r\n    assertPrivateContext(symbol);\r\n    return [...this.#sinks];\r\n  }\r\n\r\n  /**\r\n   * Creates a new `State` signal.\r\n   *\r\n   * @param initialValue - The initial value of the signal.\r\n   * @param options - Optional configuration:\r\n   *   - `equals` — custom equality function; defaults to `Object.is`.\r\n   *   - `watched` — called when the signal gains its first sink.\r\n   *   - `unwatched` — called when the signal loses its last sink.\r\n   *\r\n   * @see Signal algorithms — 'Constructor: Signal.State(initialValue, options)'\r\n   */\r\n  constructor(initialValue: T, options?: SignalOptions<T>) {\r\n    this.#value = initialValue;\r\n    this.#equals = options?.equals ?? Object.is;\r\n    this.#watched = options?.watched;\r\n    this.#unwatched = options?.unwatched;\r\n    this.#sinks = new Set;\r\n  }\r\n\r\n  /**\r\n   * Returns the current value of the signal, registering this Signal as a\r\n   * source of the innermost `Computed` currently being evaluated (if any).\r\n   *\r\n   * @throws If `frozen` is `true` — reads are forbidden while a protected\r\n   * callback (`notify`, `watched`, `unwatched`) is executing.\r\n   *\r\n   * @see Signal algorithms — 'Method: Signal.State.prototype.get()'\r\n   */\r\n  public get(): T {\r\n    if (GLOBAL_STATE.frozen) {\r\n      throw new Error('Cannot get value while signals are frozen');\r\n    }\r\n\r\n    /*\r\n      If there is a currently computing `Computed`, register this `State` as a\r\n      source of that `Computed`. \r\n      This is how the dependency graph is built.\r\n\r\n      THis is done every time a `State` is read to guarantee always up-to-date \r\n      tracking of dependencies, even if they change between computations\r\n    */\r\n    GLOBAL_STATE.computing?.addSource(this, PRIVATE)\r\n\r\n    return this.#value;\r\n  }\r\n\r\n  /**\r\n   * Updates the signal's value and propagates changes to all dependent\r\n   * sinks.\r\n   *\r\n   * If `equals(currentValue, newValue)` returns `true` the call is a no-op\r\n   * and no propagation occurs. Otherwise `#value` is updated, all direct\r\n   * `Computed` sinks are marked `~dirty~`, indirect ones `~checked~`, and\r\n   * each reachable `Watcher` has its `notify` callback invoked synchronously\r\n   * (with `frozen = true`).\r\n   *\r\n   * @param newValue - The new value to set.\r\n   * @throws If `frozen` is `true` — writes are forbidden while a protected\r\n   * callback is executing.\r\n   *\r\n   * @see Signal algorithms — 'Method: Signal.State.prototype.set(newValue)'\r\n   * @see Algorithm — 'Set Signal value'\r\n   */\r\n  public set(newValue: T): void {\r\n    if (GLOBAL_STATE.frozen) {\r\n      throw new Error('Cannot set value while signals are frozen');\r\n    }\r\n\r\n    if (!this.#equals.call(this, this.#value, newValue)) {\r\n      this.#value = newValue;\r\n      this.#sinks.forEach(sink => sink instanceof Computed ? sink.setState('dirty', PRIVATE) : sink.notify(PRIVATE));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Registers a new sink (a `Computed` or `Watcher` that depends on this\r\n   * Signal) in the internal sinks set.\r\n   *\r\n   * Called by `Watcher.prototype.watch` when building the live dependency\r\n   * chain, and by `Computed` when propagating sink registration up through\r\n   * its sources.\r\n   *\r\n   * @param sink - The dependent node to register.\r\n   * @param symbol - The private symbol for validation.\r\n   * @internal\r\n   */\r\n  public addSink(sink: Computed | Watcher, symbol: symbol): void {\r\n    assertPrivateContext(symbol);\r\n    const empty = this.#sinks.size === 0;\r\n    this.#sinks.add(sink);\r\n\r\n    if (empty && this.#watched) {\r\n      GLOBAL_STATE.frozen = true;\r\n      try {\r\n        this.#watched();\r\n      } finally {\r\n        GLOBAL_STATE.frozen = false;\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Removes a sink from the internal sinks set.\r\n   *\r\n   * Called by `Watcher.prototype.unwatch` when tearing down the live\r\n   * dependency chain. If the sinks set becomes empty after removal, the\r\n   * caller is responsible for propagating the removal up through this\r\n   * Signal's sources.\r\n   *\r\n   * @param sink - The dependent node to remove.\r\n   * @param symbol - The private symbol for validation.\r\n   * @internal\r\n   */\r\n  public removeSink(sink: Computed | Watcher, symbol: symbol): void {\r\n    assertPrivateContext(symbol);\r\n    this.#sinks.delete(sink);\r\n    const empty = this.#sinks.size === 0;\r\n\r\n    if (empty && this.#unwatched) {\r\n      GLOBAL_STATE.frozen = true;\r\n      try {\r\n        this.#unwatched();\r\n      } finally {\r\n        GLOBAL_STATE.frozen = false;\r\n      }\r\n    }\r\n  }\r\n}\r\n","import { NoArgsVoidFunction } from '@xaendar/types';\r\nimport { GLOBAL_STATE } from '../../utils/globals/globals';\r\nimport { PRIVATE, assertPrivateContext } from '../../utils/private-symbol/private-symbol';\r\nimport { State } from '../state/state';\r\nimport { WatcherState } from '../../types/watcher-state.type';\r\nimport { Computed } from '../computed/computed';\r\nimport { isDevMode } from '../../utils/dev-mode/dev-mode';\r\n\r\n/**\r\n * A `Watcher` observes a set of Signals and fires a `notify` callback\r\n * synchronously when any of their (recursive) dependencies change.\r\n *\r\n * It is the low-level primitive on top of which frameworks implement\r\n * effects and scheduling. It does not hold a value and has no generic\r\n * type parameter.\r\n *\r\n * @see Signal algorithms — 'The `Signal.subtle.Watcher` class'\r\n */\r\nexport class Watcher {\r\n  /**\r\n   * The current state of the Watcher.\r\n   *\r\n   * - `~waiting~`  — newly created, or `notify` has already been called since\r\n   *                  the last `watch` call. Not actively observing changes.\r\n   * - `~watching~` — actively watching; no dependency has changed yet.\r\n   * - `~pending~`  — a dependency has changed but `notify` has not yet run.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — 'Signal.subtle.Watcher State machine'\r\n   */\r\n  #state: WatcherState;\r\n  /**\r\n   * The ordered set of Signals this Watcher is currently watching.\r\n   * May contain both `State` and `Computed` instances.\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — 'Signal.subtle.Watcher internal slots'\r\n   */\r\n  #signals: Set<State<unknown> | Computed<unknown>>;\r\n  /**\r\n   * Returns a snapshot of the current watched signals set for introspection.\r\n   *\r\n   * @param symbol - Private access symbol; rejects calls from outside the library.\r\n   * @returns An array of `State` and `Computed` instances that this Watcher is watching.\r\n   * @internal\r\n   */\r\n  public getSources(symbol: symbol): (State<unknown> | Computed<unknown>)[] {\r\n    assertPrivateContext(symbol);\r\n    return [...this.#signals];\r\n  }\r\n  /**\r\n   * The callback invoked synchronously when a watched Signal (or one of its\r\n   * recursive dependencies) changes for the first time since the last\r\n   * `watch` call.\r\n   *\r\n   * Receives the Watcher itself as `this`. No Signals may be read or written\r\n   * during its execution (`frozen` is `true` for its entire duration).\r\n   *\r\n   * @internalSlot\r\n   * @see Signal algorithms — 'Signal.subtle.Watcher internal slots'\r\n   */\r\n  #notifyCallback: NoArgsVoidFunction;\r\n\r\n  /**\r\n   * Creates a new Watcher.\r\n   *\r\n   * The Watcher starts in the `~waiting~` state with an empty signals set.\r\n   *\r\n   * @param notifyCallback - Called synchronously (with `frozen = true`) the\r\n   * first time a watched dependency changes after each `watch` call. No\r\n   * Signals may be read or written inside this callback.\r\n   *\r\n   * @see Signal algorithms — 'Constructor: new Signal.subtle.Watcher(callback)'\r\n   */\r\n  constructor(notifyCallback: NoArgsVoidFunction) {\r\n    this.#state = 'waiting';\r\n    this.#signals = new Set;\r\n    this.#notifyCallback = notifyCallback;\r\n  }\r\n\r\n  /**\r\n   * Returns the subset of watched Signals that are `Computed` instances\r\n   * currently in a `~dirty~` or `~checked~` state, meaning they may have a\r\n   * stale value that has not yet been re-evaluated.\r\n   *\r\n   * Typically called inside the microtask scheduled by the `notify` callback\r\n   * to know which Signals need to be pulled.\r\n   *\r\n   * @returns An array of `Computed` signals that are dirty or checked.\r\n   *\r\n   * @see Signal algorithms — 'Method: Signal.subtle.Watcher.prototype.getPending()'\r\n   */\r\n  public getPending(): Computed<unknown>[] {\r\n    return [...this.#signals].filter((signal): signal is Computed<unknown> => {\r\n      if (!(signal instanceof Computed)) {\r\n        return false;\r\n      }\r\n\r\n      const state = signal.getState(PRIVATE);\r\n      return state === 'dirty' || state === 'checked';\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Adds the given Signals to the watched set and transitions the Watcher to\r\n   * the `~watching~` state.\r\n   *\r\n   * For each newly-watched Signal, the Watcher is registered as a sink and —\r\n   * if it is the first sink — the sink registration is propagated recursively\r\n   * up through the Signal's sources, building the live dependency chain.\r\n   *\r\n   * The `watched` callback of each Signal (if any) is called with\r\n   * `frozen = true`.\r\n   *\r\n   * @param signals - One or more `State` signals to start watching.\r\n   * @throws If `frozen` is `true` at the time of the call.\r\n   *\r\n   * @see Signal algorithms — 'Method: Signal.subtle.Watcher.prototype.watch(...signals)'\r\n   */\r\n  public watch(...signals: (State | Computed)[]) {\r\n    if (GLOBAL_STATE.frozen) {\r\n      throw new Error('Cannot watch signals while frozen');\r\n    }\r\n\r\n    signals.forEach(signal => {\r\n      if (this.#signals.has(signal)) {\r\n        throw new Error('Cannot watch a signal that is already being watched');\r\n      }\r\n\r\n      this.#signals.add(signal)\r\n      signal.addSink(this, PRIVATE);\r\n    });\r\n\r\n\r\n    this.setState('watching', PRIVATE);\r\n  }\r\n\r\n  /**\r\n   * Removes the given Signals from the watched set.\r\n   *\r\n   * For each removed Signal, the Watcher is unregistered as a sink. If the\r\n   * Signal's sink set becomes empty as a result, the removal is propagated\r\n   * recursively up through its sources, tearing down the live dependency\r\n   * chain and allowing garbage collection of unwatched nodes.\r\n   *\r\n   * The `unwatched` callback of each Signal (if any) is called with\r\n   * `frozen = true`.\r\n   *\r\n   * If no Signals remain in the watched set, the Watcher transitions back to\r\n   * the `~waiting~` state.\r\n   *\r\n   * @param signals - One or more `State` signals to stop watching.\r\n   * @throws If `frozen` is `true` at the time of the call.\r\n   * @throws If any of the given Signals is not currently being watched.\r\n   *\r\n   * @see Signal algorithms — 'Method: Signal.subtle.Watcher.prototype.unwatch(...signals)'\r\n   */\r\n  public unwatch(...signals: (State | Computed)[]) {\r\n    if (GLOBAL_STATE.frozen) {\r\n      throw new Error('Cannot unwatch signals while frozen');\r\n    }\r\n\r\n    signals.forEach(signal => {\r\n      if (!this.#signals.has(signal)) {\r\n        throw new Error('Cannot unwatch a signal that is not being watched');\r\n      }\r\n\r\n      this.#signals.delete(signal)\r\n      signal.removeSink(this, PRIVATE);\r\n    });\r\n\r\n    if (!this.#signals.size) {\r\n      this.setState('waiting', PRIVATE)\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the current state of the Watcher.\r\n   * @param symbol - The private symbol for prevent external calls.\r\n   */\r\n  public getState(symbol: symbol): WatcherState {\r\n    assertPrivateContext(symbol);\r\n    return this.#state;\r\n  }\r\n\r\n  /**\r\n   * Set the current state of the Watcher.\r\n   * @param newState - The new state to set.\r\n   * @param symbol - The private symbol for prevent external calls.\r\n   * @throws If the transition from `pending` to `watching` is attempted.\r\n   */\r\n  public setState(newState: WatcherState, symbol: symbol): void {\r\n    assertPrivateContext(symbol);\r\n\r\n    if (this.#state === newState) {\r\n      return;\r\n    }\r\n\r\n    if (!this.#isValidTransition(this.#state, newState)) {\r\n      if (isDevMode()) {\r\n        console.warn(`Invalid state transition from ${this.#state} to ${newState} in Watcher`);\r\n        console.warn(new Error().stack)\r\n      }\r\n      return;\r\n    }\r\n\r\n    this.#state = newState\r\n  }\r\n\r\n  /**\r\n   * Invoce the notify callback when a watched dependency changes\r\n   * @param symbol - The private symbol for prevent external calls.\r\n   */\r\n  public notify(symbol: symbol): void {\r\n    assertPrivateContext(symbol);\r\n    \r\n    GLOBAL_STATE.frozen = true;\r\n\r\n    try {\r\n      this.setState('pending', PRIVATE)\r\n      this.#notifyCallback.call(this);\r\n    } finally {\r\n      this.setState('waiting', PRIVATE);\r\n      GLOBAL_STATE.frozen = false;\r\n    }\r\n  }\r\n\r\n  #isValidTransition(from: WatcherState, to: WatcherState): boolean {\r\n    switch (from) {\r\n      case 'waiting':\r\n        return to === 'watching';\r\n      case 'watching':\r\n        return to === 'pending' || to === 'waiting';\r\n      case 'pending':\r\n        return to === 'waiting';\r\n    }\r\n  }\r\n}","import { GLOBAL_STATE } from './utils/globals/globals';\r\nimport { Computed } from './models/computed/computed';\r\nimport { State } from './models/state/state';\r\nimport { Watcher } from './models/watcher/watcher';\r\nimport { PRIVATE } from './utils/private-symbol/private-symbol';\r\n\r\n/**\r\n * Executes a function without tracking any dependencies.\r\n * @param fn - The function to execute without tracking.\r\n * @returns The result of the function execution.\r\n */\r\nexport function untrack<T>(fn: () => T): T {\r\n  const prevComputing = GLOBAL_STATE.computing;\r\n  GLOBAL_STATE.computing = null;\r\n\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    GLOBAL_STATE.computing = prevComputing;\r\n  }\r\n}\r\n\r\n/**\r\n * Returns the currently active `Computed` instance being evaluated, or `null`\r\n * @returns The currently active `Computed` instance, or `null` if none is being evaluated.\r\n */\r\nexport function currentComputed(): Computed | null {\r\n  return GLOBAL_STATE.computing;\r\n}\r\n\r\n/**\r\n * Returns the ordered list of all Signals which the given `Computed` or\r\n * `Watcher` referenced during its last evaluation.\r\n *\r\n * - For a `Computed`, these are the Signals read inside its callback.\r\n * - For a `Watcher`, these are the Signals it is currently watching.\r\n *\r\n * @param signal - The `Computed` or `Watcher` to introspect.\r\n * @returns An array of `State` and `Computed` instances.\r\n */\r\nexport function introspectSources(signal: Computed | Watcher): (State | Computed)[] {\r\n  return signal.getSources(PRIVATE);\r\n}\r\n\r\n/**\r\n * Returns the direct dependents of the given Signal — Watchers that contain\r\n * it, plus any `Computed` Signals which read it during their last evaluation\r\n * (if that `Computed` is recursively watched).\r\n *\r\n * @param signal - The `State` or `Computed` Signal to introspect.\r\n * @returns An array of `Computed` and `Watcher` instances.\r\n */\r\nexport function introspectSinks(signal: State | Computed): (Computed | Watcher)[] {\r\n  return signal.getSinks(PRIVATE);\r\n}\r\n\r\n/**\r\n * Returns `true` if the given Signal is 'live' — i.e. it is watched by a\r\n * `Watcher`, or it is read by a `Computed` Signal which is (recursively)\r\n * live.\r\n *\r\n * @param signal - The `State` or `Computed` Signal to check.\r\n * @returns `true` if the Signal has at least one sink.\r\n */\r\nexport function hasSinks(signal: State | Computed): boolean {\r\n  return signal.getSinks(PRIVATE).length > 0;\r\n}\r\n\r\n/**\r\n * Returns `true` if the given node is 'reactive' — i.e. it depends on some\r\n * other Signal. A `Computed` where `hasSources` is `false` will always\r\n * return the same constant.\r\n *\r\n * @param signal - The `Computed` or `Watcher` to check.\r\n * @returns `true` if the node has at least one source.\r\n */\r\nexport function hasSources(signal: Computed | Watcher): boolean {\r\n  return signal.getSources(PRIVATE).length > 0;\r\n}","import { Computed } from './models/computed/computed';\r\nimport { State } from './models/state/state';\r\nimport { Watcher } from './models/watcher/watcher';\r\nimport { currentComputed, hasSinks, hasSources, introspectSinks, introspectSources, untrack } from './subtle';\r\nimport { setDevMode } from './utils/dev-mode/dev-mode';\r\n\r\n/**\r\n * Loads the Signals library by defining the `Signal` global object with the following properties:\r\n * - `State`: The `State` class for creating reactive state variables.\r\n * - `Computed`: The `Computed` class for creating derived reactive values.\r\n * - `Watcher`: The `Watcher` class for observing changes in signals.\r\n * - `subtle`: An object containing internal utility functions for working with signals, including:\r\n *  - `untrack`: Executes a function without tracking dependencies.\r\n *  - `currentComputed`: Returns the currently active `Computed` instance being evaluated, or `null` if none.\r\n *  - `introspectSources`: Returns the list of sources for a given `Computed` or `Watcher`.\r\n *  - `introspectSinks`: Returns the list of sinks for a given `State` or `Computed`.\r\n *  - `hasSinks`: Returns `true` if a given `State` or `Computed` has at least one sink.\r\n *  - `hasSources`: Returns `true` if a given `Computed` or `Watcher` has at least one source.\r\n *  - `Watcher`: The `Watcher` class for observing changes in signals.\r\n * \r\n * This function should be called once to initialize the Signals library and make its API available globally.\r\n */\r\nexport function loadSignals(options?: { devMode?: boolean }): void {\r\n  setDevMode(options?.devMode ?? false)\r\n\r\n  globalThis.Signal ??= {\r\n    State,\r\n    Computed,\r\n    subtle: {\r\n      untrack,\r\n      currentComputed,\r\n      introspectSources: introspectSources as unknown as typeof Signal.subtle.introspectSources,\r\n      introspectSinks: introspectSinks as unknown as typeof Signal.subtle.introspectSinks,\r\n      hasSinks: hasSinks as unknown as typeof Signal.subtle.hasSinks,\r\n      hasSources: hasSources as unknown as typeof Signal.subtle.hasSources,\r\n      Watcher\r\n    }\r\n  }\r\n}","import { NoArgsVoidFunction } from \"@xaendar/types\";\r\n\r\n/**\r\n * Runs a side-effectful function and automatically re-runs it whenever any\r\n * Signal read during its execution changes.\r\n *\r\n * Internally, `effect` wraps the user callback inside a `Computed` node\r\n * (for dependency tracking) and observes it with a `Watcher` (for push\r\n * notifications). When any tracked dependency changes, the `Watcher`\r\n * schedules a microtask that re-evaluates the `Computed`, which in turn\r\n * re-runs the user callback and re-registers the new set of dependencies.\r\n *\r\n * The returned disposer function stops the effect: it unwatches the internal\r\n * `Computed` from the `Watcher`, severing all dependency subscriptions so\r\n * the callback is never called again and the graph nodes can be\r\n * garbage-collected.\r\n *\r\n * @example\r\n * ```ts\r\n * const count = new State(0);\r\n *\r\n * const stop = effect(() => {\r\n *   console.log('count is', count.get());\r\n * });\r\n * // logs: \"count is 0\"\r\n *\r\n * count.set(1); // logs: \"count is 1\"\r\n * count.set(2); // logs: \"count is 2\"\r\n *\r\n * stop();       // no more logs\r\n * count.set(3); // silent\r\n * ```\r\n *\r\n * @param fn - The side-effectful function to run. Any Signal read inside it\r\n *   is tracked as a dependency.\r\n * @returns A disposer function that, when called, permanently stops the effect.\r\n */\r\nexport function effect(fn: NoArgsVoidFunction): NoArgsVoidFunction {\r\n  /**\r\n   * Wrap the user callback in a Computed so that automatic dependency\r\n   * tracking (via pushComputed / popComputed) works for free.\r\n   * The Computed always returns `undefined` — we only care about the\r\n   * side-effects and the tracked sources, not the value.\r\n   */\r\n  const computed = new Signal.Computed<void>(() => fn());\r\n\r\n  let needsEnqueue = true;\r\n\r\n  /**\r\n   * The Watcher is notified synchronously as soon as any tracked dependency\r\n   * changes. Its job is purely to schedule the re-execution; the actual\r\n   * re-evaluation happens asynchronously in a microtask so that multiple\r\n   * synchronous signal updates are batched into a single re-run.\r\n   */\r\n  const watcher = new Signal.subtle.Watcher(() => {\r\n    if (needsEnqueue) {\r\n      needsEnqueue = false;\r\n      queueMicrotask(() => {\r\n        needsEnqueue = true;\r\n        watcher.getPending().forEach(computed => computed.get());\r\n        watcher.watch();\r\n      });\r\n    }\r\n  });\r\n\r\n  // Initial synchronous execution + first subscription.\r\n  watcher.watch(computed);\r\n  computed.get();\r\n\r\n  /**\r\n   * Disposer — call this to permanently stop the effect.\r\n   *\r\n   * Unwatching the Computed tears down the entire live dependency chain\r\n   * (Watcher → Computed → all sources), preventing any further\r\n   * notifications and allowing GC.\r\n   */\r\n  return () => watcher.unwatch(computed);\r\n}"],"mappings":"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"}
+export { effect, loadSignals };