@vielzeug/ripple 1.2.0

package/README.md

@@ -0,0 +1,101 @@
+# @vielzeug/ripple
+
+> Tiny, type-safe reactive primitives — signals, effects, computed values, and object stores. Zero dependencies, works everywhere.
+
+[![npm version](https://img.shields.io/npm/v/@vielzeug/ripple)](https://www.npmjs.com/package/@vielzeug/ripple) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+<details>
+<summary>Quick Reference</summary>
+
+**Package:** `@vielzeug/ripple` &nbsp;·&nbsp; **Category:** State
+
+**Key exports:** `signal`, `computed`, `effect`, `effectAsync`, `resource`, `watch`, `batch`, `store`, `storeWithHistory`, `untrack`, `scope`, `onCleanup`, `readonly`, `isSignal`, `isComputed`, `isStore`
+
+**When to use:** Fine-grained reactivity without a framework. Powers Ore templates. Works in any TS/JS environment including Node, Deno, and SSR.
+
+**Related:** [@vielzeug/ore](https://vielzeug.dev/ore/) · [@vielzeug/forge](https://vielzeug.dev/forge/) · [@vielzeug/herald](https://vielzeug.dev/herald/)
+
+</details>
+
+`@vielzeug/ripple` is part of Vielzeug and ships as a zero-dependency TypeScript package with ESM+CJS output.
+
+## Installation
+
+```sh
+# pnpm
+pnpm add @vielzeug/ripple
+# npm
+npm install @vielzeug/ripple
+# yarn
+yarn add @vielzeug/ripple
+```
+
+## Sub-paths
+
+| Import                      | Purpose                                                                  |
+| --------------------------- | ------------------------------------------------------------------------ |
+| `@vielzeug/ripple`          | Core primitives and types                                                |
+| `@vielzeug/ripple/devtools` | `installDevTools`, `debugEffect` — dev-only, tree-shaken from production |
+| `@vielzeug/ripple/ssr`      | SSR tracking isolation helpers (`setTrackingProvider`, `createAsyncProvider`, `withProvider`, `runWithProvider`). Node.js only — do not import in browser builds. |
+
+## Quick Start
+
+```ts
+import { signal, computed, effect, store, watch, batch } from '@vielzeug/ripple';
+
+// Signals
+const count = signal(0);
+const doubled = computed(() => count.value * 2); // Computed<number>
+
+const sub = effect(() => {
+  console.log('doubled:', doubled.value); // re-runs when count changes
+});
+
+count.value = 5; // → logs "doubled: 10"
+sub.dispose();
+doubled.dispose();
+
+// Stores with typed lenses
+const cart = store({ items: 0, label: 'empty' });
+const items = cart.lens('items'); // Signal<number> — cached, path-scoped
+
+items.value = 3;
+console.log(cart.value); // { items: 3, label: 'empty' }
+
+cart.replace((s) => ({ ...s, label: 'checkout' })); // replace entire state via fn
+cart.reset();
+
+// Effect options — scheduler, name
+const stop = effect(() => console.log('items:', items.value), { scheduler: 'microtask', name: 'cart-logger' });
+stop.dispose();
+
+// Async resource — tracks deps and re-runs on change
+import { resource } from '@vielzeug/ripple';
+
+const userId = signal('u1');
+const userState = resource(async (signal) => {
+  const id = userId.value; // tracked dep
+  return fetch(`/users/${id}`, { signal }).then((r) => r.json());
+});
+// userState.value → { status: 'loading' | 'ready' | 'error', data, error }
+
+// Store with undo/redo history
+import { storeWithHistory } from '@vielzeug/ripple';
+
+const editor = storeWithHistory({ text: '' }, { maxHistory: 50 });
+editor.patch({ text: 'hello' });
+editor.patch({ text: 'hello world' });
+editor.undo(); // back to 'hello'
+editor.redo(); // forward to 'hello world'
+```
+
+## Documentation
+
+- [Overview](https://vielzeug.dev/ripple/)
+- [Usage Guide](https://vielzeug.dev/ripple/usage)
+- [API Reference](https://vielzeug.dev/ripple/api)
+- [Examples](https://vielzeug.dev/ripple/examples)
+
+## License
+
+MIT © [Helmuth Saatkamp](https://github.com/helmuthdu) — part of the [Vielzeug](https://github.com/helmuthdu/vielzeug) monorepo.

package/dist/_dev.cjs

@@ -0,0 +1,2 @@
+var e=!globalThis.__RIPPLE_PROD__;function t(t){e&&console.warn(`[@vielzeug/ripple] ${t}`)}exports.warn=t;
+//# sourceMappingURL=_dev.cjs.map

package/dist/_dev.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dev.cjs","names":[],"sources":["../src/_dev.ts"],"sourcesContent":["const isDev = !(globalThis as { __RIPPLE_PROD__?: boolean }).__RIPPLE_PROD__;\n\n/** @internal @security Messages may include user-supplied data. */\nexport function warn(msg: string): void {\n  if (isDev) console.warn(`[@vielzeug/ripple] ${msg}`);\n}\n"],"mappings":"AAAA,IAAM,EAAQ,CAAE,WAA6C,gBAG7D,SAAgB,EAAK,EAAmB,CAClC,GAAO,QAAQ,KAAK,sBAAsB,GAAK,CACrD"}

package/dist/_dev.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=_dev.d.ts.map

package/dist/_dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dev.d.ts","sourceRoot":"","sources":["../src/_dev.ts"],"names":[],"mappings":""}

package/dist/_dev.js

@@ -0,0 +1,9 @@
+//#region src/_dev.ts
+var e = !globalThis.__RIPPLE_PROD__;
+function t(t) {
+	e && console.warn(`[@vielzeug/ripple] ${t}`);
+}
+//#endregion
+export { t as warn };
+
+//# sourceMappingURL=_dev.js.map

package/dist/_dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dev.js","names":[],"sources":["../src/_dev.ts"],"sourcesContent":["const isDev = !(globalThis as { __RIPPLE_PROD__?: boolean }).__RIPPLE_PROD__;\n\n/** @internal @security Messages may include user-supplied data. */\nexport function warn(msg: string): void {\n  if (isDev) console.warn(`[@vielzeug/ripple] ${msg}`);\n}\n"],"mappings":";AAAA,IAAM,IAAQ,CAAE,WAA6C;AAG7D,SAAgB,EAAK,GAAmB;CACtC,AAAI,KAAO,QAAQ,KAAK,sBAAsB,GAAK;AACrD"}

package/dist/_error-utils.cjs

@@ -0,0 +1,2 @@
+var e=e=>e instanceof Error?e:Error(`Non-Error thrown: ${String(e)}`),t=t=>{let n=[];for(let r of t)try{r()}catch(t){n.push(e(t))}return n},n=(e,n)=>{let r=t(e);if(r.length===1)throw r[0];if(r.length>0)throw AggregateError(r,n)},r=(t,n,r)=>{throw n.length===0?t:AggregateError([e(t),...n],r,{cause:e(t)})};exports.collectErrors=t,exports.ensureError=e,exports.rethrowWith=r,exports.runAll=n;
+//# sourceMappingURL=_error-utils.cjs.map

package/dist/_error-utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_error-utils.cjs","names":[],"sources":["../src/_error-utils.ts"],"sourcesContent":["import type { CleanupFn } from './types';\n\n/**\n * Coerces any thrown value to an `Error`.\n * Non-Error throws (strings, numbers, etc.) are wrapped in a plain `Error`\n * with a descriptive message — they are NOT mis-branded as `RippleError`.\n */\nexport const ensureError = (error: unknown): Error =>\n  error instanceof Error ? error : new Error(`Non-Error thrown: ${String(error)}`);\n\n/**\n * Runs each fn in `fns`, collecting any thrown errors. Does NOT re-throw.\n */\nexport const collectErrors = (fns: Iterable<CleanupFn>): Error[] => {\n  const errors: Error[] = [];\n\n  for (const fn of fns) {\n    try {\n      fn();\n    } catch (e) {\n      errors.push(ensureError(e));\n    }\n  }\n\n  return errors;\n};\n\n/**\n * Runs all `fns`, collecting errors.\n * - Single error: re-throws the original error directly (preserves type + stack).\n * - Multiple errors: wraps in AggregateError with the given context label.\n */\nexport const runAll = (fns: Iterable<CleanupFn>, context: string): void => {\n  const errors = collectErrors(fns);\n\n  if (errors.length === 1) throw errors[0]!;\n\n  if (errors.length > 0) {\n    throw new AggregateError(errors, context);\n  }\n};\n\n/**\n * Re-throws `primary`, augmented with any extra errors as an AggregateError.\n * If `extras` is empty, throws `primary` directly (preserves original type + stack).\n * Otherwise, `primary` is set as the `.cause` so callers can identify the root failure.\n */\nexport const rethrowWith = (primary: unknown, extras: Error[], context: string): never => {\n  if (extras.length === 0) throw primary;\n\n  throw new AggregateError([ensureError(primary), ...extras], context, {\n    cause: ensureError(primary),\n  });\n};\n"],"mappings":"AAOA,IAAa,EAAe,GAC1B,aAAiB,MAAQ,EAAY,MAAM,qBAAqB,OAAO,CAAK,GAAG,EAKpE,EAAiB,GAAsC,CAClE,IAAM,EAAkB,CAAC,EAEzB,IAAK,IAAM,KAAM,EACf,GAAI,CACF,EAAG,CACL,OAAS,EAAG,CACV,EAAO,KAAK,EAAY,CAAC,CAAC,CAC5B,CAGF,OAAO,CACT,EAOa,GAAU,EAA0B,IAA0B,CACzE,IAAM,EAAS,EAAc,CAAG,EAEhC,GAAI,EAAO,SAAW,EAAG,MAAM,EAAO,GAEtC,GAAI,EAAO,OAAS,EAClB,MAAU,eAAe,EAAQ,CAAO,CAE5C,EAOa,GAAe,EAAkB,EAAiB,IAA2B,CAGxF,MAFI,EAAO,SAAW,EAAS,EAErB,eAAe,CAAC,EAAY,CAAO,EAAG,GAAG,CAAM,EAAG,EAAS,CACnE,MAAO,EAAY,CAAO,CAC5B,CAAC,CACH"}

package/dist/_error-utils.d.ts

@@ -0,0 +1,24 @@
+import type { CleanupFn } from './types';
+/**
+ * Coerces any thrown value to an `Error`.
+ * Non-Error throws (strings, numbers, etc.) are wrapped in a plain `Error`
+ * with a descriptive message — they are NOT mis-branded as `RippleError`.
+ */
+export declare const ensureError: (error: unknown) => Error;
+/**
+ * Runs each fn in `fns`, collecting any thrown errors. Does NOT re-throw.
+ */
+export declare const collectErrors: (fns: Iterable<CleanupFn>) => Error[];
+/**
+ * Runs all `fns`, collecting errors.
+ * - Single error: re-throws the original error directly (preserves type + stack).
+ * - Multiple errors: wraps in AggregateError with the given context label.
+ */
+export declare const runAll: (fns: Iterable<CleanupFn>, context: string) => void;
+/**
+ * Re-throws `primary`, augmented with any extra errors as an AggregateError.
+ * If `extras` is empty, throws `primary` directly (preserves original type + stack).
+ * Otherwise, `primary` is set as the `.cause` so callers can identify the root failure.
+ */
+export declare const rethrowWith: (primary: unknown, extras: Error[], context: string) => never;
+//# sourceMappingURL=_error-utils.d.ts.map

package/dist/_error-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_error-utils.d.ts","sourceRoot":"","sources":["../src/_error-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,KACqC,CAAC;AAEnF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,QAAQ,CAAC,SAAS,CAAC,KAAG,KAAK,EAY7D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,KAAG,IAQlE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,OAAO,EAAE,QAAQ,KAAK,EAAE,EAAE,SAAS,MAAM,KAAG,KAMhF,CAAC"}

package/dist/_error-utils.js

@@ -0,0 +1,20 @@
+//#region src/_error-utils.ts
+var e = (e) => e instanceof Error ? e : /* @__PURE__ */ Error(`Non-Error thrown: ${String(e)}`), t = (t) => {
+	let n = [];
+	for (let r of t) try {
+		r();
+	} catch (t) {
+		n.push(e(t));
+	}
+	return n;
+}, n = (e, n) => {
+	let r = t(e);
+	if (r.length === 1) throw r[0];
+	if (r.length > 0) throw AggregateError(r, n);
+}, r = (t, n, r) => {
+	throw n.length === 0 ? t : AggregateError([e(t), ...n], r, { cause: e(t) });
+};
+//#endregion
+export { t as collectErrors, e as ensureError, r as rethrowWith, n as runAll };
+
+//# sourceMappingURL=_error-utils.js.map

package/dist/_error-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_error-utils.js","names":[],"sources":["../src/_error-utils.ts"],"sourcesContent":["import type { CleanupFn } from './types';\n\n/**\n * Coerces any thrown value to an `Error`.\n * Non-Error throws (strings, numbers, etc.) are wrapped in a plain `Error`\n * with a descriptive message — they are NOT mis-branded as `RippleError`.\n */\nexport const ensureError = (error: unknown): Error =>\n  error instanceof Error ? error : new Error(`Non-Error thrown: ${String(error)}`);\n\n/**\n * Runs each fn in `fns`, collecting any thrown errors. Does NOT re-throw.\n */\nexport const collectErrors = (fns: Iterable<CleanupFn>): Error[] => {\n  const errors: Error[] = [];\n\n  for (const fn of fns) {\n    try {\n      fn();\n    } catch (e) {\n      errors.push(ensureError(e));\n    }\n  }\n\n  return errors;\n};\n\n/**\n * Runs all `fns`, collecting errors.\n * - Single error: re-throws the original error directly (preserves type + stack).\n * - Multiple errors: wraps in AggregateError with the given context label.\n */\nexport const runAll = (fns: Iterable<CleanupFn>, context: string): void => {\n  const errors = collectErrors(fns);\n\n  if (errors.length === 1) throw errors[0]!;\n\n  if (errors.length > 0) {\n    throw new AggregateError(errors, context);\n  }\n};\n\n/**\n * Re-throws `primary`, augmented with any extra errors as an AggregateError.\n * If `extras` is empty, throws `primary` directly (preserves original type + stack).\n * Otherwise, `primary` is set as the `.cause` so callers can identify the root failure.\n */\nexport const rethrowWith = (primary: unknown, extras: Error[], context: string): never => {\n  if (extras.length === 0) throw primary;\n\n  throw new AggregateError([ensureError(primary), ...extras], context, {\n    cause: ensureError(primary),\n  });\n};\n"],"mappings":";AAOA,IAAa,KAAe,MAC1B,aAAiB,QAAQ,IAAQ,gBAAI,MAAM,qBAAqB,OAAO,CAAK,GAAG,GAKpE,KAAiB,MAAsC;CAClE,IAAM,IAAkB,CAAC;CAEzB,KAAK,IAAM,KAAM,GACf,IAAI;EACF,EAAG;CACL,SAAS,GAAG;EACV,EAAO,KAAK,EAAY,CAAC,CAAC;CAC5B;CAGF,OAAO;AACT,GAOa,KAAU,GAA0B,MAA0B;CACzE,IAAM,IAAS,EAAc,CAAG;CAEhC,IAAI,EAAO,WAAW,GAAG,MAAM,EAAO;CAEtC,IAAI,EAAO,SAAS,GAClB,MAAU,eAAe,GAAQ,CAAO;AAE5C,GAOa,KAAe,GAAkB,GAAiB,MAA2B;CAGxF,MAFI,EAAO,WAAW,IAAS,IAErB,eAAe,CAAC,EAAY,CAAO,GAAG,GAAG,CAAM,GAAG,GAAS,EACnE,OAAO,EAAY,CAAO,EAC5B,CAAC;AACH"}

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,7 @@
+//#region \0rolldown/runtime.js
+var e = /* @__PURE__ */ ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (e, t) => (typeof require < "u" ? require : e)[t] }) : e)(function(e) {
+	if (typeof require < "u") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + e + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { e as __require };

package/dist/async-computed.cjs

@@ -0,0 +1,2 @@
+const e=require("./tracking.cjs"),t=require("./symbols.cjs"),n=require("./effect.cjs"),r=require("./signal.cjs");var i=(i,a)=>{let o=a?.name,s=r.signal({data:a?.initialValue,status:`loading`},o?{name:o}:void 0),c=r.signal(0),l=null,u=!1,d=n.effect(()=>{c.value,l?.abort(),l=new AbortController;let{signal:e}=l,t=s.peek(),n=`data`in t?t.data:void 0;s.value={data:n,status:`loading`},(async()=>{try{let t=await i(e);!e.aborted&&!u&&(s.value={data:t,status:`ready`})}catch(t){!e.aborted&&!u&&(s.value={data:n,error:t,status:`error`})}})()},o?{name:o}:void 0),f=()=>{u||(c.value=c.peek()+1)},p=()=>{u||(u=!0,l?.abort(),d.dispose(),s.dispose(),c.dispose())};return e.autoRegisterDisposal(p),{dispose:p,get disposed(){return u},[t.IS_COMPUTED]:!0,[t.IS_SIGNAL]:!0,get name(){return s.name},peek:()=>s.peek(),refresh:f,subscribe:e=>s.subscribe(e),[Symbol.dispose]:p,get value(){return s.value}}};exports.resource=i;
+//# sourceMappingURL=async-computed.cjs.map

package/dist/async-computed.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-computed.cjs","names":[],"sources":["../src/async-computed.ts"],"sourcesContent":["import type { Resource, ResourceOptions, ResourceState } from './types';\n\nimport { effect } from './effect';\nimport { signal } from './signal';\nimport { IS_COMPUTED, IS_SIGNAL } from './symbols';\nimport { autoRegisterDisposal } from './tracking';\n\n/**\n * Creates a reactive async resource that emits a `ResourceState<T>` discriminated union.\n *\n * Dependencies are tracked synchronously in the factory (before the first `await`).\n * The factory receives an `AbortSignal` that fires when dependencies change or\n * the resource is disposed, cancelling any in-flight work.\n *\n * If `resource()` is created inside an active `effect()` or `scope.run()` context,\n * it is automatically registered for cleanup and disposed with that context —\n * matching `computed()`'s auto-disposal behavior.\n *\n * Call `refresh()` to force the factory to re-run immediately, even if no tracked\n * dependency changed — useful for manual \"retry\"/\"refetch\" actions.\n *\n * @example\n * ```ts\n * const userId = signal('u1');\n * const user = resource(async (signal) => {\n *   const id = userId.value; // tracked dep — re-runs when userId changes\n *   return fetchUser(id, { signal });\n * });\n *\n * effect(() => {\n *   const s = user.value;\n *   if (s.status === 'loading') return showSpinner();\n *   if (s.status === 'error')   return showError(s.error);\n *   renderUser(s.data);\n * });\n *\n * user.refresh(); // force a re-fetch without changing userId\n * user.dispose();\n * ```\n */\nexport const resource = <T>(\n  factory: (abortSignal: AbortSignal) => Promise<T>,\n  options?: ResourceOptions<T>,\n): Resource<T> => {\n  const name = options?.name;\n  const state = signal<ResourceState<T>>(\n    { data: options?.initialValue, status: 'loading' },\n    name ? { name } : undefined,\n  );\n  // Internal-only trigger — never exposed. Read (but never written to a meaningful\n  // value) inside the effect purely so it becomes a tracked dep; refresh() bumps it\n  // to force a re-run without requiring a real dependency to change.\n  const epoch = signal(0);\n\n  let controller: AbortController | null = null;\n  let disposed = false;\n\n  const stop = effect(\n    () => {\n      void epoch.value;\n\n      controller?.abort();\n      controller = new AbortController();\n\n      const { signal: abortSignal } = controller;\n\n      const current = state.peek();\n      const prevData = 'data' in current ? current.data : undefined;\n\n      state.value = { data: prevData, status: 'loading' };\n\n      void (async () => {\n        try {\n          const result = await factory(abortSignal);\n\n          if (!abortSignal.aborted && !disposed) {\n            state.value = { data: result, status: 'ready' };\n          }\n        } catch (err) {\n          if (!abortSignal.aborted && !disposed) {\n            state.value = { data: prevData, error: err, status: 'error' };\n          }\n        }\n      })();\n    },\n    name ? { name } : undefined,\n  );\n\n  const refresh = (): void => {\n    if (disposed) return;\n\n    epoch.value = epoch.peek() + 1;\n  };\n\n  const dispose = (): void => {\n    if (disposed) return;\n\n    disposed = true;\n    controller?.abort();\n    stop.dispose();\n    state.dispose();\n    epoch.dispose();\n  };\n\n  autoRegisterDisposal(dispose);\n\n  return {\n    dispose,\n    get disposed() {\n      return disposed;\n    },\n    [IS_COMPUTED]: true as const,\n    [IS_SIGNAL]: true as const,\n    get name() {\n      return state.name;\n    },\n    peek: () => state.peek(),\n    refresh,\n    subscribe: (listener: () => void) => state.subscribe(listener),\n    [Symbol.dispose]: dispose,\n    get value() {\n      return state.value;\n    },\n  } as Resource<T>;\n};\n"],"mappings":"iHAwCA,IAAa,GACX,EACA,IACgB,CAChB,IAAM,EAAO,GAAS,KAChB,EAAQ,EAAA,OACZ,CAAE,KAAM,GAAS,aAAc,OAAQ,SAAU,EACjD,EAAO,CAAE,MAAK,EAAI,IAAA,EACpB,EAIM,EAAQ,EAAA,OAAO,CAAC,EAElB,EAAqC,KACrC,EAAW,GAET,EAAO,EAAA,WACL,CACJ,EAAW,MAEX,GAAY,MAAM,EAClB,EAAa,IAAI,gBAEjB,GAAM,CAAE,OAAQ,GAAgB,EAE1B,EAAU,EAAM,KAAK,EACrB,EAAW,SAAU,EAAU,EAAQ,KAAO,IAAA,GAEpD,EAAM,MAAQ,CAAE,KAAM,EAAU,OAAQ,SAAU,GAE5C,SAAY,CAChB,GAAI,CACF,IAAM,EAAS,MAAM,EAAQ,CAAW,EAEpC,CAAC,EAAY,SAAW,CAAC,IAC3B,EAAM,MAAQ,CAAE,KAAM,EAAQ,OAAQ,OAAQ,EAElD,OAAS,EAAK,CACR,CAAC,EAAY,SAAW,CAAC,IAC3B,EAAM,MAAQ,CAAE,KAAM,EAAU,MAAO,EAAK,OAAQ,OAAQ,EAEhE,CACF,EAAA,CAAG,CACL,EACA,EAAO,CAAE,MAAK,EAAI,IAAA,EACpB,EAEM,MAAsB,CACtB,IAEJ,EAAM,MAAQ,EAAM,KAAK,EAAI,EAC/B,EAEM,MAAsB,CACtB,IAEJ,EAAW,GACX,GAAY,MAAM,EAClB,EAAK,QAAQ,EACb,EAAM,QAAQ,EACd,EAAM,QAAQ,EAChB,EAIA,OAFA,EAAA,qBAAqB,CAAO,EAErB,CACL,UACA,IAAI,UAAW,CACb,OAAO,CACT,GACC,EAAA,aAAc,IACd,EAAA,WAAY,GACb,IAAI,MAAO,CACT,OAAO,EAAM,IACf,EACA,SAAY,EAAM,KAAK,EACvB,UACA,UAAY,GAAyB,EAAM,UAAU,CAAQ,GAC5D,OAAO,SAAU,EAClB,IAAI,OAAQ,CACV,OAAO,EAAM,KACf,CACF,CACF"}

package/dist/async-computed.d.ts

@@ -0,0 +1,36 @@
+import type { Resource, ResourceOptions } from './types';
+/**
+ * Creates a reactive async resource that emits a `ResourceState<T>` discriminated union.
+ *
+ * Dependencies are tracked synchronously in the factory (before the first `await`).
+ * The factory receives an `AbortSignal` that fires when dependencies change or
+ * the resource is disposed, cancelling any in-flight work.
+ *
+ * If `resource()` is created inside an active `effect()` or `scope.run()` context,
+ * it is automatically registered for cleanup and disposed with that context —
+ * matching `computed()`'s auto-disposal behavior.
+ *
+ * Call `refresh()` to force the factory to re-run immediately, even if no tracked
+ * dependency changed — useful for manual "retry"/"refetch" actions.
+ *
+ * @example
+ * ```ts
+ * const userId = signal('u1');
+ * const user = resource(async (signal) => {
+ *   const id = userId.value; // tracked dep — re-runs when userId changes
+ *   return fetchUser(id, { signal });
+ * });
+ *
+ * effect(() => {
+ *   const s = user.value;
+ *   if (s.status === 'loading') return showSpinner();
+ *   if (s.status === 'error')   return showError(s.error);
+ *   renderUser(s.data);
+ * });
+ *
+ * user.refresh(); // force a re-fetch without changing userId
+ * user.dispose();
+ * ```
+ */
+export declare const resource: <T>(factory: (abortSignal: AbortSignal) => Promise<T>, options?: ResourceOptions<T>) => Resource<T>;
+//# sourceMappingURL=async-computed.d.ts.map

package/dist/async-computed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-computed.d.ts","sourceRoot":"","sources":["../src/async-computed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAiB,MAAM,SAAS,CAAC;AAOxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,SAAS,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EACjD,UAAU,eAAe,CAAC,CAAC,CAAC,KAC3B,QAAQ,CAAC,CAAC,CAiFZ,CAAC"}

package/dist/async-computed.js

@@ -0,0 +1,58 @@
+import { autoRegisterDisposal as e } from "./tracking.js";
+import { IS_COMPUTED as t, IS_SIGNAL as n } from "./symbols.js";
+import { effect as r } from "./effect.js";
+import { signal as i } from "./signal.js";
+//#region src/async-computed.ts
+var a = (a, o) => {
+	let s = o?.name, c = i({
+		data: o?.initialValue,
+		status: "loading"
+	}, s ? { name: s } : void 0), l = i(0), u = null, d = !1, f = r(() => {
+		l.value, u?.abort(), u = new AbortController();
+		let { signal: e } = u, t = c.peek(), n = "data" in t ? t.data : void 0;
+		c.value = {
+			data: n,
+			status: "loading"
+		}, (async () => {
+			try {
+				let t = await a(e);
+				!e.aborted && !d && (c.value = {
+					data: t,
+					status: "ready"
+				});
+			} catch (t) {
+				!e.aborted && !d && (c.value = {
+					data: n,
+					error: t,
+					status: "error"
+				});
+			}
+		})();
+	}, s ? { name: s } : void 0), p = () => {
+		d || (l.value = l.peek() + 1);
+	}, m = () => {
+		d || (d = !0, u?.abort(), f.dispose(), c.dispose(), l.dispose());
+	};
+	return e(m), {
+		dispose: m,
+		get disposed() {
+			return d;
+		},
+		[t]: !0,
+		[n]: !0,
+		get name() {
+			return c.name;
+		},
+		peek: () => c.peek(),
+		refresh: p,
+		subscribe: (e) => c.subscribe(e),
+		[Symbol.dispose]: m,
+		get value() {
+			return c.value;
+		}
+	};
+};
+//#endregion
+export { a as resource };
+
+//# sourceMappingURL=async-computed.js.map

package/dist/async-computed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-computed.js","names":[],"sources":["../src/async-computed.ts"],"sourcesContent":["import type { Resource, ResourceOptions, ResourceState } from './types';\n\nimport { effect } from './effect';\nimport { signal } from './signal';\nimport { IS_COMPUTED, IS_SIGNAL } from './symbols';\nimport { autoRegisterDisposal } from './tracking';\n\n/**\n * Creates a reactive async resource that emits a `ResourceState<T>` discriminated union.\n *\n * Dependencies are tracked synchronously in the factory (before the first `await`).\n * The factory receives an `AbortSignal` that fires when dependencies change or\n * the resource is disposed, cancelling any in-flight work.\n *\n * If `resource()` is created inside an active `effect()` or `scope.run()` context,\n * it is automatically registered for cleanup and disposed with that context —\n * matching `computed()`'s auto-disposal behavior.\n *\n * Call `refresh()` to force the factory to re-run immediately, even if no tracked\n * dependency changed — useful for manual \"retry\"/\"refetch\" actions.\n *\n * @example\n * ```ts\n * const userId = signal('u1');\n * const user = resource(async (signal) => {\n *   const id = userId.value; // tracked dep — re-runs when userId changes\n *   return fetchUser(id, { signal });\n * });\n *\n * effect(() => {\n *   const s = user.value;\n *   if (s.status === 'loading') return showSpinner();\n *   if (s.status === 'error')   return showError(s.error);\n *   renderUser(s.data);\n * });\n *\n * user.refresh(); // force a re-fetch without changing userId\n * user.dispose();\n * ```\n */\nexport const resource = <T>(\n  factory: (abortSignal: AbortSignal) => Promise<T>,\n  options?: ResourceOptions<T>,\n): Resource<T> => {\n  const name = options?.name;\n  const state = signal<ResourceState<T>>(\n    { data: options?.initialValue, status: 'loading' },\n    name ? { name } : undefined,\n  );\n  // Internal-only trigger — never exposed. Read (but never written to a meaningful\n  // value) inside the effect purely so it becomes a tracked dep; refresh() bumps it\n  // to force a re-run without requiring a real dependency to change.\n  const epoch = signal(0);\n\n  let controller: AbortController | null = null;\n  let disposed = false;\n\n  const stop = effect(\n    () => {\n      void epoch.value;\n\n      controller?.abort();\n      controller = new AbortController();\n\n      const { signal: abortSignal } = controller;\n\n      const current = state.peek();\n      const prevData = 'data' in current ? current.data : undefined;\n\n      state.value = { data: prevData, status: 'loading' };\n\n      void (async () => {\n        try {\n          const result = await factory(abortSignal);\n\n          if (!abortSignal.aborted && !disposed) {\n            state.value = { data: result, status: 'ready' };\n          }\n        } catch (err) {\n          if (!abortSignal.aborted && !disposed) {\n            state.value = { data: prevData, error: err, status: 'error' };\n          }\n        }\n      })();\n    },\n    name ? { name } : undefined,\n  );\n\n  const refresh = (): void => {\n    if (disposed) return;\n\n    epoch.value = epoch.peek() + 1;\n  };\n\n  const dispose = (): void => {\n    if (disposed) return;\n\n    disposed = true;\n    controller?.abort();\n    stop.dispose();\n    state.dispose();\n    epoch.dispose();\n  };\n\n  autoRegisterDisposal(dispose);\n\n  return {\n    dispose,\n    get disposed() {\n      return disposed;\n    },\n    [IS_COMPUTED]: true as const,\n    [IS_SIGNAL]: true as const,\n    get name() {\n      return state.name;\n    },\n    peek: () => state.peek(),\n    refresh,\n    subscribe: (listener: () => void) => state.subscribe(listener),\n    [Symbol.dispose]: dispose,\n    get value() {\n      return state.value;\n    },\n  } as Resource<T>;\n};\n"],"mappings":";;;;;AAwCA,IAAa,KACX,GACA,MACgB;CAChB,IAAM,IAAO,GAAS,MAChB,IAAQ,EACZ;EAAE,MAAM,GAAS;EAAc,QAAQ;CAAU,GACjD,IAAO,EAAE,QAAK,IAAI,KAAA,CACpB,GAIM,IAAQ,EAAO,CAAC,GAElB,IAAqC,MACrC,IAAW,IAET,IAAO,QACL;EAIJ,AAHA,EAAW,OAEX,GAAY,MAAM,GAClB,IAAa,IAAI,gBAAgB;EAEjC,IAAM,EAAE,QAAQ,MAAgB,GAE1B,IAAU,EAAM,KAAK,GACrB,IAAW,UAAU,IAAU,EAAQ,OAAO,KAAA;EAIpD,AAFA,EAAM,QAAQ;GAAE,MAAM;GAAU,QAAQ;EAAU,IAE5C,YAAY;GAChB,IAAI;IACF,IAAM,IAAS,MAAM,EAAQ,CAAW;IAExC,AAAI,CAAC,EAAY,WAAW,CAAC,MAC3B,EAAM,QAAQ;KAAE,MAAM;KAAQ,QAAQ;IAAQ;GAElD,SAAS,GAAK;IACZ,AAAI,CAAC,EAAY,WAAW,CAAC,MAC3B,EAAM,QAAQ;KAAE,MAAM;KAAU,OAAO;KAAK,QAAQ;IAAQ;GAEhE;EACF,EAAA,CAAG;CACL,GACA,IAAO,EAAE,QAAK,IAAI,KAAA,CACpB,GAEM,UAAsB;EACtB,MAEJ,EAAM,QAAQ,EAAM,KAAK,IAAI;CAC/B,GAEM,UAAsB;EACtB,MAEJ,IAAW,IACX,GAAY,MAAM,GAClB,EAAK,QAAQ,GACb,EAAM,QAAQ,GACd,EAAM,QAAQ;CAChB;CAIA,OAFA,EAAqB,CAAO,GAErB;EACL;EACA,IAAI,WAAW;GACb,OAAO;EACT;GACC,IAAc;GACd,IAAY;EACb,IAAI,OAAO;GACT,OAAO,EAAM;EACf;EACA,YAAY,EAAM,KAAK;EACvB;EACA,YAAY,MAAyB,EAAM,UAAU,CAAQ;GAC5D,OAAO,UAAU;EAClB,IAAI,QAAQ;GACV,OAAO,EAAM;EACf;CACF;AACF"}

package/dist/computed.cjs

@@ -0,0 +1,2 @@
+const e=require("./devtools-hook.cjs"),t=require("./_error-utils.cjs"),n=require("./errors.cjs"),r=require("./tracking.cjs"),i=require("./subscription.cjs"),a=require("./symbols.cjs"),o=require("./reactive-base.cjs");var s=class extends o.ComputedBase{value_;dirty_;computing_;disposed_;deps_;compute_;equals_;maxRevision_;constructor(e,t){let{equals:n,name:r}=t??{};super(r),this.value_=a.UNINITIALIZED,this.dirty_=!0,this.computing_=!1,this.disposed_=!1,this.deps_=[],this.maxRevision_=-1,this.compute_=e,this.equals_=n===void 0?Object.is:(e,t)=>n(e,t)}markDirty(){return this.disposed_||this.dirty_?!1:(this.dirty_=!0,!0)}refreshIfDirty(){if(!this.dirty_)return!1;if(r.getRevision()<=this.maxRevision_)return this.dirty_=!1,!1;if(this.deps_.length>0){let e=!0;for(let t of this.deps_){let n=t.source;if(`refreshIfDirty`in n&&n.refreshIfDirty(),n.version!==t.version){e=!1;break}}if(e)return this.dirty_=!1,this.maxRevision_=r.getRevision(),!1}return this.recompute()}runCompute(e){try{return r.withTracking({computed:this,depCollector:e,kind:`computed`},this.compute_)}catch(e){throw t.ensureError(e)}}recompute(){if(this.computing_)throw new n.RippleComputedCycleError(`computed cycle detected${this.name?` "${this.name}"`:``}`);this.computing_=!0;try{let t=[];e.getDevToolsHook()?.compute?.({name:this.name});let n=this.runCompute(t);return this.dirty_=!1,this.maxRevision_=r.getRevision(),this.updateDeps(t),this.value_===a.UNINITIALIZED||!this.equals_(this.value_,n)?(this.value_=n,this.version++,!0):!1}finally{this.computing_=!1}}updateDeps(e){let t=this.deps_;if(t.length===e.length&&t.every((t,n)=>t.source===e[n].source)){for(let n=0;n<e.length;n++)t[n].version=e[n].version;return}let n=new Set(t.map(e=>e.source)),r=new Set(e.map(e=>e.source));for(let e of t)r.has(e.source)||e.source.removeComputedSub(this);for(let t of e)n.has(t.source)||t.source.addComputedSub(this);this.deps_=e}get value(){return this.disposed_?this.value_===a.UNINITIALIZED?void 0:this.value_:(this.refreshIfDirty(),r.trackSource(this),this.value_)}peek(){return this.disposed_?this.value_===a.UNINITIALIZED?void 0:this.value_:(this.refreshIfDirty(),this.value_)}subscribe=e=>{if(this.disposed_){let e=new i.SubscriptionImpl(()=>{});return e.dispose(),e}return this.refreshIfDirty(),this.addEffectSub(e),new i.SubscriptionImpl(()=>{this.removeEffectSub(e)})};get disposed(){return this.disposed_}dispose(){if(!this.disposed_){this.disposed_=!0;for(let e of this.deps_)e.source.removeComputedSub(this);this.deps_=[],this.clearSubscribers(),e.getDevToolsHook()?.dispose?.({kind:`computed`,name:this.name})}}[Symbol.dispose](){this.dispose()}},c=(e,t)=>{let n=new s(e,t);return r.autoRegisterDisposal(()=>n.dispose()),n};exports.ComputedImpl=s,exports.computed=c;
+//# sourceMappingURL=computed.cjs.map

package/dist/computed.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed.cjs","names":[],"sources":["../src/computed.ts"],"sourcesContent":["import type { Refreshable } from './reactive-base';\nimport type { DepEntry } from './tracking';\nimport type { Computed, ComputedOptions, Subscription } from './types';\n\nimport { ensureError } from './_error-utils';\nimport { getDevToolsHook } from './devtools-hook';\nimport { RippleComputedCycleError } from './errors';\nimport { ComputedBase } from './reactive-base';\nimport { SubscriptionImpl } from './subscription';\nimport { UNINITIALIZED } from './symbols';\nimport { autoRegisterDisposal, getRevision, trackSource, withTracking } from './tracking';\n\nexport class ComputedImpl<T> extends ComputedBase<T> implements Computed<T> {\n  private value_: T | typeof UNINITIALIZED;\n  private dirty_: boolean;\n  private computing_: boolean;\n  private disposed_: boolean;\n  private deps_: DepEntry[];\n  private compute_: () => T;\n  private equals_: (a: unknown, b: unknown) => boolean;\n  // Global revision at last successful compute — enables O(1) \"nothing changed\" fast-path.\n  private maxRevision_: number;\n\n  constructor(compute: () => T, options?: ComputedOptions<T>) {\n    const { equals, name } = options ?? {};\n\n    super(name);\n    this.value_ = UNINITIALIZED;\n    this.dirty_ = true;\n    this.computing_ = false;\n    this.disposed_ = false;\n    this.deps_ = [];\n    this.maxRevision_ = -1;\n    this.compute_ = compute;\n    this.equals_ = equals !== undefined ? (a, b) => equals(a as T, b as T) : Object.is;\n  }\n\n  markDirty(): boolean {\n    if (this.disposed_ || this.dirty_) return false;\n\n    this.dirty_ = true;\n\n    return true;\n  }\n\n  refreshIfDirty(): boolean {\n    if (!this.dirty_) return false;\n\n    // O(1) global revision fast-path:\n    // If the global revision clock has not advanced past our recorded maximum,\n    // no signal anywhere in the system has been written since our last compute.\n    // No dep can have changed — clear dirty and skip the per-dep scan entirely.\n    if (getRevision() <= this.maxRevision_) {\n      this.dirty_ = false;\n\n      return false;\n    }\n\n    // Per-dep scan: if all dep versions still match, value cannot have changed.\n    // For computed deps, we must refresh them first — their version only updates\n    // after recompute, so a stale-version check would incorrectly short-circuit.\n    if (this.deps_.length > 0) {\n      let allSame = true;\n\n      for (const d of this.deps_) {\n        const src = d.source;\n\n        // Flush dirty computed deps before comparing versions (lazy pull chain).\n        if ('refreshIfDirty' in src) {\n          (src as Refreshable).refreshIfDirty();\n        }\n\n        if (src.version !== d.version) {\n          allSame = false;\n          break;\n        }\n      }\n\n      if (allSame) {\n        this.dirty_ = false;\n        this.maxRevision_ = getRevision();\n\n        return false;\n      }\n    }\n\n    return this.recompute();\n  }\n\n  private runCompute(depCollector: DepEntry[]): T {\n    try {\n      return withTracking({ computed: this, depCollector, kind: 'computed' }, this.compute_);\n    } catch (error) {\n      // Sources accessed before the throw remain in their computedSubs_ until the\n      // next successful recompute or dispose(). The computed stays dirty and will retry.\n      throw ensureError(error);\n    }\n  }\n\n  private recompute(): boolean {\n    if (this.computing_) {\n      const label = this.name ? ` \"${this.name}\"` : '';\n\n      throw new RippleComputedCycleError(`computed cycle detected${label}`);\n    }\n\n    this.computing_ = true;\n\n    try {\n      const newDeps: DepEntry[] = [];\n\n      getDevToolsHook()?.compute?.({ name: this.name });\n\n      const next = this.runCompute(newDeps);\n\n      this.dirty_ = false;\n      this.maxRevision_ = getRevision();\n\n      // Diff deps: remove subscriptions for sources that are no longer dependencies.\n      // Only subscribe to genuinely NEW deps — prevents duplicate WeakRef entries.\n      this.updateDeps(newDeps);\n\n      const isNew = this.value_ === UNINITIALIZED;\n\n      if (isNew || !this.equals_(this.value_ as T, next)) {\n        this.value_ = next;\n        this.version++;\n\n        return true;\n      }\n\n      return false;\n    } finally {\n      this.computing_ = false;\n    }\n  }\n\n  private updateDeps(newDeps: DepEntry[]): void {\n    const oldDeps = this.deps_;\n\n    // Fast path: same sources in same order — just refresh stored versions\n    if (oldDeps.length === newDeps.length && oldDeps.every((d, i) => d.source === newDeps[i].source)) {\n      for (let i = 0; i < newDeps.length; i++) {\n        oldDeps[i]!.version = newDeps[i]!.version;\n      }\n\n      return;\n    }\n\n    // Slow path: deps changed.\n    // Build a set of OLD sources so we can detect which are genuinely NEW and\n    // need a fresh addComputedSub call (WeakRef registration).\n    const oldSourceSet = new Set(oldDeps.map((d) => d.source));\n    const newSourceSet = new Set(newDeps.map((d) => d.source));\n\n    // Unsubscribe from sources that are no longer dependencies\n    for (const old of oldDeps) {\n      if (!newSourceSet.has(old.source)) {\n        old.source.removeComputedSub(this);\n      }\n    }\n\n    // Subscribe to sources that are genuinely NEW (not in old deps)\n    for (const dep of newDeps) {\n      if (!oldSourceSet.has(dep.source)) {\n        dep.source.addComputedSub(this);\n      }\n    }\n\n    this.deps_ = newDeps;\n  }\n\n  get value(): T {\n    // After disposal: return last known value without tracking (inert node, like signal).\n    // If the computed was never evaluated (still UNINITIALIZED), return undefined.\n    if (this.disposed_) {\n      return this.value_ !== UNINITIALIZED ? (this.value_ as T) : (undefined as unknown as T);\n    }\n\n    this.refreshIfDirty();\n    trackSource(this);\n\n    return this.value_ as T;\n  }\n\n  // peek() after dispose: return last known value silently, consistent with signal.peek().\n  // If the computed was never evaluated, return undefined (same as signal with undefined initial).\n  peek(): T {\n    if (this.disposed_) {\n      return this.value_ !== UNINITIALIZED ? (this.value_ as T) : (undefined as unknown as T);\n    }\n\n    this.refreshIfDirty();\n\n    return this.value_ as T;\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.refreshIfDirty();\n    this.addEffectSub(listener);\n\n    return new SubscriptionImpl(() => {\n      this.removeEffectSub(listener);\n    });\n  };\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\n    // Unsubscribe from all upstream sources\n    for (const dep of this.deps_) {\n      dep.source.removeComputedSub(this);\n    }\n\n    this.deps_ = [];\n    this.clearSubscribers();\n    getDevToolsHook()?.dispose?.({ kind: 'computed', name: this.name });\n  }\n\n  [Symbol.dispose](): void {\n    this.dispose();\n  }\n}\n\n// ── computed() ───────────────────────────────────────────────────────────────\n\nexport const computed = <T>(compute: () => T, options?: ComputedOptions<T>): Computed<T> => {\n  const comp = new ComputedImpl(compute, options);\n\n  autoRegisterDisposal(() => comp.dispose());\n\n  return comp;\n};\n"],"mappings":"yNAYA,IAAa,EAAb,cAAqC,EAAA,YAAuC,CAC1E,OACA,OACA,WACA,UACA,MACA,SACA,QAEA,aAEA,YAAY,EAAkB,EAA8B,CAC1D,GAAM,CAAE,SAAQ,QAAS,GAAW,CAAC,EAErC,MAAM,CAAI,EACV,KAAK,OAAS,EAAA,cACd,KAAK,OAAS,GACd,KAAK,WAAa,GAClB,KAAK,UAAY,GACjB,KAAK,MAAQ,CAAC,EACd,KAAK,aAAe,GACpB,KAAK,SAAW,EAChB,KAAK,QAAU,IAAW,IAAA,GAA+C,OAAO,IAAzC,EAAG,IAAM,EAAO,EAAQ,CAAM,CACvE,CAEA,WAAqB,CAKnB,OAJI,KAAK,WAAa,KAAK,OAAe,IAE1C,KAAK,OAAS,GAEP,GACT,CAEA,gBAA0B,CACxB,GAAI,CAAC,KAAK,OAAQ,MAAO,GAMzB,GAAI,EAAA,YAAY,GAAK,KAAK,aAGxB,MAFA,MAAK,OAAS,GAEP,GAMT,GAAI,KAAK,MAAM,OAAS,EAAG,CACzB,IAAI,EAAU,GAEd,IAAK,IAAM,KAAK,KAAK,MAAO,CAC1B,IAAM,EAAM,EAAE,OAOd,GAJI,mBAAoB,GACtB,EAAqB,eAAe,EAGlC,EAAI,UAAY,EAAE,QAAS,CAC7B,EAAU,GACV,KACF,CACF,CAEA,GAAI,EAIF,MAHA,MAAK,OAAS,GACd,KAAK,aAAe,EAAA,YAAY,EAEzB,EAEX,CAEA,OAAO,KAAK,UAAU,CACxB,CAEA,WAAmB,EAA6B,CAC9C,GAAI,CACF,OAAO,EAAA,aAAa,CAAE,SAAU,KAAM,eAAc,KAAM,UAAW,EAAG,KAAK,QAAQ,CACvF,OAAS,EAAO,CAGd,MAAM,EAAA,YAAY,CAAK,CACzB,CACF,CAEA,WAA6B,CAC3B,GAAI,KAAK,WAGP,MAAM,IAAI,EAAA,yBAAyB,0BAFrB,KAAK,KAAO,KAAK,KAAK,KAAK,GAAK,IAEsB,EAGtE,KAAK,WAAa,GAElB,GAAI,CACF,IAAM,EAAsB,CAAC,EAE7B,EAAA,gBAAgB,CAAC,EAAE,UAAU,CAAE,KAAM,KAAK,IAAK,CAAC,EAEhD,IAAM,EAAO,KAAK,WAAW,CAAO,EAkBpC,MAhBA,MAAK,OAAS,GACd,KAAK,aAAe,EAAA,YAAY,EAIhC,KAAK,WAAW,CAAO,EAET,KAAK,SAAW,EAAA,eAEjB,CAAC,KAAK,QAAQ,KAAK,OAAa,CAAI,GAC/C,KAAK,OAAS,EACd,KAAK,UAEE,IAGF,EACT,QAAU,CACR,KAAK,WAAa,EACpB,CACF,CAEA,WAAmB,EAA2B,CAC5C,IAAM,EAAU,KAAK,MAGrB,GAAI,EAAQ,SAAW,EAAQ,QAAU,EAAQ,OAAO,EAAG,IAAM,EAAE,SAAW,EAAQ,EAAE,CAAC,MAAM,EAAG,CAChG,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,OAAQ,IAClC,EAAQ,EAAE,CAAE,QAAU,EAAQ,EAAE,CAAE,QAGpC,MACF,CAKA,IAAM,EAAe,IAAI,IAAI,EAAQ,IAAK,GAAM,EAAE,MAAM,CAAC,EACnD,EAAe,IAAI,IAAI,EAAQ,IAAK,GAAM,EAAE,MAAM,CAAC,EAGzD,IAAK,IAAM,KAAO,EACX,EAAa,IAAI,EAAI,MAAM,GAC9B,EAAI,OAAO,kBAAkB,IAAI,EAKrC,IAAK,IAAM,KAAO,EACX,EAAa,IAAI,EAAI,MAAM,GAC9B,EAAI,OAAO,eAAe,IAAI,EAIlC,KAAK,MAAQ,CACf,CAEA,IAAI,OAAW,CAUb,OAPI,KAAK,UACA,KAAK,SAAW,EAAA,cAAsC,IAAA,GAArB,KAAK,QAG/C,KAAK,eAAe,EACpB,EAAA,YAAY,IAAI,EAET,KAAK,OACd,CAIA,MAAU,CAOR,OANI,KAAK,UACA,KAAK,SAAW,EAAA,cAAsC,IAAA,GAArB,KAAK,QAG/C,KAAK,eAAe,EAEb,KAAK,OACd,CAEA,UAAsB,GAAuC,CAC3D,GAAI,KAAK,UAAW,CAClB,IAAM,EAAO,IAAI,EAAA,qBAAuB,CAAC,CAAC,EAI1C,OAFA,EAAK,QAAQ,EAEN,CACT,CAKA,OAHA,KAAK,eAAe,EACpB,KAAK,aAAa,CAAQ,EAEnB,IAAI,EAAA,qBAAuB,CAChC,KAAK,gBAAgB,CAAQ,CAC/B,CAAC,CACH,EAEA,IAAI,UAAoB,CACtB,OAAO,KAAK,SACd,CAEA,SAAgB,CACV,SAAK,UAET,MAAK,UAAY,GAGjB,IAAK,IAAM,KAAO,KAAK,MACrB,EAAI,OAAO,kBAAkB,IAAI,EAGnC,KAAK,MAAQ,CAAC,EACd,KAAK,iBAAiB,EACtB,EAAA,gBAAgB,CAAC,EAAE,UAAU,CAAE,KAAM,WAAY,KAAM,KAAK,IAAK,CAAC,CATjD,CAUnB,CAEA,CAAC,OAAO,UAAiB,CACvB,KAAK,QAAQ,CACf,CACF,EAIa,GAAe,EAAkB,IAA8C,CAC1F,IAAM,EAAO,IAAI,EAAa,EAAS,CAAO,EAI9C,OAFA,EAAA,yBAA2B,EAAK,QAAQ,CAAC,EAElC,CACT"}

package/dist/computed.d.ts

@@ -0,0 +1,26 @@
+import type { Computed, ComputedOptions, Subscription } from './types';
+import { ComputedBase } from './reactive-base';
+export declare class ComputedImpl<T> extends ComputedBase<T> implements Computed<T> {
+    private value_;
+    private dirty_;
+    private computing_;
+    private disposed_;
+    private deps_;
+    private compute_;
+    private equals_;
+    private maxRevision_;
+    constructor(compute: () => T, options?: ComputedOptions<T>);
+    markDirty(): boolean;
+    refreshIfDirty(): boolean;
+    private runCompute;
+    private recompute;
+    private updateDeps;
+    get value(): T;
+    peek(): T;
+    readonly subscribe: (listener: () => void) => Subscription;
+    get disposed(): boolean;
+    dispose(): void;
+    [Symbol.dispose](): void;
+}
+export declare const computed: <T>(compute: () => T, options?: ComputedOptions<T>) => Computed<T>;
+//# sourceMappingURL=computed.d.ts.map

package/dist/computed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed.d.ts","sourceRoot":"","sources":["../src/computed.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAKvE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAK/C,qBAAa,YAAY,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IACzE,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,QAAQ,CAAU;IAC1B,OAAO,CAAC,OAAO,CAAsC;IAErD,OAAO,CAAC,YAAY,CAAS;gBAEjB,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC;IAc1D,SAAS,IAAI,OAAO;IAQpB,cAAc,IAAI,OAAO;IA4CzB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,SAAS;IAsCjB,OAAO,CAAC,UAAU;IAmClB,IAAI,KAAK,IAAI,CAAC,CAWb;IAID,IAAI,IAAI,CAAC;IAUT,QAAQ,CAAC,SAAS,GAAI,UAAU,MAAM,IAAI,KAAG,YAAY,CAevD;IAEF,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,OAAO,IAAI,IAAI;IAef,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAGzB;AAID,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,SAAS,MAAM,CAAC,EAAE,UAAU,eAAe,CAAC,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,CAMtF,CAAC"}

package/dist/computed.js

@@ -0,0 +1,113 @@
+import { getDevToolsHook as e } from "./devtools-hook.js";
+import { ensureError as t } from "./_error-utils.js";
+import { RippleComputedCycleError as n } from "./errors.js";
+import { autoRegisterDisposal as r, getRevision as i, trackSource as a, withTracking as o } from "./tracking.js";
+import { SubscriptionImpl as s } from "./subscription.js";
+import { UNINITIALIZED as c } from "./symbols.js";
+import { ComputedBase as l } from "./reactive-base.js";
+//#region src/computed.ts
+var u = class extends l {
+	value_;
+	dirty_;
+	computing_;
+	disposed_;
+	deps_;
+	compute_;
+	equals_;
+	maxRevision_;
+	constructor(e, t) {
+		let { equals: n, name: r } = t ?? {};
+		super(r), this.value_ = c, this.dirty_ = !0, this.computing_ = !1, this.disposed_ = !1, this.deps_ = [], this.maxRevision_ = -1, this.compute_ = e, this.equals_ = n === void 0 ? Object.is : (e, t) => n(e, t);
+	}
+	markDirty() {
+		return this.disposed_ || this.dirty_ ? !1 : (this.dirty_ = !0, !0);
+	}
+	refreshIfDirty() {
+		if (!this.dirty_) return !1;
+		if (i() <= this.maxRevision_) return this.dirty_ = !1, !1;
+		if (this.deps_.length > 0) {
+			let e = !0;
+			for (let t of this.deps_) {
+				let n = t.source;
+				if ("refreshIfDirty" in n && n.refreshIfDirty(), n.version !== t.version) {
+					e = !1;
+					break;
+				}
+			}
+			if (e) return this.dirty_ = !1, this.maxRevision_ = i(), !1;
+		}
+		return this.recompute();
+	}
+	runCompute(e) {
+		try {
+			return o({
+				computed: this,
+				depCollector: e,
+				kind: "computed"
+			}, this.compute_);
+		} catch (e) {
+			throw t(e);
+		}
+	}
+	recompute() {
+		if (this.computing_) throw new n(`computed cycle detected${this.name ? ` "${this.name}"` : ""}`);
+		this.computing_ = !0;
+		try {
+			let t = [];
+			e()?.compute?.({ name: this.name });
+			let n = this.runCompute(t);
+			return this.dirty_ = !1, this.maxRevision_ = i(), this.updateDeps(t), this.value_ === c || !this.equals_(this.value_, n) ? (this.value_ = n, this.version++, !0) : !1;
+		} finally {
+			this.computing_ = !1;
+		}
+	}
+	updateDeps(e) {
+		let t = this.deps_;
+		if (t.length === e.length && t.every((t, n) => t.source === e[n].source)) {
+			for (let n = 0; n < e.length; n++) t[n].version = e[n].version;
+			return;
+		}
+		let n = new Set(t.map((e) => e.source)), r = new Set(e.map((e) => e.source));
+		for (let e of t) r.has(e.source) || e.source.removeComputedSub(this);
+		for (let t of e) n.has(t.source) || t.source.addComputedSub(this);
+		this.deps_ = e;
+	}
+	get value() {
+		return this.disposed_ ? this.value_ === c ? void 0 : this.value_ : (this.refreshIfDirty(), a(this), this.value_);
+	}
+	peek() {
+		return this.disposed_ ? this.value_ === c ? void 0 : this.value_ : (this.refreshIfDirty(), this.value_);
+	}
+	subscribe = (e) => {
+		if (this.disposed_) {
+			let e = new s(() => {});
+			return e.dispose(), e;
+		}
+		return this.refreshIfDirty(), this.addEffectSub(e), new s(() => {
+			this.removeEffectSub(e);
+		});
+	};
+	get disposed() {
+		return this.disposed_;
+	}
+	dispose() {
+		if (!this.disposed_) {
+			this.disposed_ = !0;
+			for (let e of this.deps_) e.source.removeComputedSub(this);
+			this.deps_ = [], this.clearSubscribers(), e()?.dispose?.({
+				kind: "computed",
+				name: this.name
+			});
+		}
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+}, d = (e, t) => {
+	let n = new u(e, t);
+	return r(() => n.dispose()), n;
+};
+//#endregion
+export { u as ComputedImpl, d as computed };
+
+//# sourceMappingURL=computed.js.map

package/dist/computed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed.js","names":[],"sources":["../src/computed.ts"],"sourcesContent":["import type { Refreshable } from './reactive-base';\nimport type { DepEntry } from './tracking';\nimport type { Computed, ComputedOptions, Subscription } from './types';\n\nimport { ensureError } from './_error-utils';\nimport { getDevToolsHook } from './devtools-hook';\nimport { RippleComputedCycleError } from './errors';\nimport { ComputedBase } from './reactive-base';\nimport { SubscriptionImpl } from './subscription';\nimport { UNINITIALIZED } from './symbols';\nimport { autoRegisterDisposal, getRevision, trackSource, withTracking } from './tracking';\n\nexport class ComputedImpl<T> extends ComputedBase<T> implements Computed<T> {\n  private value_: T | typeof UNINITIALIZED;\n  private dirty_: boolean;\n  private computing_: boolean;\n  private disposed_: boolean;\n  private deps_: DepEntry[];\n  private compute_: () => T;\n  private equals_: (a: unknown, b: unknown) => boolean;\n  // Global revision at last successful compute — enables O(1) \"nothing changed\" fast-path.\n  private maxRevision_: number;\n\n  constructor(compute: () => T, options?: ComputedOptions<T>) {\n    const { equals, name } = options ?? {};\n\n    super(name);\n    this.value_ = UNINITIALIZED;\n    this.dirty_ = true;\n    this.computing_ = false;\n    this.disposed_ = false;\n    this.deps_ = [];\n    this.maxRevision_ = -1;\n    this.compute_ = compute;\n    this.equals_ = equals !== undefined ? (a, b) => equals(a as T, b as T) : Object.is;\n  }\n\n  markDirty(): boolean {\n    if (this.disposed_ || this.dirty_) return false;\n\n    this.dirty_ = true;\n\n    return true;\n  }\n\n  refreshIfDirty(): boolean {\n    if (!this.dirty_) return false;\n\n    // O(1) global revision fast-path:\n    // If the global revision clock has not advanced past our recorded maximum,\n    // no signal anywhere in the system has been written since our last compute.\n    // No dep can have changed — clear dirty and skip the per-dep scan entirely.\n    if (getRevision() <= this.maxRevision_) {\n      this.dirty_ = false;\n\n      return false;\n    }\n\n    // Per-dep scan: if all dep versions still match, value cannot have changed.\n    // For computed deps, we must refresh them first — their version only updates\n    // after recompute, so a stale-version check would incorrectly short-circuit.\n    if (this.deps_.length > 0) {\n      let allSame = true;\n\n      for (const d of this.deps_) {\n        const src = d.source;\n\n        // Flush dirty computed deps before comparing versions (lazy pull chain).\n        if ('refreshIfDirty' in src) {\n          (src as Refreshable).refreshIfDirty();\n        }\n\n        if (src.version !== d.version) {\n          allSame = false;\n          break;\n        }\n      }\n\n      if (allSame) {\n        this.dirty_ = false;\n        this.maxRevision_ = getRevision();\n\n        return false;\n      }\n    }\n\n    return this.recompute();\n  }\n\n  private runCompute(depCollector: DepEntry[]): T {\n    try {\n      return withTracking({ computed: this, depCollector, kind: 'computed' }, this.compute_);\n    } catch (error) {\n      // Sources accessed before the throw remain in their computedSubs_ until the\n      // next successful recompute or dispose(). The computed stays dirty and will retry.\n      throw ensureError(error);\n    }\n  }\n\n  private recompute(): boolean {\n    if (this.computing_) {\n      const label = this.name ? ` \"${this.name}\"` : '';\n\n      throw new RippleComputedCycleError(`computed cycle detected${label}`);\n    }\n\n    this.computing_ = true;\n\n    try {\n      const newDeps: DepEntry[] = [];\n\n      getDevToolsHook()?.compute?.({ name: this.name });\n\n      const next = this.runCompute(newDeps);\n\n      this.dirty_ = false;\n      this.maxRevision_ = getRevision();\n\n      // Diff deps: remove subscriptions for sources that are no longer dependencies.\n      // Only subscribe to genuinely NEW deps — prevents duplicate WeakRef entries.\n      this.updateDeps(newDeps);\n\n      const isNew = this.value_ === UNINITIALIZED;\n\n      if (isNew || !this.equals_(this.value_ as T, next)) {\n        this.value_ = next;\n        this.version++;\n\n        return true;\n      }\n\n      return false;\n    } finally {\n      this.computing_ = false;\n    }\n  }\n\n  private updateDeps(newDeps: DepEntry[]): void {\n    const oldDeps = this.deps_;\n\n    // Fast path: same sources in same order — just refresh stored versions\n    if (oldDeps.length === newDeps.length && oldDeps.every((d, i) => d.source === newDeps[i].source)) {\n      for (let i = 0; i < newDeps.length; i++) {\n        oldDeps[i]!.version = newDeps[i]!.version;\n      }\n\n      return;\n    }\n\n    // Slow path: deps changed.\n    // Build a set of OLD sources so we can detect which are genuinely NEW and\n    // need a fresh addComputedSub call (WeakRef registration).\n    const oldSourceSet = new Set(oldDeps.map((d) => d.source));\n    const newSourceSet = new Set(newDeps.map((d) => d.source));\n\n    // Unsubscribe from sources that are no longer dependencies\n    for (const old of oldDeps) {\n      if (!newSourceSet.has(old.source)) {\n        old.source.removeComputedSub(this);\n      }\n    }\n\n    // Subscribe to sources that are genuinely NEW (not in old deps)\n    for (const dep of newDeps) {\n      if (!oldSourceSet.has(dep.source)) {\n        dep.source.addComputedSub(this);\n      }\n    }\n\n    this.deps_ = newDeps;\n  }\n\n  get value(): T {\n    // After disposal: return last known value without tracking (inert node, like signal).\n    // If the computed was never evaluated (still UNINITIALIZED), return undefined.\n    if (this.disposed_) {\n      return this.value_ !== UNINITIALIZED ? (this.value_ as T) : (undefined as unknown as T);\n    }\n\n    this.refreshIfDirty();\n    trackSource(this);\n\n    return this.value_ as T;\n  }\n\n  // peek() after dispose: return last known value silently, consistent with signal.peek().\n  // If the computed was never evaluated, return undefined (same as signal with undefined initial).\n  peek(): T {\n    if (this.disposed_) {\n      return this.value_ !== UNINITIALIZED ? (this.value_ as T) : (undefined as unknown as T);\n    }\n\n    this.refreshIfDirty();\n\n    return this.value_ as T;\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.refreshIfDirty();\n    this.addEffectSub(listener);\n\n    return new SubscriptionImpl(() => {\n      this.removeEffectSub(listener);\n    });\n  };\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\n    // Unsubscribe from all upstream sources\n    for (const dep of this.deps_) {\n      dep.source.removeComputedSub(this);\n    }\n\n    this.deps_ = [];\n    this.clearSubscribers();\n    getDevToolsHook()?.dispose?.({ kind: 'computed', name: this.name });\n  }\n\n  [Symbol.dispose](): void {\n    this.dispose();\n  }\n}\n\n// ── computed() ───────────────────────────────────────────────────────────────\n\nexport const computed = <T>(compute: () => T, options?: ComputedOptions<T>): Computed<T> => {\n  const comp = new ComputedImpl(compute, options);\n\n  autoRegisterDisposal(() => comp.dispose());\n\n  return comp;\n};\n"],"mappings":"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"}

package/dist/devtools-hook.cjs

@@ -0,0 +1,2 @@
+var e=null,t=()=>e,n=t=>{e=t};exports.getDevToolsHook=t,exports.setDevToolsHook=n;
+//# sourceMappingURL=devtools-hook.cjs.map

package/dist/devtools-hook.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools-hook.cjs","names":[],"sources":["../src/devtools-hook.ts"],"sourcesContent":["// ── DevTools hook — core stub ─────────────────────────────────────────────────\n//\n// This module is intentionally minimal: it only holds the module-level _hook\n// variable and exposes getDevToolsHook() for the hot paths in signal.ts,\n// computed.ts, effect.ts, and store.ts.\n//\n// installDevTools() lives in the @vielzeug/ripple/devtools sub-path and is\n// tree-shaken from production bundles when that sub-path is never imported.\n// setDevToolsHook() is the internal bridge called by installDevTools().\n\nimport type { RippleDevToolsHook } from './types';\n\nlet _hook: RippleDevToolsHook | null = null;\n\n/** Returns the currently installed DevTools hook, or `null` if none is installed. */\nexport const getDevToolsHook = (): RippleDevToolsHook | null => _hook;\n\n/** @internal Called only by `installDevTools` in `@vielzeug/ripple/devtools`. */\nexport const setDevToolsHook = (hook: RippleDevToolsHook | null): void => {\n  _hook = hook;\n};\n"],"mappings":"AAYA,IAAI,EAAmC,KAG1B,MAAmD,EAGnD,EAAmB,GAA0C,CACxE,EAAQ,CACV"}

package/dist/devtools-hook.d.ts

@@ -0,0 +1,4 @@
+import type { RippleDevToolsHook } from './types';
+/** Returns the currently installed DevTools hook, or `null` if none is installed. */
+export declare const getDevToolsHook: () => RippleDevToolsHook | null;
+//# sourceMappingURL=devtools-hook.d.ts.map

package/dist/devtools-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools-hook.d.ts","sourceRoot":"","sources":["../src/devtools-hook.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAIlD,qFAAqF;AACrF,eAAO,MAAM,eAAe,QAAO,kBAAkB,GAAG,IAAa,CAAC"}

package/dist/devtools-hook.js

@@ -0,0 +1,8 @@
+//#region src/devtools-hook.ts
+var e = null, t = () => e, n = (t) => {
+	e = t;
+};
+//#endregion
+export { t as getDevToolsHook, n as setDevToolsHook };
+
+//# sourceMappingURL=devtools-hook.js.map

package/dist/devtools-hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools-hook.js","names":[],"sources":["../src/devtools-hook.ts"],"sourcesContent":["// ── DevTools hook — core stub ─────────────────────────────────────────────────\n//\n// This module is intentionally minimal: it only holds the module-level _hook\n// variable and exposes getDevToolsHook() for the hot paths in signal.ts,\n// computed.ts, effect.ts, and store.ts.\n//\n// installDevTools() lives in the @vielzeug/ripple/devtools sub-path and is\n// tree-shaken from production bundles when that sub-path is never imported.\n// setDevToolsHook() is the internal bridge called by installDevTools().\n\nimport type { RippleDevToolsHook } from './types';\n\nlet _hook: RippleDevToolsHook | null = null;\n\n/** Returns the currently installed DevTools hook, or `null` if none is installed. */\nexport const getDevToolsHook = (): RippleDevToolsHook | null => _hook;\n\n/** @internal Called only by `installDevTools` in `@vielzeug/ripple/devtools`. */\nexport const setDevToolsHook = (hook: RippleDevToolsHook | null): void => {\n  _hook = hook;\n};\n"],"mappings":";AAYA,IAAI,IAAmC,MAG1B,UAAmD,GAGnD,KAAmB,MAA0C;CACxE,IAAQ;AACV"}

package/dist/devtools.d.ts

@@ -0,0 +1,39 @@
+import type { EffectCallback, EffectHandle, EffectOptions, RippleDevToolsHook } from './types';
+export type { DisposeEvent, MutateEvent, NamedEvent, RippleDevToolsHook, WriteEvent } from './types';
+/**
+ * Installs a DevTools hook for observing ripple internals.
+ * Pass `null` to uninstall.
+ *
+ * Import from the dedicated sub-path to keep this out of production bundles:
+ * ```ts
+ * import { installDevTools } from '@vielzeug/ripple/devtools';
+ *
+ * installDevTools({
+ *   write({ name, oldValue, newValue }) {
+ *     console.log(`[ripple] ${name ?? '(unnamed)'}: ${String(oldValue)} → ${String(newValue)}`);
+ *   },
+ *   dispose({ kind, name }) {
+ *     console.log(`[ripple] ${kind} "${name ?? '(unnamed)'}" disposed`);
+ *   },
+ * });
+ * ```
+ */
+export declare const installDevTools: (hook: RippleDevToolsHook | null) => void;
+/**
+ * Wraps `effect()` and logs reactive dependency information on every run:
+ * - **Initial run**: logs all deps the effect subscribed to.
+ * - **Re-runs**: logs which deps changed (with old and new version numbers).
+ *
+ * Use instead of `effect()` when debugging unexpected re-renders.
+ *
+ * @example
+ * ```ts
+ * import { debugEffect } from '@vielzeug/ripple/devtools';
+ *
+ * const stop = debugEffect(() => {
+ *   renderUser(userId.value, name.value);
+ * }, { name: 'renderUser' });
+ * ```
+ */
+export declare const debugEffect: (fn: EffectCallback, options?: Omit<EffectOptions, "trace">) => EffectHandle;
+//# sourceMappingURL=devtools.d.ts.map

package/dist/devtools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.d.ts","sourceRoot":"","sources":["../src/devtools.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAa,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAQ1G,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAIrG;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,kBAAkB,GAAG,IAAI,KAAG,IAQjE,CAAC;AAIF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,GAAI,IAAI,cAAc,EAAE,UAAU,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,KAAG,YA+CxF,CAAC"}