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 a124577
Browse filesBrowse the repository at this point in the historyBrowse files
authored
fix(signals): a boundary whose fallback is pending reveals landed content without waiting for the fallback's flight (#3540) (#3581)
* test(signals): pin what an on= re-arm does not license (#3540)
Reveal-timing and fallback-pending pins for re-armed Loading boundaries.
One pins a live defect: a re-armed boundary whose fallback is itself not
ready does not reveal landed content until the fallback's read lands.
Co-authored-by: Cursor <[email protected]>
* test(signals): re-derive the on= reveal-timing pins under frame-following (#3540, #3575)
The two reveal-timing pins were written against #3556's mainline swap. Under
#3575 the swap is staged into the notifying write's transaction, and the
boundary's output is that frame's from then on:
- staged source: the action outlasts the data, so old content holds through
the flight, `data 2` lands at the commit, the fallback is never shown, and
LOADING_ON_OUTSIDE_HOLD reports once after the fact.
- independent source: the content's own hold (the pending write it derives
from) is joined to the action's frame when the staged output pass reads
its landing — reveal at the commit, no fallback, same diagnostic. The
pre-#3575 sequence is the display-ahead read's (`latest()`), pinned
beside it.
Co-authored-by: Claude via Cursor <[email protected]>
Co-authored-by: Cursor <[email protected]>
* fix(signals): judge a boundary whose fallback is pending before the verdict (#3540)
A collecting Loading boundary whose FALLBACK read something not ready left
its output pass pending on that read; an initialized parent held the frame
on it. When the content landed, the boundary was ready — but its output pass
derives from `_disabled`, not the tree, so the tree settling never re-ran
it; only the boundary sweep does, and that sweep ran at the commit
(finalizePureQueue), after the verdict the output's own read kept parking.
The content waited for the fallback's flight.
Judge that one shape before the verdict, under the transaction
(`CollectionQueue._judgeHeld`, walked by `checkBoundaryChildren(this, true)`
after the re-arm drain): a collecting boundary whose output is pending
stages `_disabled` false with the frame and its output re-runs in the same
heap, reads the tree, and drops the fallback's read through recompute's
ordinary settle of a pass's outgoing pending sources — the verdict sees the
release. Boundaries with a ready fallback park nothing and keep the commit
sweep's reveal unchanged.
The DEV after-the-fact LOADING_ON_OUTSIDE_HOLD rule (devHeldSweep) now also
recognizes a swap the pre-verdict sweep cleared while still staged
(`_disabled` staged false over a never-committed true) as never displayed;
`_checkSources` drops `_swapUnseen` only for a swap that committed.
Pins: the on= case (loading-on-rearm-reveal-3540 'content lands before the
fallback') and its no-on analogue (loading-fallback-release-3540, whose
second test shows the general computed case always released — the bug was
boundary-specific). Core floor +63 B, documented in treeshake.test.ts.
Co-authored-by: Claude via Cursor <[email protected]>
Co-authored-by: Cursor <[email protected]>
* chore(size): re-set four caps for the pre-verdict boundary judgment (#3540)
+38..+81 B brotli per scenario, re-measured rebased over #3577 (origin/next
709c02b, same solid/web dist): the flush's pre-verdict boundary walk in
core, and `_judgeHeld` / `_output` in boundaries. Re-set: isPending/latest
(12.40 -> 12.45), hydrating no-stores (20.70 -> 20.75), CSR (15.75 ->
15.80, over #3577's own bump) and the CSR observe tier (17.30 -> 17.35,
no observe-gated bytes; brotli layout). Each carries its measurement
note. The simple-app floor (12,493 / 12.50) and observe + attribution
(27,743 / 27.75) now land within `next`'s caps and keep them; the other
four scenarios are within their caps too.
Co-authored-by: Claude via Cursor <[email protected]>
Co-authored-by: Cursor <[email protected]>
---------
Co-authored-by: Cursor <[email protected]>
Co-authored-by: Claude via Cursor <[email protected]>
A Loading boundary whose fallback reads something not ready now reveals its content as soon as the content lands, instead of waiting for the fallback's own flight (#3540). The boundary's output pass derives from its `_disabled` switch, not its tree, so only the boundary sweep re-runs it — and that sweep ran at the commit, after the verdict the output's own pending read kept parking. Such a boundary is now judged before the verdict, under the transaction, so its output re-runs, reads the tree and drops the fallback's read ahead of the verdict. Boundaries whose fallback is ready are unaffected. The DEV `LOADING_ON_OUTSIDE_HOLD` after-the-fact rule recognizes a swap cleared this way as never displayed.
0 commit comments