@vielzeug/ripple 1.3.0 → 2.0.0

package/dist/effect.js

@@ -1,174 +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, withScopeCleanups as c } from "./execution-context.js";
-import "./scheduling.js";
-import { AsyncSubscriptionImpl as l, SubscriptionImpl as u } from "./subscription.js";
-import { IS_COMPUTED as d, SUPPRESS_RUN_EVENT as f } from "./symbols.js";
-import { getTracking as p, withTracking as m } from "./tracking.js";
-//#region src/effect.ts
-var h = (e, t) => {
-	if (t === "sync" || t === void 0) return e;
-	let n = !1;
-	return () => {
-		n || (n = !0, queueMicrotask(() => {
-			n = !1, e();
-		}));
-	};
-}, g = (i, c) => {
-	let l = c?.scheduler ?? "sync", p = c?.name, g = c?.[f], _ = [], v = /* @__PURE__ */ new Set(), y = /* @__PURE__ */ new Map(), b = !1, x = !1, S = !1, C = () => {
-		if (y.clear(), _.length === 0 && v.size === 0) return;
-		let e = [..._, ...v];
-		_.length = 0, v.clear(), r(e, "effect teardown errors");
-	}, w = () => {
-		if (!S) {
-			if (b) {
-				x = !0;
-				return;
-			}
-			b = !0;
-			try {
-				let r = 0;
-				do {
-					if (++r > 100) throw new a(`infinite effect loop (> 100 iterations)${p ? ` in "${p}"` : ""}`);
-					x = !1, C(), g || e()?.run?.({ name: p });
-					let s;
-					try {
-						s = m({
-							cleanups: _,
-							deps: y,
-							effect: T,
-							kind: "effect",
-							subscriptions: v
-						}, i);
-					} catch (e) {
-						let r = [...t(v), ...t(_)];
-						_.length = 0, v.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" && _.push(s);
-				} while (x && !S);
-			} finally {
-				b = !1;
-			}
-		}
-	}, T = h(w, l);
-	w();
-	let E = new u(() => {
-		S || (S = !0, C(), e()?.dispose?.({
-			kind: "effect",
-			name: p
-		}));
-	});
-	return s()?.push(() => E.dispose()), {
-		dispose: () => E.dispose(),
-		get disposed() {
-			return E.disposed;
-		},
-		getDependencies() {
-			return [...y.keys()].map((e) => ({
-				kind: d in e ? "computed" : "signal",
-				name: e.name
-			}));
-		},
-		[Symbol.dispose]() {
-			E.dispose();
-		}
-	};
-}, _ = (e, t) => {
-	let n = null, r = null, i = null, a = t?.onError ?? ((e) => {
-		queueMicrotask(() => {
-			throw e;
-		});
-	});
-	return new l(g(() => {
-		n?.abort(), r?.(), r = null, n = new AbortController();
-		let { signal: t } = n, o = y(), 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);
-}, v = (e) => {
-	let t = p();
-	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.");
-}, y = (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 c(t, e);
-	}, l = () => {
-		a || (a = !0, n.abort(), r([...t].reverse(), "scope cleanup errors"), t.length = 0);
-	}, u = {
-		add: o,
-		get disposalSignal() {
-			return n.signal;
-		},
-		dispose: l,
-		get disposed() {
-			return a;
-		},
-		run: s,
-		[Symbol.dispose]: l
-	};
-	return e && s(e), u;
-};
-function b(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 = g(() => {
-			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 u(() => {
-			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 u(() => {
-			i?.(), i = void 0, o.dispose();
-		}), n?.immediate && (a(t, void 0), n.once && c.dispose());
-	}
-	return s()?.push(() => c.dispose()), c;
-}
-//#endregion
-export { g as effect, _ as effectAsync, v as onCleanup, y as scope, b 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 { getScopeCleanups, withScopeCleanups } from './execution-context';\nimport { DEFAULT_MAX_ITERATIONS } from './scheduling';\nimport { AsyncSubscriptionImpl, SubscriptionImpl } from './subscription';\nimport { IS_COMPUTED, SUPPRESS_RUN_EVENT } from './symbols';\nimport { getTracking, 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  // Internal-only escape hatch — see SUPPRESS_RUN_EVENT's JSDoc in symbols.ts.\n  // No public option can ever reach this: EffectOptions doesn't declare the key, and\n  // the symbol is never exported from index.ts.\n  const suppressRunEvent = (options as Partial<Record<typeof SUPPRESS_RUN_EVENT, boolean>> | undefined)?.[\n    SUPPRESS_RUN_EVENT\n  ];\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        if (!suppressRunEvent) 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/execution-context.cjs

@@ -1,2 +0,0 @@
-var e=()=>({activeDirty:`a`,batchDepth:0,dirtyWithEffectSubsA:new Set,dirtyWithEffectSubsB:new Set,pendingSubscribers:new Set}),t={scheduling:e(),scopeCleanups:null,tracking:null},n=null,r=()=>n===null?t:n.get(),i=(e,i)=>{let a={...r(),...e};if(n!==null)return n.run(a,i);let o=t;t=a;try{return i()}finally{t=o}},a=()=>r().scheduling,o=()=>n!==null,s=()=>r().scopeCleanups,c=(e,t)=>i({scopeCleanups:e},t),l=e=>{let t=n;return n=e,t};exports._installContextHook=l,exports.createSchedulingState=e,exports.getExecutionContext=r,exports.getSchedulingState=a,exports.getScopeCleanups=s,exports.hasContextHook=o,exports.runInContext=i,exports.withScopeCleanups=c;
-//# sourceMappingURL=execution-context.cjs.map

package/dist/execution-context.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"execution-context.cjs","names":[],"sources":["../src/execution-context.ts"],"sourcesContent":["// ── ExecutionContext ──────────────────────────────────────────────────────────\n//\n// Owns the one piece of process-wide (or, once an SSR hook is installed,\n// per-request) mutable state every reactive primitive reads through: the active\n// scheduling bucket, the active scope's cleanup array, and the active tracking\n// context. Split out of tracking.ts so this file's only job is \"where does the\n// current execution context live and how do you swap it\" — tracking.ts owns\n// what a TrackingCtx *means* (dep collection), this file owns how one gets\n// installed for the duration of a call.\n//\n// TrackingCtx is imported type-only here (erased at compile time) so tracking.ts\n// can depend on this file's runtime exports (getExecutionContext, runInContext)\n// without creating an actual circular import — only one direction is real at\n// runtime: tracking.ts -> execution-context.ts.\n\nimport type { ComputedBase } from './reactive-base';\nimport type { TrackingCtx } from './tracking';\nimport type { CleanupFn, Subscriber } from './types';\n\n// ── Scheduling state ────────────────────────────────────────────────────────\n//\n// batchDepth, pendingSubscribers, and the dirty-computed sets live here (rather\n// than as scheduling.ts module-level variables) so the /ripple/ssr sub-path can\n// isolate the flush queue per request via the same context hook that isolates\n// tracking — closing the gap where concurrent SSR requests would otherwise share\n// one flush queue. Outside SSR (no hook installed), this is a single\n// module-level singleton with identical behavior and cost to a plain global.\n\nexport type SchedulingState = {\n  activeDirty: 'a' | 'b';\n  batchDepth: number;\n  readonly dirtyWithEffectSubsA: Set<ComputedBase<unknown>>;\n  readonly dirtyWithEffectSubsB: Set<ComputedBase<unknown>>;\n  readonly pendingSubscribers: Set<Subscriber>;\n};\n\nexport const createSchedulingState = (): SchedulingState => ({\n  activeDirty: 'a',\n  batchDepth: 0,\n  dirtyWithEffectSubsA: new Set(),\n  dirtyWithEffectSubsB: new Set(),\n  pendingSubscribers: new Set(),\n});\n\n// ── The context itself ────────────────────────────────────────────────────────\n\nexport type ExecutionContext = {\n  readonly scheduling: SchedulingState;\n  readonly scopeCleanups: CleanupFn[] | null;\n  readonly tracking: TrackingCtx | null;\n};\n\nexport type ContextHook = {\n  get(): ExecutionContext;\n  run<T>(ctx: ExecutionContext, fn: () => T): T;\n};\n\nlet _ctx: ExecutionContext = { scheduling: createSchedulingState(), scopeCleanups: null, tracking: null };\nlet _hook: ContextHook | null = null;\n\n/** Returns the active context — the installed SSR hook's, or the module-level singleton. */\nexport const getExecutionContext = (): ExecutionContext => (_hook !== null ? _hook.get() : _ctx);\n\n/**\n * Runs `fn` with `patch` merged onto the active context, restoring the previous\n * context afterwards. Delegates to the SSR hook when one is installed (it owns its\n * own restore semantics, e.g. via AsyncLocalStorage); otherwise swaps the module-level\n * singleton directly. Every \"run with a modified context\" helper (withTracking,\n * withScopeCleanups) is a one-line call to this — there is exactly one context\n * swap/restore implementation.\n *\n * Takes a `Partial<ExecutionContext>` (merged internally), not a full replacement\n * context — a caller can only ever override the field(s) it names, so it's\n * impossible to accidentally drop `scheduling` or `scopeCleanups` by forgetting to\n * spread the current context first.\n */\nexport const runInContext = <T>(patch: Partial<ExecutionContext>, fn: () => T): T => {\n  const ctx = { ...getExecutionContext(), ...patch };\n\n  if (_hook !== null) return _hook.run(ctx, fn);\n\n  const prev = _ctx;\n\n  _ctx = ctx;\n\n  try {\n    return fn();\n  } finally {\n    _ctx = prev;\n  }\n};\n\n/** Returns the scheduling-state bucket for the active execution context. */\nexport const getSchedulingState = (): SchedulingState => getExecutionContext().scheduling;\n\n/** `true` once an SSR context hook is installed — scheduling state is then request-isolated. */\nexport const hasContextHook = (): boolean => _hook !== null;\n\n// ── Scope cleanup ─────────────────────────────────────────────────────────────\n\n/** Returns the cleanup array of the innermost active scope, or `null` if not inside a scope. */\nexport const getScopeCleanups = (): CleanupFn[] | null => getExecutionContext().scopeCleanups;\n\n/**\n * Pushes `cleanups` as the active scope cleanup array for the duration of `fn`.\n * Any `onCleanup()` calls inside `fn` register into these cleanups; effects and\n * computed values created inside `fn` auto-register their disposal too.\n */\nexport const withScopeCleanups = <T>(cleanups: CleanupFn[], fn: () => T): T =>\n  runInContext({ scopeCleanups: cleanups }, fn);\n\n// ── Context hook (for SSR) ────────────────────────────────────────────────────\n\n/**\n * @internal Used only by `/ripple/ssr`.\n * Installs a context hook that overrides both tracking and scope-cleanup access.\n * Returns the previous hook so callers can restore it.\n */\nexport const _installContextHook = (hook: ContextHook | null): ContextHook | null => {\n  const prev = _hook;\n\n  _hook = hook;\n\n  return prev;\n};\n"],"mappings":"AAoCA,IAAa,OAAgD,CAC3D,YAAa,IACb,WAAY,EACZ,qBAAsB,IAAI,IAC1B,qBAAsB,IAAI,IAC1B,mBAAoB,IAAI,GAC1B,GAeI,EAAyB,CAAE,WAAY,EAAsB,EAAG,cAAe,KAAM,SAAU,IAAK,EACpG,EAA4B,KAGnB,MAA+C,IAAU,KAAqB,EAAd,EAAM,IAAI,EAe1E,GAAmB,EAAkC,IAAmB,CACnF,IAAM,EAAM,CAAE,GAAG,EAAoB,EAAG,GAAG,CAAM,EAEjD,GAAI,IAAU,KAAM,OAAO,EAAM,IAAI,EAAK,CAAE,EAE5C,IAAM,EAAO,EAEb,EAAO,EAEP,GAAI,CACF,OAAO,EAAG,CACZ,QAAU,CACR,EAAO,CACT,CACF,EAGa,MAA4C,EAAoB,CAAC,CAAC,WAGlE,MAAgC,IAAU,KAK1C,MAA6C,EAAoB,CAAC,CAAC,cAOnE,GAAwB,EAAuB,IAC1D,EAAa,CAAE,cAAe,CAAS,EAAG,CAAE,EASjC,EAAuB,GAAiD,CACnF,IAAM,EAAO,EAIb,MAFA,GAAQ,EAED,CACT"}

package/dist/execution-context.d.ts

@@ -1,49 +0,0 @@
-import type { ComputedBase } from './reactive-base';
-import type { TrackingCtx } from './tracking';
-import type { CleanupFn, Subscriber } from './types';
-export type SchedulingState = {
-    activeDirty: 'a' | 'b';
-    batchDepth: number;
-    readonly dirtyWithEffectSubsA: Set<ComputedBase<unknown>>;
-    readonly dirtyWithEffectSubsB: Set<ComputedBase<unknown>>;
-    readonly pendingSubscribers: Set<Subscriber>;
-};
-export declare const createSchedulingState: () => SchedulingState;
-export type ExecutionContext = {
-    readonly scheduling: SchedulingState;
-    readonly scopeCleanups: CleanupFn[] | null;
-    readonly tracking: TrackingCtx | null;
-};
-export type ContextHook = {
-    get(): ExecutionContext;
-    run<T>(ctx: ExecutionContext, fn: () => T): T;
-};
-/** Returns the active context — the installed SSR hook's, or the module-level singleton. */
-export declare const getExecutionContext: () => ExecutionContext;
-/**
- * Runs `fn` with `patch` merged onto the active context, restoring the previous
- * context afterwards. Delegates to the SSR hook when one is installed (it owns its
- * own restore semantics, e.g. via AsyncLocalStorage); otherwise swaps the module-level
- * singleton directly. Every "run with a modified context" helper (withTracking,
- * withScopeCleanups) is a one-line call to this — there is exactly one context
- * swap/restore implementation.
- *
- * Takes a `Partial<ExecutionContext>` (merged internally), not a full replacement
- * context — a caller can only ever override the field(s) it names, so it's
- * impossible to accidentally drop `scheduling` or `scopeCleanups` by forgetting to
- * spread the current context first.
- */
-export declare const runInContext: <T>(patch: Partial<ExecutionContext>, fn: () => T) => T;
-/** Returns the scheduling-state bucket for the active execution context. */
-export declare const getSchedulingState: () => SchedulingState;
-/** `true` once an SSR context hook is installed — scheduling state is then request-isolated. */
-export declare const hasContextHook: () => boolean;
-/** Returns the cleanup array of the innermost active scope, or `null` if not inside a scope. */
-export declare const getScopeCleanups: () => CleanupFn[] | null;
-/**
- * Pushes `cleanups` as the active scope cleanup array for the duration of `fn`.
- * Any `onCleanup()` calls inside `fn` register into these cleanups; effects and
- * computed values created inside `fn` auto-register their disposal too.
- */
-export declare const withScopeCleanups: <T>(cleanups: CleanupFn[], fn: () => T) => T;
-//# sourceMappingURL=execution-context.d.ts.map

package/dist/execution-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"execution-context.d.ts","sourceRoot":"","sources":["../src/execution-context.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAWrD,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,GAAG,GAAG,GAAG,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,oBAAoB,EAAE,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,QAAQ,CAAC,oBAAoB,EAAE,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,QAAQ,CAAC,kBAAkB,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;CAC9C,CAAC;AAEF,eAAO,MAAM,qBAAqB,QAAO,eAMvC,CAAC;AAIH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,IAAI,gBAAgB,CAAC;IACxB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,gBAAgB,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;CAC/C,CAAC;AAKF,4FAA4F;AAC5F,eAAO,MAAM,mBAAmB,QAAO,gBAAyD,CAAC;AAEjG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,OAAO,OAAO,CAAC,gBAAgB,CAAC,EAAE,IAAI,MAAM,CAAC,KAAG,CAc/E,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,QAAO,eAAmD,CAAC;AAE1F,gGAAgG;AAChG,eAAO,MAAM,cAAc,QAAO,OAAyB,CAAC;AAI5D,gGAAgG;AAChG,eAAO,MAAM,gBAAgB,QAAO,SAAS,EAAE,GAAG,IAA2C,CAAC;AAE9F;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,UAAU,SAAS,EAAE,EAAE,IAAI,MAAM,CAAC,KAAG,CAC3B,CAAC"}

package/dist/execution-context.js

@@ -1,32 +0,0 @@
-//#region src/execution-context.ts
-var e = () => ({
-	activeDirty: "a",
-	batchDepth: 0,
-	dirtyWithEffectSubsA: /* @__PURE__ */ new Set(),
-	dirtyWithEffectSubsB: /* @__PURE__ */ new Set(),
-	pendingSubscribers: /* @__PURE__ */ new Set()
-}), t = {
-	scheduling: e(),
-	scopeCleanups: null,
-	tracking: null
-}, n = null, r = () => n === null ? t : n.get(), i = (e, i) => {
-	let a = {
-		...r(),
-		...e
-	};
-	if (n !== null) return n.run(a, i);
-	let o = t;
-	t = a;
-	try {
-		return i();
-	} finally {
-		t = o;
-	}
-}, a = () => r().scheduling, o = () => n !== null, s = () => r().scopeCleanups, c = (e, t) => i({ scopeCleanups: e }, t), l = (e) => {
-	let t = n;
-	return n = e, t;
-};
-//#endregion
-export { l as _installContextHook, e as createSchedulingState, r as getExecutionContext, a as getSchedulingState, s as getScopeCleanups, o as hasContextHook, i as runInContext, c as withScopeCleanups };
-
-//# sourceMappingURL=execution-context.js.map

package/dist/execution-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"execution-context.js","names":[],"sources":["../src/execution-context.ts"],"sourcesContent":["// ── ExecutionContext ──────────────────────────────────────────────────────────\n//\n// Owns the one piece of process-wide (or, once an SSR hook is installed,\n// per-request) mutable state every reactive primitive reads through: the active\n// scheduling bucket, the active scope's cleanup array, and the active tracking\n// context. Split out of tracking.ts so this file's only job is \"where does the\n// current execution context live and how do you swap it\" — tracking.ts owns\n// what a TrackingCtx *means* (dep collection), this file owns how one gets\n// installed for the duration of a call.\n//\n// TrackingCtx is imported type-only here (erased at compile time) so tracking.ts\n// can depend on this file's runtime exports (getExecutionContext, runInContext)\n// without creating an actual circular import — only one direction is real at\n// runtime: tracking.ts -> execution-context.ts.\n\nimport type { ComputedBase } from './reactive-base';\nimport type { TrackingCtx } from './tracking';\nimport type { CleanupFn, Subscriber } from './types';\n\n// ── Scheduling state ────────────────────────────────────────────────────────\n//\n// batchDepth, pendingSubscribers, and the dirty-computed sets live here (rather\n// than as scheduling.ts module-level variables) so the /ripple/ssr sub-path can\n// isolate the flush queue per request via the same context hook that isolates\n// tracking — closing the gap where concurrent SSR requests would otherwise share\n// one flush queue. Outside SSR (no hook installed), this is a single\n// module-level singleton with identical behavior and cost to a plain global.\n\nexport type SchedulingState = {\n  activeDirty: 'a' | 'b';\n  batchDepth: number;\n  readonly dirtyWithEffectSubsA: Set<ComputedBase<unknown>>;\n  readonly dirtyWithEffectSubsB: Set<ComputedBase<unknown>>;\n  readonly pendingSubscribers: Set<Subscriber>;\n};\n\nexport const createSchedulingState = (): SchedulingState => ({\n  activeDirty: 'a',\n  batchDepth: 0,\n  dirtyWithEffectSubsA: new Set(),\n  dirtyWithEffectSubsB: new Set(),\n  pendingSubscribers: new Set(),\n});\n\n// ── The context itself ────────────────────────────────────────────────────────\n\nexport type ExecutionContext = {\n  readonly scheduling: SchedulingState;\n  readonly scopeCleanups: CleanupFn[] | null;\n  readonly tracking: TrackingCtx | null;\n};\n\nexport type ContextHook = {\n  get(): ExecutionContext;\n  run<T>(ctx: ExecutionContext, fn: () => T): T;\n};\n\nlet _ctx: ExecutionContext = { scheduling: createSchedulingState(), scopeCleanups: null, tracking: null };\nlet _hook: ContextHook | null = null;\n\n/** Returns the active context — the installed SSR hook's, or the module-level singleton. */\nexport const getExecutionContext = (): ExecutionContext => (_hook !== null ? _hook.get() : _ctx);\n\n/**\n * Runs `fn` with `patch` merged onto the active context, restoring the previous\n * context afterwards. Delegates to the SSR hook when one is installed (it owns its\n * own restore semantics, e.g. via AsyncLocalStorage); otherwise swaps the module-level\n * singleton directly. Every \"run with a modified context\" helper (withTracking,\n * withScopeCleanups) is a one-line call to this — there is exactly one context\n * swap/restore implementation.\n *\n * Takes a `Partial<ExecutionContext>` (merged internally), not a full replacement\n * context — a caller can only ever override the field(s) it names, so it's\n * impossible to accidentally drop `scheduling` or `scopeCleanups` by forgetting to\n * spread the current context first.\n */\nexport const runInContext = <T>(patch: Partial<ExecutionContext>, fn: () => T): T => {\n  const ctx = { ...getExecutionContext(), ...patch };\n\n  if (_hook !== null) return _hook.run(ctx, fn);\n\n  const prev = _ctx;\n\n  _ctx = ctx;\n\n  try {\n    return fn();\n  } finally {\n    _ctx = prev;\n  }\n};\n\n/** Returns the scheduling-state bucket for the active execution context. */\nexport const getSchedulingState = (): SchedulingState => getExecutionContext().scheduling;\n\n/** `true` once an SSR context hook is installed — scheduling state is then request-isolated. */\nexport const hasContextHook = (): boolean => _hook !== null;\n\n// ── Scope cleanup ─────────────────────────────────────────────────────────────\n\n/** Returns the cleanup array of the innermost active scope, or `null` if not inside a scope. */\nexport const getScopeCleanups = (): CleanupFn[] | null => getExecutionContext().scopeCleanups;\n\n/**\n * Pushes `cleanups` as the active scope cleanup array for the duration of `fn`.\n * Any `onCleanup()` calls inside `fn` register into these cleanups; effects and\n * computed values created inside `fn` auto-register their disposal too.\n */\nexport const withScopeCleanups = <T>(cleanups: CleanupFn[], fn: () => T): T =>\n  runInContext({ scopeCleanups: cleanups }, fn);\n\n// ── Context hook (for SSR) ────────────────────────────────────────────────────\n\n/**\n * @internal Used only by `/ripple/ssr`.\n * Installs a context hook that overrides both tracking and scope-cleanup access.\n * Returns the previous hook so callers can restore it.\n */\nexport const _installContextHook = (hook: ContextHook | null): ContextHook | null => {\n  const prev = _hook;\n\n  _hook = hook;\n\n  return prev;\n};\n"],"mappings":";AAoCA,IAAa,WAAgD;CAC3D,aAAa;CACb,YAAY;CACZ,sCAAsB,IAAI,IAAI;CAC9B,sCAAsB,IAAI,IAAI;CAC9B,oCAAoB,IAAI,IAAI;AAC9B,IAeI,IAAyB;CAAE,YAAY,EAAsB;CAAG,eAAe;CAAM,UAAU;AAAK,GACpG,IAA4B,MAGnB,UAA+C,MAAU,OAAqB,IAAd,EAAM,IAAI,GAe1E,KAAmB,GAAkC,MAAmB;CACnF,IAAM,IAAM;EAAE,GAAG,EAAoB;EAAG,GAAG;CAAM;CAEjD,IAAI,MAAU,MAAM,OAAO,EAAM,IAAI,GAAK,CAAE;CAE5C,IAAM,IAAO;CAEb,IAAO;CAEP,IAAI;EACF,OAAO,EAAG;CACZ,UAAU;EACR,IAAO;CACT;AACF,GAGa,UAA4C,EAAoB,CAAC,CAAC,YAGlE,UAAgC,MAAU,MAK1C,UAA6C,EAAoB,CAAC,CAAC,eAOnE,KAAwB,GAAuB,MAC1D,EAAa,EAAE,eAAe,EAAS,GAAG,CAAE,GASjC,KAAuB,MAAiD;CACnF,IAAM,IAAO;CAIb,OAFA,IAAQ,GAED;AACT"}

package/dist/history.d.ts

@@ -1,56 +0,0 @@
-/**
- * @vielzeug/ripple — snapshot-based store undo/redo.
- *
- * Import from the dedicated sub-path so it is tree-shaken from bundles that
- * never use it:
- * ```ts
- * import { storeWithHistory } from '@vielzeug/ripple/history';
- * ```
- *
- * This is a thin, synchronous, single-store adapter — for async commands,
- * multi-step undo grouping, or history over anything other than a `Store<T>`,
- * use `@vielzeug/ledger` instead.
- */
-import type { Store, StoreWithHistory } from './types';
-export type { HistoryEntry, StoreWithHistory } from './types';
-/**
- * Wraps a store (or creates one from an initial value) with explicit snapshot history
- * for undo/redo / time-travel.
- *
- * **Ownership:** if called with an initial value, the adapter creates and owns
- * the underlying store — `dispose()` will also dispose it. If called with an
- * existing `Store<T>`, the adapter does NOT own it — `dispose()` leaves the
- * store alive.
- *
- * History is **explicit** — call `push()` or `pushNamed()` after mutations you want
- * to be undoable. This gives you full control over snapshot granularity: you can
- * batch multiple mutations before pushing, or avoid pushing for programmatic
- * operations like server sync or reset-and-reload.
- *
- * This is a pure external adapter — it does not access any store internals.
- *
- * @example
- * ```ts
- * const h = storeWithHistory({ count: 0 }, { maxHistory: 10 });
- *
- * h.patch({ count: 1 });
- * h.push();          // save checkpoint
- * h.patch({ count: 2 });
- * h.pushNamed('increment');
- *
- * h.undo();          // back to { count: 1 }
- * h.redo();          // forward to { count: 2 }
- * h.historyAt(0);    // { label: undefined, state: { count: 0 } }
- * h.canUndo;         // true
- *
- * // Wrap an existing store:
- * const existingStore = store({ x: 0 });
- * const h2 = storeWithHistory(existingStore);
- * h2.dispose(); // existingStore is NOT disposed
- * ```
- */
-export declare const storeWithHistory: <T extends object>(storeOrInitial: Store<T> | T, options?: {
-    maxHistory?: number;
-    name?: string;
-}) => StoreWithHistory<T>;
-//# sourceMappingURL=history.d.ts.map

package/dist/history.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../src/history.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAgB,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAQrE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAO9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,EAC/C,gBAAgB,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAC5B,UAAU;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KAC/C,gBAAgB,CAAC,CAAC,CAgGpB,CAAC"}

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("./execution-context.cjs"),r=require("./_dev.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&&!n.hasContextHook()&&(i=!0,r.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=n.getSchedulingState();c(t,e),t.batchDepth===0&&u(t)},p=e=>{let t=n.getSchedulingState();t.batchDepth++;let r;try{r=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),r};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 './execution-context';\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":"6HAgBA,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"}