You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
Commit 542ff6f
Browse filesBrowse the repository at this point in the historyBrowse files
fix(solid,web): a failed Errored waits for its fallback's async holes before streaming (#4308)
* fix(solid,web): draw an Errored fallback for a Loading's async failure, and adopt it (#4287)
Outside a server component, a <Loading> whose async read failed during a
streamed render settled its fragment blank, and the hydrating client
rendered the failed boundary from scratch: it asked again and showed the
loading fallback.
Server: the failing <Loading> now asks the enclosing <Errored> for its
outcome outside server components too, passing its own id. The Errored
answers only when that Loading is all of its content (its resolved markup
is the Loading's placeholder): its fallback is drawn into the fragment, or
inlined pre-flush, and the error is serialized at the Errored id. Deeper
in the content it answers nothing, as before. A rejected fragment's
template is marked `e`, and `$dfr` records the nodes it swaps in for it.
Client: inside a hydrated Errored's no-claim content run, a <Loading>
runs its content with its data adopted instead of waiting on its
fragment, so the Errored holds the client's own error and tracks the
content's inputs (#4273). A boundary that claimed its fallback and then
renders a rejected fragment fresh clears the nodes the swap put in first,
so nothing of the server's outcome is left beside the client's render.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(solid): serialize an Errored's error only when its fallback markup is sent
When a streamed <Loading> fails after the shell and asks the enclosing
<Errored> for its outcome, the fallback may hold an async hole that has
not resolved yet. renderOutcome then returns no markup (the fragment
settles as a plain rejection), but handleError had already serialized
the error at the Errored id. A client hydrating after the failure read
that record, claimed a fallback that was never sent, and went blank
with a hydration key miss.
The outcome path now defers the record and writes it only once the
fallback resolved to finished markup. Without it the client renders the
failure itself, as on `next`. Server-only; no client bytes.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_018LY7F9czoRqdMEvk2QwPr1
* fix(solid,web): stream a parked Errored fallback once its async hole resolves (#4306)
An <Errored> whose fallback reads async data, around a <Loading> that
fails after the shell inside an outer <Loading> still pending, lost its
region: the outcome render met the fallback's pending hole, answered no
markup, and the parked fragment spliced a blank into the outer one while
its `_fr` resolved. The client claimed against the blank and showed
nothing there, with hydration warnings.
renderOutcome now answers a still-resolving fallback with a function
that waits out its holes and returns the finished markup, serializing
the error only then. The <Loading> calls it only while its fragment is
parked in an enclosing pending one (the registry's new `parked()` query
on the settle function), where nothing of the failure shows yet: the
outer fragment carries the fallback, or, if the outer settles first,
the inner fragment streams it when it lands. A failure in a region
already shown settles at once, as before. Server-only; no client bytes.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(solid,web): a failed Errored always waits for its fallback's async holes (#4306)
Per RULES-DERIVED D-18 (a swap to a fallback waits for the fallback to be
ready), the wait for an Errored fallback's async holes no longer depends
on the fragment being parked. A <Loading> that fails after the shell under
an <Errored> whose fallback is still resolving keeps its placeholder until
the finished fallback is ready, then streams it with the error record, in
the parked case (carried by the outer fragment while that is pending) and
the unparked one alike. The registry's `parked()` query is dropped.
#4303's async-fallback scenario now expects the server's finished fallback
and its record: a client hydrating after the failure arrived claims it and
asks nothing again. Server-only; no client bytes.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
---------
Co-authored-by: Claude <[email protected]>
An `<Errored>` whose fallback reads async data, around a `<Loading>` that fails after the shell, now streams its fallback once that data is ready, and a client hydrating after it arrived claims it. Before, the failure landed while the fallback's read was still pending, so the server had no markup for it. On its own, the boundary swapped to a blank and the client rendered the failure itself, asking for the failed read again. Inside an outer `<Loading>` still pending, the outer fragment arrived with the Errored region blank, and the client hydrated against the blank with warnings and showed nothing there. Now the failure waits for the fallback, as a swap to a fallback waits for the fallback to be ready: the loading placeholder stays until the finished fallback replaces it (carried by the outer fragment when that is still pending), and the error is serialized with it (#4306).
0 commit comments