@pumped-fn/lite 2.0.0 → 2.1.2

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @pumped-fn/lite
 
+## 2.1.2
+
+### Patch Changes
+
+- 8ed17e7: - Fix watch and invalidation edge cases in `@pumped-fn/lite` by aligning `select()` with `Object.is`, snapshotting select listeners during notification, making watch option typing match the runtime contract, and surfacing invalidation-chain failures from `flush()` instead of leaking them as background rejections.
+  - Fix `@pumped-fn/lite-react` hook refresh behavior by keeping stale values visible during re-resolution, recomputing `useSelect` snapshots when selector or equality semantics change, tracking pending promises per controller, and suppressing non-Suspense `unhandledRejection` leaks on failed refreshes.
+
+## 2.1.1
+
+### Patch Changes
+
+- 2ce41fc: Fix 16 bugs found via adversarial triage + 5 rounds of Codex review:
+
+  **Correctness**
+
+  - `preset(atom, undefined)` now works — uses `has()` check instead of `!== undefined`
+  - `seekHas()` traverses parent chain via interface dispatch, not `instanceof`
+  - Error-path `pendingSet` only reschedules value-type sets — `fn(undefined)` no longer produces garbage
+  - `doInvalidateSequential` swallows resolve errors when pending operations exist
+  - Resource cycle detection moved to per-execution-chain WeakMap — fixes false errors with `ctx.exec()`
+  - Resource inflight check runs before circular check — sibling `ctx.exec()` no longer false-positives
+
+  **Reactive system**
+
+  - `set()`/`update()` pendingSet path skips cleanups — watch deps preserved since factory doesn't re-run
+  - Unconditional `invalidationChain.delete()` in pendingSet fast-path — prevents self-loops
+  - Copy-on-iterate on all 4 listener iteration sites — unsub during notification no longer drops siblings
+
+  **Lifecycle**
+
+  - `dispose()` awaits `chainPromise` before setting `disposed` — drains pending invalidation chain
+  - `resolve()`, `controller()`, `createContext()` throw after dispose
+  - `release()` cleans up dependents + schedules GC on freed deps
+
+  **SelectHandle**
+
+  - Eager subscription in constructor — tracks changes without active subscribers
+  - `dispose()` method for explicit teardown
+  - Re-subscribe refreshes cached value after auto-cleanup
+  - Added `seekHas()` to `ContextData` interface, `dispose()` to `SelectHandle` interface
+
+## 2.1.0
+
+### Minor Changes
+
+- a87362f: Add `controller({ resolve: true, watch: true, eq? })` for automatic reactive invalidation.
+
+  When `watch: true` is set, the parent atom re-runs automatically whenever the dep resolves to a new value (equality-gated via `Object.is` or a custom `eq` function). Replaces manual `ctx.cleanup(ctx.scope.on('resolved', dep, () => ctx.invalidate()))` wiring. Watch listeners are auto-cleaned on re-resolve, release, and dispose.
+
 ## 2.0.0
 
 ### Major Changes

package/PATTERNS.md

@@ -218,22 +218,23 @@ sequenceDiagram
 
 ### Controller as Dependency
 
-Receive reactive handle instead of resolved value in atom/flow deps.
+Receive a reactive handle instead of the resolved value in atom deps. Use `resolve: true` to pre-resolve before the factory runs. Add `watch: true` (atom deps only) to auto-invalidate the parent when the dep value changes — replaces manual `ctx.cleanup(ctx.scope.on('resolved', dep, () => ctx.invalidate()))`.
 
 ```mermaid
 sequenceDiagram
     participant Scope
-    participant AtomA as serverAtom
+    participant Parent as derivedAtom
+    participant Dep as configAtom
     participant Ctrl as Controller
-    participant AtomB as configAtom
-
-    Scope->>AtomA: resolve(serverAtom)
-    Note over AtomA: deps: { cfg: controller(configAtom, { resolve: true }) }
-    AtomA->>Scope: resolve configAtom first
-    Scope-->>Ctrl: ctrl (already resolved)
-    AtomA->>AtomA: factory(ctx, { cfg: ctrl })
-    AtomA->>Ctrl: ctrl.on('resolved', () => ctx.invalidate())
-    Note over AtomA: react to config changes
+
+    Scope->>Parent: resolve(derivedAtom)
+    Note over Parent: deps: { cfg: controller(configAtom, { resolve: true, watch: true, eq? }) }
+    Parent->>Scope: resolve configAtom first
+    Scope-->>Ctrl: ctrl (resolved)
+    Parent->>Parent: factory(_, { cfg: ctrl })
+    Note over Scope: on dep 'resolved': compare prev/next via eq ?? Object.is
+    Scope->>Parent: scheduleInvalidation if changed
+    Note over Parent: watch listener auto-cleaned on re-resolve / release / dispose
 ```
 
 ### Inline Function Execution

package/README.md

@@ -1,6 +1,6 @@
 # @pumped-fn/lite
 
-![Coverage: 97%+ statements](https://img.shields.io/badge/coverage-97%25%2B_statements-brightgreen) ![Coverage: 100% functions](https://img.shields.io/badge/coverage-100%25_functions-brightgreen) ![Tests: 263 passed](https://img.shields.io/badge/tests-263_passed-brightgreen)
+![Coverage: 97%+ statements](https://img.shields.io/badge/coverage-97%25%2B_statements-brightgreen) ![Coverage: 100% functions](https://img.shields.io/badge/coverage-100%25_functions-brightgreen) ![Tests: 300 passed](https://img.shields.io/badge/tests-300_passed-brightgreen)
 
 **Scoped Ambient State** for TypeScript — a scope-local atom graph with explicit dependencies and opt-in reactivity.
 
@@ -151,6 +151,13 @@ sequenceDiagram
 
         App->>Scope: select(atom, selector, { eq })
         Scope-->>App: handle { get, subscribe }
+
+        Note over App,Ctrl: Dependency reactivity — atom deps only
+        Note right of Scope: watch:true replaces manual ctx.cleanup(ctx.scope.on('resolved', dep, () => ctx.invalidate()))
+        App->>Scope: resolve(derivedAtom)
+        Note right of Scope: deps: { src: controller(srcAtom, { resolve: true, watch: true, eq? }) }
+        Scope->>Scope: on dep 'resolved': eq(prev, next) → scheduleInvalidation if changed
+        Note right of Scope: watch listener auto-cleaned on re-resolve / release / dispose
     end
 
     %% ── Cleanup & Teardown ──