@abide/abide 0.52.0 → 0.53.0

package/src/lib/ui/runtime/flushEffects.ts

@@ -1,6 +1,7 @@
 import { boundaryFor } from './boundaryFor.ts'
 import { NODE_STATE } from './NODE_STATE.ts'
 import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
+import { SuspenseSignal } from './SuspenseSignal.ts'
 import type { ReactiveNode } from './types/ReactiveNode.ts'
 import { updateIfNecessary } from './updateIfNecessary.ts'
 
@@ -50,16 +51,23 @@ function drain(): void {
             try {
                 updateIfNecessary(node)
             } catch (error) {
-                /* A node built inside a reactive `{#try}` routes its throw to that boundary
-                   (swap the guarded content to the catch branch) instead of the rethrow
-                   fallback — this is the "later re-run throw" the sync boundary could not
-                   catch. Reset it CLEAN either way so a later write to its deps can re-queue
-                   it (otherwise `mark`'s CLEAN→dirty gate leaves it permanently inert). */
-                const boundary = boundaryFor.get(node)
-                if (boundary !== undefined) {
-                    boundary.handle(error)
-                    node.status = NODE_STATE.CLEAN
-                    continue
+                /* A `SuspenseSignal` is "no value yet", not an error, and must NEVER route to a
+                   reactive `{#try}` (that would flash the author's `{:catch}` during loading,
+                   ADR-0042 D3). Every reading region catches its own suspend locally and re-runs on
+                   settle (the throwing read subscribed its cell), so a `SuspenseSignal` reaches here
+                   only if it escaped an unguarded read — surface it via the error collector below
+                   rather than leaking it to a boundary. A normal error routes to the node's nearest
+                   `{#try}` boundary: swap the guarded content to the catch branch instead of the
+                   rethrow fallback — the "later re-run throw" the sync boundary could not catch.
+                   Reset it CLEAN either way so a later write to its deps can re-queue it (otherwise
+                   `mark`'s CLEAN→dirty gate leaves it permanently inert). */
+                if (!(error instanceof SuspenseSignal)) {
+                    const boundary = boundaryFor.get(node)
+                    if (boundary !== undefined) {
+                        boundary.handle(error)
+                        node.status = NODE_STATE.CLEAN
+                        continue
+                    }
                 }
                 /* No boundary — one effect throwing must not strand the effects queued behind
                    it (they live in this same `batch`, unreachable once we swap

package/src/lib/ui/watch.ts

@@ -3,6 +3,7 @@ import { REMOTE_FUNCTION } from '../shared/REMOTE_FUNCTION.ts'
 import type { CacheOnContext } from '../shared/types/CacheOnContext.ts'
 import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
 import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
+import { withSuspense } from './dom/withSuspense.ts'
 import { effect } from './effect.ts'
 import { generationGuard } from './runtime/generationGuard.ts'
 import type { EffectResult } from './runtime/types/EffectResult.ts'
@@ -61,9 +62,13 @@ export function watch(
        also silence the compiler's generated bindings, which build on the client where the test
        DOM sets no global `window`). SSR-safety comes from the compiler stripping author
        `watch(...)` calls, and the subscribable branch's own server guard (cache.on). */
-    /* Compiler binding form watch(thunk): a bare auto-tracked effect (== today's $$effect). */
+    /* Compiler binding form watch(thunk): a bare auto-tracked effect (== today's $$effect). A
+       pending blocking `await` read throws a `SuspenseSignal` (ADR-0042) — withhold this reaction
+       (e.g. leave a `class:`/`style:` binding untouched) until the value resolves; the read tracked
+       its cell, so the effect re-runs on settle. Rethrows any real error. */
     if (argsOrHandler === undefined) {
-        return effect(source as () => EffectResult)
+        const thunk = source as () => EffectResult
+        return effect(() => withSuspense<EffectResult>(thunk, undefined))
     }
     /* watch(fn, args, handler): an rpc selector with explicit args. */
     if (maybeHandler !== undefined) {