@vielzeug/stateit 2.0.0 → 3.0.1

package/README.md

@@ -1,337 +1,107 @@
 # @vielzeug/stateit
 
-> Tiny, zero-dependency reactive state — signals, computed values, effects, and typed object stores
-
-[![npm version](https://img.shields.io/npm/v/@vielzeug/stateit)](https://www.npmjs.com/package/@vielzeug/stateit) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-**Stateit** is a tiny, zero-dependency reactive library with two complementary primitives:
-
-- **Signals** — fine-grained reactive atoms with `signal()`, `computed()`, `effect()`, `watch()`, `batch()`, and more
-- **Stores** — typed reactive object containers with partial patching, updater functions, selectors, and freeze
-
-A `Store<T>` extends `Signal<T>`, so every signal primitive — `effect`, `watch`, `computed`, `batch` — works seamlessly on stores.
+Tiny reactive state with direct singleton primitives.
 
 ## Installation
 
 ```sh
 pnpm add @vielzeug/stateit
-# npm install @vielzeug/stateit
-# yarn add @vielzeug/stateit
 ```
 
-## Quick Start
+## Usage
 
-### Signals
+Stateit exports singleton primitives directly.
 
-```typescript
-import { signal, computed, effect, watch, batch } from '@vielzeug/stateit';
+```ts
+import { batch, computed, effect, signal } from '@vielzeug/stateit';
 
 const count = signal(0);
 const doubled = computed(() => count.value * 2);
 
-// effect runs immediately and re-runs on every dependency change
-const sub = effect(() => {
-  console.log(`count=${count.value}, doubled=${doubled.value}`);
+const stop = effect(() => {
+  console.log(count.value, doubled.value);
 });
-// → count=0, doubled=0
 
-count.value = 3;
-// → count=3, doubled=6
-
-// Update via function — shorthand for count.value = count.value + n
-count.update((n) => n + 1);
-// → count=4, doubled=8
-
-// Watch explicitly (does not fire immediately by default)
-const stopWatch = watch(count, (next, prev) => console.log(prev, '→', next));
-count.value = 5; // → 4 → 5
-
-// Batch coalesces notifications into one flush
 batch(() => {
-  count.value = 10;
-  count.value = 20;
+  count.value = 1;
+  count.value = 2;
 });
-// One notification: → 5 → 20
 
-sub.dispose(); // or: sub() — direct call also disposes
+stop();
 doubled.dispose();
-stopWatch.dispose();
-```
-
-### Stores
-
-```typescript
-import { store, watch, batch } from '@vielzeug/stateit';
-
-const counter = store({ count: 0, user: null as User | null });
-
-// Read
-console.log(counter.value); // { count: 0, user: null }
-
-// Partial patch
-counter.patch({ count: 1 });
-
-// Updater function
-counter.update((s) => ({ ...s, count: s.count + 1 }));
-
-// Watch a slice — compose store.select() with watch()
-const countSignal = counter.select((s) => s.count);
-const stopWatch = watch(countSignal, (count, prev) => {
-  console.log('count:', prev, '→', count);
-});
-
-// Batch updates into one notification
-batch(() => {
-  counter.patch({ count: 10 });
-  counter.patch({ user: currentUser });
-});
-
-// Reset to initial state
-counter.reset();
-
-stopWatch.dispose();
-counter.freeze();
 ```
 
-## Features
-
-- ✅ **Signals** — reactive atoms with `.value` getter/setter, `.update(fn)`, and `.peek()` for untracked reads
-- ✅ **Computed** — lazy derived signals; call `.dispose()` to stop tracking dependencies
-- ✅ **Effects** — run immediately and re-run when dependencies change; support cleanup returns; return a `Subscription`
-- ✅ **Watch** — explicit subscriptions with `{ immediate?, once?, equals? }` options; returns a `Subscription`
-- ✅ **Batch** — coalesce multiple writes into a single downstream notification
-- ✅ **Untrack** — read signals without registering reactive dependencies
-- ✅ **derived** — multi-source computed from an array of signals
-- ✅ **nextValue** — `Promise` that resolves on the next matching signal emission
-- ✅ **Custom equality** — `signal/computed/watch/store` all accept a custom `equals` function
-- ✅ **Stores** — object state with `patch(partial)`, `update(fn)`, `reset()`, `select()`, and `freeze()`
-- ✅ **Writable computed** — bidirectional computed with `writable(get, set)`
-- ✅ **Symbol.dispose** — all dispose handles support `using` declarations (TC39 explicit resource management)
-- ✅ **Type guards** — `isSignal(v)` and `isStore(v)`
-- ✅ **Zero dependencies** — no supply-chain risk, minimal bundle size
-- ✅ **Framework agnostic** — works in React, Vue, Svelte, or plain TypeScript
-
-## Usage
+## Store As Small Recipe
 
-### Signals
+`store()` is a thin object helper over `signal()` with immutable-style updates. Stores expose the readable signal contract (`value`, `peek`, `subscribe`) plus object-focused mutation helpers.
 
-```typescript
-import { signal, readonly } from '@vielzeug/stateit';
+```ts
+import { store } from '@vielzeug/stateit';
 
-const count = signal(0);
-count.value = 5;
-count.peek(); // read without tracking
-count.update((n) => n + 1); // derive next value in place
+const user = store({ profile: { name: 'Ada' }, count: 0 });
 
-// Narrow to read-only view (no proxy overhead)
-const ro = readonly(count);
+user.patch({ count: 1 });
+user.update((state) => ({ ...state, count: state.count + 1 }));
+user.reset();
 ```
 
-### Computed
-
-```typescript
-import { signal, computed } from '@vielzeug/stateit';
+## Watching Derived Values
 
-const first = signal('Ada');
-const last = signal('Lovelace');
-const full = computed(() => `${first.value} ${last.value}`);
+Use `watch` with a getter function to watch any derived value directly:
 
-console.log(full.value); // 'Ada Lovelace'
-full.stale; // false — just computed
-first.value = 'Grace';
-full.stale; // true — deps changed, not yet re-read
-
-// Dispose (stop tracking dependencies)
-full.dispose();
-// or: using full = computed(...) — TC39 using declaration
-```
+```ts
+import { store, watch } from '@vielzeug/stateit';
 
-### Effects
+const cart = store({ count: 0, label: 'x' });
 
-```typescript
-import { signal, effect, onCleanup } from '@vielzeug/stateit';
-
-const name = signal('Ada');
-
-const sub = effect(() => {
-  console.log('Hello,', name.value);
-  return () => console.log('cleanup'); // optional teardown
+const stop = watch(() => cart.value.count, (next, prev) => {
+  console.log(prev, '->', next);
 });
 
-name.value = 'Grace'; // logs 'cleanup' then 'Hello, Grace'
-sub.dispose(); // logs 'cleanup', effect is removed
+stop();
 ```
 
-### Watch
-
-```typescript
-import { signal, store, watch } from '@vielzeug/stateit';
-
-const count = signal(0);
+## Interop Helpers
 
-// Plain watch
-const sub = watch(count, (next, prev) => console.log(prev, '→', next));
-
-// Slice watch — compose with store.select()
-const user = store({ name: 'Ada', age: 30 });
-const nameSig = user.select((s) => s.name);
-watch(nameSig, (name) => console.log('name:', name));
-
-// Options
-watch(count, (v) => console.log(v), { immediate: true, once: true });
-
-sub.dispose();
-```
+Stateit stays framework-agnostic, but the core exports are designed to plug directly into common reactive contracts.
 
-### Stores
+```ts
+import { computed, readonly, signal, toObservable, toStore } from '@vielzeug/stateit';
 
-```typescript
-import { store, watch, batch } from '@vielzeug/stateit';
-
-const cart = store({ items: [] as string[], total: 0 });
-
-// Partial patch
-cart.patch({ total: 42 });
-
-// Updater function
-cart.update((s) => ({ ...s, items: [...s.items, 'apple'] }));
-
-// Derived slice
-const totalSignal = cart.select((s) => s.total);
-
-// Watch slice
-watch(totalSignal, (total) => console.log('total:', total));
-
-// Batch
-batch(() => {
-  cart.patch({ total: 0 });
-  cart.update((s) => ({ ...s, items: [] }));
-});
-
-cart.reset();
-cart.freeze();
-```
-
-### Writable Computed
-
-```typescript
-import { signal, writable } from '@vielzeug/stateit';
-
-const celsius = signal(0);
-const fahrenheit = writable(
-  () => (celsius.value * 9) / 5 + 32,
-  (f) => {
-    celsius.value = ((f - 32) * 5) / 9;
-  },
-);
-
-fahrenheit.value = 212;
-console.log(celsius.value); // 100
-
-fahrenheit.update((f) => f + 10); // increment via fn
-fahrenheit.dispose();
-```
-
-### `nextValue` — Async Watch
-
-```typescript
-import { signal, nextValue } from '@vielzeug/stateit';
-
-const status = signal<'idle' | 'loading' | 'done'>('idle');
-
-// Wait for the next change (any value)
-const next = await nextValue(status);
-
-// Wait for a specific condition
-const done = await nextValue(status, (v) => v === 'done');
+const count = signal(0);
+const doubled = computed(() => count.value * 2);
 
-// Abortable wait
-const controller = new AbortController();
-const p = nextValue(status, (v) => v === 'done', { signal: controller.signal });
-controller.abort(new Error('cancelled'));
+const publicCount = readonly(count);
+const svelteStore = toStore(doubled);
+const observable = toObservable(publicCount);
 ```
 
-### Custom Equality
-
-```typescript
-import { signal, computed } from '@vielzeug/stateit';
+## Strict Runtime Rules
 
-// Signal only notifies when the array reference AND contents differ
-const tags = signal(['ts'], { equals: (a, b) => JSON.stringify(a) === JSON.stringify(b) });
-
-// Computed suppresses downstream when result is structurally unchanged
-const sorted = computed(() => [...tags.value].sort(), { equals: (a, b) => a.join() === b.join() });
-```
+- `onCleanup()` throws when called outside an active effect.
+- Reading a disposed computed signal throws.
+- Store constructor/patch misuse (non-object values) throws.
 
 ## API
 
-### Signal Functions
-
-| Export             | Signature                                                | Returns                  |
-| ------------------ | -------------------------------------------------------- | ------------------------ |
-| `signal`           | `signal(initial, options?)`                              | `Signal<T>`              |
-| `computed`         | `computed(fn, options?)`                                 | `ComputedSignal<T>`      |
-| `writable`         | `writable(get, set, options?)`                           | `WritableSignal<T>`      |
-| `derived`          | `derived(sources, fn, options?)`                         | `ComputedSignal<R>`      |
-| `effect`           | `effect(fn, options?)`                                   | `Subscription`           |
-| `watch`            | `watch(source, cb, options?)`                            | `Subscription`           |
-| `nextValue`        | `nextValue(source, predicate?, { signal? }?)`           | `Promise<T>`             |
-| `batch`            | `batch(fn)`                                              | `T`                      |
-| `untrack`          | `untrack(fn)`                                            | `T`                      |
-| `onCleanup`        | `onCleanup(fn)`                                          | `void`                   |
-| `readonly`         | `readonly(sig)`                                          | `ReadonlySignal<T>`      |
-| `toValue`          | `toValue(v)`                                             | `T`                      |
-| `peekValue`        | `peekValue(v)`                                           | `T`                      |
-| `isSignal`         | `isSignal(v)`                                            | `v is ReadonlySignal<T>` |
-| `isStore`          | `isStore(v)`                                             | `v is Store<T>`          |
-| `shallowEqual`     | `shallowEqual(a, b)`                                     | `boolean`                |
-| `configureStateit` | `configureStateit(opts)`                                 | `void`                   |
-| `_resetContextForTesting` | `_resetContextForTesting()`                       | `void`                   |
-
-### Store Functions
-
-| Export  | Signature                  | Returns    |
-| ------- | -------------------------- | ---------- |
-| `store` | `store(initial, options?)` | `Store<T>` |
-
-### `Store<T>` Methods
-
-| Member                        | Description                                                             |
-| ----------------------------- | ----------------------------------------------------------------------- |
-| `.value`                      | Read the current state (tracked)                                        |
-| `.peek()`                     | Read the current state (untracked)                                      |
-| `.update(fn)`                 | Derive next state via `fn(copy) => next`                                |
-| `.patch(partial)`             | Shallow-merge a `Partial<T>` into state                                 |
-| `.reset()`                    | Restore the original initial state                                      |
-| `.select(selector, options?)` | Lazily derived `ComputedSignal<U>` from a slice; compose with `watch()` |
-| `.frozen`                     | `true` after `freeze()` has been called                                 |
-| `.freeze()`                   | Freeze the store; further writes are silently ignored                   |
-
-### Types
-
-| Type                 | Description                                                                          |
-| -------------------- | ------------------------------------------------------------------------------------ |
-| `Signal<T>`          | Readable/writable reactive atom with `.update(fn)`                                   |
-| `ReadonlySignal<T>`  | Read-only signal (no setter)                                                         |
-| `ComputedSignal<T>`  | `ReadonlySignal<T> & Disposable` — has `.stale`, `.dispose()`                        |
-| `WritableSignal<T>`  | `Signal<T> & Disposable` — has `.stale`, `.update(fn)`, `.dispose()`                 |
-| `Store<T>`           | Object store extending `Signal<T>`                                                   |
-| `Subscription`       | Callable + `.dispose()` + `[Symbol.dispose]` — returned by `effect`/`watch`          |
-| `Disposable`         | `.dispose()` + `[Symbol.dispose]` — implemented by `ComputedSignal`/`WritableSignal` |
-| `CleanupFn`          | `() => void`                                                                         |
-| `EffectCallback`     | `() => CleanupFn \| void`                                                            |
-| `EffectOptions`      | `{ maxIterations?, onError? }`                                                       |
-| `EqualityFn<T>`      | `(a: T, b: T) => boolean`                                                            |
-| `ReactiveOptions<T>` | `{ equals?: EqualityFn<T> }`                                                         |
-| `WatchOptions<T>`    | `{ immediate?, once?, equals? }`                                                     |
-| `StoreOptions<T>`    | `{ equals?: EqualityFn<T> }`                                                         |
-
-## Documentation
-
-Full docs at **[vielzeug.dev/stateit](https://vielzeug.dev/stateit)**
-
-|                                                   |                                        |
-| ------------------------------------------------- | -------------------------------------- |
-| [Usage Guide](https://vielzeug.dev/stateit/usage) | Concepts, patterns, and best practices |
-| [API Reference](https://vielzeug.dev/stateit/api) | Complete type signatures               |
-| [Examples](https://vielzeug.dev/stateit/examples) | Framework integrations and recipes     |
+```ts
+type ObservableObserver<T> = { next(value: T): void };
+type ObservableLike<T> = {
+  subscribe(observer: ObservableObserver<T> | ((value: T) => void)): { unsubscribe(): void };
+};
+
+signal<T>(initial: T, options?: { equals?: (a: T, b: T) => boolean }): Signal<T>;
+computed<T>(compute: () => T, options?: { equals?: (a: T, b: T) => boolean }): ComputedSignal<T>;
+effect(fn: () => void | (() => void)): Subscription;
+watch<T>(source: ReadonlySignal<T>, cb: (value: T, prev: T) => void, options?: WatchOptions<T>): Subscription;
+watch<T>(source: () => T, cb: (value: T, prev: T) => void, options?: WatchOptions<T>): Subscription;
+batch<T>(fn: () => T): T;
+untrack<T>(fn: () => T): T;
+readonly<T>(source: ReadonlySignal<T>): ReadonlySignal<T>;
+toStore<T>(source: ReadonlySignal<T>): { subscribe(run: (value: T) => void): Subscription };
+toObservable<T>(source: ReadonlySignal<T>): ObservableLike<T>;
+onCleanup(fn: () => void): void;
+scope(setup?: () => void): Scope;
+store<T extends object>(initial: T): Store<T>;
+isSignal<T>(value: unknown): value is ReadonlySignal<T>;
+```

package/dist/index.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./runtime.cjs`),t=require(`./batch.cjs`),n=require(`./types.cjs`),r=require(`./computed.cjs`),i=require(`./effect.cjs`),a=require(`./signal.cjs`),o=require(`./store.cjs`),s=require(`./watch.cjs`);exports.ComputedNode=r.ComputedNode,exports.SignalImpl=a.SignalImpl,exports.WritableNode=r.WritableNode,exports._SIGNAL_BRAND=n._SIGNAL_BRAND,exports._STORE_BRAND=n._STORE_BRAND,exports._flushPending=t._flushPending,exports._resetContextForTesting=e._resetContextForTesting,exports.batch=t.batch,exports.computed=r.computed,exports.configureStateit=e.configureStateit,exports.derived=r.derived,exports.effect=i.effect,exports.isSignal=a.isSignal,exports.isStore=o.isStore,exports.nextValue=s.nextValue,exports.onCleanup=i.onCleanup,exports.peekValue=a.peekValue,exports.readonly=a.readonly,exports.shallowEqual=o.shallowEqual,exports.signal=a.signal,exports.store=o.store,exports.toValue=a.toValue,exports.untrack=i.untrack,exports.watch=s.watch,exports.writable=r.writable;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./stateit.cjs`);exports.batch=e.batch,exports.computed=e.computed,exports.effect=e.effect,exports.isSignal=e.isSignal,exports.observableSymbol=e.observableSymbol,exports.onCleanup=e.onCleanup,exports.readonly=e.readonly,exports.scope=e.scope,exports.signal=e.signal,exports.store=e.store,exports.toObservable=e.toObservable,exports.toStore=e.toStore,exports.toSubscription=e.toSubscription,exports.untrack=e.untrack,exports.watch=e.watch;

package/dist/index.d.ts

@@ -1,20 +1,2 @@
-/** stateit -- Lightweight reactive state
- *
- * Reactive primitives:
- *   Signal<T>         -- synchronous, fine-grained reactive atom
- *   ReadonlySignal<T> -- read-only view of a signal
- *   Store<T>          -- object-state store with set/freeze/reset/select
- *
- * All primitives interoperate: computed, derived, effect, watch, batch,
- * untrack, onCleanup, toValue, configureStateit work uniformly
- * on Signal<T> and Store<T>.
- */
-export * from './batch';
-export * from './computed';
-export * from './effect';
-export { _resetContextForTesting, configureStateit } from './runtime';
-export * from './signal';
-export * from './store';
-export * from './types';
-export * from './watch';
+export * from './stateit';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACtE,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -1,9 +1,2 @@
-import { _resetContextForTesting as e, configureStateit as t } from "./runtime.js";
-import { _flushPending as n, batch as r } from "./batch.js";
-import { _SIGNAL_BRAND as i, _STORE_BRAND as a } from "./types.js";
-import { ComputedNode as o, WritableNode as s, computed as c, derived as l, writable as u } from "./computed.js";
-import { effect as d, onCleanup as f, untrack as p } from "./effect.js";
-import { SignalImpl as m, isSignal as h, peekValue as g, readonly as _, signal as v, toValue as y } from "./signal.js";
-import { isStore as b, shallowEqual as x, store as S } from "./store.js";
-import { nextValue as C, watch as w } from "./watch.js";
-export { o as ComputedNode, m as SignalImpl, s as WritableNode, i as _SIGNAL_BRAND, a as _STORE_BRAND, n as _flushPending, e as _resetContextForTesting, r as batch, c as computed, t as configureStateit, l as derived, d as effect, h as isSignal, b as isStore, C as nextValue, f as onCleanup, g as peekValue, _ as readonly, x as shallowEqual, v as signal, S as store, y as toValue, p as untrack, w as watch, u as writable };
+import { batch as e, computed as t, effect as n, isSignal as r, observableSymbol as i, onCleanup as a, readonly as o, scope as s, signal as c, store as l, toObservable as u, toStore as d, toSubscription as f, untrack as p, watch as m } from "./stateit.js";
+export { e as batch, t as computed, n as effect, r as isSignal, i as observableSymbol, a as onCleanup, o as readonly, s as scope, c as signal, l as store, u as toObservable, d as toStore, f as toSubscription, p as untrack, m as watch };

package/dist/stateit.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=Symbol(`stateit.uninitialized`),t={cleanups:null,deps:null,effect:null},n={depth:0,pending:new Set},r=100,i=e=>{e.maxEffectIterations!==void 0&&(r=e.maxEffectIterations)},a=()=>{n.depth=0,t.deps=null,t.effect=null,t.cleanups=null,n.pending.clear()},o=class{#e=new Set;_track(){if(t.deps!==null&&t.effect!==null){let e=t.effect;this.#e.add(e),t.deps.add(()=>this.#e.delete(e))}}_notify(){if(this.#e.size===0)return;if(n.depth>0){for(let e of this.#e)n.pending.add(e);return}let e=[];for(let t of[...this.#e])try{t()}catch(t){e.push(t)}if(e.length)throw e.length===1?e[0]:AggregateError(e,`[stateit] multiple subscriber errors`)}},s=(e,n,r,i)=>{let a=t.effect,o=t.deps,s=t.cleanups;t.effect=e,t.deps=n,t.cleanups=r;try{return i()}finally{t.effect=a,t.deps=o,t.cleanups=s}},c=()=>{let e=[...n.pending];n.pending.clear();let t=[];for(let n of e)try{n()}catch(e){t.push(e)}if(t.length)throw t.length===1?t[0]:AggregateError(t,`[stateit] batch errors`)},l=e=>{n.depth++;try{let t=e();return--n.depth===0&&c(),t}catch(e){if(--n.depth===0)try{c()}catch{}throw e}},u=Symbol(`stateit.signal`),d=Symbol(`stateit.store`),f=class extends o{[u]=!0;#e;#t=e;#n=!0;#r=!1;#i;#a=new Set;#o=()=>{this.#n||(this.#n=!0,this._notify())};constructor(e,t){super(),this.#e=e,this.#i=t?.equals??Object.is,t?.lazy||this.#s()}#s(){for(let e of this.#a)e();this.#a.clear();let t=s(this.#o,this.#a,null,this.#e);this.#n=!1,(this.#t===e||!this.#i(this.#t,t))&&(this.#t=t)}get value(){return this.#r?this.#t:(this.#n&&this.#s(),this._track(),this.#t)}peek(){if(this.#t===e){if(this.#r)return;this.#s()}return this.#t}get stale(){return this.#n||this.#r}dispose(){if(!this.#r){this.#r=!0;for(let e of this.#a)e();this.#a.clear()}}[Symbol.dispose](){this.dispose()}},p=(e,t)=>new f(e,t),m=class extends f{#e;constructor(e,t,n){super(e,n),this.#e=t}get value(){return super.value}set value(e){this.#e(e)}update(e){this.#e(e(this.peek()))}},h=(e,t,n)=>new m(e,t,n),g=(e,t,n)=>p(()=>t(...e.map(e=>e.value)),n),_=(e,t)=>{let n,i=new Set,a=!1,o=!1,c=!1,l=t?.maxIterations??r,u=()=>{n?.(),n=void 0;for(let e of i)e();i.clear()},d=()=>{o=!1,u();let r=[],a,l=!1;try{s(f,i,r,()=>{let t=e();typeof t==`function`&&r.push(t)})}catch(e){if(t?.onError)l=!0,a=e;else throw e}return n=r.length>0?()=>{for(let e of r)e()}:void 0,l&&(u(),t.onError(a),c=!0),l},f=()=>{if(c||a){a&&(o=!0);return}a=!0;try{let e=0;do{if(++e>l)throw Error(`[stateit] effect: possible infinite reactive loop (> ${l} iterations)`);if(d())break}while(o)}finally{a=!1}};f();let p=()=>{c||(c=!0,u())};return Object.assign(p,{dispose:p,[Symbol.dispose]:p})},v=e=>s(null,null,null,e),y=e=>{t.cleanups?.push(e)},b=class extends o{[u]=!0;#e;#t;constructor(e,t){super(),this.#e=e,this.#t=t?.equals??Object.is}get value(){return this._track(),this.#e}set value(e){this.#t(this.#e,e)||(this.#e=e,this._notify())}update(e){this.value=e(this.#e)}peek(){return this.#e}},x=(e,t)=>new b(e,t),S=new WeakMap,C=e=>{let t=S.get(e);if(t)return t;let n={get[u](){return!0},peek:()=>e.peek(),get value(){return e.value}};return S.set(e,n),n},w=e=>typeof e==`object`&&!!e&&u in e,T=e=>w(e)?e.value:e,E=e=>w(e)?e.peek():e,D=(e,t)=>{if(e===t)return!0;if(e==null||t==null)return e===t;if(typeof e!=`object`||typeof t!=`object`)return!1;let n=Object.keys(e),r=Object.keys(t);if(n.length!==r.length)return!1;for(let r of n)if(!Object.is(e[r],t[r]))return!1;return!0},O=class extends b{[d]=!0;#e;#t=!1;constructor(e,t){super(e,{equals:t?.equals??D}),this.#e={...e}}get frozen(){return this.#t}get value(){return super.value}set value(e){this.#t||(super.value=e)}patch(e){this.value={...this.peek(),...e}}update(e){this.value=e({...this.peek()})}reset(){this.value={...this.#e}}select(e,t){return p(()=>e(this.value),t)}freeze(){this.#t=!0}},k=(e,t)=>new O(e,t),A=e=>typeof e==`object`&&!!e&&d in e,j=(e,t,n)=>{let r=n?.equals??Object.is,i=e.peek();n?.immediate&&t(i,i);let a;return a=_(()=>{let o=e.value;if(!r(i,o)){let e=i;i=o,t(o,e),n?.once&&a()}}),a},M=(e,t,n)=>new Promise((r,i)=>{let a=n?.signal;try{a?.throwIfAborted()}catch(e){i(e);return}let o=j(e,e=>{(!t||t(e))&&(o(),a?.removeEventListener(`abort`,s),r(e))}),s=()=>{o(),i(a.reason)};a?.addEventListener(`abort`,s,{once:!0})});exports.ComputedNode=f,exports.SignalImpl=b,exports.WritableNode=m,exports._SIGNAL_BRAND=u,exports._STORE_BRAND=d,exports._flushPending=c,exports._resetContextForTesting=a,exports.batch=l,exports.computed=p,exports.configureStateit=i,exports.derived=g,exports.effect=_,exports.isSignal=w,exports.isStore=A,exports.nextValue=M,exports.onCleanup=y,exports.peekValue=E,exports.readonly=C,exports.shallowEqual=D,exports.signal=x,exports.store=k,exports.toValue=T,exports.untrack=v,exports.watch=j,exports.writable=h;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=100,t=Symbol(`stateit.is-signal`),n=Symbol.observable??Symbol.for(`observable`),r=n,i=e=>Object.assign(e,{dispose:e,[Symbol.dispose]:e}),a=new WeakMap,o=e=>e instanceof Error?e:Error(String(e)),s=(e,t)=>{if(typeof e!=`object`||!e||Array.isArray(e))throw TypeError(t)},c=(e,t)=>{let n=[];for(let t of e)try{t()}catch(e){n.push(e)}if(n.length===1)throw n[0];if(n.length>1)throw AggregateError(n,`[stateit] ${t}`)},l=(e,t,n)=>{let r=o(e);throw t.length===0?r:AggregateError([r,...t.map(o)],`[stateit] ${n}`,{cause:r})},u=e=>{try{return c(e,`cleanup errors`),[]}catch(e){return e instanceof AggregateError?e.errors:[e]}},d=null,f=null,p=null,m=null,h=(e,t,n,r,i)=>{let a=d,o=f,s=p,c=m;d=e,f=t,p=n,m=r;try{return i()}finally{d=a,f=o,p=s,m=c}},g=0,_=new Set,v=new Set,y=e=>{let t=new Set(e),n=new Map;for(let t of e)n.set(t,0);for(let r of e)for(let e of r.computedSubscribers())t.has(e)&&n.set(e,(n.get(e)??0)+1);let r=[];for(let t of e)(n.get(t)??0)===0&&r.push(t);let i=[];for(;r.length>0;){let e=r.shift();i.push(e);for(let i of e.computedSubscribers()){if(!t.has(i))continue;let e=(n.get(i)??0)-1;n.set(i,e),e===0&&r.push(i)}}if(i.length<e.length)for(let t of e)i.includes(t)||i.push(t);return i},b=e=>{let t=[...e.computedSubscribers()],n=new Set;for(let t of e.subscribers())_.add(t);for(;t.length>0;){let e=t.pop();if(!n.has(e)&&(n.add(e),e.markDirty())){v.add(e);for(let n of e.computedSubscribers())t.push(n)}}},x=()=>{for(;v.size>0;){let e=y([...v]);v.clear();for(let t of e)if(t.hasAnySubscribers()&&t.refreshIfDirty()){for(let e of t.subscribers())_.add(e);for(let e of t.computedSubscribers())e.markDirty()&&v.add(e)}}},S=()=>{let t=0;for(;_.size>0||v.size>0;){if(++t>e)throw Error(`[stateit] infinite flush loop (> ${e} iterations)`);if(v.size>0&&x(),_.size===0)continue;let n=[..._];_.clear(),c(n,`subscriber errors`)}},C=e=>{e.hasAnySubscribers()&&(b(e),g===0&&S())},w=class{computedSubs_=new Set;subscribers_=new Set;track(){if(p){if(f!==null){let e=f;this.computedSubs_.add(e),p.add(()=>this.computedSubs_.delete(e));return}if(d!==null){let e=d;this.subscribers_.add(e),p.add(()=>this.subscribers_.delete(e))}}}notify(){C(this)}hasAnySubscribers(){return this.computedSubs_.size>0||this.subscribers_.size>0}computedSubscribers(){return this.computedSubs_}subscribers(){return this.subscribers_}subscribe(e){return this.subscribers_.add(e),i(()=>{this.subscribers_.delete(e)})}},T=class extends w{value_;equals_;[t]=!0;constructor(e,t){super(),this.value_=e,this.equals_=t??Object.is}get value(){return this.track(),this.value_}peek(){return this.value_}subscribe=e=>super.subscribe(e);update(e){this.value=e(this.value_)}set value(e){this.equals_(this.value_,e)||(this.value_=e,this.notify())}},E=class extends w{hasValue_=!1;value_;dirty_=!0;computing_=!1;disposed_=!1;deps_=new Set;compute_;equals_;[t]=!0;constructor(e,t){super(),this.compute_=e,this.equals_=t??Object.is}markDirty(){return this.disposed_||this.dirty_?!1:(this.dirty_=!0,!0)}refreshIfDirty(){return this.dirty_?this.recompute():!1}recompute(){if(this.computing_)throw Error(`[stateit] computed cycle detected`);for(let e of this.deps_)e();this.deps_.clear(),this.computing_=!0;try{let e=h(null,this,this.deps_,null,this.compute_);return this.dirty_=!1,!this.hasValue_||!this.equals_(this.value_,e)?(this.hasValue_=!0,this.value_=e,!0):!1}catch(e){let t=u(this.deps_);return this.deps_.clear(),l(e,t,`computed failed dependency cleanup errors`)}finally{this.computing_=!1}}get value(){if(this.disposed_)throw Error(`[stateit] Cannot read disposed computed signal`);return this.refreshIfDirty(),this.track(),this.value_}peek(){if(this.disposed_)throw Error(`[stateit] Cannot read disposed computed signal`);return this.refreshIfDirty(),this.value_}subscribe=e=>{if(this.disposed_)throw Error(`[stateit] Cannot subscribe to a disposed computed signal`);return this.refreshIfDirty(),super.subscribe(e)};dispose(){if(!this.disposed_){this.disposed_=!0;for(let e of this.deps_)e();this.deps_.clear()}}[Symbol.dispose](){this.dispose()}},D=(e,t)=>new T(e,t?.equals),O=(e,t)=>{let n=new E(e,t?.equals);return m!==null&&F(()=>n.dispose()),n},k=e=>{g++;let t,n;try{t=e()}catch(e){n=e}if(g--,g===0)try{S()}catch(e){throw n===void 0?o(e):AggregateError([n,e],`[stateit] batch error with flush errors`,{cause:e})}if(n!==void 0)throw o(n);return t},A=t=>{let n,r=new Set,a=!1,o=!1,s=!1,d=()=>{if(!n&&r.size===0)return;let e=n?[n,...r]:[...r];n=void 0,r.clear(),c(e,`effect teardown errors`)},f=()=>{if(!s){if(a){o=!0;return}a=!0;try{let i=0;do{if(++i>e)throw Error(`[stateit] infinite effect loop (> ${e} iterations)`);o=!1,d();let a=[],s;try{s=h(f,null,r,a,t)}catch(e){let t=[...u(r),...u(a)];r.clear(),l(e,t,`effect failure with cleanup errors`)}typeof s==`function`&&a.push(s),n=a.length>0?()=>{c(a,`effect cleanup errors`)}:void 0}while(o&&!s)}finally{a=!1}}};return f(),i(()=>{s||(s=!0,d())})},j=e=>h(null,null,null,null,e),M=e=>{let t=e,n=a.get(t);if(n)return n;let r={peek(){return e.peek()},subscribe(t){return e.subscribe(t)},get value(){return e.value}};return a.set(t,r),r},N=e=>({subscribe(t){return t(e.value),e.subscribe(()=>t(e.value))}}),P=e=>{let t=t=>{let n=typeof t==`function`?{next:t}:t;n.next?.(e.value);let r=e.subscribe(()=>n.next?.(e.value));return{unsubscribe(){r()}}},r={[n](){return r},subscribe:t};return r},F=e=>{if(m===null)throw Error(`[stateit] onCleanup() must be called from within an active effect or scope.`);m.push(e)},I=e=>{let t=[],n=!1,r=e=>{if(n)throw Error(`[stateit] Cannot run inside a disposed scope.`);return h(null,null,null,t,e)},i=()=>{n||(n=!0,c([...t].reverse(),`scope cleanup errors`),t.length=0)},a={dispose:i,run:r,[Symbol.dispose]:i};return e&&r(e),a};function L(e,t,n){let r=typeof e==`function`?e:()=>e.value,i=n?.equals??Object.is,a=!1,o;return n?.immediate&&(o=j(r),a=!0,t(o,o)),A(()=>{let e=r();if(!a){a=!0,o=e;return}if(i(o,e))return;let n=o;o=e,t(e,n)})}var R=e=>{s(e,`[stateit] store() requires a plain object initial state.`);let n=structuredClone(e),r=D(structuredClone(e));return{[t]:!0,patch(e){s(e,`[stateit] store.patch() requires a plain object partial.`);let t=j(()=>r.value);Object.keys(e).some(n=>!Object.is(t[n],e[n]))&&(r.value={...t,...e})},peek(){return r.peek()},reset(){r.value=structuredClone(n)},subscribe(e){return r.subscribe(e)},update(e){r.update(e)},get value(){return r.value}}},z=e=>typeof e==`object`&&!!e&&!!e[t];exports.batch=k,exports.computed=O,exports.effect=A,exports.isSignal=z,exports.observableSymbol=r,exports.onCleanup=F,exports.readonly=M,exports.scope=I,exports.signal=D,exports.store=R,exports.toObservable=P,exports.toStore=N,exports.toSubscription=i,exports.untrack=j,exports.watch=L;
 //# sourceMappingURL=stateit.cjs.map