Repository navigation
Commit 81a12d8
* fix(signals): latest() of a memo born in a lane throws NotReady instead of undefined (#4362, #4363, #4376)
A memo whose compute reads latest(s) is re-asked as the write's verdict
lane work, so it becomes a lane derivation. While its first pass is in
flight, nothing is in the lane, and laneValueOf/display fell back to the
committed value, which an uninitialized node does not have:
- latest(m)/isPending(m) served undefined and probed it pending (#4363);
- the lane's end committed that undefined as the node's answer and
cleared STATUS_UNINITIALIZED with the flight still up, which tripped
the flush loop guard for [latest(m), isPending(m)] (#4362);
- in hydration, m2 = fetchC(1 + latest(m1)) asked fetchC(NaN) instead of
adopting the streamed answer (#4376).
laneValueOf/display now return NOT_PENDING for such a node, so every
read throws NotReady (A7; A19 exc. 1) and the lane's end leaves the node
in flight.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): latest(a) beside b() computes one pass on the frame's world (#4365)
A memo or render effect that reads `latest(a)` beside `b()` computed a
torn pass on a batched write. The `latest()` read of a's staging opened the
flush's transaction for its verdict (verdict.ts `provisionalVerdict`).
The plain `b()` read after it then took that transaction for a hold
(`stagedScreen`): it served b's committed value and made the reader a
stale reader of the transaction. Nothing held the flush, so that torn pass
was one of the flush's frames. Through a memo, a render effect ran `[2,1]`
before `[2,2]`. A throw from the pass stuck, because the landing skips
errored readers.
A pass seated in the verdict lane only by its own `latest()` read
(REACTIVE_PROVISIONAL) now reads a staging as the frame does: it leaves
the lane and is recorded in `stagedReaders`. If the frame commits, the
pass was the frame's one pass. If the flush parks, the lane seam
re-derives it on the committed world as display-ahead work. A reader
whose own stale pass threw now re-derives at the landing.
`stagedScreen` moves into lanes.ts behind a hook, so the core floor does
not carry it.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): keep a verdict reader's lane routing and own-error recovery (async-gen #119, #1238)
- verdictValue: read the lane value before routing the reader into the
verdict lane, so a node born in the lane with nothing in it yet is read
as any uninitialized node (NotReady) without moving its reader (#1238).
- reruns: a stale reader whose error is its own (thrown by its pass over
the committed value it was served) re-derives at the landing; only an
error from an errored source is skipped (#3945). With #4363 no longer
committing `undefined`, async-gen case 119 reached this stuck error.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* chore: re-measure sizes over next @ 40cde2c, record async-gen improvements
- scripts/size: ledger lines for `signals: + isPending/latest`, the
compiled live page and live + router (+46/+46/+47 B minified over
next); this PR's store-app line re-measured (97,019 B).
- async-gen baseline: 15 recorded failures no longer reproduce (10
undefined-value, 4 final-screen, 1 unhandled-rejection).
- RULES-INDEX regenerated; changeset notes the error recovery.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): re-derive a self-errored stale reader at the lane's end, not in reruns
The verdict reader's own error from a served committed value (async-gen
#119) now re-derives from `dissolveLane` (lane engine only) instead of a
widened `reruns` condition, so the floors pay nothing (0 B; the lane
scenarios +20 B over the previous form). `reruns` is next's again.
Ledger re-measured; async-gen baseline unchanged.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): latest() opens no transaction for its verdict; its reader watches the seam (#4365)
Rework #4365 to the ruled shape (R5): in provisionalVerdict, latest()
no longer calls joinFuture(null). Like a probe read before anything has
joined, it goes through watchVerdict. Its pass is the frame's. If the
flush parks, it re-derives once in the verdict lane: it is marked
unanswered, so the seam does not take the transaction it joined as its
answer. A flush that has already joined a transaction (Vl1), and reads
outside a flush (Vl3), are unchanged.
This drops the stagedScreen variant (REACTIVE_PROVISIONAL, the
stagedScreen hook move and the laneSeams change). It also drops this
branch's `reruns` change: #4383 handles a self-errored stale reader in
lanes.ts dissolveLane, and that branch merges next.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* test(signals, web): re-pin the keyed Show over latest() to two mounts at a park (R-5, #4365)
Under design ruling R-5, latest() opens no transaction for its verdict.
The keyed condition's first pass is the frame's, and Show mounts A there.
The parked flush re-runs the latest() reader once in the verdict lane,
and Show mounts A again. The lane's mount is the one shown (the early
fallback, still asserted); the held frame's mount is discarded at the
lane's reveal. mounts goes [1,2,2] -> [1,3,3] for the static and
callback forms over latest(count). The committed-key and `on` rows are
unchanged. This re-pin waits on Ryan's ruling.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): the lane's end re-derives a render effect's own stale error too
The re-enqueue of a self-errored stale reader at the lane's end sat inside
the non-effect branch, so a render effect whose display-ahead pass threw
over a held write's screen value kept its error after the landing (found
by the #4365 thread). It now applies to both. Byte-neutral (0 B minified
in every scenario); floors 0 B.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* test(signals, web): note why the keyed Show over latest() mounts 3 at a park (D-2, A10)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): an async memo over a verdict memo asks each question once
A memo that reads a verdict memo is a verdict reader (F-6, #4050), and
propagateStatus re-derived every verdict reader when its source went
pending. Re-derived, an async one was served the committed value it had
already derived from (A10) and asked that question again; that flight
held the verdict lane, and the source's held landing re-ran it as lane
work onto the same committed value, a third ask. Only the landing's
re-derive asked the new question.
Now an async memo that is a verdict reader only by reading a verdict
memo (it opened no isPending/latest window of its own: REACTIVE_WINDOW,
set per pass by markVerdictReader) drops CONFIG_VERDICT when that memo
goes pending and takes the plain pending mark: it is pending through the
flight (F-9) and the hold's work until it lands, reading plainly (D-25,
#3884), and asks once at the landing. Sync readers re-derive as before.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* test(signals): with #4383, isPending of the unresolved m1 holds its Loading, so the unheld latest case asks like the held one
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* docs(signals): regenerate RULES-INDEX
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): a latest() reader's frame flight is adopted at the landing, not asked again (#4365)
Under R5 a latest() reader's first pass is the frame's: an async one
asks the frame's question there. When the flush parks, the seam
re-derives it in the verdict lane (F-6: the display-ahead view's own
async), and that re-derive superseded the frame's flight. The
transaction's landing then re-ran the reader as a stale reader and asked
the frame's question a second time on the same input.
The seam now parks the frame pass's flight (`_parked`) when it re-derives
an async unanswered reader outside a lane, and the landing's `reruns`
adopts it (`adoptFlight`: registered as if the re-derive had returned it,
through a promise of its own so the frame pass's listener cannot land it
twice) instead of re-running the reader. That happens whether the flight
landed before the transaction or is still in the air. Any later pass
drops the parked flight. Asks for m0 = ask(1 + latest(s) + s()) and
m1 = ask(1 + m0()) after setS(2): m0:5, m0:4, m1:5, m0:5, m1:6 become
m0:5, m0:4, m1:5, m1:6 (F-9: a re-ask of the same question is no new
question).
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* test(web): #4375 hydration pins the asks over latest(s) under R5's adopted frame flight
Over `latest(s)` the write asks m0's frame question first (R5), the
verdict lane's intermediate next, and the landing adopts the frame's
flight: `m0:5, m0:4, m1:5, m1:6`, each question asked once. The control
keeps its `m0:5, m1:6` tail.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): an async memo with no verdict window of its own takes no verdict role
#4397 review: with two verdict sources (`m1 = ask(1 + m0() + m0b())` over
`m0 = ask(1 + latest(s) + s())` and `m0b = ask(10 * (latest(t) + t()))`),
the grouped `[isPending(m1), m1()]` reader asked `m1:5` a second time on
stale inputs after both sources landed. m1 lost CONFIG_VERDICT when its
first source went pending, but a pass that threw NotReady at that
source's read picked it back up (F-6, `read`). The settle walk then
re-ran m1 as a verdict reader, and the committed values a hold had moved
past were served to it (A10).
The demotion is now per pass, in `recompute`. An async memo (new
CONFIG_ASYNC: its last answering pass registered a flight) whose pass
opened no isPending/latest window of its own (REACTIVE_WINDOW) does not
become a verdict reader by reading a verdict memo. It waits on its
sources like any derivation (F-9), reads them plainly (D-25), and asks
each question once. The side-effecting clear in `propagateStatus` is
gone, since that path no longer sees such a memo as a verdict reader.
Pinned: two verdict memos into one async memo, grouped and split, with
no question asked twice and equal final screens. A `test.fails` pin
records that the grouped shape still skips the t lane's m1:15/m1:16
asks that split makes: whether a later write merges into an open
transaction or opens its own lane depends on grouping (#4398).
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): two latest() readers under one async memo ask each question once
- A latest() reader whose frame lands at the seam that would re-derive it
in the verdict lane keeps its flight: the pass was the landing's (it
asked the frame question twice in one flush). The check moves from
core's `_update` into lanes.ts `laneSeams`.
- Verdict-lane work that read a staging re-derives on the committed world
only while the transaction holding the staging stays parked: judged on
the flush's transaction, not the lane's parent, and not when the pass's
own render effect is all that keeps it parked (`heldBy`). The re-derive
asked a question already asked and showed it over inputs the landing
replaced.
- The landing's adopt of a parked frame flight is a lane hook
(`laneAdoptHook`): scheduler.ts no longer imports `adoptFlight`.
- #4398's grouped/split pin passes here: grouped and split ask the same
questions with latest()'s pass the frame's.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): a grouped reader over a held write shows the lane's answer
A reader that groups isPending with the value over a held write
(`[isPending(m1), m1()]`) never showed m1's lane answer, though a plain
value reader did. Two things kept it out:
- A pass served a held node's committed value (frameRead, a stale reader
of the hold) still kept the node's propagated pending sources, so when
it went pending on another source it never woke when that source
settled. frameRead now drops what the served node propagated onto it
(A15): the landing re-derives it.
- A lane's reveal (reruns on a lane) cleared REACTIVE_FRAME_READ, the
mark the held transaction's landing needed to re-run the reader. Only
the transaction's own reruns clear it now.
CONFIG_ASYNC is worked out once, at the end of each pass, from the pass's
`_inFlight` (registered a flight: async; answered sync: not; pending or
errored without a flight: the last answer's), so a plain sync recompute
does no extra work and handleAsync no longer touches it.
refresh(m0) mid-hold now shows the lane's answer for the refreshed
question in every reader shape. Pins for the held write, an equal
landing, and refresh after and mid-hold cover the value, pair and split
readers.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* test(signals): name frameRead in the held-shapes pin comment
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* chore(size): re-record this PR's four sizes over next @ 7ebd4a3
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): a latest() reader's lane answer reaches the screen whatever the grouping
Three review cases on R5, decided from F-6 (display-ahead readers show
the held change now, beside the held screen, in their own lane; the lane
reveals at its own landing, ahead of the parent's) and D-22/D-23:
- An isPending(m0) effect beside `v${m0()}`, with an unrelated async
keeping the flush parked: the verdict lane revealed at the write, before
R5's lane pass of m0 joined it, so m0's reader read m0 outside the shown
lane and waited for the unrelated async. The verdict lane a re-derived
latest() reader joins no longer reveals at that seam (laneSeams).
- An async memo over latest(s) held only by its own flight: the lane
asked m1:120 and its parent landed at the same seam, adopting the frame
flight before the lane's reader re-ran, so only v220 showed. A parent
whose lane reveals with readers to re-derive now lands a round later
(`revealing`), so they show the lane's answer first: v120, then v220,
inline and with latest(s) extracted into a memo (F-6; Ryan, 2026-10-29,
after #4284).
- A sync latest() memo's `[isPending(m0), m0()]` reader under an
unrelated hold showed the frame pass's `true,12` before the lane's
`false,22`: the same early reveal. It now shows `false,22` directly, as
next does (D-22: the pass re-derives once as a verdict reader; D-23).
`heldBy` now counts a lane under `t` that only `r`'s own flight keeps
blocked: with the parent landing a round later, a lane pass's flight was
the only thing parking it, and the seam re-derived the pass and asked
its question again.
Size: adoptFlight folds into adoptParked (-16 B) and adopts through
`parked.then()` (-4 B).
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* docs(signals): changeset for the latest() lane-answer fixes
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): an async memo over a verdict memo stays a verdict reader (D-25)
Review of #4397: the strict rule (an async memo with no `latest`/`isPending`
window of its own took no verdict role at all) overrode D-25 ("one that
reads a verdict reader's value is ... a verdict reader itself"; "a memo
computes under its own posture"). It caused two regressions against next:
1. Memo-extracted `latest()` (`v = createMemo(() => latest(s))`, `m1` async
over `v()` and `s()`): m1's pass at the write read the transaction's
staging and asked m1:220, the lane re-derived it (m1:120), and the
landing asked m1:220 again. It now asks m1:120 then m1:220, once each,
as the inline form does (D-22, F-9 exc. 2), showing v120 then v220 (F-6).
2. A reader disposed and remounted while the lane answer was in flight:
`[isPending(m1), m1()]` in one effect showed true,4 -> true,5 -> false,6
while `m1()` alone and split showed 4 -> 6. All shapes now show the
screen, then the landing (F-6: grouped holds like a lone read; D-26).
The strict rule is gone. In its place, D-25's "a node whose fetch a hold
is waiting on is that hold's work" (#3884), kept by the verdict engine
(verdict.ts `holdWork`, behind `holdWorkHook`, like `observeFlightHook`):
- A verdict source going pending does not re-derive an async memo with no
window of its own: none of its reads changed, and re-derived it was
served the committed value it had already derived from and asked that
question again (A10). It waits on the source like any derivation (F-9).
Except when its own flight is up outside a lane on a new question of the
source's: that re-run supersedes a flight asked of a value the source
has moved past (a `refresh()` re-ask is the same question).
- A held re-run of such a memo reads plainly, as a pending one already did
(#3884): the write that re-ran it is its hold's.
- Its async posture (CONFIG_ASYNC) is kept at each pass end in verdict.ts,
not computed in core.
Kept from the PR, as review asked: the frame read's drop of a served
flight's pending (A15; now in lanes.ts `laneServed`, behind a hook, run
only for lane work and verdict readers, with no closure), and `reruns`
leaving the stale-reader mark to the transaction at a lane's reveal.
Pins (tests/verdict-memo-flight-no-reask.test.ts): the memo-extracted and
inline forms ask m1:120, m1:220 once and show v110, v120, v220 in every
reader shape (D-22, D-25, F-6); a reader remounted mid-flight shows the
screen, then the landing, grouped as alone or split (F-6, D-26). Both
fail on the previous head.
Size: the floors are +14 B minified over next (was +126). The verdict
scenarios carry the rule: + isPending/latest +339 B. Ledger lines and the
frozen live-server-components floor are re-recorded to the measured sizes
(Size-Exception: floor-caps.json 115,423 -> 115,646 B minified, measured
38,197 B brotli; the maintainer relaxed the size rule for this fix).
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* test(signals): pin the remount shapes on what holds whatever the timing
CI ran the "remounted mid-flight, then a write" pin slower than local runs:
the landing's `m1:6` was asked before the remount in the grouped run and
after the write in the lone run, so comparing one shape's asks against
another's compared two timings, not two shapes. Run at a later remount
locally, every shape asks `m1:6` alike, and none diverges.
The pin now states what holds at any timing, per shape: no question asked
twice (F-9), the lane's `m1:5` never shown to a reader mounted mid-hold
(D-26), and the grouped `[isPending(m1), m1()]` ending on the landing like
the lone read (F-6). The no-write case still fails on the strict rule's
head, where the grouped remount showed `true,5`.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* test(signals): land the extracted pin's flights by hand, not by timer
CI's coverage run (slower than a plain run) let m1's 10 ms lane flight land
before the pin's 2 ms sleep ended, so the later write came after the
landing and the run asked m1:220 where the pin expects m1:125. The pin
compared two timings, not two behaviours.
m1's flights now land only when the test lands them, so the later write
always comes while the write's flights are up. The pin's expectations are
unchanged (D-25, D-22, F-6, F-9), and it still fails on ee0b535's source in
all three reader shapes (the m1:220, m1:120, m1:220 triple ask).
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): only an async memo with no window of its own is hold work (D-25)
Review of #4397: REACTIVE_WINDOW was wiped at the pass tail, and both of
holdWork's consumers (the pass head and propagateStatus) run between
passes, so `own` was CONFIG_ASYNC alone. The rule hit every async verdict
memo, including one that calls latest()/isPending() itself, and changed
screens against next on the canonical F-6 shape: an async memo over
`${isPending(m0)}:${latest(m0)}` never showed the lane's true:2, and one
over latest(m0) read through [isPending(m1), m1()] skipped l1 and showed
true,l1.
CONFIG_ASYNC is now set at the pass end, while the pass's REACTIVE_WINDOW
is still up, only for a pass that registered a flight and opened no window;
a pass that opened one clears it. A memo that asks is a verdict reader
whoever dirties it (D-25, ruled 2026-10-28), unchanged from next. The held
re-run arm applies only to memos that never asked; removing it reasks
m1:5/m1:104/m1:15 in five pins, so it stays, documented against D-25.
Pins: the two own-window shapes, as next shows them (D-25, F-6). The pin
file takes the hand-landed flights from the split prepared for review, so
no pin races a timer. Ledger re-records dropped: the size ledger is
re-recorded once on next after the batch.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* perf(signals): keep D-25's async posture off recompute's hot path
CONFIG_ASYNC is now set where a flight registers (handleAsync) and
cleared by a verdict window (markVerdictReader) or a sync answer, instead
of a holdWork call at every pass's end. The pass-head check is inline.
holdWork only answers propagateStatus.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): R5 with #4397 asks each question once
Merging #4397 into #4393 asked three questions twice:
- An async memo over `latest()` of a flight (the own-window pins) took
R5's frame pass and then a verdict-lane pass that asked the same
question again. `latest` of a flight serves the committed value in
either world (D-22), so the seam has nothing to decide. The reader
joins the verdict lane at once, as a plain read of a flight makes it
(`observeFlight`). `latest` of a staging stays the seam's (#4365).
- An async memo over a `latest()` memo (D-22 extracted): R5 parked only
the reader's own flight. The memo's frame flight was superseded by its
lane pass, and the landing asked `m1:220` again. The seam now parks
the frame flights of a sync reader's async readers held by the frame,
and the landing adopts them as it does inline (F-9).
The remount and extracted pins take R5's order: the frame's question
comes first.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* fix(signals): a verdict effect's staged read before the frame's transaction re-derives once if the flush parks (D-22)
In R5, latest() opens no transaction. A render effect that is a verdict
reader (`v:${s()} a:${A()} l:${latest(s)}`) read s's staging before the
frame had a transaction, so it stayed the frame's pass. Its held run
then showed `l:0` until the landing. stagedRead now also lists such an
effect for the seam, which re-derives it once as a verdict reader when
the flush parks, as D-22 and D-25 require: it shows `v:0 a:0 l:1`.
This is limited to effects. A memo is not a leaf, and with async memos
the re-run asked its question again. With every memo, the async-gen
case e1-3289-1831 ended on [ROOT-E].
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* test(signals): pin #4393's beside shape as it.fails for the reader-seat carve (F-6, D-26)
With #4397 merged, m1 is a verdict reader between its flights (D-25) and
m0's lane pass re-derives it into the s lane early, so the t transaction
lands while m1:1122 is in flight. Telling that pass apart as the hold's
work needs a per-pass check; it goes to the carve.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* test(signals): land twoVerdicts' flights by hand
The grouped-vs-split ask order raced its 10 ms flights against a 12 ms
sleep on a slow runner (m0b:20 before m1:5). The t write now comes after
the s write's first flights land, while m1's question is up.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
* perf(signals): keep R5's parked flight off the floors
The recompute clear runs only with the lane engine, and ext() no longer
seeds the field, so builds without lanes drop both (-39 B minified on
every floor).
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2
---------
Co-authored-by: Claude <[email protected]>
1 parent 9baaba3 commit 81a12d8
15 files changed
Lines changed: 908 additions & 104 deletions
File tree
- .changeset
- packages
- signals
- docs
- src/core
- tests
- web/test
- hydration
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
| 1 | + | |
| 2 | + | |
| 3 | + | |
| 4 | + | |
| 5 | + | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
| 1 | + | |
| 2 | + | |
| 3 | + | |
| 4 | + | |
| 5 | + | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
| 1 | + | |
| 2 | + | |
| 3 | + | |
| 4 | + | |
| 5 | + | |
| 6 | + | |
| 7 | + | |
Large diffs are not rendered by default.
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
399 | 399 | | |
400 | 400 | | |
401 | 401 | | |
| 402 | + | |
| 403 | + | |
| 404 | + | |
| 405 | + | |
| 406 | + | |
402 | 407 | | |
403 | 408 | | |
404 | 409 | | |
| |||
2195 | 2200 | | |
2196 | 2201 | | |
2197 | 2202 | | |
2198 | | - | |
| 2203 | + | |
| 2204 | + | |
| 2205 | + | |
| 2206 | + | |
| 2207 | + | |
| 2208 | + | |
| 2209 | + | |
| 2210 | + | |
2199 | 2211 | | |
2200 | 2212 | | |
2201 | 2213 | | |
| |||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
60 | 60 | | |
61 | 61 | | |
62 | 62 | | |
63 | | - | |
64 | | - | |
| 63 | + | |
| 64 | + | |
| 65 | + | |
| 66 | + | |
| 67 | + | |
| 68 | + | |
| 69 | + | |
| 70 | + | |
65 | 71 | | |
66 | 72 | | |
67 | 73 | | |
| |||
576 | 582 | | |
577 | 583 | | |
578 | 584 | | |
| 585 | + | |
| 586 | + | |
| 587 | + | |
| 588 | + | |
| 589 | + | |
| 590 | + | |
| 591 | + | |
| 592 | + | |
| 593 | + | |
| 594 | + | |
| 595 | + | |
| 596 | + | |
579 | 597 | | |
580 | 598 | | |
581 | 599 | | |
| |||
784 | 802 | | |
785 | 803 | | |
786 | 804 | | |
787 | | - | |
| 805 | + | |
788 | 806 | | |
789 | 807 | | |
790 | 808 | | |
| |||
850 | 868 | | |
851 | 869 | | |
852 | 870 | | |
| 871 | + | |
| 872 | + | |
| 873 | + | |
| 874 | + | |
| 875 | + | |
853 | 876 | | |
854 | 877 | | |
| 878 | + | |
855 | 879 | | |
856 | 880 | | |
857 | 881 | | |
| |||
950 | 974 | | |
951 | 975 | | |
952 | 976 | | |
| 977 | + | |
| 978 | + | |
| 979 | + | |
| 980 | + | |
| 981 | + | |
| 982 | + | |
| 983 | + | |
| 984 | + | |
| 985 | + | |
| 986 | + | |
| 987 | + | |
| 988 | + | |
| 989 | + | |
| 990 | + | |
| 991 | + | |
| 992 | + | |
| 993 | + | |
| 994 | + | |
| 995 | + | |
| 996 | + | |
| 997 | + | |
| 998 | + | |
| 999 | + | |
| 1000 | + | |
953 | 1001 | | |
954 | 1002 | | |
955 | 1003 | | |
956 | 1004 | | |
957 | 1005 | | |
958 | 1006 | | |
| 1007 | + | |
959 | 1008 | | |
960 | 1009 | | |
961 | 1010 | | |
| |||
970 | 1019 | | |
971 | 1020 | | |
972 | 1021 | | |
973 | | - | |
974 | | - | |
975 | | - | |
976 | | - | |
977 | | - | |
978 | | - | |
979 | | - | |
980 | | - | |
981 | | - | |
982 | | - | |
| 1022 | + | |
| 1023 | + | |
| 1024 | + | |
| 1025 | + | |
| 1026 | + | |
| 1027 | + | |
| 1028 | + | |
| 1029 | + | |
| 1030 | + | |
| 1031 | + | |
| 1032 | + | |
| 1033 | + | |
| 1034 | + | |
| 1035 | + | |
| 1036 | + | |
| 1037 | + | |
983 | 1038 | | |
984 | 1039 | | |
985 | 1040 | | |
986 | 1041 | | |
987 | 1042 | | |
988 | 1043 | | |
989 | | - | |
| 1044 | + | |
990 | 1045 | | |
991 | 1046 | | |
992 | 1047 | | |
| |||
1001 | 1056 | | |
1002 | 1057 | | |
1003 | 1058 | | |
| 1059 | + | |
| 1060 | + | |
| 1061 | + | |
| 1062 | + | |
| 1063 | + | |
| 1064 | + | |
| 1065 | + | |
| 1066 | + | |
| 1067 | + | |
| 1068 | + | |
| 1069 | + | |
| 1070 | + | |
| 1071 | + | |
| 1072 | + | |
| 1073 | + | |
| 1074 | + | |
| 1075 | + | |
| 1076 | + | |
| 1077 | + | |
| 1078 | + | |
| 1079 | + | |
| 1080 | + | |
| 1081 | + | |
| 1082 | + | |
| 1083 | + | |
| 1084 | + | |
| 1085 | + | |
| 1086 | + | |
| 1087 | + | |
| 1088 | + | |
| 1089 | + | |
| 1090 | + | |
1004 | 1091 | | |
1005 | 1092 | | |
1006 | 1093 | | |
| |||
1019 | 1106 | | |
1020 | 1107 | | |
1021 | 1108 | | |
| 1109 | + | |
| 1110 | + | |
| 1111 | + | |
| 1112 | + | |
| 1113 | + | |
| 1114 | + | |
| 1115 | + | |
| 1116 | + | |
| 1117 | + | |
| 1118 | + | |
| 1119 | + | |
| 1120 | + | |
| 1121 | + | |
| 1122 | + | |
| 1123 | + | |
| 1124 | + | |
| 1125 | + | |
| 1126 | + | |
| 1127 | + | |
1022 | 1128 | | |
1023 | 1129 | | |
1024 | 1130 | | |
| |||
1042 | 1148 | | |
1043 | 1149 | | |
1044 | 1150 | | |
| 1151 | + | |
1045 | 1152 | | |
1046 | 1153 | | |
1047 | 1154 | | |
| |||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
80 | 80 | | |
81 | 81 | | |
82 | 82 | | |
| 83 | + | |
| 84 | + | |
| 85 | + | |
83 | 86 | | |
84 | 87 | | |
85 | 88 | | |
| |||
101 | 104 | | |
102 | 105 | | |
103 | 106 | | |
| 107 | + | |
104 | 108 | | |
105 | 109 | | |
106 | 110 | | |
| |||
112 | 116 | | |
113 | 117 | | |
114 | 118 | | |
| 119 | + | |
115 | 120 | | |
116 | 121 | | |
117 | 122 | | |
| |||
1217 | 1222 | | |
1218 | 1223 | | |
1219 | 1224 | | |
1220 | | - | |
| 1225 | + | |
| 1226 | + | |
| 1227 | + | |
1221 | 1228 | | |
1222 | 1229 | | |
1223 | 1230 | | |
| |||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
123 | 123 | | |
124 | 124 | | |
125 | 125 | | |
| 126 | + | |
| 127 | + | |
| 128 | + | |
| 129 | + | |
| 130 | + | |
| 131 | + | |
126 | 132 | | |
127 | 133 | | |
128 | 134 | | |
| |||
0 commit comments