@vielzeug/ripple 1.2.3 → 2.0.0

package/dist/effect.js

@@ -1,173 +0,0 @@
-import { getDevToolsHook as e } from "./devtools-hook.js";
-import { collectErrors as t, rethrowWith as n, runAll as r } from "./_error-utils.js";
-import { RippleDisposedScopeError as i, RippleInfiniteLoopError as a, RippleInvalidCleanupError as o } from "./errors.js";
-import { getScopeCleanups as s, getTracking as c, withScopeCleanups as l, withTracking as u } from "./tracking.js";
-import "./scheduling.js";
-import { AsyncSubscriptionImpl as d, SubscriptionImpl as f } from "./subscription.js";
-import { IS_COMPUTED as p } from "./symbols.js";
-//#region src/effect.ts
-var m = (e, t) => {
-	if (t === "sync" || t === void 0) return e;
-	let n = !1;
-	return () => {
-		n || (n = !0, queueMicrotask(() => {
-			n = !1, e();
-		}));
-	};
-}, h = (i, c) => {
-	let l = c?.scheduler ?? "sync", d = c?.name, h = [], g = /* @__PURE__ */ new Set(), _ = /* @__PURE__ */ new Map(), v = !1, y = !1, b = !1, x = () => {
-		if (_.clear(), h.length === 0 && g.size === 0) return;
-		let e = [...h, ...g];
-		h.length = 0, g.clear(), r(e, "effect teardown errors");
-	}, S = () => {
-		if (!b) {
-			if (v) {
-				y = !0;
-				return;
-			}
-			v = !0;
-			try {
-				let r = 0;
-				do {
-					if (++r > 100) throw new a(`infinite effect loop (> 100 iterations)${d ? ` in "${d}"` : ""}`);
-					y = !1, x(), e()?.run?.({ name: d });
-					let s;
-					try {
-						s = u({
-							cleanups: h,
-							deps: _,
-							effect: C,
-							kind: "effect",
-							subscriptions: g
-						}, i);
-					} catch (e) {
-						let r = [...t(g), ...t(h)];
-						h.length = 0, g.clear(), n(e, r, "effect failure with cleanup errors");
-					}
-					if (s !== void 0 && typeof s != "function") throw new o(`effect() returned ${typeof s} — expected a cleanup function or void.`);
-					typeof s == "function" && h.push(s);
-				} while (y && !b);
-			} finally {
-				v = !1;
-			}
-		}
-	}, C = m(S, l);
-	S();
-	let w = new f(() => {
-		b || (b = !0, x(), e()?.dispose?.({
-			kind: "effect",
-			name: d
-		}));
-	});
-	return s()?.push(() => w.dispose()), {
-		dispose: () => w.dispose(),
-		get disposed() {
-			return w.disposed;
-		},
-		getDependencies() {
-			return [..._.keys()].map((e) => ({
-				kind: p in e ? "computed" : "signal",
-				name: e.name
-			}));
-		},
-		[Symbol.dispose]() {
-			w.dispose();
-		}
-	};
-}, g = (e, t) => {
-	let n = null, r = null, i = null, a = t?.onError ?? ((e) => {
-		queueMicrotask(() => {
-			throw e;
-		});
-	});
-	return new d(h(() => {
-		n?.abort(), r?.(), r = null, n = new AbortController();
-		let { signal: t } = n, o = v(), s;
-		return i = s = (async () => {
-			try {
-				let n = await e(t, o);
-				typeof n == "function" && (t.aborted ? n() : r = n);
-			} catch (e) {
-				t.aborted || a(e);
-			} finally {
-				o.dispose(), i === s && (i = null);
-			}
-		})(), () => {
-			n?.abort(), r?.(), r = null;
-		};
-	}, { name: t?.name }), async () => {
-		let e = i;
-		e && await e;
-	}, () => i);
-}, _ = (e) => {
-	let t = c();
-	if (t?.kind === "effect") {
-		t.cleanups.push(e);
-		return;
-	}
-	let n = s();
-	if (n !== null) {
-		n.push(e);
-		return;
-	}
-	throw new o("onCleanup() must be called from within an active effect or scope.");
-}, v = (e) => {
-	let t = [], n = new AbortController(), a = !1, o = (e) => {
-		if (a) throw new i("Cannot register cleanup on a disposed scope.");
-		t.push(e);
-	}, s = (e) => {
-		if (a) throw new i("Cannot run inside a disposed scope.");
-		return l(t, e);
-	}, c = () => {
-		a || (a = !0, n.abort(), r([...t].reverse(), "scope cleanup errors"), t.length = 0);
-	}, u = {
-		add: o,
-		get disposalSignal() {
-			return n.signal;
-		},
-		dispose: c,
-		get disposed() {
-			return a;
-		},
-		run: s,
-		[Symbol.dispose]: c
-	};
-	return e && s(e), u;
-};
-function y(e, t, n) {
-	let r = n?.equals ?? Object.is, i, a = (e, n) => {
-		i?.(), i = void 0;
-		let r = t(e, n);
-		if (r !== void 0 && typeof r != "function") throw new o(`watch() callback returned ${typeof r} — expected a cleanup function or void.`);
-		typeof r == "function" && (i = r);
-	}, c;
-	if (typeof e == "function") {
-		let t, o = !0, s = h(() => {
-			let i = e();
-			if (o) {
-				o = !1, t = i;
-				return;
-			}
-			if (!r(t, i)) {
-				let e = t;
-				t = i, a(i, e), n?.once && c.dispose();
-			}
-		}, { name: n?.name });
-		c = new f(() => {
-			i?.(), i = void 0, s.dispose();
-		}), n?.immediate && (a(t, void 0), n.once && c.dispose());
-	} else {
-		let t = e.peek(), o = e.subscribe(() => {
-			let i = e.peek();
-			r(t, i) || (a(i, t), t = i, n?.once && c.dispose());
-		});
-		c = new f(() => {
-			i?.(), i = void 0, o.dispose();
-		}), n?.immediate && (a(t, void 0), n.once && c.dispose());
-	}
-	return s()?.push(() => c.dispose()), c;
-}
-//#endregion
-export { h as effect, g as effectAsync, _ as onCleanup, v as scope, y as watch };
-
-//# sourceMappingURL=effect.js.map

package/dist/effect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect.js","names":[],"sources":["../src/effect.ts"],"sourcesContent":["import type { ReactiveBase } from './reactive-base';\nimport type {\n  AsyncEffectCallback,\n  AsyncSubscription,\n  CleanupFn,\n  DepInfo,\n  EffectAsyncOptions,\n  EffectCallback,\n  EffectHandle,\n  EffectOptions,\n  EqualityFn,\n  Readable,\n  Scope,\n  Subscriber,\n  Subscription,\n  WatchOptions,\n} from './types';\n\nimport { collectErrors, rethrowWith, runAll } from './_error-utils';\nimport { getDevToolsHook } from './devtools-hook';\nimport { RippleDisposedScopeError, RippleInfiniteLoopError, RippleInvalidCleanupError } from './errors';\nimport { DEFAULT_MAX_ITERATIONS } from './scheduling';\nimport { AsyncSubscriptionImpl, SubscriptionImpl } from './subscription';\nimport { IS_COMPUTED } from './symbols';\nimport { getScopeCleanups, getTracking, withScopeCleanups, withTracking } from './tracking';\n\n/**\n * Wraps a core `run` function with a microtask-based scheduler that coalesces rapid re-runs.\n * The `subscriber` returned here is what gets registered in signal subscriber sets —\n * so notifications call the deferred wrapper, not `run` directly.\n *\n * The scheduler identity is stable for the lifetime of the effect.\n * Never replace `subscriber` with a new function after creation — doing so would break\n * the removeEffectSub calls that rely on reference identity.\n */\nconst withScheduler = (run: Subscriber, scheduler: EffectOptions['scheduler']): Subscriber => {\n  if (scheduler === 'sync' || scheduler === undefined) return run;\n\n  // 'microtask'\n  let scheduled = false;\n\n  return (): void => {\n    if (scheduled) return;\n\n    scheduled = true;\n    queueMicrotask(() => {\n      scheduled = false;\n      run();\n    });\n  };\n};\n\n/**\n * Creates a reactive side-effect.\n * Runs immediately, re-runs whenever tracked dependencies change.\n * The callback may return a cleanup function that runs before the next re-run and on dispose.\n *\n * @example\n * ```ts\n * const stop = effect(() => {\n *   document.title = count.value.toString();\n *   return () => { document.title = ''; }; // optional cleanup\n * });\n *\n * stop.dispose(); // or: using stop = effect(...)\n * console.log(stop.getDependencies()); // reactive graph introspection\n * ```\n */\nexport const effect = (fn: EffectCallback, options?: EffectOptions): EffectHandle => {\n  const scheduler = options?.scheduler ?? 'sync';\n  const effectName = options?.name;\n\n  const runCleanups: CleanupFn[] = [];\n  const subscriptions = new Set<CleanupFn>();\n  const currentDeps = new Map<ReactiveBase<unknown>, number>();\n  let isRunning = false;\n  let isDirty = false;\n  let isDisposed = false;\n\n  const teardown = (): void => {\n    currentDeps.clear();\n\n    if (runCleanups.length === 0 && subscriptions.size === 0) return;\n\n    const toRun = [...runCleanups, ...subscriptions];\n\n    runCleanups.length = 0;\n    subscriptions.clear();\n\n    runAll(toRun, 'effect teardown errors');\n  };\n\n  // The inner do-while handles self-cascade: when the effect body writes to a signal it reads,\n  // the recursive flush sets isDirty via the isRunning guard.\n  const run: Subscriber = (): void => {\n    if (isDisposed) return;\n\n    if (isRunning) {\n      isDirty = true;\n\n      return;\n    }\n\n    isRunning = true;\n\n    try {\n      let iterations = 0;\n\n      do {\n        if (++iterations > DEFAULT_MAX_ITERATIONS) {\n          const label = effectName ? ` in \"${effectName}\"` : '';\n\n          throw new RippleInfiniteLoopError(`infinite effect loop (> ${DEFAULT_MAX_ITERATIONS} iterations)${label}`);\n        }\n\n        isDirty = false;\n        teardown();\n\n        getDevToolsHook()?.run?.({ name: effectName });\n\n        let returnedCleanup: CleanupFn | void = undefined;\n\n        try {\n          returnedCleanup = withTracking(\n            { cleanups: runCleanups, deps: currentDeps, effect: subscriber, kind: 'effect', subscriptions },\n            fn,\n          );\n        } catch (error) {\n          const cleanupErrors = [...collectErrors(subscriptions), ...collectErrors(runCleanups)];\n\n          runCleanups.length = 0;\n          subscriptions.clear();\n          rethrowWith(error, cleanupErrors, 'effect failure with cleanup errors');\n        }\n\n        if (returnedCleanup !== undefined && typeof returnedCleanup !== 'function') {\n          throw new RippleInvalidCleanupError(\n            `effect() returned ${typeof returnedCleanup} — expected a cleanup function or void.`,\n          );\n        }\n\n        if (typeof returnedCleanup === 'function') runCleanups.push(returnedCleanup);\n      } while (isDirty && !isDisposed);\n    } finally {\n      isRunning = false;\n    }\n  };\n\n  // subscriber is what gets registered in signal subscriber Sets.\n  // For 'sync' it is the same as run; for deferred schedulers it's the debouncing wrapper.\n  const subscriber = withScheduler(run, scheduler);\n\n  // Always run synchronously on creation to establish initial tracking.\n  run();\n\n  const sub = new SubscriptionImpl(() => {\n    if (isDisposed) return;\n\n    isDisposed = true;\n    teardown();\n    getDevToolsHook()?.dispose?.({ kind: 'effect', name: effectName });\n  });\n\n  // Auto-register disposal into the enclosing scope (if any).\n  // Uses the separate scope stack — orthogonal to the effect/computed tracking context.\n  getScopeCleanups()?.push(() => sub.dispose());\n\n  const handle: EffectHandle = {\n    dispose: () => sub.dispose(),\n    get disposed() {\n      return sub.disposed;\n    },\n    getDependencies(): ReadonlyArray<DepInfo> {\n      return [...currentDeps.keys()].map((src) => ({\n        kind: IS_COMPUTED in (src as object) ? 'computed' : 'signal',\n        name: src.name,\n      }));\n    },\n    [Symbol.dispose]() {\n      sub.dispose();\n    },\n  };\n\n  return handle;\n};\n\n/**\n * Like `effect()`, but the callback is async and receives an AbortSignal that fires when the\n * effect re-runs or is disposed. Read reactive dependencies synchronously before the first\n * `await` to register them as tracked.\n *\n * Returns an {@link AsyncSubscription} — call `await stop[Symbol.asyncDispose]()` to await\n * full teardown, or `stop.run()` to await just the current in-flight run.\n *\n * @example\n * ```ts\n * const userId = signal('u1');\n * const stop = effectAsync(async (signal) => {\n *   const id = userId.value;            // sync dep — tracked\n *   const data = await fetchUser(id, { signal }); // aborted automatically if id changes\n *   renderUser(data);\n * });\n *\n * await stop[Symbol.asyncDispose]();\n * ```\n */\nexport const effectAsync = (fn: AsyncEffectCallback, options?: EffectAsyncOptions): AsyncSubscription => {\n  let controller: AbortController | null = null;\n  let asyncCleanup: CleanupFn | null = null;\n  let currentRunPromise: Promise<void> | null = null;\n\n  const onError =\n    options?.onError ??\n    ((err: unknown) => {\n      queueMicrotask(() => {\n        throw err;\n      });\n    });\n\n  const syncStop = effect(\n    () => {\n      controller?.abort();\n      asyncCleanup?.();\n      asyncCleanup = null;\n\n      controller = new AbortController();\n\n      const { signal } = controller;\n      const runOwner = scope(); // per-run owner scope for async body resources\n\n      let theRun!: Promise<void>;\n\n      currentRunPromise = theRun = (async () => {\n        try {\n          const returned = await fn(signal, runOwner);\n\n          if (typeof returned === 'function') {\n            if (signal.aborted) {\n              // Aborted while async fn was running — run cleanup immediately.\n              returned();\n            } else {\n              asyncCleanup = returned;\n            }\n          }\n        } catch (err) {\n          if (!signal.aborted) onError(err);\n        } finally {\n          runOwner.dispose();\n\n          if (currentRunPromise === theRun) currentRunPromise = null;\n        }\n      })();\n\n      return () => {\n        controller?.abort();\n        asyncCleanup?.();\n        asyncCleanup = null;\n      };\n    },\n    { name: options?.name },\n  );\n\n  return new AsyncSubscriptionImpl(\n    syncStop,\n    async () => {\n      const runningPromise = currentRunPromise;\n\n      if (runningPromise) await runningPromise;\n    },\n    () => currentRunPromise,\n  );\n};\n\nexport const onCleanup = (fn: CleanupFn): void => {\n  const ctx = getTracking();\n\n  if (ctx?.kind === 'effect') {\n    ctx.cleanups.push(fn);\n\n    return;\n  }\n\n  const scopeCleanups = getScopeCleanups();\n\n  if (scopeCleanups !== null) {\n    scopeCleanups.push(fn);\n\n    return;\n  }\n\n  throw new RippleInvalidCleanupError('onCleanup() must be called from within an active effect or scope.');\n};\n\n/**\n * Creates a lifecycle scope that collects `onCleanup()` registrations and runs\n * them in reverse order when `dispose()` is called.\n *\n * The optional `setup` callback is run immediately inside the scope so that\n * `onCleanup()` calls in setup are captured without requiring a separate\n * `scope.run(setup)` call.\n *\n * Use `scope.add(fn)` to explicitly register a cleanup into this scope from\n * anywhere — including from inside an effect body where `onCleanup()` would otherwise\n * go to the effect's own cleanup queue.\n *\n * @example\n * ```ts\n * const s = scope(() => {\n *   onCleanup(() => expensiveCleanup()); // captured by scope\n * });\n *\n * const stop = effect(() => {\n *   void count.value;\n *   s.add(() => doWork()); // explicit: goes to scope, not effect\n *   onCleanup(() => cheapCleanup()); // goes to effect\n * });\n *\n * // later:\n * s.dispose(); // or: using s = scope(...)\n * ```\n */\nexport const scope = (setup?: () => void): Scope => {\n  const cleanups: CleanupFn[] = [];\n  const ac = new AbortController();\n  let disposed = false;\n\n  const scopeOnCleanup = (fn: CleanupFn): void => {\n    if (disposed) throw new RippleDisposedScopeError('Cannot register cleanup on a disposed scope.');\n\n    cleanups.push(fn);\n  };\n\n  const run = <T>(fn: () => T): T => {\n    if (disposed) throw new RippleDisposedScopeError('Cannot run inside a disposed scope.');\n\n    return withScopeCleanups(cleanups, fn);\n  };\n\n  const dispose = (): void => {\n    if (disposed) return;\n\n    disposed = true;\n    ac.abort();\n    runAll([...cleanups].reverse(), 'scope cleanup errors');\n    cleanups.length = 0;\n  };\n\n  const api: Scope = {\n    add: scopeOnCleanup,\n    get disposalSignal() {\n      return ac.signal;\n    },\n    dispose,\n    get disposed() {\n      return disposed;\n    },\n    run,\n    [Symbol.dispose]: dispose,\n  };\n\n  if (setup) run(setup);\n\n  return api;\n};\n\n// ── watch() ───────────────────────────────────────────────────────────────────\n\n/**\n * Observes a reactive source and calls `callback` whenever its value changes.\n * Does NOT invoke `callback` on creation (unless `immediate: true` is passed).\n *\n * `source` may be a single `Readable<T>` (signal, computed, or store lens), or a\n * function that reads multiple reactive sources — the function form tracks every\n * dependency read inside it, like `computed()`, without needing an intermediate\n * `computed()` node.\n *\n * When called without `immediate`, `prev` is always `T` — the previous value.\n * When `immediate: true` is passed, `prev` is `T | undefined` on the first call.\n *\n * @example\n * ```ts\n * const stop = watch(count, (next, prev) => {\n *   console.log(`count changed: ${prev} → ${next}`);\n * });\n *\n * stop.dispose();\n * ```\n *\n * @example\n * ```ts\n * // Function form — tracks every signal read inside, re-runs when any changes.\n * const stopSum = watch(\n *   () => a.value + b.value,\n *   (sum, prevSum) => console.log(`sum: ${prevSum} → ${sum}`),\n * );\n *\n * stopSum.dispose();\n * ```\n */\nexport function watch<T>(\n  source: Readable<T>,\n  callback: (value: T, prev: T | undefined) => CleanupFn | void,\n  options?: WatchOptions<T>,\n): Subscription;\nexport function watch<T>(\n  source: () => T,\n  callback: (value: T, prev: T | undefined) => CleanupFn | void,\n  options?: WatchOptions<T>,\n): Subscription;\nexport function watch<T>(\n  source: Readable<T> | (() => T),\n  callback: (value: T, prev: T | undefined) => CleanupFn | void,\n  options?: WatchOptions<T>,\n): Subscription {\n  const equals: EqualityFn<T> = options?.equals ?? Object.is;\n  let pendingCleanup: CleanupFn | undefined;\n  const invokeCallback = (next: T, p: T | undefined): void => {\n    pendingCleanup?.();\n    pendingCleanup = undefined;\n\n    const returned = callback(next, p);\n\n    if (returned !== undefined && typeof returned !== 'function') {\n      throw new RippleInvalidCleanupError(\n        `watch() callback returned ${typeof returned} — expected a cleanup function or void.`,\n      );\n    }\n\n    if (typeof returned === 'function') pendingCleanup = returned;\n  };\n\n  // Declared before the subscriber/effect closures so both they and the immediate\n  // path can call watchSub.dispose() when once:true. Subscribers/effects always\n  // (re-)run after watchSub is assigned, since it's assigned synchronously right after.\n\n  let watchSub!: SubscriptionImpl;\n\n  if (typeof source === 'function') {\n    // Function form — track every dependency read inside `source` via a real effect,\n    // mirroring computed()'s dependency collection. `first` suppresses the callback\n    // on the initial (tracking-establishing) run — handled explicitly below (after\n    // watchSub exists) instead of inside this synchronous first run, since effect()\n    // runs its body immediately and watchSub isn't assigned until after it returns.\n    let prev!: T;\n    let first = true;\n\n    const stopEffect = effect(\n      () => {\n        const next = source();\n\n        if (first) {\n          first = false;\n          prev = next;\n\n          return;\n        }\n\n        if (!equals(prev, next)) {\n          const p = prev;\n\n          prev = next;\n          invokeCallback(next, p);\n\n          if (options?.once) watchSub.dispose();\n        }\n      },\n      { name: options?.name },\n    );\n\n    watchSub = new SubscriptionImpl(() => {\n      pendingCleanup?.();\n      pendingCleanup = undefined;\n      stopEffect.dispose();\n    });\n\n    if (options?.immediate) {\n      invokeCallback(prev, undefined);\n\n      if (options.once) watchSub.dispose();\n    }\n  } else {\n    let prev: T = source.peek();\n\n    const innerSub = source.subscribe(() => {\n      const next = source.peek();\n\n      if (!equals(prev, next)) {\n        invokeCallback(next, prev);\n        prev = next;\n\n        if (options?.once) watchSub.dispose();\n      }\n    });\n\n    watchSub = new SubscriptionImpl(() => {\n      pendingCleanup?.();\n      pendingCleanup = undefined;\n      innerSub.dispose();\n    });\n\n    if (options?.immediate) {\n      invokeCallback(prev, undefined);\n\n      if (options.once) watchSub.dispose();\n    }\n  }\n\n  // Auto-register disposal into the enclosing scope (if any) — matches effect() behaviour.\n  getScopeCleanups()?.push(() => watchSub.dispose());\n\n  return watchSub;\n}\n"],"mappings":"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"}

package/dist/reactive-base.cjs

@@ -1,2 +0,0 @@
-const e=require("./symbols.cjs");var t=new FinalizationRegistry(({key:e,map:t})=>{t.delete(e)}),n=class{version=0;name;[e.IS_SIGNAL]=!0;computedSubs_=new Map;effectSubs_=new Set;constructor(e){this.name=e}addComputedSub(e){let n=new WeakRef(e);this.computedSubs_.set(e,n),t.register(e,{key:e,map:this.computedSubs_},n)}removeComputedSub(e){let n=this.computedSubs_.get(e);n!==void 0&&(this.computedSubs_.delete(e),t.unregister(n))}addEffectSub(e){this.effectSubs_.add(e)}removeEffectSub(e){this.effectSubs_.delete(e)}clearSubscribers(){for(let e of this.computedSubs_.values())t.unregister(e);this.computedSubs_.clear(),this.effectSubs_.clear()}hasSubscribers(){if(this.effectSubs_.size>0)return!0;for(let e of this.computedSubs_.values())if(e.deref()!==void 0)return!0;return!1}*computedSubs(){for(let[e,n]of this.computedSubs_){let r=n.deref();r===void 0?(this.computedSubs_.delete(e),t.unregister(n)):yield r}}effectSubs(){return this.effectSubs_}},r=class extends n{[e.IS_COMPUTED]=!0;lastPropEpoch_=0};exports.ComputedBase=r,exports.ReactiveBase=n;
-//# sourceMappingURL=reactive-base.cjs.map

package/dist/reactive-base.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"reactive-base.cjs","names":[],"sources":["../src/reactive-base.ts"],"sourcesContent":["import type { Subscriber } from './types';\n\nimport { IS_COMPUTED, IS_SIGNAL } from './symbols';\n\n// ── Global FinalizationRegistry (F1) ──────────────────────────────────────────\n//\n// When a ComputedBase node becomes garbage-collectible, the registry fires and\n// removes the entry from its source's computedSubs_ map.  This lets orphaned\n// computeds (created outside a scope/effect and never explicitly disposed) be\n// reclaimed by the GC without manual lifecycle management.\n\ntype ComputedWeakEntry = {\n  readonly key: ComputedBase<unknown>;\n  readonly map: Map<ComputedBase<unknown>, WeakRef<ComputedBase<unknown>>>;\n};\n\nconst computedSubRegistry = new FinalizationRegistry<ComputedWeakEntry>(({ key, map }) => {\n  map.delete(key);\n});\n\n// ── ReactiveBase ──────────────────────────────────────────────────────────────\n\n/**\n * Abstract base shared by SignalImpl and ComputedImpl.\n *\n * Centralises:\n * - Subscriber-set management (computed subs via WeakRef, effect subs directly)\n * - Version counter (used for dep-version cache invalidation in computed)\n * - The [IS_SIGNAL] brand marker\n */\nexport abstract class ReactiveBase<T> {\n  version = 0;\n  readonly name: string | undefined;\n  [IS_SIGNAL] = true;\n\n  // A single Map<computed, WeakRef> replaces the previous Set<WeakRef> + WeakMap pair.\n  // O(1) add, remove, and lookup without keeping two structures in sync.\n  private readonly computedSubs_ = new Map<ComputedBase<unknown>, WeakRef<ComputedBase<unknown>>>();\n  private readonly effectSubs_ = new Set<Subscriber>();\n\n  constructor(name?: string) {\n    this.name = name;\n  }\n\n  /**\n   * Registers a computed as a downstream subscriber.  Callers (trackSource in\n   * tracking.ts) must ensure they only call this for genuinely NEW deps — i.e.\n   * deps not already present in the previous dep list.  This guarantees each\n   * computed is registered exactly once per source, keeping the WeakRef set\n   * clean without needing a dedup scan.\n   */\n  addComputedSub(c: ComputedBase<unknown>): void {\n    const ref = new WeakRef(c);\n\n    this.computedSubs_.set(c, ref);\n    computedSubRegistry.register(c, { key: c, map: this.computedSubs_ }, ref);\n  }\n\n  removeComputedSub(c: ComputedBase<unknown>): void {\n    const ref = this.computedSubs_.get(c);\n\n    if (ref === undefined) return;\n\n    this.computedSubs_.delete(c);\n    computedSubRegistry.unregister(ref);\n  }\n\n  addEffectSub(subscriber: Subscriber): void {\n    this.effectSubs_.add(subscriber);\n  }\n\n  removeEffectSub(subscriber: Subscriber): void {\n    this.effectSubs_.delete(subscriber);\n  }\n\n  protected clearSubscribers(): void {\n    for (const ref of this.computedSubs_.values()) {\n      computedSubRegistry.unregister(ref);\n    }\n\n    this.computedSubs_.clear();\n    this.effectSubs_.clear();\n  }\n\n  hasSubscribers(): boolean {\n    if (this.effectSubs_.size > 0) return true;\n\n    for (const ref of this.computedSubs_.values()) {\n      if (ref.deref() !== undefined) return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Yields live downstream computed subscribers.\n   * Dead WeakRefs (GC'd computeds) are pruned eagerly from the map on each traversal,\n   * keeping the subscriber set compact without requiring manual dispose calls.\n   */\n  *computedSubs(): Generator<ComputedBase<unknown>> {\n    for (const [key, ref] of this.computedSubs_) {\n      const node = ref.deref();\n\n      if (node !== undefined) {\n        yield node;\n      } else {\n        this.computedSubs_.delete(key);\n        computedSubRegistry.unregister(ref);\n      }\n    }\n  }\n\n  effectSubs(): ReadonlySet<Subscriber> {\n    return this.effectSubs_;\n  }\n\n  abstract get value(): T;\n  abstract peek(): T;\n}\n\n// ── Refreshable ──────────────────────────────────────────────────────────────\n\n/**\n * Structural interface for lazy nodes that support dirty-flagging and\n * on-demand recompute. Used by tracking.ts to pull computed deps without\n * importing the concrete ComputedImpl class.\n */\nexport interface Refreshable {\n  refreshIfDirty(): boolean;\n}\n\n// ── ComputedBase ──────────────────────────────────────────────────────────────\n\n/**\n * Extension of ReactiveBase for derived (lazy) nodes that can be marked dirty\n * and refreshed on demand.  Exposes the two methods scheduling.ts needs without\n * importing the concrete ComputedImpl class (breaks the potential circular dep).\n */\nexport abstract class ComputedBase<T> extends ReactiveBase<T> implements Refreshable {\n  [IS_COMPUTED] = true;\n  lastPropEpoch_ = 0;\n\n  abstract markDirty(): boolean;\n  abstract refreshIfDirty(): boolean;\n}\n"],"mappings":"iCAgBA,IAAM,EAAsB,IAAI,sBAAyC,CAAE,MAAK,SAAU,CACxF,EAAI,OAAO,CAAG,CAChB,CAAC,EAYqB,EAAtB,KAAsC,CACpC,QAAU,EACV,KACA,CAAC,EAAA,WAAa,GAId,cAAiC,IAAI,IACrC,YAA+B,IAAI,IAEnC,YAAY,EAAe,CACzB,KAAK,KAAO,CACd,CASA,eAAe,EAAgC,CAC7C,IAAM,EAAM,IAAI,QAAQ,CAAC,EAEzB,KAAK,cAAc,IAAI,EAAG,CAAG,EAC7B,EAAoB,SAAS,EAAG,CAAE,IAAK,EAAG,IAAK,KAAK,aAAc,EAAG,CAAG,CAC1E,CAEA,kBAAkB,EAAgC,CAChD,IAAM,EAAM,KAAK,cAAc,IAAI,CAAC,EAEhC,IAAQ,IAAA,KAEZ,KAAK,cAAc,OAAO,CAAC,EAC3B,EAAoB,WAAW,CAAG,EACpC,CAEA,aAAa,EAA8B,CACzC,KAAK,YAAY,IAAI,CAAU,CACjC,CAEA,gBAAgB,EAA8B,CAC5C,KAAK,YAAY,OAAO,CAAU,CACpC,CAEA,kBAAmC,CACjC,IAAK,IAAM,KAAO,KAAK,cAAc,OAAO,EAC1C,EAAoB,WAAW,CAAG,EAGpC,KAAK,cAAc,MAAM,EACzB,KAAK,YAAY,MAAM,CACzB,CAEA,gBAA0B,CACxB,GAAI,KAAK,YAAY,KAAO,EAAG,MAAO,GAEtC,IAAK,IAAM,KAAO,KAAK,cAAc,OAAO,EAC1C,GAAI,EAAI,MAAM,IAAM,IAAA,GAAW,MAAO,GAGxC,MAAO,EACT,CAOA,CAAC,cAAiD,CAChD,IAAK,GAAM,CAAC,EAAK,KAAQ,KAAK,cAAe,CAC3C,IAAM,EAAO,EAAI,MAAM,EAEnB,IAAS,IAAA,IAGX,KAAK,cAAc,OAAO,CAAG,EAC7B,EAAoB,WAAW,CAAG,GAHlC,MAAM,CAKV,CACF,CAEA,YAAsC,CACpC,OAAO,KAAK,WACd,CAIF,EAoBsB,EAAtB,cAA8C,CAAuC,CACnF,CAAC,EAAA,aAAe,GAChB,eAAiB,CAInB"}

package/dist/reactive-base.d.ts

@@ -1,60 +0,0 @@
-import type { Subscriber } from './types';
-import { IS_COMPUTED, IS_SIGNAL } from './symbols';
-/**
- * Abstract base shared by SignalImpl and ComputedImpl.
- *
- * Centralises:
- * - Subscriber-set management (computed subs via WeakRef, effect subs directly)
- * - Version counter (used for dep-version cache invalidation in computed)
- * - The [IS_SIGNAL] brand marker
- */
-export declare abstract class ReactiveBase<T> {
-    version: number;
-    readonly name: string | undefined;
-    [IS_SIGNAL]: boolean;
-    private readonly computedSubs_;
-    private readonly effectSubs_;
-    constructor(name?: string);
-    /**
-     * Registers a computed as a downstream subscriber.  Callers (trackSource in
-     * tracking.ts) must ensure they only call this for genuinely NEW deps — i.e.
-     * deps not already present in the previous dep list.  This guarantees each
-     * computed is registered exactly once per source, keeping the WeakRef set
-     * clean without needing a dedup scan.
-     */
-    addComputedSub(c: ComputedBase<unknown>): void;
-    removeComputedSub(c: ComputedBase<unknown>): void;
-    addEffectSub(subscriber: Subscriber): void;
-    removeEffectSub(subscriber: Subscriber): void;
-    protected clearSubscribers(): void;
-    hasSubscribers(): boolean;
-    /**
-     * Yields live downstream computed subscribers.
-     * Dead WeakRefs (GC'd computeds) are pruned eagerly from the map on each traversal,
-     * keeping the subscriber set compact without requiring manual dispose calls.
-     */
-    computedSubs(): Generator<ComputedBase<unknown>>;
-    effectSubs(): ReadonlySet<Subscriber>;
-    abstract get value(): T;
-    abstract peek(): T;
-}
-/**
- * Structural interface for lazy nodes that support dirty-flagging and
- * on-demand recompute. Used by tracking.ts to pull computed deps without
- * importing the concrete ComputedImpl class.
- */
-export interface Refreshable {
-    refreshIfDirty(): boolean;
-}
-/**
- * Extension of ReactiveBase for derived (lazy) nodes that can be marked dirty
- * and refreshed on demand.  Exposes the two methods scheduling.ts needs without
- * importing the concrete ComputedImpl class (breaks the potential circular dep).
- */
-export declare abstract class ComputedBase<T> extends ReactiveBase<T> implements Refreshable {
-    [IS_COMPUTED]: boolean;
-    lastPropEpoch_: number;
-    abstract markDirty(): boolean;
-    abstract refreshIfDirty(): boolean;
-}
-//# sourceMappingURL=reactive-base.d.ts.map

package/dist/reactive-base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reactive-base.d.ts","sourceRoot":"","sources":["../src/reactive-base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAoBnD;;;;;;;GAOG;AACH,8BAAsB,YAAY,CAAC,CAAC;IAClC,OAAO,SAAK;IACZ,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,CAAC,SAAS,CAAC,UAAQ;IAInB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoE;IAClG,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;gBAEzC,IAAI,CAAC,EAAE,MAAM;IAIzB;;;;;;OAMG;IACH,cAAc,CAAC,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,IAAI;IAO9C,iBAAiB,CAAC,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,IAAI;IASjD,YAAY,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAI1C,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAI7C,SAAS,CAAC,gBAAgB,IAAI,IAAI;IASlC,cAAc,IAAI,OAAO;IAUzB;;;;OAIG;IACF,YAAY,IAAI,SAAS,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAajD,UAAU,IAAI,WAAW,CAAC,UAAU,CAAC;IAIrC,QAAQ,KAAK,KAAK,IAAI,CAAC,CAAC;IACxB,QAAQ,CAAC,IAAI,IAAI,CAAC;CACnB;AAID;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,cAAc,IAAI,OAAO,CAAC;CAC3B;AAID;;;;GAIG;AACH,8BAAsB,YAAY,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAE,YAAW,WAAW;IAClF,CAAC,WAAW,CAAC,UAAQ;IACrB,cAAc,SAAK;IAEnB,QAAQ,CAAC,SAAS,IAAI,OAAO;IAC7B,QAAQ,CAAC,cAAc,IAAI,OAAO;CACnC"}

package/dist/reactive-base.js

@@ -1,56 +0,0 @@
-import { IS_COMPUTED as e, IS_SIGNAL as t } from "./symbols.js";
-//#region src/reactive-base.ts
-var n = new FinalizationRegistry(({ key: e, map: t }) => {
-	t.delete(e);
-}), r = class {
-	version = 0;
-	name;
-	[t] = !0;
-	computedSubs_ = /* @__PURE__ */ new Map();
-	effectSubs_ = /* @__PURE__ */ new Set();
-	constructor(e) {
-		this.name = e;
-	}
-	addComputedSub(e) {
-		let t = new WeakRef(e);
-		this.computedSubs_.set(e, t), n.register(e, {
-			key: e,
-			map: this.computedSubs_
-		}, t);
-	}
-	removeComputedSub(e) {
-		let t = this.computedSubs_.get(e);
-		t !== void 0 && (this.computedSubs_.delete(e), n.unregister(t));
-	}
-	addEffectSub(e) {
-		this.effectSubs_.add(e);
-	}
-	removeEffectSub(e) {
-		this.effectSubs_.delete(e);
-	}
-	clearSubscribers() {
-		for (let e of this.computedSubs_.values()) n.unregister(e);
-		this.computedSubs_.clear(), this.effectSubs_.clear();
-	}
-	hasSubscribers() {
-		if (this.effectSubs_.size > 0) return !0;
-		for (let e of this.computedSubs_.values()) if (e.deref() !== void 0) return !0;
-		return !1;
-	}
-	*computedSubs() {
-		for (let [e, t] of this.computedSubs_) {
-			let r = t.deref();
-			r === void 0 ? (this.computedSubs_.delete(e), n.unregister(t)) : yield r;
-		}
-	}
-	effectSubs() {
-		return this.effectSubs_;
-	}
-}, i = class extends r {
-	[e] = !0;
-	lastPropEpoch_ = 0;
-};
-//#endregion
-export { i as ComputedBase, r as ReactiveBase };
-
-//# sourceMappingURL=reactive-base.js.map

package/dist/reactive-base.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reactive-base.js","names":[],"sources":["../src/reactive-base.ts"],"sourcesContent":["import type { Subscriber } from './types';\n\nimport { IS_COMPUTED, IS_SIGNAL } from './symbols';\n\n// ── Global FinalizationRegistry (F1) ──────────────────────────────────────────\n//\n// When a ComputedBase node becomes garbage-collectible, the registry fires and\n// removes the entry from its source's computedSubs_ map.  This lets orphaned\n// computeds (created outside a scope/effect and never explicitly disposed) be\n// reclaimed by the GC without manual lifecycle management.\n\ntype ComputedWeakEntry = {\n  readonly key: ComputedBase<unknown>;\n  readonly map: Map<ComputedBase<unknown>, WeakRef<ComputedBase<unknown>>>;\n};\n\nconst computedSubRegistry = new FinalizationRegistry<ComputedWeakEntry>(({ key, map }) => {\n  map.delete(key);\n});\n\n// ── ReactiveBase ──────────────────────────────────────────────────────────────\n\n/**\n * Abstract base shared by SignalImpl and ComputedImpl.\n *\n * Centralises:\n * - Subscriber-set management (computed subs via WeakRef, effect subs directly)\n * - Version counter (used for dep-version cache invalidation in computed)\n * - The [IS_SIGNAL] brand marker\n */\nexport abstract class ReactiveBase<T> {\n  version = 0;\n  readonly name: string | undefined;\n  [IS_SIGNAL] = true;\n\n  // A single Map<computed, WeakRef> replaces the previous Set<WeakRef> + WeakMap pair.\n  // O(1) add, remove, and lookup without keeping two structures in sync.\n  private readonly computedSubs_ = new Map<ComputedBase<unknown>, WeakRef<ComputedBase<unknown>>>();\n  private readonly effectSubs_ = new Set<Subscriber>();\n\n  constructor(name?: string) {\n    this.name = name;\n  }\n\n  /**\n   * Registers a computed as a downstream subscriber.  Callers (trackSource in\n   * tracking.ts) must ensure they only call this for genuinely NEW deps — i.e.\n   * deps not already present in the previous dep list.  This guarantees each\n   * computed is registered exactly once per source, keeping the WeakRef set\n   * clean without needing a dedup scan.\n   */\n  addComputedSub(c: ComputedBase<unknown>): void {\n    const ref = new WeakRef(c);\n\n    this.computedSubs_.set(c, ref);\n    computedSubRegistry.register(c, { key: c, map: this.computedSubs_ }, ref);\n  }\n\n  removeComputedSub(c: ComputedBase<unknown>): void {\n    const ref = this.computedSubs_.get(c);\n\n    if (ref === undefined) return;\n\n    this.computedSubs_.delete(c);\n    computedSubRegistry.unregister(ref);\n  }\n\n  addEffectSub(subscriber: Subscriber): void {\n    this.effectSubs_.add(subscriber);\n  }\n\n  removeEffectSub(subscriber: Subscriber): void {\n    this.effectSubs_.delete(subscriber);\n  }\n\n  protected clearSubscribers(): void {\n    for (const ref of this.computedSubs_.values()) {\n      computedSubRegistry.unregister(ref);\n    }\n\n    this.computedSubs_.clear();\n    this.effectSubs_.clear();\n  }\n\n  hasSubscribers(): boolean {\n    if (this.effectSubs_.size > 0) return true;\n\n    for (const ref of this.computedSubs_.values()) {\n      if (ref.deref() !== undefined) return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Yields live downstream computed subscribers.\n   * Dead WeakRefs (GC'd computeds) are pruned eagerly from the map on each traversal,\n   * keeping the subscriber set compact without requiring manual dispose calls.\n   */\n  *computedSubs(): Generator<ComputedBase<unknown>> {\n    for (const [key, ref] of this.computedSubs_) {\n      const node = ref.deref();\n\n      if (node !== undefined) {\n        yield node;\n      } else {\n        this.computedSubs_.delete(key);\n        computedSubRegistry.unregister(ref);\n      }\n    }\n  }\n\n  effectSubs(): ReadonlySet<Subscriber> {\n    return this.effectSubs_;\n  }\n\n  abstract get value(): T;\n  abstract peek(): T;\n}\n\n// ── Refreshable ──────────────────────────────────────────────────────────────\n\n/**\n * Structural interface for lazy nodes that support dirty-flagging and\n * on-demand recompute. Used by tracking.ts to pull computed deps without\n * importing the concrete ComputedImpl class.\n */\nexport interface Refreshable {\n  refreshIfDirty(): boolean;\n}\n\n// ── ComputedBase ──────────────────────────────────────────────────────────────\n\n/**\n * Extension of ReactiveBase for derived (lazy) nodes that can be marked dirty\n * and refreshed on demand.  Exposes the two methods scheduling.ts needs without\n * importing the concrete ComputedImpl class (breaks the potential circular dep).\n */\nexport abstract class ComputedBase<T> extends ReactiveBase<T> implements Refreshable {\n  [IS_COMPUTED] = true;\n  lastPropEpoch_ = 0;\n\n  abstract markDirty(): boolean;\n  abstract refreshIfDirty(): boolean;\n}\n"],"mappings":";;AAgBA,IAAM,IAAsB,IAAI,sBAAyC,EAAE,QAAK,aAAU;CACxF,EAAI,OAAO,CAAG;AAChB,CAAC,GAYqB,IAAtB,MAAsC;CACpC,UAAU;CACV;CACA,CAAC,KAAa;CAId,gCAAiC,IAAI,IAA2D;CAChG,8BAA+B,IAAI,IAAgB;CAEnD,YAAY,GAAe;EACzB,KAAK,OAAO;CACd;CASA,eAAe,GAAgC;EAC7C,IAAM,IAAM,IAAI,QAAQ,CAAC;EAGzB,AADA,KAAK,cAAc,IAAI,GAAG,CAAG,GAC7B,EAAoB,SAAS,GAAG;GAAE,KAAK;GAAG,KAAK,KAAK;EAAc,GAAG,CAAG;CAC1E;CAEA,kBAAkB,GAAgC;EAChD,IAAM,IAAM,KAAK,cAAc,IAAI,CAAC;EAEhC,MAAQ,KAAA,MAEZ,KAAK,cAAc,OAAO,CAAC,GAC3B,EAAoB,WAAW,CAAG;CACpC;CAEA,aAAa,GAA8B;EACzC,KAAK,YAAY,IAAI,CAAU;CACjC;CAEA,gBAAgB,GAA8B;EAC5C,KAAK,YAAY,OAAO,CAAU;CACpC;CAEA,mBAAmC;EACjC,KAAK,IAAM,KAAO,KAAK,cAAc,OAAO,GAC1C,EAAoB,WAAW,CAAG;EAIpC,AADA,KAAK,cAAc,MAAM,GACzB,KAAK,YAAY,MAAM;CACzB;CAEA,iBAA0B;EACxB,IAAI,KAAK,YAAY,OAAO,GAAG,OAAO;EAEtC,KAAK,IAAM,KAAO,KAAK,cAAc,OAAO,GAC1C,IAAI,EAAI,MAAM,MAAM,KAAA,GAAW,OAAO;EAGxC,OAAO;CACT;CAOA,CAAC,eAAiD;EAChD,KAAK,IAAM,CAAC,GAAK,MAAQ,KAAK,eAAe;GAC3C,IAAM,IAAO,EAAI,MAAM;GAEvB,AAAI,MAAS,KAAA,KAGX,KAAK,cAAc,OAAO,CAAG,GAC7B,EAAoB,WAAW,CAAG,KAHlC,MAAM;EAKV;CACF;CAEA,aAAsC;EACpC,OAAO,KAAK;CACd;AAIF,GAoBsB,IAAtB,cAA8C,EAAuC;CACnF,CAAC,KAAe;CAChB,iBAAiB;AAInB"}

package/dist/scheduling.cjs

@@ -1,2 +0,0 @@
-const e=require("./_error-utils.cjs"),t=require("./errors.cjs"),n=require("./_dev.cjs"),r=require("./tracking.cjs");var i=!1,a=0,o=[],s=e=>e.activeDirty===`a`?e.dirtyWithEffectSubsA:e.dirtyWithEffectSubsB,c=(e,t)=>{let n=++a;for(let n of t.effectSubs())e.pendingSubscribers.add(n);for(let e of t.computedSubs())o.push(e);try{for(;o.length>0;){let t=o.pop();if(t.lastPropEpoch_!==n&&(t.lastPropEpoch_=n,t.markDirty())){t.effectSubs().size>0&&s(e).add(t);for(let e of t.computedSubs())o.push(e)}}}finally{o.length=0}},l=e=>{for(;s(e).size>0;){let t=s(e);e.activeDirty=e.activeDirty===`a`?`b`:`a`,s(e).clear();for(let n of t)if(n.hasSubscribers()&&n.refreshIfDirty()){for(let t of n.effectSubs())e.pendingSubscribers.add(t);for(let t of n.computedSubs())t.markDirty()&&t.effectSubs().size>0&&s(e).add(t)}t.clear()}},u=n=>{let r=0;for(;n.pendingSubscribers.size>0||s(n).size>0;){if(++r>100)throw new t.RippleInfiniteLoopError(`infinite flush loop (> 100 iterations)`);if(s(n).size>0&&l(n),n.pendingSubscribers.size===0)continue;let i=[...n.pendingSubscribers];n.pendingSubscribers.clear(),e.runAll(i,`subscriber errors`)}},d=globalThis.process?.versions!=null,f=e=>{if(!e.hasSubscribers())return;!i&&d&&!r.hasContextHook()&&(i=!0,n.warn(`Signal updated in a Node.js-like environment. The module-level flush queue is shared across concurrent requests — use per-request worker isolation or the @vielzeug/ripple/ssr sub-path for request-isolated scheduling.`));let t=r.getSchedulingState();c(t,e),t.batchDepth===0&&u(t)},p=e=>{let t=r.getSchedulingState();t.batchDepth++;let n;try{n=e()}catch(e){throw t.batchDepth--,t.batchDepth===0&&(t.pendingSubscribers.clear(),t.dirtyWithEffectSubsA.clear(),t.dirtyWithEffectSubsB.clear()),e}return t.batchDepth--,t.batchDepth===0&&u(t),n};exports.batch=p,exports.notifyNodeChange=f;
-//# sourceMappingURL=scheduling.cjs.map

package/dist/scheduling.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduling.cjs","names":[],"sources":["../src/scheduling.ts"],"sourcesContent":["import type { ComputedBase, ReactiveBase } from './reactive-base';\nimport type { Subscriber } from './types';\n\nimport { warn } from './_dev';\nimport { runAll } from './_error-utils';\nimport { RippleInfiniteLoopError } from './errors';\nimport { getSchedulingState, hasContextHook, type SchedulingState } from './tracking';\n\nexport const DEFAULT_MAX_ITERATIONS = 100;\n\n// batchDepth, pendingSubscribers, and the dirty-computed sets live in `SchedulingState`\n// (see tracking.ts) rather than as module-level variables — this lets the /ripple/ssr\n// sub-path isolate the flush queue per request (via the same AsyncLocalStorage-backed\n// context hook that already isolates tracking), closing the gap where concurrent SSR\n// requests previously shared one flush queue. Outside SSR (no hook installed), this is\n// a single module-level singleton with identical behavior and cost to before.\nlet ssrWarnFired = false;\n\n// ── F1: Simplified flush — no topological sort ─────────────────────────────\n//\n// Push phase (propagateDirty):\n//   Mark all downstream computeds dirty in a BFS pass.\n//   Directly collect effect subscribers of the changed signal.\n//   For computeds with direct effect subscribers, defer to the pull phase.\n//\n// Pull phase (recomputeWithEffectSubs):\n//   For each dirty computed that has direct effect subscribers, recompute it.\n//   If the value changed, queue its effect subscribers.\n//   Any further downstream dirty computeds with effect subs are handled in the\n//   same loop (re-queued into dirtyWithEffectSubs if they become dirty during\n//   a parent recompute).\n//\n// Effect phase: run all queued effect subscribers.\n//\n// This eliminates the O(n²) topo sort while preserving the equality-suppression\n// guarantee: effect subs of a computed are only notified when the computed's\n// value actually changes.\n//\n// Computeds without direct effect subs (pure lazy nodes) are still pulled\n// lazily when an effect reads them during re-run.\n\n// Module-level scratch state — safe to share even under SSR isolation. Both are only\n// touched within a single synchronous call stack (no `await` inside propagateDirty /\n// recomputeWithEffectSubs / flushEffects), which JS's run-to-completion model already\n// isolates; they never carry information across two separate top-level signal writes.\nlet _propEpoch = 0;\nconst _propagateStack: ComputedBase<unknown>[] = [];\n\n/** Returns (and possibly swaps) the currently-active dirty-with-effect-subs set. */\nconst activeDirtySet = (s: SchedulingState): Set<ComputedBase<unknown>> =>\n  s.activeDirty === 'a' ? s.dirtyWithEffectSubsA : s.dirtyWithEffectSubsB;\n\nconst propagateDirty = (\n  s: SchedulingState,\n  node: {\n    computedSubs(): Generator<ComputedBase<unknown>>;\n    effectSubs(): ReadonlySet<Subscriber>;\n  },\n): void => {\n  const epoch = ++_propEpoch;\n\n  // Queue direct effect subs of the changed node\n  for (const sub of node.effectSubs()) {\n    s.pendingSubscribers.add(sub);\n  }\n\n  for (const c of node.computedSubs()) {\n    _propagateStack.push(c);\n  }\n\n  try {\n    while (_propagateStack.length > 0) {\n      const c = _propagateStack.pop()!;\n\n      if (c.lastPropEpoch_ === epoch) continue;\n\n      c.lastPropEpoch_ = epoch;\n\n      if (!c.markDirty()) continue; // already dirty — already processed\n\n      // If this computed has effect subs, defer recompute to the pull phase.\n      // We cannot queue them immediately because the computed might not change.\n      if (c.effectSubs().size > 0) {\n        activeDirtySet(s).add(c);\n      }\n\n      for (const downstream of c.computedSubs()) {\n        _propagateStack.push(downstream);\n      }\n    }\n  } finally {\n    _propagateStack.length = 0;\n  }\n};\n\nconst recomputeWithEffectSubs = (s: SchedulingState): void => {\n  // Iterate until stable — recomputing one computed may dirty others.\n  // Set-swap pattern: swap active/idle sets each pass so new dirty nodes accumulate\n  // in the idle set while we iterate the current batch — zero array allocations.\n  while (activeDirtySet(s).size > 0) {\n    const toProcess = activeDirtySet(s);\n\n    // Swap: new dirty nodes from this iteration go into the other set\n    s.activeDirty = s.activeDirty === 'a' ? 'b' : 'a';\n    activeDirtySet(s).clear();\n\n    for (const c of toProcess) {\n      if (!c.hasSubscribers()) continue;\n\n      const changed = c.refreshIfDirty();\n\n      if (!changed) continue;\n\n      // Value changed — queue effect subs\n      for (const sub of c.effectSubs()) {\n        s.pendingSubscribers.add(sub);\n      }\n\n      // Downstream computeds may now need recomputing too\n      for (const downstream of c.computedSubs()) {\n        if (downstream.markDirty() && downstream.effectSubs().size > 0) {\n          activeDirtySet(s).add(downstream);\n        }\n      }\n    }\n\n    toProcess.clear();\n  }\n};\n\nconst flushEffects = (s: SchedulingState): void => {\n  let iterations = 0;\n\n  while (s.pendingSubscribers.size > 0 || activeDirtySet(s).size > 0) {\n    if (++iterations > DEFAULT_MAX_ITERATIONS) {\n      throw new RippleInfiniteLoopError(`infinite flush loop (> ${DEFAULT_MAX_ITERATIONS} iterations)`);\n    }\n\n    if (activeDirtySet(s).size > 0) recomputeWithEffectSubs(s);\n\n    if (s.pendingSubscribers.size === 0) continue;\n\n    const subscribersToRun = [...s.pendingSubscribers];\n\n    s.pendingSubscribers.clear();\n    runAll(subscribersToRun, 'subscriber errors');\n  }\n};\n\n// Fire the warning once per module load in environments that look like Node.js,\n// and only when no SSR context hook is installed (once installed, the flush queue\n// is genuinely request-isolated via SchedulingState — see tracking.ts).\n// window-check is unreliable (jsdom sets window in tests); check for process.versions instead.\n// Access entirely via globalThis to avoid requiring @types/node in downstream tsconfigs.\nconst isNodeLike = (globalThis as { process?: { versions?: unknown } }).process?.versions != null;\n\nexport const notifyNodeChange = (node: ReactiveBase<unknown>): void => {\n  if (!node.hasSubscribers()) return;\n\n  if (!ssrWarnFired && isNodeLike && !hasContextHook()) {\n    ssrWarnFired = true;\n    warn(\n      'Signal updated in a Node.js-like environment. The module-level flush queue is shared across concurrent requests ' +\n        '— use per-request worker isolation or the @vielzeug/ripple/ssr sub-path for request-isolated scheduling.',\n    );\n  }\n\n  const s = getSchedulingState();\n\n  propagateDirty(s, node);\n\n  if (s.batchDepth === 0) flushEffects(s);\n};\n\nexport const batch = <T>(fn: () => T): T => {\n  const s = getSchedulingState();\n\n  s.batchDepth++;\n\n  let result: T;\n\n  try {\n    result = fn();\n  } catch (e) {\n    s.batchDepth--;\n\n    // Outermost batch: clear the pending flush queue on body error.\n    // Leaving stale subscribers in the queue would flush them on the next unrelated\n    // signal write, surfacing errors in unexpected contexts.\n    if (s.batchDepth === 0) {\n      s.pendingSubscribers.clear();\n      s.dirtyWithEffectSubsA.clear();\n      s.dirtyWithEffectSubsB.clear();\n    }\n\n    throw e;\n  }\n\n  s.batchDepth--;\n\n  if (s.batchDepth === 0) flushEffects(s);\n\n  return result;\n};\n"],"mappings":"oHAgBA,IAAI,EAAe,GA6Bf,EAAa,EACX,EAA2C,CAAC,EAG5C,EAAkB,GACtB,EAAE,cAAgB,IAAM,EAAE,qBAAuB,EAAE,qBAE/C,GACJ,EACA,IAIS,CACT,IAAM,EAAQ,EAAE,EAGhB,IAAK,IAAM,KAAO,EAAK,WAAW,EAChC,EAAE,mBAAmB,IAAI,CAAG,EAG9B,IAAK,IAAM,KAAK,EAAK,aAAa,EAChC,EAAgB,KAAK,CAAC,EAGxB,GAAI,CACF,KAAO,EAAgB,OAAS,GAAG,CACjC,IAAM,EAAI,EAAgB,IAAI,EAE1B,KAAE,iBAAmB,IAEzB,EAAE,eAAiB,EAEd,EAAE,UAAU,GAIjB,CAAI,EAAE,WAAW,CAAC,CAAC,KAAO,GACxB,EAAe,CAAC,CAAC,CAAC,IAAI,CAAC,EAGzB,IAAK,IAAM,KAAc,EAAE,aAAa,EACtC,EAAgB,KAAK,CAAU,CAJR,CAM3B,CACF,QAAU,CACR,EAAgB,OAAS,CAC3B,CACF,EAEM,EAA2B,GAA6B,CAI5D,KAAO,EAAe,CAAC,CAAC,CAAC,KAAO,GAAG,CACjC,IAAM,EAAY,EAAe,CAAC,EAGlC,EAAE,YAAc,EAAE,cAAgB,IAAM,IAAM,IAC9C,EAAe,CAAC,CAAC,CAAC,MAAM,EAExB,IAAK,IAAM,KAAK,EACT,KAAE,eAAe,GAEN,EAAE,eAEb,EAGL,KAAK,IAAM,KAAO,EAAE,WAAW,EAC7B,EAAE,mBAAmB,IAAI,CAAG,EAI9B,IAAK,IAAM,KAAc,EAAE,aAAa,EAClC,EAAW,UAAU,GAAK,EAAW,WAAW,CAAC,CAAC,KAAO,GAC3D,EAAe,CAAC,CAAC,CAAC,IAAI,CAAU,CANN,CAWhC,EAAU,MAAM,CAClB,CACF,EAEM,EAAgB,GAA6B,CACjD,IAAI,EAAa,EAEjB,KAAO,EAAE,mBAAmB,KAAO,GAAK,EAAe,CAAC,CAAC,CAAC,KAAO,GAAG,CAClE,GAAI,EAAE,EAAA,IACJ,MAAM,IAAI,EAAA,wBAAwB,wCAA8D,EAKlG,GAFI,EAAe,CAAC,CAAC,CAAC,KAAO,GAAG,EAAwB,CAAC,EAErD,EAAE,mBAAmB,OAAS,EAAG,SAErC,IAAM,EAAmB,CAAC,GAAG,EAAE,kBAAkB,EAEjD,EAAE,mBAAmB,MAAM,EAC3B,EAAA,OAAO,EAAkB,mBAAmB,CAC9C,CACF,EAOM,EAAc,WAAoD,SAAS,UAAY,KAEhF,EAAoB,GAAsC,CACrE,GAAI,CAAC,EAAK,eAAe,EAAG,OAExB,CAAC,GAAgB,GAAc,CAAC,EAAA,eAAe,IACjD,EAAe,GACf,EAAA,KACE,0NAEF,GAGF,IAAM,EAAI,EAAA,mBAAmB,EAE7B,EAAe,EAAG,CAAI,EAElB,EAAE,aAAe,GAAG,EAAa,CAAC,CACxC,EAEa,EAAY,GAAmB,CAC1C,IAAM,EAAI,EAAA,mBAAmB,EAE7B,EAAE,aAEF,IAAI,EAEJ,GAAI,CACF,EAAS,EAAG,CACd,OAAS,EAAG,CAYV,KAXA,GAAE,aAKE,EAAE,aAAe,IACnB,EAAE,mBAAmB,MAAM,EAC3B,EAAE,qBAAqB,MAAM,EAC7B,EAAE,qBAAqB,MAAM,GAGzB,CACR,CAMA,MAJA,GAAE,aAEE,EAAE,aAAe,GAAG,EAAa,CAAC,EAE/B,CACT"}

package/dist/scheduling.d.ts

@@ -1,5 +0,0 @@
-import type { ReactiveBase } from './reactive-base';
-export declare const DEFAULT_MAX_ITERATIONS = 100;
-export declare const notifyNodeChange: (node: ReactiveBase<unknown>) => void;
-export declare const batch: <T>(fn: () => T) => T;
-//# sourceMappingURL=scheduling.d.ts.map

package/dist/scheduling.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduling.d.ts","sourceRoot":"","sources":["../src/scheduling.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAQlE,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAoJ1C,eAAO,MAAM,gBAAgB,GAAI,MAAM,YAAY,CAAC,OAAO,CAAC,KAAG,IAgB9D,CAAC;AAEF,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,IAAI,MAAM,CAAC,KAAG,CA6BtC,CAAC"}

package/dist/scheduling.js

@@ -1,57 +0,0 @@
-import { runAll as e } from "./_error-utils.js";
-import { RippleInfiniteLoopError as t } from "./errors.js";
-import { warn as n } from "./_dev.js";
-import { getSchedulingState as r, hasContextHook as i } from "./tracking.js";
-var a = !1, o = 0, s = [], c = (e) => e.activeDirty === "a" ? e.dirtyWithEffectSubsA : e.dirtyWithEffectSubsB, l = (e, t) => {
-	let n = ++o;
-	for (let n of t.effectSubs()) e.pendingSubscribers.add(n);
-	for (let e of t.computedSubs()) s.push(e);
-	try {
-		for (; s.length > 0;) {
-			let t = s.pop();
-			if (t.lastPropEpoch_ !== n && (t.lastPropEpoch_ = n, t.markDirty())) {
-				t.effectSubs().size > 0 && c(e).add(t);
-				for (let e of t.computedSubs()) s.push(e);
-			}
-		}
-	} finally {
-		s.length = 0;
-	}
-}, u = (e) => {
-	for (; c(e).size > 0;) {
-		let t = c(e);
-		e.activeDirty = e.activeDirty === "a" ? "b" : "a", c(e).clear();
-		for (let n of t) if (n.hasSubscribers() && n.refreshIfDirty()) {
-			for (let t of n.effectSubs()) e.pendingSubscribers.add(t);
-			for (let t of n.computedSubs()) t.markDirty() && t.effectSubs().size > 0 && c(e).add(t);
-		}
-		t.clear();
-	}
-}, d = (n) => {
-	let r = 0;
-	for (; n.pendingSubscribers.size > 0 || c(n).size > 0;) {
-		if (++r > 100) throw new t("infinite flush loop (> 100 iterations)");
-		if (c(n).size > 0 && u(n), n.pendingSubscribers.size === 0) continue;
-		let i = [...n.pendingSubscribers];
-		n.pendingSubscribers.clear(), e(i, "subscriber errors");
-	}
-}, f = globalThis.process?.versions != null, p = (e) => {
-	if (!e.hasSubscribers()) return;
-	!a && f && !i() && (a = !0, n("Signal updated in a Node.js-like environment. The module-level flush queue is shared across concurrent requests — use per-request worker isolation or the @vielzeug/ripple/ssr sub-path for request-isolated scheduling."));
-	let t = r();
-	l(t, e), t.batchDepth === 0 && d(t);
-}, m = (e) => {
-	let t = r();
-	t.batchDepth++;
-	let n;
-	try {
-		n = e();
-	} catch (e) {
-		throw t.batchDepth--, t.batchDepth === 0 && (t.pendingSubscribers.clear(), t.dirtyWithEffectSubsA.clear(), t.dirtyWithEffectSubsB.clear()), e;
-	}
-	return t.batchDepth--, t.batchDepth === 0 && d(t), n;
-};
-//#endregion
-export { m as batch, p as notifyNodeChange };
-
-//# sourceMappingURL=scheduling.js.map

package/dist/scheduling.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduling.js","names":[],"sources":["../src/scheduling.ts"],"sourcesContent":["import type { ComputedBase, ReactiveBase } from './reactive-base';\nimport type { Subscriber } from './types';\n\nimport { warn } from './_dev';\nimport { runAll } from './_error-utils';\nimport { RippleInfiniteLoopError } from './errors';\nimport { getSchedulingState, hasContextHook, type SchedulingState } from './tracking';\n\nexport const DEFAULT_MAX_ITERATIONS = 100;\n\n// batchDepth, pendingSubscribers, and the dirty-computed sets live in `SchedulingState`\n// (see tracking.ts) rather than as module-level variables — this lets the /ripple/ssr\n// sub-path isolate the flush queue per request (via the same AsyncLocalStorage-backed\n// context hook that already isolates tracking), closing the gap where concurrent SSR\n// requests previously shared one flush queue. Outside SSR (no hook installed), this is\n// a single module-level singleton with identical behavior and cost to before.\nlet ssrWarnFired = false;\n\n// ── F1: Simplified flush — no topological sort ─────────────────────────────\n//\n// Push phase (propagateDirty):\n//   Mark all downstream computeds dirty in a BFS pass.\n//   Directly collect effect subscribers of the changed signal.\n//   For computeds with direct effect subscribers, defer to the pull phase.\n//\n// Pull phase (recomputeWithEffectSubs):\n//   For each dirty computed that has direct effect subscribers, recompute it.\n//   If the value changed, queue its effect subscribers.\n//   Any further downstream dirty computeds with effect subs are handled in the\n//   same loop (re-queued into dirtyWithEffectSubs if they become dirty during\n//   a parent recompute).\n//\n// Effect phase: run all queued effect subscribers.\n//\n// This eliminates the O(n²) topo sort while preserving the equality-suppression\n// guarantee: effect subs of a computed are only notified when the computed's\n// value actually changes.\n//\n// Computeds without direct effect subs (pure lazy nodes) are still pulled\n// lazily when an effect reads them during re-run.\n\n// Module-level scratch state — safe to share even under SSR isolation. Both are only\n// touched within a single synchronous call stack (no `await` inside propagateDirty /\n// recomputeWithEffectSubs / flushEffects), which JS's run-to-completion model already\n// isolates; they never carry information across two separate top-level signal writes.\nlet _propEpoch = 0;\nconst _propagateStack: ComputedBase<unknown>[] = [];\n\n/** Returns (and possibly swaps) the currently-active dirty-with-effect-subs set. */\nconst activeDirtySet = (s: SchedulingState): Set<ComputedBase<unknown>> =>\n  s.activeDirty === 'a' ? s.dirtyWithEffectSubsA : s.dirtyWithEffectSubsB;\n\nconst propagateDirty = (\n  s: SchedulingState,\n  node: {\n    computedSubs(): Generator<ComputedBase<unknown>>;\n    effectSubs(): ReadonlySet<Subscriber>;\n  },\n): void => {\n  const epoch = ++_propEpoch;\n\n  // Queue direct effect subs of the changed node\n  for (const sub of node.effectSubs()) {\n    s.pendingSubscribers.add(sub);\n  }\n\n  for (const c of node.computedSubs()) {\n    _propagateStack.push(c);\n  }\n\n  try {\n    while (_propagateStack.length > 0) {\n      const c = _propagateStack.pop()!;\n\n      if (c.lastPropEpoch_ === epoch) continue;\n\n      c.lastPropEpoch_ = epoch;\n\n      if (!c.markDirty()) continue; // already dirty — already processed\n\n      // If this computed has effect subs, defer recompute to the pull phase.\n      // We cannot queue them immediately because the computed might not change.\n      if (c.effectSubs().size > 0) {\n        activeDirtySet(s).add(c);\n      }\n\n      for (const downstream of c.computedSubs()) {\n        _propagateStack.push(downstream);\n      }\n    }\n  } finally {\n    _propagateStack.length = 0;\n  }\n};\n\nconst recomputeWithEffectSubs = (s: SchedulingState): void => {\n  // Iterate until stable — recomputing one computed may dirty others.\n  // Set-swap pattern: swap active/idle sets each pass so new dirty nodes accumulate\n  // in the idle set while we iterate the current batch — zero array allocations.\n  while (activeDirtySet(s).size > 0) {\n    const toProcess = activeDirtySet(s);\n\n    // Swap: new dirty nodes from this iteration go into the other set\n    s.activeDirty = s.activeDirty === 'a' ? 'b' : 'a';\n    activeDirtySet(s).clear();\n\n    for (const c of toProcess) {\n      if (!c.hasSubscribers()) continue;\n\n      const changed = c.refreshIfDirty();\n\n      if (!changed) continue;\n\n      // Value changed — queue effect subs\n      for (const sub of c.effectSubs()) {\n        s.pendingSubscribers.add(sub);\n      }\n\n      // Downstream computeds may now need recomputing too\n      for (const downstream of c.computedSubs()) {\n        if (downstream.markDirty() && downstream.effectSubs().size > 0) {\n          activeDirtySet(s).add(downstream);\n        }\n      }\n    }\n\n    toProcess.clear();\n  }\n};\n\nconst flushEffects = (s: SchedulingState): void => {\n  let iterations = 0;\n\n  while (s.pendingSubscribers.size > 0 || activeDirtySet(s).size > 0) {\n    if (++iterations > DEFAULT_MAX_ITERATIONS) {\n      throw new RippleInfiniteLoopError(`infinite flush loop (> ${DEFAULT_MAX_ITERATIONS} iterations)`);\n    }\n\n    if (activeDirtySet(s).size > 0) recomputeWithEffectSubs(s);\n\n    if (s.pendingSubscribers.size === 0) continue;\n\n    const subscribersToRun = [...s.pendingSubscribers];\n\n    s.pendingSubscribers.clear();\n    runAll(subscribersToRun, 'subscriber errors');\n  }\n};\n\n// Fire the warning once per module load in environments that look like Node.js,\n// and only when no SSR context hook is installed (once installed, the flush queue\n// is genuinely request-isolated via SchedulingState — see tracking.ts).\n// window-check is unreliable (jsdom sets window in tests); check for process.versions instead.\n// Access entirely via globalThis to avoid requiring @types/node in downstream tsconfigs.\nconst isNodeLike = (globalThis as { process?: { versions?: unknown } }).process?.versions != null;\n\nexport const notifyNodeChange = (node: ReactiveBase<unknown>): void => {\n  if (!node.hasSubscribers()) return;\n\n  if (!ssrWarnFired && isNodeLike && !hasContextHook()) {\n    ssrWarnFired = true;\n    warn(\n      'Signal updated in a Node.js-like environment. The module-level flush queue is shared across concurrent requests ' +\n        '— use per-request worker isolation or the @vielzeug/ripple/ssr sub-path for request-isolated scheduling.',\n    );\n  }\n\n  const s = getSchedulingState();\n\n  propagateDirty(s, node);\n\n  if (s.batchDepth === 0) flushEffects(s);\n};\n\nexport const batch = <T>(fn: () => T): T => {\n  const s = getSchedulingState();\n\n  s.batchDepth++;\n\n  let result: T;\n\n  try {\n    result = fn();\n  } catch (e) {\n    s.batchDepth--;\n\n    // Outermost batch: clear the pending flush queue on body error.\n    // Leaving stale subscribers in the queue would flush them on the next unrelated\n    // signal write, surfacing errors in unexpected contexts.\n    if (s.batchDepth === 0) {\n      s.pendingSubscribers.clear();\n      s.dirtyWithEffectSubsA.clear();\n      s.dirtyWithEffectSubsB.clear();\n    }\n\n    throw e;\n  }\n\n  s.batchDepth--;\n\n  if (s.batchDepth === 0) flushEffects(s);\n\n  return result;\n};\n"],"mappings":";;;;AAgBA,IAAI,IAAe,IA6Bf,IAAa,GACX,IAA2C,CAAC,GAG5C,KAAkB,MACtB,EAAE,gBAAgB,MAAM,EAAE,uBAAuB,EAAE,sBAE/C,KACJ,GACA,MAIS;CACT,IAAM,IAAQ,EAAE;CAGhB,KAAK,IAAM,KAAO,EAAK,WAAW,GAChC,EAAE,mBAAmB,IAAI,CAAG;CAG9B,KAAK,IAAM,KAAK,EAAK,aAAa,GAChC,EAAgB,KAAK,CAAC;CAGxB,IAAI;EACF,OAAO,EAAgB,SAAS,IAAG;GACjC,IAAM,IAAI,EAAgB,IAAI;GAE1B,MAAE,mBAAmB,MAEzB,EAAE,iBAAiB,GAEd,EAAE,UAAU,IAIjB;IAAI,EAAE,WAAW,CAAC,CAAC,OAAO,KACxB,EAAe,CAAC,CAAC,CAAC,IAAI,CAAC;IAGzB,KAAK,IAAM,KAAc,EAAE,aAAa,GACtC,EAAgB,KAAK,CAAU;GAJR;EAM3B;CACF,UAAU;EACR,EAAgB,SAAS;CAC3B;AACF,GAEM,KAA2B,MAA6B;CAI5D,OAAO,EAAe,CAAC,CAAC,CAAC,OAAO,IAAG;EACjC,IAAM,IAAY,EAAe,CAAC;EAIlC,AADA,EAAE,cAAc,EAAE,gBAAgB,MAAM,MAAM,KAC9C,EAAe,CAAC,CAAC,CAAC,MAAM;EAExB,KAAK,IAAM,KAAK,GACT,MAAE,eAAe,KAEN,EAAE,eAEb,GAGL;QAAK,IAAM,KAAO,EAAE,WAAW,GAC7B,EAAE,mBAAmB,IAAI,CAAG;GAI9B,KAAK,IAAM,KAAc,EAAE,aAAa,GACtC,AAAI,EAAW,UAAU,KAAK,EAAW,WAAW,CAAC,CAAC,OAAO,KAC3D,EAAe,CAAC,CAAC,CAAC,IAAI,CAAU;EANN;EAWhC,EAAU,MAAM;CAClB;AACF,GAEM,KAAgB,MAA6B;CACjD,IAAI,IAAa;CAEjB,OAAO,EAAE,mBAAmB,OAAO,KAAK,EAAe,CAAC,CAAC,CAAC,OAAO,IAAG;EAClE,IAAI,EAAE,IAAA,KACJ,MAAM,IAAI,EAAwB,wCAA8D;EAKlG,IAFI,EAAe,CAAC,CAAC,CAAC,OAAO,KAAG,EAAwB,CAAC,GAErD,EAAE,mBAAmB,SAAS,GAAG;EAErC,IAAM,IAAmB,CAAC,GAAG,EAAE,kBAAkB;EAGjD,AADA,EAAE,mBAAmB,MAAM,GAC3B,EAAO,GAAkB,mBAAmB;CAC9C;AACF,GAOM,IAAc,WAAoD,SAAS,YAAY,MAEhF,KAAoB,MAAsC;CACrE,IAAI,CAAC,EAAK,eAAe,GAAG;CAE5B,AAAI,CAAC,KAAgB,KAAc,CAAC,EAAe,MACjD,IAAe,IACf,EACE,0NAEF;CAGF,IAAM,IAAI,EAAmB;CAI7B,AAFA,EAAe,GAAG,CAAI,GAElB,EAAE,eAAe,KAAG,EAAa,CAAC;AACxC,GAEa,KAAY,MAAmB;CAC1C,IAAM,IAAI,EAAmB;CAE7B,EAAE;CAEF,IAAI;CAEJ,IAAI;EACF,IAAS,EAAG;CACd,SAAS,GAAG;EAYV,MAXA,EAAE,cAKE,EAAE,eAAe,MACnB,EAAE,mBAAmB,MAAM,GAC3B,EAAE,qBAAqB,MAAM,GAC7B,EAAE,qBAAqB,MAAM,IAGzB;CACR;CAMA,OAJA,EAAE,cAEE,EAAE,eAAe,KAAG,EAAa,CAAC,GAE/B;AACT"}

package/dist/signal.cjs

@@ -1,2 +0,0 @@
-const e=require("./devtools-hook.cjs"),t=require("./tracking.cjs"),n=require("./scheduling.cjs"),r=require("./subscription.cjs"),i=require("./reactive-base.cjs");var a=class extends i.ReactiveBase{value_;equals_;disposed_;constructor(e,t,n){super(n),this.value_=e,this.equals_=t??Object.is,this.disposed_=!1}get value(){return this.disposed_||t.trackSource(this),this.value_}set value(r){if(this.disposed_||this.equals_(this.value_,r))return;let i=this.value_;this.value_=r,this.version=t.tickRevision(),e.getDevToolsHook()?.write?.({name:this.name,newValue:r,oldValue:i}),n.notifyNodeChange(this)}peek(){return this.value_}subscribe=e=>{if(this.disposed_){let e=new r.SubscriptionImpl(()=>{});return e.dispose(),e}return this.addEffectSub(e),new r.SubscriptionImpl(()=>{this.removeEffectSub(e)})};get disposed(){return this.disposed_}dispose(){this.disposed_||(this.disposed_=!0,this.clearSubscribers(),e.getDevToolsHook()?.dispose?.({kind:`signal`,name:this.name}))}[Symbol.dispose](){this.dispose()}},o=(e,t)=>new a(e,t?.equals,t?.name);exports.SignalImpl=a,exports.signal=o;
-//# sourceMappingURL=signal.cjs.map

package/dist/signal.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"signal.cjs","names":[],"sources":["../src/signal.ts"],"sourcesContent":["import type { Signal, SignalOptions, Subscription } from './types';\n\nimport { getDevToolsHook } from './devtools-hook';\nimport { ReactiveBase } from './reactive-base';\nimport { notifyNodeChange } from './scheduling';\nimport { SubscriptionImpl } from './subscription';\nimport { tickRevision, trackSource } from './tracking';\n\nexport class SignalImpl<T> extends ReactiveBase<T> implements Signal<T> {\n  private value_: T;\n  private equals_: (a: T, b: T) => boolean;\n  private disposed_: boolean;\n\n  constructor(initial: T, equals?: (a: T, b: T) => boolean, name?: string) {\n    super(name);\n    this.value_ = initial;\n    this.equals_ = equals ?? Object.is;\n    this.disposed_ = false;\n  }\n\n  get value(): T {\n    if (!this.disposed_) trackSource(this);\n\n    return this.value_;\n  }\n\n  set value(next: T) {\n    if (this.disposed_) return;\n\n    if (this.equals_(this.value_, next)) return;\n\n    const oldValue = this.value_;\n\n    this.value_ = next;\n    this.version = tickRevision();\n\n    getDevToolsHook()?.write?.({ name: this.name, newValue: next, oldValue });\n    notifyNodeChange(this);\n  }\n\n  peek(): T {\n    return this.value_;\n  }\n\n  readonly subscribe = (listener: () => void): Subscription => {\n    if (this.disposed_) {\n      const noop = new SubscriptionImpl(() => {});\n\n      noop.dispose();\n\n      return noop;\n    }\n\n    this.addEffectSub(listener);\n\n    return new SubscriptionImpl(() => {\n      this.removeEffectSub(listener);\n    });\n  };\n\n  /**\n   * Marks the signal as permanently inert. After disposal:\n   * - reads still return the last known value (but no longer track dependencies)\n   * - writes are silently ignored\n   * - new subscriptions are immediately unsubscribed\n   * - all existing subscriber and computed-subscriber references are dropped\n   */\n  get disposed(): boolean {\n    return this.disposed_;\n  }\n\n  dispose(): void {\n    if (this.disposed_) return;\n\n    this.disposed_ = true;\n    this.clearSubscribers();\n    getDevToolsHook()?.dispose?.({ kind: 'signal', name: this.name });\n  }\n\n  [Symbol.dispose](): void {\n    this.dispose();\n  }\n}\n\nexport const signal = <T>(initial: T, options?: SignalOptions<T>): Signal<T> =>\n  new SignalImpl(initial, options?.equals, options?.name);\n"],"mappings":"kKAQA,IAAa,EAAb,cAAmC,EAAA,YAAqC,CACtE,OACA,QACA,UAEA,YAAY,EAAY,EAAkC,EAAe,CACvE,MAAM,CAAI,EACV,KAAK,OAAS,EACd,KAAK,QAAU,GAAU,OAAO,GAChC,KAAK,UAAY,EACnB,CAEA,IAAI,OAAW,CAGb,OAFK,KAAK,WAAW,EAAA,YAAY,IAAI,EAE9B,KAAK,MACd,CAEA,IAAI,MAAM,EAAS,CAGjB,GAFI,KAAK,WAEL,KAAK,QAAQ,KAAK,OAAQ,CAAI,EAAG,OAErC,IAAM,EAAW,KAAK,OAEtB,KAAK,OAAS,EACd,KAAK,QAAU,EAAA,aAAa,EAE5B,EAAA,gBAAgB,CAAC,EAAE,QAAQ,CAAE,KAAM,KAAK,KAAM,SAAU,EAAM,UAAS,CAAC,EACxE,EAAA,iBAAiB,IAAI,CACvB,CAEA,MAAU,CACR,OAAO,KAAK,MACd,CAEA,UAAsB,GAAuC,CAC3D,GAAI,KAAK,UAAW,CAClB,IAAM,EAAO,IAAI,EAAA,qBAAuB,CAAC,CAAC,EAI1C,OAFA,EAAK,QAAQ,EAEN,CACT,CAIA,OAFA,KAAK,aAAa,CAAQ,EAEnB,IAAI,EAAA,qBAAuB,CAChC,KAAK,gBAAgB,CAAQ,CAC/B,CAAC,CACH,EASA,IAAI,UAAoB,CACtB,OAAO,KAAK,SACd,CAEA,SAAgB,CACV,KAAK,YAET,KAAK,UAAY,GACjB,KAAK,iBAAiB,EACtB,EAAA,gBAAgB,CAAC,EAAE,UAAU,CAAE,KAAM,SAAU,KAAM,KAAK,IAAK,CAAC,EAClE,CAEA,CAAC,OAAO,UAAiB,CACvB,KAAK,QAAQ,CACf,CACF,EAEa,GAAa,EAAY,IACpC,IAAI,EAAW,EAAS,GAAS,OAAQ,GAAS,IAAI"}

package/dist/signal.d.ts

@@ -1,24 +0,0 @@
-import type { Signal, SignalOptions, Subscription } from './types';
-import { ReactiveBase } from './reactive-base';
-export declare class SignalImpl<T> extends ReactiveBase<T> implements Signal<T> {
-    private value_;
-    private equals_;
-    private disposed_;
-    constructor(initial: T, equals?: (a: T, b: T) => boolean, name?: string);
-    get value(): T;
-    set value(next: T);
-    peek(): T;
-    readonly subscribe: (listener: () => void) => Subscription;
-    /**
-     * Marks the signal as permanently inert. After disposal:
-     * - reads still return the last known value (but no longer track dependencies)
-     * - writes are silently ignored
-     * - new subscriptions are immediately unsubscribed
-     * - all existing subscriber and computed-subscriber references are dropped
-     */
-    get disposed(): boolean;
-    dispose(): void;
-    [Symbol.dispose](): void;
-}
-export declare const signal: <T>(initial: T, options?: SignalOptions<T>) => Signal<T>;
-//# sourceMappingURL=signal.d.ts.map

package/dist/signal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../src/signal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGnE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAK/C,qBAAa,UAAU,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC;IACrE,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,SAAS,CAAU;gBAEf,OAAO,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM;IAOvE,IAAI,KAAK,IAAI,CAAC,CAIb;IAED,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,EAYhB;IAED,IAAI,IAAI,CAAC;IAIT,QAAQ,CAAC,SAAS,GAAI,UAAU,MAAM,IAAI,KAAG,YAAY,CAcvD;IAEF;;;;;;OAMG;IACH,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,OAAO,IAAI,IAAI;IAQf,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAGzB;AAED,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,aAAa,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CAClB,CAAC"}

package/dist/signal.js

@@ -1,54 +0,0 @@
-import { getDevToolsHook as e } from "./devtools-hook.js";
-import { tickRevision as t, trackSource as n } from "./tracking.js";
-import { notifyNodeChange as r } from "./scheduling.js";
-import { SubscriptionImpl as i } from "./subscription.js";
-import { ReactiveBase as a } from "./reactive-base.js";
-//#region src/signal.ts
-var o = class extends a {
-	value_;
-	equals_;
-	disposed_;
-	constructor(e, t, n) {
-		super(n), this.value_ = e, this.equals_ = t ?? Object.is, this.disposed_ = !1;
-	}
-	get value() {
-		return this.disposed_ || n(this), this.value_;
-	}
-	set value(n) {
-		if (this.disposed_ || this.equals_(this.value_, n)) return;
-		let i = this.value_;
-		this.value_ = n, this.version = t(), e()?.write?.({
-			name: this.name,
-			newValue: n,
-			oldValue: i
-		}), r(this);
-	}
-	peek() {
-		return this.value_;
-	}
-	subscribe = (e) => {
-		if (this.disposed_) {
-			let e = new i(() => {});
-			return e.dispose(), e;
-		}
-		return this.addEffectSub(e), new i(() => {
-			this.removeEffectSub(e);
-		});
-	};
-	get disposed() {
-		return this.disposed_;
-	}
-	dispose() {
-		this.disposed_ || (this.disposed_ = !0, this.clearSubscribers(), e()?.dispose?.({
-			kind: "signal",
-			name: this.name
-		}));
-	}
-	[Symbol.dispose]() {
-		this.dispose();
-	}
-}, s = (e, t) => new o(e, t?.equals, t?.name);
-//#endregion
-export { o as SignalImpl, s as signal };
-
-//# sourceMappingURL=signal.js.map

package/dist/signal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"signal.js","names":[],"sources":["../src/signal.ts"],"sourcesContent":["import type { Signal, SignalOptions, Subscription } from './types';\n\nimport { getDevToolsHook } from './devtools-hook';\nimport { ReactiveBase } from './reactive-base';\nimport { notifyNodeChange } from './scheduling';\nimport { SubscriptionImpl } from './subscription';\nimport { tickRevision, trackSource } from './tracking';\n\nexport class SignalImpl<T> extends ReactiveBase<T> implements Signal<T> {\n  private value_: T;\n  private equals_: (a: T, b: T) => boolean;\n  private disposed_: boolean;\n\n  constructor(initial: T, equals?: (a: T, b: T) => boolean, name?: string) {\n    super(name);\n    this.value_ = initial;\n    this.equals_ = equals ?? Object.is;\n    this.disposed_ = false;\n  }\n\n  get value(): T {\n    if (!this.disposed_) trackSource(this);\n\n    return this.value_;\n  }\n\n  set value(next: T) {\n    if (this.disposed_) return;\n\n    if (this.equals_(this.value_, next)) return;\n\n    const oldValue = this.value_;\n\n    this.value_ = next;\n    this.version = tickRevision();\n\n    getDevToolsHook()?.write?.({ name: this.name, newValue: next, oldValue });\n    notifyNodeChange(this);\n  }\n\n  peek(): T {\n    return this.value_;\n  }\n\n  readonly subscribe = (listener: () => void): Subscription => {\n    if (this.disposed_) {\n      const noop = new SubscriptionImpl(() => {});\n\n      noop.dispose();\n\n      return noop;\n    }\n\n    this.addEffectSub(listener);\n\n    return new SubscriptionImpl(() => {\n      this.removeEffectSub(listener);\n    });\n  };\n\n  /**\n   * Marks the signal as permanently inert. After disposal:\n   * - reads still return the last known value (but no longer track dependencies)\n   * - writes are silently ignored\n   * - new subscriptions are immediately unsubscribed\n   * - all existing subscriber and computed-subscriber references are dropped\n   */\n  get disposed(): boolean {\n    return this.disposed_;\n  }\n\n  dispose(): void {\n    if (this.disposed_) return;\n\n    this.disposed_ = true;\n    this.clearSubscribers();\n    getDevToolsHook()?.dispose?.({ kind: 'signal', name: this.name });\n  }\n\n  [Symbol.dispose](): void {\n    this.dispose();\n  }\n}\n\nexport const signal = <T>(initial: T, options?: SignalOptions<T>): Signal<T> =>\n  new SignalImpl(initial, options?.equals, options?.name);\n"],"mappings":";;;;;;AAQA,IAAa,IAAb,cAAmC,EAAqC;CACtE;CACA;CACA;CAEA,YAAY,GAAY,GAAkC,GAAe;EAIvE,AAHA,MAAM,CAAI,GACV,KAAK,SAAS,GACd,KAAK,UAAU,KAAU,OAAO,IAChC,KAAK,YAAY;CACnB;CAEA,IAAI,QAAW;EAGb,OAFK,KAAK,aAAW,EAAY,IAAI,GAE9B,KAAK;CACd;CAEA,IAAI,MAAM,GAAS;EAGjB,IAFI,KAAK,aAEL,KAAK,QAAQ,KAAK,QAAQ,CAAI,GAAG;EAErC,IAAM,IAAW,KAAK;EAMtB,AAJA,KAAK,SAAS,GACd,KAAK,UAAU,EAAa,GAE5B,EAAgB,CAAC,EAAE,QAAQ;GAAE,MAAM,KAAK;GAAM,UAAU;GAAM;EAAS,CAAC,GACxE,EAAiB,IAAI;CACvB;CAEA,OAAU;EACR,OAAO,KAAK;CACd;CAEA,aAAsB,MAAuC;EAC3D,IAAI,KAAK,WAAW;GAClB,IAAM,IAAO,IAAI,QAAuB,CAAC,CAAC;GAI1C,OAFA,EAAK,QAAQ,GAEN;EACT;EAIA,OAFA,KAAK,aAAa,CAAQ,GAEnB,IAAI,QAAuB;GAChC,KAAK,gBAAgB,CAAQ;EAC/B,CAAC;CACH;CASA,IAAI,WAAoB;EACtB,OAAO,KAAK;CACd;CAEA,UAAgB;EACV,KAAK,cAET,KAAK,YAAY,IACjB,KAAK,iBAAiB,GACtB,EAAgB,CAAC,EAAE,UAAU;GAAE,MAAM;GAAU,MAAM,KAAK;EAAK,CAAC;CAClE;CAEA,CAAC,OAAO,WAAiB;EACvB,KAAK,QAAQ;CACf;AACF,GAEa,KAAa,GAAY,MACpC,IAAI,EAAW,GAAS,GAAS,QAAQ,GAAS,IAAI"}

package/dist/src/devtools.cjs

@@ -1,2 +0,0 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../devtools-hook.cjs"),t=require("../tracking.cjs"),n=require("../effect.cjs");var r=t=>{e.setDevToolsHook(t),typeof globalThis<`u`&&(globalThis.__RIPPLE_DEVTOOLS__=t??void 0)},i=(e,r)=>{let i=r?.name??`anonymous`,a=[];return n.effect(()=>{let n=[],r=t.withSourceObserver(e=>{n.push({source:e,version:e.version})},e);if(a.length===0){if(n.length>0){console.group(`[ripple:debug] "${i}" initial deps:`);for(let e of n)console.debug(`  ${e.source.name??`(unnamed)`} (v${e.source.version})`);console.groupEnd()}}else{let e=a.filter(e=>e.source.version!==e.version);if(e.length>0){console.group(`[ripple:debug] "${i}" re-running — changed sources:`);for(let t of e)console.debug(`  ${t.source.name??`(unnamed)`} (v${t.version} -> v${t.source.version})`);console.groupEnd()}}return a=n,r},r)};exports.debugEffect=i,exports.installDevTools=r;
-//# sourceMappingURL=devtools.cjs.map