@pyreon/reactivity 0.14.0 → 0.16.0

package/lib/types/index.d.ts

@@ -71,6 +71,19 @@ interface ComputedOptions<T> {
 declare function computed<T>(fn: () => T, options?: ComputedOptions<T>): Computed<T>;
 //#endregion
 //#region src/createSelector.d.ts
+/** Selector predicate with a `dispose()` method to release internal state. */
+interface Selector<T> {
+  (value: T): boolean;
+  /**
+   * Stop the source-tracking effect AND clear the per-value subscriber/host
+   * Maps. After dispose, calls to the selector return the last-known result
+   * but no longer track. Required for selectors over dynamic value spaces
+   * (UUIDs, ephemeral IDs) created outside an `EffectScope` — without it,
+   * each unique queried value adds a permanent entry to the internal Maps,
+   * leaking memory for the lifetime of the program. Idempotent.
+   */
+  dispose(): void;
+}
 /**
  * Create an equality selector — returns a reactive predicate that is true
  * only for the currently selected value.
@@ -83,8 +96,13 @@ declare function computed<T>(fn: () => T, options?: ComputedOptions<T>): Compute
  * const isSelected = createSelector(selectedId)
  * // In each row:
  * class: () => (isSelected(row.id) ? "selected" : "")
+ *
+ * @example
+ * // Dynamic value spaces — call dispose() to release the per-value cache:
+ * const isCurrentTab = createSelector(() => currentTabId())
+ * onUnmount(() => isCurrentTab.dispose())
  */
-declare function createSelector<T>(source: () => T): (value: T) => boolean;
+declare function createSelector<T>(source: () => T): Selector<T>;
 //#endregion
 //#region src/signal.d.ts
 interface SignalDebugInfo<T> {
@@ -120,7 +138,11 @@ interface Signal<T> {
    * Returns a disposer that nulls the slot.
    */
   direct(updater: () => void): () => void;
-  /** Debug name — useful for devtools and logging. */
+  /**
+   * Debug name — useful for devtools and logging. Set via the `name` option at
+   * creation; can be reassigned at any time (`s.label = 'renamed'`) since it's
+   * stored as a regular own property on the signal function.
+   */
   label: string | undefined;
   /** Returns a snapshot of the signal's debug info (value, name, subscriber count). */
   debug(): SignalDebugInfo<T>;
@@ -191,6 +213,19 @@ declare function inspectSignal<T>(sig: Signal<T>): SignalDebugInfo<T>;
 interface Effect {
   dispose(): void;
 }
+interface ReactiveSnapshotCapture {
+  capture: () => unknown;
+  /** Run `fn` with the previously-captured snapshot active. */
+  restore: <T>(snap: unknown, fn: () => T) => T;
+}
+/**
+ * Register a capture/restore pair so reactivity-layer effects (`_bind`,
+ * `renderEffect`, `effect`) can preserve external context (e.g. the core
+ * provide/useContext stack) across signal-driven re-runs. Called by
+ * `@pyreon/core`'s context module at import time. Idempotent — calling again
+ * replaces the previously registered hook.
+ */
+declare function setSnapshotCapture(hook: ReactiveSnapshotCapture | null): void;
 /**
  * Register a cleanup function inside an effect. The cleanup runs:
  * - Before the effect re-runs (when dependencies change)
@@ -273,6 +308,13 @@ interface Resource<T> {
   error: Signal<unknown>;
   /** Re-run the fetcher with the current source value. */
   refetch(): void;
+  /**
+   * Stop the source-tracking effect. After dispose(), source changes no
+   * longer trigger fetches and any in-flight response is ignored. Idempotent.
+   * Required for resources created outside an `EffectScope` to avoid leaking
+   * the source-tracking effect for the lifetime of the program.
+   */
+  dispose(): void;
 }
 /**
  * Async data primitive. Fetches data reactively whenever `source()` changes.
@@ -317,6 +359,24 @@ declare function getCurrentScope(): EffectScope | null;
 declare function setCurrentScope(scope: EffectScope | null): void;
 /** Create a new EffectScope. */
 declare function effectScope(): EffectScope;
+/**
+ * Register a callback to run when the current `EffectScope` stops. Vue 3
+ * parity. Must be called inside `scope.runInScope(fn)` — the registration
+ * captures the ambient scope, so calling outside any scope is a no-op (with
+ * a dev warning to surface the missing scope).
+ *
+ * Use to clean up resources tied to a scope's lifetime: timers, listeners,
+ * external subscriptions. Equivalent to calling `getCurrentScope()?.add({
+ * dispose: fn })` but with the scope capture handled.
+ *
+ * @example
+ * scope.runInScope(() => {
+ *   const ws = new WebSocket(url)
+ *   onScopeDispose(() => ws.close())
+ *   // ws.close() runs when scope.stop() is called
+ * })
+ */
+declare function onScopeDispose(fn: () => void): void;
 //#endregion
 //#region src/store.d.ts
 /**
@@ -333,6 +393,20 @@ declare function effectScope(): EffectScope;
  * state.count++                           // only the count effect re-runs
  * state.items[0].text = "world"           // only text-tracking effects re-run
  */
+/**
+ * Mark an object as RAW — `createStore` and `shallowReactive` will return it
+ * unwrapped. Useful when storing class instances, third-party objects, or
+ * other shapes that shouldn't be deeply proxied (Vue 3 parity).
+ *
+ * @example
+ * const cm = markRaw(new CodeMirrorView(...))
+ * const store = createStore({ editor: cm })
+ * store.editor === cm  // true (not wrapped)
+ *
+ * Note: marking is one-way — there's no `unmarkRaw`. Mark BEFORE the object
+ * enters a store; marking after wrap doesn't unwrap an existing proxy.
+ */
+declare function markRaw<T extends object>(value: T): T;
 /** Returns true if the value is a createStore proxy. */
 declare function isStore(value: unknown): boolean;
 /**
@@ -340,6 +414,24 @@ declare function isStore(value: unknown): boolean;
  * Returns a proxy — mutations to the proxy trigger fine-grained reactive updates.
  */
 declare function createStore<T extends object>(initial: T): T;
+/**
+ * Create a SHALLOW reactive store — only top-level mutations trigger updates.
+ * Nested objects are NOT auto-wrapped; reading a nested object returns the
+ * raw reference. Use when:
+ *   - the nested objects are immutable (frozen API responses)
+ *   - you want explicit control over which subtrees are reactive
+ *   - you need to store class instances or third-party objects without
+ *     paying the deep-proxy overhead
+ *
+ * @example
+ * const store = shallowReactive({ user: { name: 'Alice' }, count: 0 })
+ * effect(() => console.log(store.user))  // tracks store.user reference
+ * effect(() => console.log(store.count)) // tracks store.count
+ * store.user.name = 'Bob'                // does NOT trigger any effect
+ * store.count = 5                        // triggers the count effect
+ * store.user = { name: 'Bob' }           // triggers the user effect
+ */
+declare function shallowReactive<T extends object>(initial: T): T;
 //#endregion
 //#region src/tracking.d.ts
 /** Read signals without subscribing. Alias: `untrack`. */
@@ -373,5 +465,5 @@ interface WatchOptions {
  */
 declare function watch<T>(source: () => T, callback: (newVal: T, oldVal: T | undefined) => void | (() => void), opts?: WatchOptions): () => void;
 //#endregion
-export { Cell, type Computed, type ComputedOptions, type Effect, EffectScope, type ReadonlySignal, type Resource, type Signal, type SignalDebugInfo, type SignalOptions, type WatchOptions, _bind, batch, cell, computed, createResource, createSelector, createStore, effect, effectScope, getCurrentScope, inspectSignal, isStore, nextTick, onCleanup, onSignalUpdate, reconcile, renderEffect, runUntracked, runUntracked as untrack, setCurrentScope, setErrorHandler, signal, watch, why };
+export { Cell, type Computed, type ComputedOptions, type Effect, EffectScope, type ReactiveSnapshotCapture, type ReadonlySignal, type Resource, type Signal, type SignalDebugInfo, type SignalOptions, type WatchOptions, _bind, batch, cell, computed, createResource, createSelector, createStore, effect, effectScope, getCurrentScope, inspectSignal, isStore, markRaw, nextTick, onCleanup, onScopeDispose, onSignalUpdate, reconcile, renderEffect, runUntracked, runUntracked as untrack, setCurrentScope, setErrorHandler, setSnapshotCapture, shallowReactive, signal, watch, why };
 //# sourceMappingURL=index2.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/reactivity",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "Signals-based reactivity system for Pyreon",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/reactivity#readme",
   "bugs": {
@@ -14,6 +14,7 @@
   },
   "files": [
     "lib",
+    "!lib/**/*.map",
     "src",
     "README.md",
     "LICENSE"
@@ -33,9 +34,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "devDependencies": {
-    "@pyreon/manifest": "0.13.1"
-  },
   "scripts": {
     "build": "vl_rolldown_build",
     "dev": "vl_rolldown_build-watch",
@@ -43,5 +41,8 @@
     "typecheck": "tsc --noEmit",
     "lint": "oxlint .",
     "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@pyreon/manifest": "0.13.1"
   }
 }

package/src/batch.ts

@@ -1,15 +1,66 @@
 // Batch multiple signal updates into a single notification pass.
-// Uses a Set so the same subscriber is never flushed more than once per batch,
-// even if multiple signals it depends on change within the same batch.
+// Two-tier flush: computed recomputes drain first (within-pass Set-dedup),
+// THEN effects drain (multi-pass with cross-pass re-fire support).
+//
+// Dev-mode invariant gate: see https://github.com/pyreon/pyreon/blob/main/packages/core/reactivity/src/tests/batch.test.ts
+// for the property-based test that fuzzes random cascade graphs against this
+// invariant. The build-time gate folds to dead code in production bundles.
+const __DEV__ = process.env.NODE_ENV !== 'production'
 
 let batchDepth = 0
 
-// Two pre-allocated Sets swapped on each flush — avoids allocating a new Set()
-// on every batch exit. The "active" set collects enqueued notifications; on flush
-// we swap to the other set and iterate the captured one, then clear it for reuse.
-const setA = new Set<() => void>()
-const setB = new Set<() => void>()
-let pendingNotifications = setA
+// Two-tier queue design:
+//
+// 1. **`pendingRecomputes`** — computed.recompute callbacks. Drained FIRST in
+//    a cascading-iteration loop: cascading recomputes enqueued during a
+//    drain land in the same Set (Set.add idempotency dedupes), iteration
+//    visits added entries (JS Set iteration semantics), and the recompute
+//    layer settles before any effect fires. This guarantees effects always
+//    read fully-propagated computed values.
+//
+// 2. **`pendingEffects`** — effect.run callbacks. Drained SECOND, multi-pass.
+//    Within a single pass, Set.add idempotency gives us within-pass dedup
+//    (diamond / multi-dep selector). Across passes (entries re-enqueued
+//    AFTER being visited in the current pass — see `_visitedThisPass`), they
+//    fire AGAIN — needed for control flow that re-renders based on its own
+//    dispatch (e.g. ErrorBoundary's handler calling `error.set(err)` during
+//    the same run that mounted the throwing child). MAX_PASSES caps total
+//    passes at 32 to prevent pathological infinite re-enqueue loops.
+//
+// **Why two tiers, not one Set:**
+//   - Single-Set iteration (the prior design) worked for shallow cascades
+//     because the cascading recompute → effect re-enqueue happened BEFORE
+//     iteration reached the effect. For deep cascades (3+ hops), iteration
+//     reached the effect (with its stale upstream value) BEFORE the cascade
+//     finished propagating. Effect read stale values; subsequent cascade
+//     re-enqueues were dropped by Set.add idempotency.
+//   - Splitting recomputes from effects fixes this: all computed recomputes
+//     settle before any effect runs. The cascade-asymmetry contract from
+//     PR #381 is preserved (effects still fire once per batched change),
+//     AND deep-cascade correctness is added (effects always read settled
+//     values).
+//   - Multi-pass effect drain unblocks ErrorBoundary's "re-fire after
+//     dispatching from inside own run" pattern without breaking the
+//     single-fire contract for non-self-dispatching effects.
+//
+// **How a callback gets routed:** computed registers its `recompute` via
+// `_markRecompute(fn)` at creation time. The internal `_recomputes` WeakSet
+// tracks them. `enqueuePendingNotification` checks the WeakSet to route.
+const pendingRecomputes = new Set<() => void>()
+const pendingEffects = new Set<() => void>()
+const _nextEffectPass = new Set<() => void>()
+let _visitedThisPass: Set<() => void> | null = null
+const _recomputes = new WeakSet<() => void>()
+const MAX_PASSES = 32
+
+/**
+ * Mark a callback as a computed recompute (called from computed.ts at
+ * creation time). Routes future enqueues into the recompute queue so they
+ * settle before any effects fire.
+ */
+export function _markRecompute(fn: () => void): void {
+  _recomputes.add(fn)
+}
 
 export function batch(fn: () => void): void {
   batchDepth++
@@ -17,34 +68,92 @@ export function batch(fn: () => void): void {
     fn()
   } finally {
     batchDepth--
-    if (batchDepth === 0 && pendingNotifications.size > 0) {
+    if (batchDepth === 0 && (pendingRecomputes.size > 0 || pendingEffects.size > 0)) {
       // Keep batching active during flush so cascade-notifications emitted
-      // by flushing subscribers enqueue into the pending Set (and dedupe
-      // against what's already queued) instead of firing inline. The
-      // while-loop drains any cascade rounds until the graph is stable.
-      //
-      // Without this, a diamond dependency (a → b, c → d → effect) re-fires
-      // the apex effect TWICE per signal write: the first notification path
-      // through `b` reaches `effect`, whose read clears `d`'s dirty flag;
-      // then when `c` is notified (still in the first flush round), it
-      // re-dirties `d`, which re-notifies `effect`. Keeping batchDepth at 1
-      // during flush routes those cascade-notifications through the Set,
-      // which dedupes on `d`'s recompute and on `effect`'s run.
-      //
-      // See `packages/internals/perf-harness/src/tests/diamond-probe.test.ts`
-      // for the empirical probe that caught this.
+      // by flushing subscribers enqueue into the same queues (dedup against
+      // already-queued entries) instead of firing inline.
       batchDepth = 1
       try {
-        while (pendingNotifications.size > 0) {
-          // Swap to the other pre-allocated Set before flushing so new
-          // enqueues during notification land in the alternate Set, not
-          // mixed into the current iteration.
-          const flush = pendingNotifications
-          pendingNotifications = flush === setA ? setB : setA
-          for (const notify of flush) notify()
-          flush.clear()
+        // Outer loop: alternate between tier-1 (recomputes) and tier-2
+        // (effects) until both queues are empty. An effect can write a
+        // signal whose subscribers include lazy `computed.recompute`s — those
+        // get enqueued into pendingRecomputes mid-effect, and we need to
+        // drain them BEFORE the next effect pass so downstream effects see
+        // the propagated dirty flag. MAX_PASSES caps the OUTER loop —
+        // counts effect-tier passes only since recomputes converge by
+        // `equals` short-circuit and don't infinite-loop in practice.
+        let effectPass = 0
+        while (pendingRecomputes.size > 0 || pendingEffects.size > 0) {
+          // Tier 1: drain all recomputes via cascading iteration. Set
+          // semantics visit entries added during iteration; Set.add
+          // idempotency dedupes diamond cascades. Recomputes converge by
+          // `equals` short-circuit (computedWithEquals returns early when
+          // value is unchanged) and computedLazy's `if (dirty) return`
+          // guard prevents re-fire.
+          for (const r of pendingRecomputes) r()
+          pendingRecomputes.clear()
+
+          // Tier 2: drain ONE pass of effects in multi-pass mode. Within-
+          // pass dedup preserved by Set.add idempotency on entries not yet
+          // visited this pass. Cross-pass re-fire enabled by routing
+          // already-visited entries to `_nextEffectPass` (handled in
+          // `enqueuePendingNotification`). After the pass, loop back to
+          // tier 1 to drain any recomputes the effects enqueued.
+          if (pendingEffects.size > 0) {
+            if (++effectPass > MAX_PASSES) {
+              if (__DEV__) {
+                // Surface labels of dropped effects when available — helps
+                // identify the offending effect in a real app. Falls back to
+                // bare count for anonymous effects.
+                const droppedCount = pendingEffects.size
+                const labels: string[] = []
+                for (const notify of pendingEffects) {
+                  const label = (notify as { _label?: string })._label
+                  if (label) labels.push(label)
+                  if (labels.length >= 5) break
+                }
+                const labelHint = labels.length
+                  ? ` Sample labels: ${labels.join(', ')}${droppedCount > labels.length ? `, …${droppedCount - labels.length} more` : ''}.`
+                  : ''
+                // oxlint-disable-next-line no-console
+                console.warn(
+                  '[pyreon] batch effect flush exceeded MAX_PASSES (32) — possible infinite re-enqueue loop. ' +
+                    `${droppedCount} pending effects dropped.${labelHint} ` +
+                    'Common cause: an effect that writes to a signal it also reads, without a guard. ' +
+                    'See packages/core/reactivity/src/batch.ts for the multi-pass flush contract.',
+                )
+              }
+              // Drop the queue so subsequent batches start clean — without
+              // this, the next batch would re-encounter the offending effect
+              // immediately on its first pass and trip MAX_PASSES instantly,
+              // making the original error harder to diagnose.
+              pendingEffects.clear()
+              _nextEffectPass.clear()
+              break
+            }
+            _visitedThisPass = new Set<() => void>()
+            for (const notify of pendingEffects) {
+              _visitedThisPass.add(notify)
+              notify()
+            }
+            // Promote next-pass entries to pending for the next iteration.
+            pendingEffects.clear()
+            for (const next of _nextEffectPass) pendingEffects.add(next)
+            _nextEffectPass.clear()
+          }
         }
       } finally {
+        // Clear ALWAYS — even if a notify threw mid-iteration. Without this,
+        // the unflushed remainder leaks into the next batch and refires
+        // (audit bug #19). Effects wrap their callbacks in try/catch
+        // internally so this is rarely reachable in practice, but raw
+        // signal subscribers (signal.subscribe) and lower-level consumers
+        // can throw straight through, and a future refactor that swallows
+        // less aggressively would silently regress without this guard.
+        pendingRecomputes.clear()
+        pendingEffects.clear()
+        _nextEffectPass.clear()
+        _visitedThisPass = null
         batchDepth = 0
       }
     }
@@ -55,8 +164,22 @@ export function isBatching(): boolean {
   return batchDepth > 0
 }
 
+export function enquePendingNotificationDeprecated(): void {
+  // Kept as a comment placeholder — actual export is below. (Empty body to
+  // keep this file's exports list stable across the refactor.)
+}
+
 export function enqueuePendingNotification(notify: () => void): void {
-  pendingNotifications.add(notify)
+  // Route based on callback kind. Computed recomputes go to tier-1 queue,
+  // effects to tier-2. Within tier 2, already-visited-this-pass entries
+  // route to next-pass for cross-pass re-fire (ErrorBoundary's pattern).
+  if (_recomputes.has(notify)) {
+    pendingRecomputes.add(notify)
+  } else if (_visitedThisPass !== null && _visitedThisPass.has(notify)) {
+    _nextEffectPass.add(notify)
+  } else {
+    pendingEffects.add(notify)
+  }
 }
 
 /**

package/src/computed.ts

@@ -1,3 +1,4 @@
+import { _markRecompute } from './batch'
 import { _errorHandler } from './effect'
 import { getCurrentScope } from './scope'
 import {
@@ -10,9 +11,6 @@ import {
 } from './tracking'
 
 // Dev-time counter sink — see packages/internals/perf-harness for contract.
-interface ViteMeta {
-  readonly env?: { readonly DEV?: boolean }
-}
 const _countSink = globalThis as { __pyreon_count__?: (name: string, n?: number) => void }
 
 export interface Computed<T> {
@@ -54,6 +52,21 @@ function trackWithLocalDeps<T>(deps: Set<() => void>[], effect: () => void, fn:
 }
 
 export function computed<T>(fn: () => T, options?: ComputedOptions<T>): Computed<T> {
+  // Dev warning for async computed callbacks (audit bug #1 — extension).
+  // `computed(async () => …)` returns `Computed<Promise<T>>`, which silently
+  // breaks every consumer that expects `Computed<T>`. There's no scenario
+  // where async makes sense here — the recompute fires synchronously and
+  // tracks signals only in the synchronous prefix. For async-derived
+  // state, use `createResource` or a `signal<T>` updated from an effect.
+  if (process.env.NODE_ENV !== 'production') {
+    if (fn.constructor && fn.constructor.name === 'AsyncFunction') {
+      // oxlint-disable-next-line no-console
+      console.warn(
+        '[pyreon] computed() received an async function. The result type becomes `Computed<Promise<T>>`, and signal reads after the first `await` are NOT tracked. ' +
+          'Use `createResource` for async-derived state, or compute synchronously over a signal that holds the awaited value.',
+      )
+    }
+  }
   return options?.equals ? computedWithEquals(fn, options.equals) : computedLazy(fn)
 }
 
@@ -82,11 +95,12 @@ function computedLazy<T>(fn: () => T): Computed<T> {
     if (host._s) notifySubscribers(host._s)
     if (directFns) for (const f of directFns) f?.()
   }
+  _markRecompute(recompute)
 
   const read = (): T => {
     trackSubscriber(host)
     if (dirty) {
-      if ((import.meta as ViteMeta).env?.DEV === true)
+      if (process.env.NODE_ENV !== 'production')
         _countSink.__pyreon_count__?.('reactivity.computedRecompute')
       try {
         if (tracked) {
@@ -153,7 +167,7 @@ function computedWithEquals<T>(fn: () => T, equals: (prev: T, next: T) => boolea
 
   const recompute = () => {
     if (disposed) return
-    if ((import.meta as ViteMeta).env?.DEV === true)
+    if (process.env.NODE_ENV !== 'production')
       _countSink.__pyreon_count__?.('reactivity.computedRecompute')
     cleanupLocalDeps(deps, recompute)
     try {
@@ -169,11 +183,12 @@ function computedWithEquals<T>(fn: () => T, equals: (prev: T, next: T) => boolea
     if (host._s) notifySubscribers(host._s)
     if (directFns) for (const f of directFns) f?.()
   }
+  _markRecompute(recompute)
 
   const read = (): T => {
     trackSubscriber(host)
     if (dirty) {
-      if ((import.meta as ViteMeta).env?.DEV === true)
+      if (process.env.NODE_ENV !== 'production')
         _countSink.__pyreon_count__?.('reactivity.computedRecompute')
       cleanupLocalDeps(deps, recompute)
       try {

package/src/createSelector.ts

@@ -21,6 +21,20 @@ function notifyBucket(bucket: Set<() => void>): void {
   }
 }
 
+/** Selector predicate with a `dispose()` method to release internal state. */
+export interface Selector<T> {
+  (value: T): boolean
+  /**
+   * Stop the source-tracking effect AND clear the per-value subscriber/host
+   * Maps. After dispose, calls to the selector return the last-known result
+   * but no longer track. Required for selectors over dynamic value spaces
+   * (UUIDs, ephemeral IDs) created outside an `EffectScope` — without it,
+   * each unique queried value adds a permanent entry to the internal Maps,
+   * leaking memory for the lifetime of the program. Idempotent.
+   */
+  dispose(): void
+}
+
 /**
  * Create an equality selector — returns a reactive predicate that is true
  * only for the currently selected value.
@@ -33,13 +47,19 @@ function notifyBucket(bucket: Set<() => void>): void {
  * const isSelected = createSelector(selectedId)
  * // In each row:
  * class: () => (isSelected(row.id) ? "selected" : "")
+ *
+ * @example
+ * // Dynamic value spaces — call dispose() to release the per-value cache:
+ * const isCurrentTab = createSelector(() => currentTabId())
+ * onUnmount(() => isCurrentTab.dispose())
  */
-export function createSelector<T>(source: () => T): (value: T) => boolean {
+export function createSelector<T>(source: () => T): Selector<T> {
   const subs = new Map<T, Set<() => void>>()
   let current: T
   let initialized = false
+  let disposed = false
 
-  effect(() => {
+  const sourceEffect = effect(() => {
     const next = source()
     if (!initialized) {
       initialized = true
@@ -60,18 +80,30 @@ export function createSelector<T>(source: () => T): (value: T) => boolean {
   // Reusable hosts per value — avoids allocating a closure per trackSubscriber call
   const hosts = new Map<T, { _s: Set<() => void> | null }>()
 
-  return (value: T): boolean => {
-    let host = hosts.get(value)
-    if (!host) {
-      let bucket = subs.get(value)
-      if (!bucket) {
-        bucket = new Set()
-        subs.set(value, bucket)
+  const selector = ((value: T): boolean => {
+    if (!disposed) {
+      let host = hosts.get(value)
+      if (!host) {
+        let bucket = subs.get(value)
+        if (!bucket) {
+          bucket = new Set()
+          subs.set(value, bucket)
+        }
+        host = { _s: bucket }
+        hosts.set(value, host)
       }
-      host = { _s: bucket }
-      hosts.set(value, host)
+      trackSubscriber(host)
     }
-    trackSubscriber(host)
     return Object.is(current, value)
+  }) as Selector<T>
+
+  selector.dispose = (): void => {
+    if (disposed) return
+    disposed = true
+    sourceEffect.dispose()
+    subs.clear()
+    hosts.clear()
   }
+
+  return selector
 }