elements-kit 0.0.2 → 0.0.3

package/dist/signals-Cr7xgAJH.mjs

@@ -0,0 +1,966 @@
+//#region src/signals/system.ts
+/**
+* Bitmask flags that encode the current state of a {@link ReactiveNode}.
+*
+* | Flag            | Meaning |
+* |-----------------|---------|
+* | `None`          | Clean, not tracking. |
+* | `Mutable`       | Node can propagate value changes downstream (signal / computed). |
+* | `Watching`      | Node is actively watching for changes and should be notified (effect). |
+* | `RecursedCheck` | Node is mid-execution; used to detect self-referential cycles. |
+* | `Recursed`      | Node was found to be recursed during propagation. |
+* | `Dirty`         | Node's value is known to be stale; must recompute before reading. |
+* | `Pending`       | A dep *might* be dirty; check before deciding whether to recompute. |
+*/
+let ReactiveFlags = /* @__PURE__ */ function(ReactiveFlags) {
+	ReactiveFlags[ReactiveFlags["None"] = 0] = "None";
+	ReactiveFlags[ReactiveFlags["Mutable"] = 1] = "Mutable";
+	ReactiveFlags[ReactiveFlags["Watching"] = 2] = "Watching";
+	ReactiveFlags[ReactiveFlags["RecursedCheck"] = 4] = "RecursedCheck";
+	ReactiveFlags[ReactiveFlags["Recursed"] = 8] = "Recursed";
+	ReactiveFlags[ReactiveFlags["Dirty"] = 16] = "Dirty";
+	ReactiveFlags[ReactiveFlags["Pending"] = 32] = "Pending";
+	return ReactiveFlags;
+}({});
+/**
+* Creates and returns the five core graph-manipulation functions that together
+* implement push-pull reactive dependency tracking.
+*
+* The caller supplies three callbacks that customise high-level behaviour while
+* the returned functions handle all graph bookkeeping:
+*
+* @param update   - Called when a Mutable+Dirty node needs to recompute.
+*                   Return `true` if the computed value changed (triggers
+*                   downstream dirty propagation).
+* @param notify   - Called when a Watching node should be scheduled for
+*                   re-execution (i.e. a dep became dirty).
+* @param unwatched - Called when a dep node's last subscriber is removed.
+*                   The caller may choose to stop the node or keep it alive.
+*
+* @returns `{ link, unlink, propagate, checkDirty, shallowPropagate }`
+*/
+function createReactiveSystem({ update, notify, unwatched }) {
+	return {
+		link,
+		unlink,
+		propagate,
+		checkDirty,
+		shallowPropagate
+	};
+	/**
+	* Records that `sub` now depends on `dep` at the given `version`.
+	*
+	* Duplicate links (same dep/sub pair within the same tracking cycle) are
+	* detected and skipped in O(1) by checking the tail of both chains before
+	* allocating a new `Link` object.
+	*
+	* @param dep     - The upstream node being read.
+	* @param sub     - The downstream node doing the reading.
+	* @param version - Current logical clock value; used for stale-link detection.
+	*/
+	function link(dep, sub, version) {
+		const prevDep = sub.depsTail;
+		if (prevDep !== void 0 && prevDep.dep === dep) return;
+		const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
+		if (nextDep !== void 0 && nextDep.dep === dep) {
+			nextDep.version = version;
+			sub.depsTail = nextDep;
+			return;
+		}
+		const prevSub = dep.subsTail;
+		if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) return;
+		const newLink = sub.depsTail = dep.subsTail = {
+			version,
+			dep,
+			sub,
+			prevDep,
+			nextDep,
+			prevSub,
+			nextSub: void 0
+		};
+		if (nextDep !== void 0) nextDep.prevDep = newLink;
+		if (prevDep !== void 0) prevDep.nextDep = newLink;
+		else sub.deps = newLink;
+		if (prevSub !== void 0) prevSub.nextSub = newLink;
+		else dep.subs = newLink;
+	}
+	/**
+	* Removes a link from both the dep-chain and the sub-chain.
+	*
+	* If removing the link leaves the dep with **no remaining subscribers**,
+	* {@link unwatched} is called on the dep so the caller can decide whether to
+	* stop tracking it.
+	*
+	* @param link - The edge to remove.
+	* @param sub  - The subscriber owning the dep-chain (defaults to `link.sub`).
+	* @returns The next link in the subscriber's dep-chain, or `undefined`.
+	*/
+	function unlink(link, sub = link.sub) {
+		const dep = link.dep;
+		const prevDep = link.prevDep;
+		const nextDep = link.nextDep;
+		const nextSub = link.nextSub;
+		const prevSub = link.prevSub;
+		if (nextDep !== void 0) nextDep.prevDep = prevDep;
+		else sub.depsTail = prevDep;
+		if (prevDep !== void 0) prevDep.nextDep = nextDep;
+		else sub.deps = nextDep;
+		if (nextSub !== void 0) nextSub.prevSub = prevSub;
+		else dep.subsTail = prevSub;
+		if (prevSub !== void 0) prevSub.nextSub = nextSub;
+		else if ((dep.subs = nextSub) === void 0) unwatched(dep);
+		return nextDep;
+	}
+	/**
+	* Performs a **deep, push-based** propagation starting from `link`.
+	*
+	* Traverses the subscriber graph breadth-first (using an explicit stack to
+	* avoid call-stack overflows on deep graphs), marking each reachable node:
+	*
+	* - Watching nodes (effects) are passed to {@link notify}.
+	* - Mutable nodes (computeds) are traversed further so their subscribers are
+	*   also marked.
+	* - Already-dirty or recursed nodes are handled conservatively to avoid
+	*   duplicate notifications.
+	*
+	* @param link - The first subscriber link from which propagation begins.
+	*/
+	function propagate(link) {
+		let next = link.nextSub;
+		let stack;
+		top: do {
+			const sub = link.sub;
+			let flags = sub.flags;
+			if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed | ReactiveFlags.Dirty | ReactiveFlags.Pending))) sub.flags = flags | ReactiveFlags.Pending;
+			else if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed))) flags = ReactiveFlags.None;
+			else if (!(flags & ReactiveFlags.RecursedCheck)) sub.flags = flags & ~ReactiveFlags.Recursed | ReactiveFlags.Pending;
+			else if (!(flags & (ReactiveFlags.Dirty | ReactiveFlags.Pending)) && isValidLink(link, sub)) {
+				sub.flags = flags | (ReactiveFlags.Recursed | ReactiveFlags.Pending);
+				flags &= ReactiveFlags.Mutable;
+			} else flags = ReactiveFlags.None;
+			if (flags & ReactiveFlags.Watching) notify(sub);
+			if (flags & ReactiveFlags.Mutable) {
+				const subSubs = sub.subs;
+				if (subSubs !== void 0) {
+					const nextSub = (link = subSubs).nextSub;
+					if (nextSub !== void 0) {
+						stack = {
+							value: next,
+							prev: stack
+						};
+						next = nextSub;
+					}
+					continue;
+				}
+			}
+			if ((link = next) !== void 0) {
+				next = link.nextSub;
+				continue;
+			}
+			while (stack !== void 0) {
+				link = stack.value;
+				stack = stack.prev;
+				if (link !== void 0) {
+					next = link.nextSub;
+					continue top;
+				}
+			}
+			break;
+		} while (true);
+	}
+	/**
+	* **Pull-based** dirty check: walks up the dep graph from `sub` to determine
+	* whether any ancestor signal has actually changed.
+	*
+	* This is the "lazy" half of the push-pull model.  After `propagate` marks a
+	* computed as `Pending`, `checkDirty` is called before the computed is read
+	* to decide whether a full recompute is warranted.  It short-circuits as soon
+	* as it confirms the node is dirty (or clean).
+	*
+	* @param link - First dep link of the node being checked.
+	* @param sub  - The node whose dirtiness is in question.
+	* @returns `true` if the node must recompute, `false` if it is still clean.
+	*/
+	function checkDirty(link, sub) {
+		let stack;
+		let checkDepth = 0;
+		let dirty = false;
+		top: do {
+			const dep = link.dep;
+			const flags = dep.flags;
+			if (sub.flags & ReactiveFlags.Dirty) dirty = true;
+			else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) === (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) {
+				if (update(dep)) {
+					const subs = dep.subs;
+					if (subs.nextSub !== void 0) shallowPropagate(subs);
+					dirty = true;
+				}
+			} else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Pending)) === (ReactiveFlags.Mutable | ReactiveFlags.Pending)) {
+				if (link.nextSub !== void 0 || link.prevSub !== void 0) stack = {
+					value: link,
+					prev: stack
+				};
+				link = dep.deps;
+				sub = dep;
+				++checkDepth;
+				continue;
+			}
+			if (!dirty) {
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue;
+				}
+			}
+			while (checkDepth--) {
+				const firstSub = sub.subs;
+				const hasMultipleSubs = firstSub.nextSub !== void 0;
+				if (hasMultipleSubs) {
+					link = stack.value;
+					stack = stack.prev;
+				} else link = firstSub;
+				if (dirty) {
+					if (update(sub)) {
+						if (hasMultipleSubs) shallowPropagate(firstSub);
+						sub = link.sub;
+						continue;
+					}
+					dirty = false;
+				} else sub.flags &= ~ReactiveFlags.Pending;
+				sub = link.sub;
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue top;
+				}
+			}
+			return dirty;
+		} while (true);
+	}
+	/**
+	* Marks all direct subscribers of `link` as `Dirty` (if they were only
+	* `Pending`) and notifies any Watching subscribers.
+	*
+	* Used after a computed node is found to have changed during `checkDirty`, to
+	* eagerly mark its immediate subscribers without recursing into the full graph.
+	*
+	* @param link - The first subscriber link of the changed computed.
+	*/
+	function shallowPropagate(link) {
+		do {
+			const sub = link.sub;
+			const flags = sub.flags;
+			if ((flags & (ReactiveFlags.Pending | ReactiveFlags.Dirty)) === ReactiveFlags.Pending) {
+				sub.flags = flags | ReactiveFlags.Dirty;
+				if ((flags & (ReactiveFlags.Watching | ReactiveFlags.RecursedCheck)) === ReactiveFlags.Watching) notify(sub);
+			}
+		} while ((link = link.nextSub) !== void 0);
+	}
+	/**
+	* Returns `true` if `checkLink` is still present in `sub`'s current dep-chain.
+	*
+	* Used during propagation to verify that a link is valid for a recursed node
+	* before upgrading its flags to `Recursed | Pending`.
+	*
+	* @internal
+	*/
+	function isValidLink(checkLink, sub) {
+		let link = sub.depsTail;
+		while (link !== void 0) {
+			if (link === checkLink) return true;
+			link = link.prevDep;
+		}
+		return false;
+	}
+}
+//#endregion
+//#region src/signals/lib.ts
+/**
+* @module signals
+*
+* High-level reactive primitives built on top of the low-level graph engine in
+* `./system`.
+*
+* The API surface intentionally mirrors alien-signals but extends it with
+* first-class **cleanup support** via {@link onCleanup}.
+*
+* ### Primitives
+* | Export | Role |
+* |--------|------|
+* | {@link signal}      | Mutable reactive value. |
+* | {@link computed}    | Derived, lazily-evaluated value. |
+* | {@link effect}      | Side-effect that re-runs when its deps change. |
+* | {@link effectScope} | Ownership scope that groups and disposes nested effects together. |
+* | {@link onCleanup}   | Register a teardown callback inside the currently running effect. |
+* | {@link batch}       | Defer flush until all synchronous mutations are done. |
+* | {@link untracked}   | Read signals without creating dependency links. |
+* | {@link trigger}     | Manually re-trigger subscribers of signals read inside `fn`. |
+*
+* ### Cleanup model
+* `onCleanup(fn)` registers a callback that fires:
+* 1. **Before each re-run** – so resources set up in the previous run are torn
+*    down before the effect body executes again.
+* 2. **On disposal** – whether the effect is stopped explicitly (calling the
+*    handle returned by `effect()`) or implicitly (an owning `effectScope` is
+*    disposed, cascading through all nested effects).
+*
+* Because `onCleanup` reads `activeSub` (the same module-level variable that
+* signals use for dependency tracking), it works correctly when called from
+* deeply nested helper functions during effect execution – no prop-drilling
+* required.
+*/
+/** Monotonically increasing counter; incremented on each tracking run to stamp links. */
+let cycle = 0;
+/** Depth counter for nested `batch` calls; flush is deferred while > 0. */
+let batchDepth = 0;
+/** Read cursor into the `queued` array during flush. */
+let notifyIndex = 0;
+/** Write cursor into the `queued` array (logical length of the queue). */
+let queuedLength = 0;
+/**
+* The currently executing subscriber (effect, computed, or effectScope).
+* Signals read while `activeSub !== undefined` automatically register a dep
+* link back to this node.
+*/
+let activeSub;
+/** Ring-buffer of effects waiting to be flushed. */
+const queued = [];
+const { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
+	update(node) {
+		if (node.depsTail !== void 0) return updateComputed(node);
+		else return updateSignal(node);
+	},
+	notify(effect) {
+		let insertIndex = queuedLength;
+		let firstInsertedIndex = insertIndex;
+		do {
+			queued[insertIndex++] = effect;
+			effect.flags &= ~ReactiveFlags.Watching;
+			effect = effect.subs?.sub;
+			if (effect === void 0 || !(effect.flags & ReactiveFlags.Watching)) break;
+		} while (true);
+		queuedLength = insertIndex;
+		while (firstInsertedIndex < --insertIndex) {
+			const left = queued[firstInsertedIndex];
+			queued[firstInsertedIndex++] = queued[insertIndex];
+			queued[insertIndex] = left;
+		}
+	},
+	unwatched(node) {
+		if (!(node.flags & ReactiveFlags.Mutable)) effectScopeOper.call(node);
+		else if (node.depsTail !== void 0) {
+			node.depsTail = void 0;
+			node.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
+			purgeDeps(node);
+		}
+	}
+});
+/**
+* Replaces the active subscriber with `sub` and returns the previous value.
+*
+* Always restore the previous value in a `finally` block:
+*
+* ```ts
+* const prev = setActiveSub(myNode);
+* try { ... } finally { setActiveSub(prev); }
+* ```
+*/
+function setActiveSub(sub) {
+	const prevSub = activeSub;
+	activeSub = sub;
+	return prevSub;
+}
+/**
+* Increments the batch depth, deferring effect flush until `endBatch` is
+* called a matching number of times.
+*
+* Prefer {@link batch} over calling `startBatch` / `endBatch` directly.
+*/
+function startBatch() {
+	++batchDepth;
+}
+/**
+* Decrements the batch depth and flushes the effect queue when the depth
+* reaches zero.
+*
+* Prefer {@link batch} over calling `startBatch` / `endBatch` directly.
+*/
+function endBatch() {
+	if (!--batchDepth) flush();
+}
+/**
+* Returns `true` if `fn` is a signal handle created by {@link signal}.
+*
+* Relies on `Function.name` matching the internal `signalOper` function name.
+*/
+function isSignal(fn) {
+	return fn.name === "bound " + signalOper.name;
+}
+/**
+* Returns `true` if `fn` is a computed handle created by {@link computed}.
+*
+* Relies on `Function.name` matching the internal `computedOper` function name.
+*/
+function isComputed(fn) {
+	return fn.name === "bound " + computedOper.name;
+}
+/**
+* Returns `true` if `fn` is an effect cleanup handle created by {@link effect}.
+*
+* Relies on `Function.name` matching the internal `effectOper` function name.
+*/
+function isEffect(fn) {
+	return fn.name === "bound " + effectOper.name;
+}
+/**
+* Returns `true` if `fn` is an effectScope cleanup handle created by
+* {@link effectScope}.
+*
+* Relies on `Function.name` matching the internal `effectScopeOper` function name.
+*/
+function isEffectScope(fn) {
+	return fn.name === "bound " + effectScopeOper.name;
+}
+function signal(initialValue) {
+	return signalOper.bind({
+		currentValue: initialValue,
+		pendingValue: initialValue,
+		subs: void 0,
+		subsTail: void 0,
+		flags: ReactiveFlags.Mutable
+	});
+}
+/**
+* Creates a lazily-evaluated computed value.
+*
+* The `getter` is only called when the computed value is read **and** one of
+* its dependencies has changed since the last evaluation.  If nothing has
+* changed the cached `value` is returned without re-running `getter`.
+*
+* Computed values are read-only; they cannot be set directly.
+*
+* @param getter - Pure function deriving a value from other reactive sources.
+*                 Receives the previous value as an optional optimisation hint.
+*
+* @example
+* ```ts
+* const a = signal(1);
+* const b = signal(2);
+* const sum = computed(() => a() + b());
+*
+* sum(); // → 3
+* a(10);
+* sum(); // → 12  (re-evaluated lazily)
+* ```
+*/
+function computed(getter) {
+	return computedOper.bind({
+		value: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: ReactiveFlags.None,
+		getter
+	});
+}
+/**
+* Creates a reactive side-effect that runs immediately and re-runs whenever
+* any signal or computed it read during its last execution changes.
+*
+* Use {@link onCleanup} inside `fn` to register teardown logic that runs
+* before each re-execution and on final disposal.
+*
+* If `effect` is called inside an `effectScope` or another `effect`, the
+* new effect is automatically owned by the outer scope and will be disposed
+* when the scope is disposed.
+*
+* @param fn - The side-effect body.  Reactive reads inside this function
+*             establish dependency links.
+* @returns A disposal function.  Call it to stop the effect and run any
+*          registered cleanup.
+*
+* @example
+* ```ts
+* const url = signal('/api/data');
+*
+* const stop = effect(() => {
+*   const controller = new AbortController();
+*   fetch(url(), { signal: controller.signal });
+*   onCleanup(() => controller.abort());
+* });
+*
+* url('/api/other'); // previous fetch is aborted, new one starts
+* stop();            // final cleanup: abort the last fetch
+* ```
+*/
+function effect(fn) {
+	const e = {
+		fn,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck
+	};
+	const prevSub = setActiveSub(e);
+	if (prevSub !== void 0) link(e, prevSub, 0);
+	try {
+		e.fn();
+	} finally {
+		activeSub = prevSub;
+		e.flags &= ~ReactiveFlags.RecursedCheck;
+	}
+	return effectOper.bind(e);
+}
+/**
+* Creates an ownership scope that groups reactive effects so they can all be
+* disposed at once.
+*
+* Effects and nested scopes created inside `fn` are linked to this scope.
+* When the returned disposal function is called, all owned effects are stopped
+* in cascade – triggering their registered {@link onCleanup} callbacks – and
+* the scope itself is removed from any parent scope that owns it.
+*
+* @param fn - Synchronous setup function.  Create effects and nested scopes
+*             here.
+* @returns A disposal function that tears down all owned effects and the scope
+*          itself.
+*
+* @example
+* ```ts
+* const stopAll = effectScope(() => {
+*   effect(() => console.log('a:', a()));
+*   effect(() => console.log('b:', b()));
+* });
+*
+* stopAll(); // both effects stopped simultaneously
+* ```
+*/
+function effectScope(fn) {
+	const e = {
+		deps: void 0,
+		depsTail: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		flags: ReactiveFlags.None
+	};
+	const prevSub = setActiveSub(e);
+	if (prevSub !== void 0) link(e, prevSub, 0);
+	try {
+		fn();
+	} finally {
+		activeSub = prevSub;
+	}
+	return effectScopeOper.bind(e);
+}
+/**
+* Registers a cleanup callback for the currently executing effect or scope.
+*
+* The callback will be called:
+* 1. **Before the next re-run** of the enclosing effect (so resources from
+*    the previous run are released before the new run sets them up again).
+* 2. **On final disposal** of the effect, whether triggered explicitly by
+*    calling the effect's cleanup handle or implicitly by an owning
+*    `effectScope` being disposed.
+*
+* Calling `onCleanup` outside of a tracking context (no active effect) is a
+* no-op; it does **not** throw.
+*
+* Only one cleanup function per effect run is supported.  Calling `onCleanup`
+* multiple times within the same run overwrites the previous registration.
+*
+* @param fn - The teardown callback.
+*
+* @example
+* ```ts
+* effect(() => {
+*   const id = setInterval(() => tick(), 1000);
+*   onCleanup(() => clearInterval(id));
+* });
+* ```
+*
+* @example Composable helper – no prop-drilling needed:
+* ```ts
+* function useEventListener(target: EventTarget, type: string, handler: EventListener) {
+*   target.addEventListener(type, handler);
+*   onCleanup(() => target.removeEventListener(type, handler));
+* }
+*
+* effect(() => {
+*   useEventListener(window, 'resize', onResize);
+* });
+* ```
+*/
+function onCleanup(fn) {
+	if (activeSub !== void 0) activeSub.onCleanup = fn;
+}
+/**
+* Runs `fn` as a single atomic update: all signal writes inside `fn` are
+* collected and effects are flushed only once after `fn` returns, rather than
+* after each individual write.
+*
+* Batches can be nested; the flush only occurs when the outermost batch
+* completes.
+*
+* @example
+* ```ts
+* batch(() => {
+*   x(1);
+*   y(2);
+*   z(3);
+* }); // effects that depend on x, y, or z run once here
+* ```
+*/
+function batch(fn) {
+	startBatch();
+	try {
+		fn();
+	} finally {
+		endBatch();
+	}
+}
+/**
+* Executes `fn` in a non-tracking context: any signals read inside `fn` do
+* **not** create dependency links on the currently active subscriber.
+*
+* Useful when you need to read a signal's current value without subscribing to
+* future changes.
+*
+* @returns The value returned by `fn`.
+*
+* @example
+* ```ts
+* const logCount = effect(() => {
+*   console.log('triggered by a:', a());
+*   // read b without subscribing – effect won't re-run when b changes
+*   console.log('current b:', untracked(() => b()));
+* });
+* ```
+*/
+function untracked(fn) {
+	const prev = setActiveSub(void 0);
+	try {
+		return fn();
+	} finally {
+		setActiveSub(prev);
+	}
+}
+/**
+* Manually triggers all subscribers of every signal read inside `fn`.
+*
+* Unlike writing to a signal, `trigger` does not change the signal's value; it
+* only forces downstream effects and computeds to re-evaluate.
+*
+* @param fn - Function whose reactive reads identify the signals to trigger.
+*
+* @example
+* ```ts
+* const items = signal([1, 2, 3]);
+*
+* // Mutate in place (referential equality won't detect the change):
+* items().push(4);
+* trigger(() => items()); // manually notify subscribers
+* ```
+*/
+function trigger(fn) {
+	const sub = {
+		deps: void 0,
+		depsTail: void 0,
+		flags: ReactiveFlags.Watching
+	};
+	const prevSub = setActiveSub(sub);
+	try {
+		fn();
+	} finally {
+		activeSub = prevSub;
+		let link = sub.deps;
+		while (link !== void 0) {
+			const dep = link.dep;
+			link = unlink(link, sub);
+			const subs = dep.subs;
+			if (subs !== void 0) {
+				sub.flags = ReactiveFlags.None;
+				propagate(subs);
+				shallowPropagate(subs);
+			}
+		}
+		if (!batchDepth) flush();
+	}
+}
+/**
+* Recomputes a computed node and returns whether its value changed.
+* Called by the graph engine's `update` callback and by `computedOper` itself.
+* @internal
+*/
+function updateComputed(c) {
+	++cycle;
+	c.depsTail = void 0;
+	c.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;
+	const prevSub = setActiveSub(c);
+	try {
+		const oldValue = c.value;
+		return oldValue !== (c.value = c.getter(oldValue));
+	} finally {
+		activeSub = prevSub;
+		c.flags &= ~ReactiveFlags.RecursedCheck;
+		purgeDeps(c);
+	}
+}
+/**
+* Commits a signal's pending value to its current value.
+* Returns `true` if the value actually changed.
+* @internal
+*/
+function updateSignal(s) {
+	s.flags = ReactiveFlags.Mutable;
+	return s.currentValue !== (s.currentValue = s.pendingValue);
+}
+/**
+* Executes an effect node if it is dirty or pending-dirty.
+*
+* Before re-running the effect body, any cleanup registered during the
+* previous run is called and cleared.
+*
+* @internal
+*/
+function run(e) {
+	const flags = e.flags;
+	if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(e.deps, e)) {
+		++cycle;
+		if (e.onCleanup !== void 0) {
+			const cleanup = e.onCleanup;
+			e.onCleanup = void 0;
+			cleanup();
+		}
+		e.depsTail = void 0;
+		e.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
+		const prevSub = setActiveSub(e);
+		try {
+			e.fn();
+		} finally {
+			activeSub = prevSub;
+			e.flags &= ~ReactiveFlags.RecursedCheck;
+			purgeDeps(e);
+		}
+	} else e.flags = ReactiveFlags.Watching;
+}
+/**
+* Drains the queued-effects array, running each effect in order.
+*
+* If an effect throws, remaining effects are marked `Recursed | Watching` (so
+* they will retry next time) and the scheduler resets cleanly.
+*
+* @internal
+*/
+function flush() {
+	try {
+		while (notifyIndex < queuedLength) {
+			const effect = queued[notifyIndex];
+			queued[notifyIndex++] = void 0;
+			run(effect);
+		}
+	} finally {
+		while (notifyIndex < queuedLength) {
+			const effect = queued[notifyIndex];
+			queued[notifyIndex++] = void 0;
+			effect.flags |= ReactiveFlags.Watching | ReactiveFlags.Recursed;
+		}
+		notifyIndex = 0;
+		queuedLength = 0;
+	}
+}
+/**
+* The bound operation function for computed nodes.
+*
+* On read:
+* 1. Checks whether the node is dirty (or pending-dirty via `checkDirty`).
+* 2. Recomputes via `updateComputed` if needed, propagating to subscribers if
+*    the value changed.
+* 3. Links `this` to the current `activeSub` so future writes propagate here.
+*
+* @internal
+*/
+function computedOper() {
+	const flags = this.flags;
+	if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && (checkDirty(this.deps, this) || (this.flags = flags & ~ReactiveFlags.Pending, false))) {
+		if (updateComputed(this)) {
+			const subs = this.subs;
+			if (subs !== void 0) shallowPropagate(subs);
+		}
+	} else if (!flags) {
+		this.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;
+		const prevSub = setActiveSub(this);
+		try {
+			this.value = this.getter();
+		} finally {
+			activeSub = prevSub;
+			this.flags &= ~ReactiveFlags.RecursedCheck;
+		}
+	}
+	const sub = activeSub;
+	if (sub !== void 0) link(this, sub, cycle);
+	return this.value;
+}
+/**
+* The bound operation function for signal nodes.
+*
+* - **Read** (no arguments): registers a dep link and returns `currentValue`.
+*   If the signal is dirty (pending write flushed by batch), commits the
+*   pending value first.
+* - **Write** (one argument): stages the new value as `pendingValue` and, if
+*   it differs from the current pending value, propagates dirtiness and
+*   schedules a flush.
+*
+* @internal
+*/
+function signalOper(...value) {
+	if (value.length) {
+		if (this.pendingValue !== (this.pendingValue = value[0])) {
+			this.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
+			const subs = this.subs;
+			if (subs !== void 0) {
+				propagate(subs);
+				if (!batchDepth) flush();
+			}
+		}
+	} else {
+		if (this.flags & ReactiveFlags.Dirty) {
+			if (updateSignal(this)) {
+				const subs = this.subs;
+				if (subs !== void 0) shallowPropagate(subs);
+			}
+		}
+		let sub = activeSub;
+		while (sub !== void 0) {
+			if (sub.flags & (ReactiveFlags.Mutable | ReactiveFlags.Watching)) {
+				link(this, sub, cycle);
+				break;
+			}
+			sub = sub.subs?.sub;
+		}
+		return this.currentValue;
+	}
+}
+/**
+* The bound disposal function for effect nodes.
+*
+* Calls the cleanup registered by the last run of the effect body (if any),
+* then delegates to `effectScopeOper` to release all dep links and unlink
+* the effect from any parent scope.
+*
+* @internal
+*/
+function effectOper() {
+	if (this.onCleanup !== void 0) {
+		const cleanup = this.onCleanup;
+		this.onCleanup = void 0;
+		cleanup();
+	}
+	effectScopeOper.call(this);
+}
+/**
+* The shared disposal implementation for both effect nodes and effectScope
+* nodes.
+*
+* For effect nodes this is also called indirectly via the `unwatched` callback
+* when the owning scope is disposed, triggering cleanup cascades through the
+* entire ownership tree.
+*
+* Steps:
+* 1. Call and clear any registered `onCleanup` (handles cascade disposal where
+*    `effectOper` is not called directly).
+* 2. Reset `depsTail` and `flags` so the node is inert.
+* 3. Purge all dep links (which may recursively trigger `unwatched` on
+*    nested effects).
+* 4. Unlink from any parent scope's sub-chain.
+*
+* @internal
+*/
+function effectScopeOper() {
+	const cleanup = this.onCleanup;
+	if (cleanup !== void 0) {
+		this.onCleanup = void 0;
+		cleanup();
+	}
+	this.depsTail = void 0;
+	this.flags = ReactiveFlags.None;
+	purgeDeps(this);
+	const sub = this.subs;
+	if (sub !== void 0) unlink(sub);
+}
+/**
+* Removes all dep links from `sub` that were not refreshed during the most
+* recent tracking run (i.e. stale links appended after `depsTail`).
+*
+* Called at the end of each tracking run (`updateComputed`, `run`) to prune
+* dependencies that the node no longer reads.
+*
+* @internal
+*/
+function purgeDeps(sub) {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink(dep, sub);
+}
+//#endregion
+//#region src/polyfill.ts
+if (!Symbol.dispose) Object.defineProperty(Symbol, "dispose", { value: Symbol("dispose") });
+//#endregion
+//#region src/signals/index.ts
+function isReactive(value) {
+	return isSignal(value) || isComputed(value);
+}
+/**
+* A decorator that makes a class field reactive by automatically wrapping its value in a signal.
+*
+* The field behaves like a normal property (get/set) but reactivity is tracked under the hood.
+* Any reads will subscribe to the signal and any writes will trigger updates.
+*
+* @example
+* ```ts
+* class Counter {
+*   @reactive()
+*   count: number = 0;
+* }
+*
+* const counter = new Counter();
+* counter.count++;        // Triggers reactivity
+* console.log(counter.count); // Subscribes to changes
+* ```
+*
+* @remarks
+* Equivalent to manually creating a private signal and getter/setter:
+* ```ts
+* class Counter {
+*   #count = signal(0);
+*   get count() { return this.#count(); }
+*   set count(value) { this.#count(value); }
+* }
+* ```
+*/
+function reactive(source) {
+	const signalStore = /* @__PURE__ */ new WeakMap();
+	return (_target, context) => {
+		context.addInitializer(function() {
+			const sig = signalStore.get(this);
+			const writable = !isComputed(sig);
+			Object.defineProperty(this, context.name, {
+				get() {
+					return sig();
+				},
+				...writable && { set(value) {
+					sig(value);
+				} },
+				enumerable: true,
+				configurable: true
+			});
+		});
+		return function(initialValue) {
+			signalStore.set(this, source ? source(this) : signal(initialValue));
+			return initialValue;
+		};
+	};
+}
+//#endregion
+export { effect as a, isEffect as c, onCleanup as d, signal as f, computed as i, isEffectScope as l, untracked as m, reactive as n, effectScope as o, trigger as p, batch as r, isComputed as s, isReactive as t, isSignal as u };