@solidjs/signals 2.0.0-beta.9 → 2.0.0-rc.0

package/README.md

@@ -107,12 +107,12 @@ const data = createMemo(async () => {
   return response.json();
 });
 
-// Check async state
-isPending(data); // true while loading
-latest(data); // last resolved value
+// Check async state for this read
+isPending(data); // true while an unrevealed value change is in flight for this read
+latest(data); // last resolved value; follows the not-ready path if no value has resolved yet
 ```
 
-Use `action()` to coordinate async workflows with the reactive graph:
+Use `action()` for mutations — imperative async workflows whose writes span an async gap. Each invocation runs as a single transaction: every write between yields batches into one atomic update, and nothing commits until the action completes or the next `yield` resolves.
 
 ```typescript
 const save = action(function* (item) {
@@ -120,6 +120,10 @@ const save = action(function* (item) {
 });
 ```
 
+Navigation-shaped updates don't need an action. A plain setter call is enough — reads pull the async, downstream async computeds hold their previous values until new ones are ready, and `isPending`/`latest` expose the in-flight state. Reach for `action` when writes happen *after* async work (pairing with optimistic primitives for tentative state that reverts on failure), not when the async is merely downstream of a synchronous write.
+
+Framework-level actions (router form actions, server actions) are specializations of this primitive: the same transactional semantics with form binding, serialization, and submission tracking layered on top.
+
 ## Optimistic Updates
 
 Optimistic signals show an immediate value while async work is pending, then automatically revert when it settles:
@@ -183,7 +187,7 @@ import { createErrorBoundary, createLoadingBoundary } from "@solidjs/signals";
 
 createErrorBoundary(
   () => riskyComputation(),
-  (error, reset) => handleError(error)
+  (error, reset) => handleError(error())
 );
 
 createLoadingBoundary(
@@ -223,10 +227,10 @@ createRoot(dispose => {
 | ------------------------ | ------------------------------------------------------------------ |
 | `flush()`                | Process all pending updates                                        |
 | `untrack(fn)`            | Run `fn` without tracking dependencies                             |
-| `isPending(accessor)`    | Check if an async accessor is loading                              |
-| `latest(accessor)`       | Get the last resolved value of an async accessor                   |
-| `refresh(accessor)`      | Re-trigger an async computation                                    |
-| `isRefreshing(accessor)` | Check if an async accessor is refreshing                           |
+| `isPending(accessor)`    | Check if an unrevealed value change is in flight for a read        |
+| `latest(accessor)`       | Get the last resolved value, or follow not-ready if none exists    |
+| `refresh(accessor)`      | Re-trigger an async computation (a quiet re-ask — not pending)     |
+| `affects(target, key?)` | Declare that in-flight work will change the targeted data (reads pending until settle) |
 | `resolve(fn)`            | Returns a promise that resolves when a reactive expression settles |
 | `mapArray(list, mapFn)`  | Reactive array mapping with keyed reconciliation                   |
 | `repeat(count, mapFn)`   | Reactive repeat based on a reactive count                          |