From 85c96090ff093966a798ead9027aba31056f47d4 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 30 Oct 2026 08:47:09 +0000 Subject: [PATCH 1/7] fix(signals): a lane's held reader settling never makes the flush join the lane (#4440) A landing's settle walk joins the flush to the transaction of each held reader it releases (`joinFuture(txOf(node))`). A render or user effect a guess's lane holds has that lane as its transaction, so the flush took the lane as its transaction. The lane was dissolved later in the same flush (a correction), and every node born held after that (the rows `` mounted for the refreshed list) was listed on the dead lane and never committed: the row rendered with every hole empty. Lane work never makes its node the transaction's (D-37), so the walk now skips a reader held by a lane. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2 --- .changeset/lane-held-settle-no-join.md | 5 + packages/signals/src/core/async.ts | 5 +- .../optimistic-lane-held-landing-4440.test.ts | 136 ++++++++++++++++++ ...timistic-guess-joins-refresh-4440.spec.tsx | 121 ++++++++++++++++ 4 files changed, 265 insertions(+), 2 deletions(-) create mode 100644 .changeset/lane-held-settle-no-join.md create mode 100644 packages/signals/tests/optimistic-lane-held-landing-4440.test.ts create mode 100644 packages/web/test/optimistic-guess-joins-refresh-4440.spec.tsx diff --git a/.changeset/lane-held-settle-no-join.md b/.changeset/lane-held-settle-no-join.md new file mode 100644 index 0000000000..8a7a417108 --- /dev/null +++ b/.changeset/lane-held-settle-no-join.md @@ -0,0 +1,5 @@ +--- +"@solidjs/signals": patch +--- + +A landing that settles a reader held by an optimistic lane no longer makes the flush join that lane as its transaction: rows a list guess mounted over a pending refresh render instead of staying empty. diff --git a/packages/signals/src/core/async.ts b/packages/signals/src/core/async.ts index 415dc4fc72..abc5d4e49a 100644 --- a/packages/signals/src/core/async.ts +++ b/packages/signals/src/core/async.ts @@ -336,8 +336,9 @@ export function settlePendingSource(el: Computed, source: Computed = e // L2: a landing resumes the transaction waiting on it (maintainer: "it // resumes the sync frame") — a held reader's re-pass over the landed // value is that transaction's work, and the flush that carries it - // parks into it. - if (node._config & CONFIG_HELD) joinFuture(txOf(node)); + // parks into it. A lane's held reader is the lane's (D-37): the flush + // never takes a lane as its transaction (#4440). + if (node._config & CONFIG_HELD && !txOf(node)._lane) joinFuture(txOf(node)); if (node._x?._blocked) { enqueueSub(node); scheduled = true; diff --git a/packages/signals/tests/optimistic-lane-held-landing-4440.test.ts b/packages/signals/tests/optimistic-lane-held-landing-4440.test.ts new file mode 100644 index 0000000000..5e4a291774 --- /dev/null +++ b/packages/signals/tests/optimistic-lane-held-landing-4440.test.ts @@ -0,0 +1,136 @@ +import { expect, it } from "vitest"; +import { + action, + createEffect, + createLoadingBoundary, + createOptimisticStore, + createRenderEffect, + createRoot, + createSignal, + flush, + mapArray, + refresh, + untrack +} from "../src/index.js"; + +// #4440: a per-key guess whose action landed, its `refresh` in the air; a +// second action replaces the list. The refresh's landing settles readers a +// guess's lane holds: the flush must not join that lane as its transaction +// (the lane dissolves in the same flush), or the rows born in it are held by +// a dead lane and never render. +const tick = async () => { + for (let i = 0; i < 4; i++) { + await new Promise(r => setTimeout(r, 0)); + flush(); + } +}; + +for (const withCount of [false, true]) + for (const withAssign of [false, true]) + it(`a new row renders after a list guess joins a pending refresh (count=${withCount}, assign=${withAssign})`, async () => { + const asks: { key: string; res: (v: any) => void }[] = []; + const ask = (key: string) => new Promise(res => asks.push({ key, res })); + const land = async (key: string, v: any) => { + for (const a of asks.filter(a => a.key === key)) { + asks.splice(asks.indexOf(a), 1); + a.res(v); + } + await tick(); + }; + let assignTo!: (id: number) => any; + let closeOne!: (id: number) => any; + let view: () => string = () => ""; + createRoot(() => { + const [issues, set] = createOptimisticStore( + async (d: any[]) => { + const r = await ask("fetch"); + d.length = r.length; + r.forEach((x: any, i: number) => { + d[i] = x; + }); + }, + [] as any[], + { key: "id" } + ); + assignTo = action(function* (id: number) { + const i = untrack(() => issues.findIndex((t: any) => t.id === id)); + set((d: any) => { + d[i].assignee = "guest"; + }); + yield ask(`assign:${id}`); + refresh(issues); + }); + closeOne = action(function* (id: number) { + const next = untrack(() => issues.filter((t: any) => t.id !== id)); + set((d: any) => { + d.length = next.length; + next.forEach((x: any, i: number) => { + d[i] = x; + }); + }); + yield ask(`close:${id}`); + refresh(issues); + }); + const [count, setCount] = createSignal(-1); + if (withCount) + createEffect( + () => issues.length, + (n: number) => { + setCount(n); + } + ); + const b = createLoadingBoundary( + () => + mapArray( + () => issues, + (it: any) => { + const s = { id: "", a: "" }; + createRenderEffect( + () => it.id, + v => { + s.id = v; + } + ); + createRenderEffect( + () => it.assignee, + v => { + s.a = v; + } + ); + return s; + } + ), + () => "loading" + ); + createRenderEffect( + () => { + const v: any = b(); + return typeof v === "function" ? v() : v; + }, + (v: any) => { + view = () => + typeof v === "string" ? v : v.map((s: any) => `[#${s.id} ${s.a}]`).join(""); + } + ); + createRenderEffect(count, () => {}); + }); + await tick(); + await land("fetch", [ + { id: 1, assignee: "ann" }, + { id: 3, assignee: "bob" }, + { id: 4, assignee: "dana" } + ]); + if (withAssign) { + assignTo(4); + await tick(); + await land("assign:4", {}); + } + closeOne(3); + await tick(); + await land("close:3", {}); + await land("fetch", [ + { id: 1, assignee: "ann" }, + { id: 4, assignee: withAssign ? "guest" : "dana" } + ]); + expect(view()).toBe(`[#1 ann][#4 ${withAssign ? "guest" : "dana"}]`); + }); diff --git a/packages/web/test/optimistic-guess-joins-refresh-4440.spec.tsx b/packages/web/test/optimistic-guess-joins-refresh-4440.spec.tsx new file mode 100644 index 0000000000..66a29414d9 --- /dev/null +++ b/packages/web/test/optimistic-guess-joins-refresh-4440.spec.tsx @@ -0,0 +1,121 @@ +/** + * @jsxImportSource @solidjs/web + * @vitest-environment jsdom + */ +// #4440: a per-key guess whose action landed and whose `refresh` is still in +// the air; a second action replaces the list. With a `Loading` around the +// list and an effect reading the list's length, row #1 rendered empty. +import { expect, test } from "vitest"; +import { + Loading, + For, + action, + createOptimisticStore, + createSignal, + createEffect, + flush, + refresh, + untrack +} from "solid-js"; +import { render } from "../src/index.js"; + +const tick = async () => { + for (let i = 0; i < 4; i++) { + await new Promise(r => setTimeout(r, 0)); + flush(); + } +}; + +for (const withCount of [false, true]) + for (const withAssign of [false, true]) + test(`list guess over a pending refresh (count effect=${withCount}, assign first=${withAssign})`, async () => { + const asks: { key: string; res: (v: any) => void }[] = []; + const ask = (key: string) => new Promise(res => asks.push({ key, res })); + const land = async (key: string, v: any) => { + for (const a of asks.filter(a => a.key === key)) { + asks.splice(asks.indexOf(a), 1); + a.res(v); + } + await tick(); + }; + const container = document.body.appendChild(document.createElement("div")); + let assignTo!: (id: number) => any; + let closeOne!: (id: number) => any; + const dispose = render(() => { + const [issues, set] = createOptimisticStore( + async (d: any[]) => { + const r = await ask("fetch"); + d.length = r.length; + r.forEach((x: any, i: number) => { + d[i] = x; + }); + }, + [] as any[], + { key: "id" } + ); + assignTo = action(function* (id: number) { + const i = untrack(() => issues.findIndex((t: any) => t.id === id)); + set((d: any) => { + d[i].assignee = "guest"; + }); + yield ask(`assign:${id}`); + refresh(issues); + }); + closeOne = action(function* (id: number) { + const next = untrack(() => issues.filter((t: any) => t.id !== id)); + set((d: any) => { + d.length = next.length; + next.forEach((x: any, i: number) => { + d[i] = x; + }); + }); + yield ask(`close:${id}`); + refresh(issues); + }); + const [count, setCount] = createSignal(-1); + if (withCount) + createEffect( + () => issues.length, + (n: number) => { + setCount(n); + } + ); + return ( + <> + ({count()}) + loading

}> + + {(it: any) => ( + + [#{it.id} {it.assignee}] + + )} + + + + ); + }, container); + await tick(); + await land("fetch", [ + { id: 1, assignee: "ann" }, + { id: 3, assignee: "bob" }, + { id: 4, assignee: "dana" } + ]); + if (withAssign) { + assignTo(4); + await tick(); + await land("assign:4", {}); + } + closeOne(3); + await tick(); + await land("close:3", {}); + await land("fetch", [ + { id: 1, assignee: "ann" }, + { id: 4, assignee: withAssign ? "guest" : "dana" } + ]); + expect(container.textContent).toBe( + `(${withCount ? 2 : -1})[#1 ann][#4 ${withAssign ? "guest" : "dana"}]` + ); + dispose(); + container.remove(); + }); From 94ea715c201683f3fbd9da6eea97910283412158 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 30 Oct 2026 10:12:54 +0000 Subject: [PATCH 2/7] chore(size): record #4440's sizes over next @ 7135a77a Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2 --- scripts/size/scenarios.js | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js index ff93f301a5..f8c8e531b8 100644 --- a/scripts/size/scenarios.js +++ b/scripts/size/scenarios.js @@ -1117,8 +1117,9 @@ module.exports = [ // 14.89 KB, recorded minified 43,874 -> 43,875 B; CI-measured at 14,875 B // (43,875 B minified). Lower only: cap at measured + 10 B rounded up to // 0.01 KB; recorded minified never raised. - limit: "14.89 KB", - capMinified: 43875, + // A lane's held reader settling never makes the flush join the lane (#4440, 2026-10-30, over next @ 7135a77a): 14.89 -> 14.96 KB, recorded minified 43,875 -> 43,884 B, measured locally (linux) at 14,945 B brotli / 43,884 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "14.96 KB", + capMinified: 43884, alias }, { @@ -3384,8 +3385,9 @@ module.exports = [ // B; CI-measured at 15,187 B (41,968 B minified). Lower only: cap at // measured + 10 B rounded up to 0.01 KB; recorded minified never raised. // Batch re-record (2026-10-30, next @ 32163a9, size job 123956613767): cap unchanged, recorded minified 41,968 -> 41,969 B, measured in CI at 15,193 B brotli. Growth is the 2026-10-30 merges (#4424, #4436, #4416, #4442); #4416's truncation sweep is the +19 B minified on the hydrating scenarios. Cap at measured + 10 B rounded up to 0.01 KB where over; recorded minified = measured. - limit: "15.20 KB", - capMinified: 41969, + // A lane's held reader settling never makes the flush join the lane (#4440, 2026-10-30, over next @ 7135a77a): 15.20 -> 15.23 KB, recorded minified 41,969 -> 41,978 B, measured locally (linux) at 15,215 B brotli / 41,978 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "15.23 KB", + capMinified: 41978, alias: observeAlias }, { @@ -3890,8 +3892,9 @@ module.exports = [ // 29.74 KB, recorded minified 88,302 -> 88,303 B; CI-measured at 29,727 B // (88,303 B minified). Lower only: cap at measured + 10 B rounded up to // 0.01 KB; recorded minified never raised. - limit: "29.74 KB", - capMinified: 88303, + // A lane's held reader settling never makes the flush join the lane (#4440, 2026-10-30, over next @ 7135a77a): 29.74 -> 29.77 KB, recorded minified 88,303 -> 88,312 B, measured locally (linux) at 29,751 B brotli / 88,312 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "29.77 KB", + capMinified: 88312, alias: observeAlias }, // Compiled-template scenarios (2026-10-05): the four `app:` fixtures above @@ -4128,8 +4131,9 @@ module.exports = [ // 26.27 KB, recorded minified 79,985 -> 79,986 B; CI-measured at 26,257 B // (79,986 B minified). Lower only: cap at measured + 10 B rounded up to // 0.01 KB; recorded minified never raised. - limit: "26.27 KB", - capMinified: 79986, + // A lane's held reader settling never makes the flush join the lane (#4440, 2026-10-30, over next @ 7135a77a): 26.27 -> 26.29 KB, recorded minified 79,986 -> 79,995 B, measured locally (linux) at 26,278 B brotli / 79,995 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "26.29 KB", + capMinified: 79995, alias }, { @@ -4301,8 +4305,9 @@ module.exports = [ // 32.43 KB, recorded minified 100,729 -> 100,748 B; CI-measured at 32,419 B // (100,748 B minified). Lower only: cap at measured + 10 B rounded up to // 0.01 KB; recorded minified never raised. - limit: "32.43 KB", - capMinified: 100748, + // A lane's held reader settling never makes the flush join the lane (#4440, 2026-10-30, over next @ 7135a77a): 32.43 -> 32.49 KB, recorded minified 100,748 -> 100,757 B, measured locally (linux) at 32,475 B brotli / 100,757 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "32.49 KB", + capMinified: 100757, alias }, { @@ -5761,8 +5766,9 @@ module.exports = [ // 35.66 KB, recorded minified 107,955 -> 107,974 B; CI-measured at 35,645 B // (107,974 B minified). Lower only: cap at measured + 10 B rounded up to // 0.01 KB; recorded minified never raised. - limit: "35.66 KB", - capMinified: 107974, + // A lane's held reader settling never makes the flush join the lane (#4440, 2026-10-30, over next @ 7135a77a): 35.66 -> 35.74 KB, recorded minified 107,974 -> 107,983 B, measured locally (linux) at 35,724 B brotli / 107,983 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "35.74 KB", + capMinified: 107983, alias: pageAlias }, { @@ -5904,11 +5910,12 @@ module.exports = [ // Re-record after the 2026-10-29 afternoon batch (#4418, #4414; 2026-10-29, over next @ 5d57e12a): 42.62 KB -> 42.65 KB, recorded minified 125,165 -> 125,266 B (+101 B), measured in CI at 42,640 B brotli. Growth is #4414 (a truncated fragment's fresh render computes what the server never sent: the truncation sweep deletes unsettled records at DOMContentLoaded, +~100 B minified in solid's hydration client); the maintainer said merge (2026-10-29). Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // Batch re-record (2026-10-30, next @ 32163a9, size job 123956613767): cap unchanged, recorded minified 125,266 -> 125,285 B, measured in CI at 42,636 B brotli. Growth is the 2026-10-30 merges (#4424, #4436, #4416, #4442); #4416's truncation sweep is the +19 B minified on the hydrating scenarios. Cap at measured + 10 B rounded up to 0.01 KB where over; recorded minified = measured. // A held memo's parked reader re-derives at the seam (#4439, 2026-10-30, over next @ b249ad96): 42.65 KB -> 42.67 KB, recorded minified 125,285 -> 125,374 B (+89 B), measured locally (linux) at 42,655 B brotli. `laneSeams` also re-derives a reader whose pass read a held node, so `isPending` of a memo parked behind a held one turns true. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. - limit: "42.67 KB", + // A lane's held reader settling never makes the flush join the lane (#4440, 2026-10-30, over next @ 7135a77a): 42.67 -> 42.69 KB, recorded minified 125,374 -> 125,383 B, measured locally (linux) at 42,677 B brotli / 125,383 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "42.69 KB", // An Errored heals when the last reader that caught its error is disposed (#4373, #4384, 2026-10-28, re-recorded over next @ cbc0eebd): recorded minified 123,191 -> 123,249 B (+58 B minified over next's record), measured locally (linux) at 41,899 B brotli. Recorded minified = measured; CI re-bases. // Boundary readers keyed by the source they wait on (#4373), with enterLane's tail folded into one else-chain as an offset (-29 B on lane pages) (#4384, 2026-10-28, re-recorded over next @ 1b32ff2e): recorded minified 123,203 -> 123,224 B (+21 B minified over next's record), measured locally (linux) at 41,966 B brotli. Recorded minified = measured; CI re-bases. // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 123,224 -> 123,733 B (+403 B minified over next), measured locally (linux) at 42,119 B brotli (+169 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 125374, + capMinified: 125383, alias: pageAlias }, { From 74124de52adcf558f646fa348197656097e416f8 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 30 Oct 2026 15:14:16 +0000 Subject: [PATCH 3/7] chore(size): record #4440's sizes over next @ 131ceb8c The simple-app floor goes over its frozen cap (9,789 B brotli, +22 B minified over the recorded) and needs a Size-Exception in the PR body. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2 --- scripts/size/floor-caps.json | 4 ++-- scripts/size/scenarios.js | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/scripts/size/floor-caps.json b/scripts/size/floor-caps.json index 2a42d8a491..2923d584a6 100644 --- a/scripts/size/floor-caps.json +++ b/scripts/size/floor-caps.json @@ -4,8 +4,8 @@ "minified": 19908 }, "app: render + one signal (the simple-app floor)": { - "cap": "9.78 KB", - "minified": 26739 + "cap": "9.80 KB", + "minified": 26761 }, "app: hydrating (no stores) with Show/For/Loading/Errored/lazy": { "cap": "18.74 KB", diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js index 99c9d6c86f..5f7c4c62d9 100644 --- a/scripts/size/scenarios.js +++ b/scripts/size/scenarios.js @@ -1757,6 +1757,7 @@ module.exports = [ // 9.78 KB, recorded minified 26,738 -> 26,739 B; CI-measured at 9,769 B // (26,739 B minified). Lower only: cap at measured + 10 B rounded up to // 0.01 KB; recorded minified never raised. + // Size-Exception (a lane's held reader settling never makes the flush join the lane, #4440, 2026-10-30, over next @ 131ceb8c): 9.78 KB -> 9.80 KB (floor-caps.json), recorded minified 26,739 -> 26,761 B, measured locally (linux) at 9,789 B brotli / 26,761 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: floorCaps["app: render + one signal (the simple-app floor)"], capMinified: floorMinified["app: render + one signal (the simple-app floor)"], alias From 35cb93380868f1ca6d44bdf9ad6ba5b0005136e0 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 30 Oct 2026 15:22:02 +0000 Subject: [PATCH 4/7] chore(size): re-record #4440's sizes over next @ e49b0c76 Two frozen floors go over their caps (each +24 B minified over the recorded): the simple-app floor (9,790 B brotli) and the hydrating (no stores) floor (18,758 B). Both need a Size-Exception in the PR body. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2 --- scripts/size/floor-caps.json | 6 +++--- scripts/size/scenarios.js | 3 ++- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/scripts/size/floor-caps.json b/scripts/size/floor-caps.json index 2923d584a6..be2e4091eb 100644 --- a/scripts/size/floor-caps.json +++ b/scripts/size/floor-caps.json @@ -5,11 +5,11 @@ }, "app: render + one signal (the simple-app floor)": { "cap": "9.80 KB", - "minified": 26761 + "minified": 26763 }, "app: hydrating (no stores) with Show/For/Loading/Errored/lazy": { - "cap": "18.74 KB", - "minified": 53585 + "cap": "18.77 KB", + "minified": 53609 }, "page: base server components (hydrating + dynamic + frames + sf reference)": { "cap": "33.77 KB", diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js index 67353017fe..b2899cc51a 100644 --- a/scripts/size/scenarios.js +++ b/scripts/size/scenarios.js @@ -1757,7 +1757,7 @@ module.exports = [ // 9.78 KB, recorded minified 26,738 -> 26,739 B; CI-measured at 9,769 B // (26,739 B minified). Lower only: cap at measured + 10 B rounded up to // 0.01 KB; recorded minified never raised. - // Size-Exception (a lane's held reader settling never makes the flush join the lane, #4440, 2026-10-30, over next @ 131ceb8c): 9.78 KB -> 9.80 KB (floor-caps.json), recorded minified 26,739 -> 26,761 B, measured locally (linux) at 9,789 B brotli / 26,761 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + // Size-Exception (a lane's held reader settling never makes the flush join the lane, #4440, 2026-10-30, over next @ e49b0c76): 9.78 KB -> 9.80 KB (floor-caps.json), recorded minified 26,739 -> 26,763 B, measured locally (linux) at 9,790 B brotli / 26,763 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: floorCaps["app: render + one signal (the simple-app floor)"], capMinified: floorMinified["app: render + one signal (the simple-app floor)"], alias @@ -2159,6 +2159,7 @@ module.exports = [ // B; CI-measured at 18,701 B (53,566 B minified). Lower only: cap at // measured + 10 B rounded up to 0.01 KB; recorded minified never raised. // Batch re-record (2026-10-30, next @ 32163a9, size job 123956613767): 18.72 KB -> 18.74 KB, recorded minified 53,566 -> 53,585 B, measured in CI at 18,726 B brotli. Growth is the 2026-10-30 merges (#4424, #4436, #4416, #4442); #4416's truncation sweep is the +19 B minified on the hydrating scenarios. Cap at measured + 10 B rounded up to 0.01 KB where over; recorded minified = measured. + // Size-Exception (a lane's held reader settling never makes the flush join the lane, #4440, 2026-10-30, over next @ e49b0c76): 18.74 KB -> 18.77 KB (floor-caps.json), recorded minified 53,585 -> 53,609 B, measured locally (linux) at 18,758 B brotli / 53,609 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: floorCaps["app: hydrating (no stores) with Show/For/Loading/Errored/lazy"], capMinified: floorMinified["app: hydrating (no stores) with Show/For/Loading/Errored/lazy"], alias From 1a724dede1f6bfb9caffdee7aaca5a134c6453df Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 30 Oct 2026 16:03:25 +0000 Subject: [PATCH 5/7] chore(size): re-record #4440's sizes over next @ ab3d2add Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2 --- scripts/size/scenarios.js | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js index b2899cc51a..7bd628c1f1 100644 --- a/scripts/size/scenarios.js +++ b/scripts/size/scenarios.js @@ -1443,9 +1443,10 @@ module.exports = [ // A probe beside `latest()` outside any Loading no longer loops on a refetch (F-6, D-23; 2026-10-30, over next @ 7135a77a): 11.07 KB -> 11.10 KB, recorded minified 30,492 -> 30,569 B (+77 B), measured locally (linux) at 11,085 B brotli. `pendingVerdict` remembers the transaction a `latest` read of an unheld flight opened, and a probe in it joins the verdict lane without asking to re-run at its landing (the re-run re-opened it every flush). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // Batch re-record (2026-10-30, over next @ 563b6b0): cap unchanged, recorded minified 30,569 -> 30,596 B (+27 B), measured locally (linux) at 11,092 B brotli. Growth is the 2026-10-30 merges (#4454, #4457, #4461). Recorded minified = measured. // D-28's verdict-seat reset compares holds, not lane objects: a seated leaf reading a merged transaction's verdict lane stays the hold's verdict reader (`laneRead`) (#4427, #4455, 2026-10-30, over next @ cddaa76): 11.10 KB -> 11.12 KB, recorded minified 30,596 -> 30,641 B (+45 B), measured locally (linux) at 11,109 B brotli. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. - limit: "11.12 KB", + // A lane's held reader settling never makes the flush join the lane (#4440, 2026-10-30, over next @ ab3d2add): 11.12 KB -> 11.14 KB, recorded minified 30,641 -> 30,665 B, measured locally (linux) at 11,122 B brotli / 30,665 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "11.14 KB", // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 28,693 -> 29,086 B (+343 B minified over next), measured locally (linux) at 10,565 B brotli (+135 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 30641, + capMinified: 30665, alias }, { @@ -1757,7 +1758,7 @@ module.exports = [ // 9.78 KB, recorded minified 26,738 -> 26,739 B; CI-measured at 9,769 B // (26,739 B minified). Lower only: cap at measured + 10 B rounded up to // 0.01 KB; recorded minified never raised. - // Size-Exception (a lane's held reader settling never makes the flush join the lane, #4440, 2026-10-30, over next @ e49b0c76): 9.78 KB -> 9.80 KB (floor-caps.json), recorded minified 26,739 -> 26,763 B, measured locally (linux) at 9,790 B brotli / 26,763 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + // Size-Exception (a lane's held reader settling never makes the flush join the lane, #4440, 2026-10-30, over next @ ab3d2add): 9.78 KB -> 9.80 KB (floor-caps.json), recorded minified 26,739 -> 26,763 B, measured locally (linux) at 9,790 B brotli / 26,763 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: floorCaps["app: render + one signal (the simple-app floor)"], capMinified: floorMinified["app: render + one signal (the simple-app floor)"], alias @@ -2159,7 +2160,7 @@ module.exports = [ // B; CI-measured at 18,701 B (53,566 B minified). Lower only: cap at // measured + 10 B rounded up to 0.01 KB; recorded minified never raised. // Batch re-record (2026-10-30, next @ 32163a9, size job 123956613767): 18.72 KB -> 18.74 KB, recorded minified 53,566 -> 53,585 B, measured in CI at 18,726 B brotli. Growth is the 2026-10-30 merges (#4424, #4436, #4416, #4442); #4416's truncation sweep is the +19 B minified on the hydrating scenarios. Cap at measured + 10 B rounded up to 0.01 KB where over; recorded minified = measured. - // Size-Exception (a lane's held reader settling never makes the flush join the lane, #4440, 2026-10-30, over next @ e49b0c76): 18.74 KB -> 18.77 KB (floor-caps.json), recorded minified 53,585 -> 53,609 B, measured locally (linux) at 18,758 B brotli / 53,609 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + // Size-Exception (a lane's held reader settling never makes the flush join the lane, #4440, 2026-10-30, over next @ ab3d2add): 18.74 KB -> 18.77 KB (floor-caps.json), recorded minified 53,585 -> 53,609 B, measured locally (linux) at 18,758 B brotli / 53,609 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: floorCaps["app: hydrating (no stores) with Show/For/Loading/Errored/lazy"], capMinified: floorMinified["app: hydrating (no stores) with Show/For/Loading/Errored/lazy"], alias @@ -5930,11 +5931,12 @@ module.exports = [ // A probe beside `latest()` outside any Loading no longer loops on a refetch (F-6, D-23; 2026-10-30, over next @ 7135a77a): 42.67 KB -> 42.71 KB, recorded minified 125,374 -> 125,450 B (+76 B), measured locally (linux) at 42,693 B brotli. `pendingVerdict` remembers the transaction a `latest` read of an unheld flight opened, and a probe in it joins the verdict lane without asking to re-run at its landing (the re-run re-opened it every flush). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // Batch re-record (2026-10-30, over next @ 563b6b0): cap unchanged, recorded minified 125,450 -> 125,478 B (+28 B), measured locally (linux) at 42,695 B brotli. Growth is the 2026-10-30 merges (#4454, #4457, #4461). Recorded minified = measured. // D-28's verdict-seat reset compares holds, not lane objects: a seated leaf reading a merged transaction's verdict lane stays the hold's verdict reader (`laneRead`) (#4427, #4455, 2026-10-30, over next @ cddaa76): 42.71 KB -> 42.73 KB, recorded minified 125,478 -> 125,518 B (+40 B), measured locally (linux) at 42,715 B brotli. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. - limit: "42.73 KB", + // A lane's held reader settling never makes the flush join the lane (#4440, 2026-10-30, over next @ ab3d2add): 42.73 KB -> 42.78 KB, recorded minified 125,518 -> 125,542 B, measured locally (linux) at 42,769 B brotli / 125,542 B minified (+9 B minified over next). The settle walk joined a held reader's transaction even when it was a lane, so the flush took the lane as its transaction and a row born in that flush was held into the lane the same flush dissolved: it never committed and rendered empty (D-37). One guard in core/async.ts. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "42.78 KB", // An Errored heals when the last reader that caught its error is disposed (#4373, #4384, 2026-10-28, re-recorded over next @ cbc0eebd): recorded minified 123,191 -> 123,249 B (+58 B minified over next's record), measured locally (linux) at 41,899 B brotli. Recorded minified = measured; CI re-bases. // Boundary readers keyed by the source they wait on (#4373), with enterLane's tail folded into one else-chain as an offset (-29 B on lane pages) (#4384, 2026-10-28, re-recorded over next @ 1b32ff2e): recorded minified 123,203 -> 123,224 B (+21 B minified over next's record), measured locally (linux) at 41,966 B brotli. Recorded minified = measured; CI re-bases. // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 123,224 -> 123,733 B (+403 B minified over next), measured locally (linux) at 42,119 B brotli (+169 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 125518, + capMinified: 125542, alias: pageAlias }, { From 5694cf810fec2fb2ab7becb019fa99b8e21909a3 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 30 Oct 2026 18:00:11 +0000 Subject: [PATCH 6/7] fix(signals): guard joinFuture against a lane's transaction, gated on lanes The merge of next above also moved the #4440 guard from the settle walk into joinFuture (`laneStageHook && t?._lane`), so it covers every held-node joinFuture call and bundles without lanes pay 0 B. This commit re-records the lane bundles' sizes; the floor raises and Size-Exception are gone. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2 --- scripts/size/scenarios.js | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js index d3ef4fffbe..f9a9f60330 100644 --- a/scripts/size/scenarios.js +++ b/scripts/size/scenarios.js @@ -1445,9 +1445,10 @@ module.exports = [ // D-28's verdict-seat reset compares holds, not lane objects: a seated leaf reading a merged transaction's verdict lane stays the hold's verdict reader (`laneRead`) (#4427, #4455, 2026-10-30, over next @ cddaa76): 11.10 KB -> 11.12 KB, recorded minified 30,596 -> 30,641 B (+45 B), measured locally (linux) at 11,109 B brotli. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A staged error reaches the memos and derived stores that derive from it (#4456, 2026-10-30, re-measured over next @ b773146): 11.12 KB -> 11.17 KB, recorded minified 30,641 -> 30,771 B (+130 B), measured locally (linux) at 11,153 B brotli. The settle walk marks a derivation of a staged error with it, and a derived store's family hears it (D-41), with the verdict engine alone. Correctness; Size-Exception in #4456. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A verdict reader born into a hold joins it at its re-pass (#4471, #4467, 2026-10-30, re-measured over next @ 749b0d7): cap unchanged at 11.17 KB, recorded minified 30,771 -> 30,800 B (+29 B), measured locally (linux) at 11,166 B brotli. Correctness (D-25, D-13); Size-Exception in #4471 for the floor. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. - limit: "11.17 KB", + // A lane's held reader never makes the flush join the lane (D-37, #4440, 2026-10-30, over next @ 663ecb0a): 11.17 KB -> 11.19 KB, recorded minified 30,800 -> 30,818 B (+18 B), measured locally (linux) at 11,172 B brotli. joinFuture returns on a lane's transaction, gated on the lane engine (bundles without lanes pay 0 B). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "11.19 KB", // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 28,693 -> 29,086 B (+343 B minified over next), measured locally (linux) at 10,565 B brotli (+135 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 30800, + capMinified: 30818, alias }, { @@ -2740,11 +2741,12 @@ module.exports = [ // A held memo's parked reader re-derives at the seam (#4439, 2026-10-30, over next @ b249ad96): 32.42 KB -> 32.45 KB, recorded minified 98,607 -> 98,689 B (+82 B), measured locally (linux) at 32,433 B brotli. `laneSeams` also re-derives a reader whose pass read a held node, so `isPending` of a memo parked behind a held one turns true. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // Batch re-record (2026-10-30, over next @ 563b6b0): cap unchanged, recorded minified 98,689 -> 98,387 B (-302 B), measured locally (linux) at 32,372 B brotli. Growth is the 2026-10-30 merges (#4454, #4457, #4461). Recorded minified = measured. // D-28's verdict-seat reset compares holds, not lane objects: a seated leaf reading a merged transaction's verdict lane stays the hold's verdict reader (`laneRead`) (#4427, #4455, 2026-10-30, over next @ cddaa76): 32.45 KB -> 32.48 KB, recorded minified 98,387 -> 98,432 B (+45 B), measured locally (linux) at 32,465 B brotli. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + // A lane's held reader never makes the flush join the lane (D-37, #4440, 2026-10-30, over next @ 663ecb0a): cap unchanged at 32.48 KB, recorded minified 98,432 -> 98,463 B (+31 B), measured locally (linux) at 32,466 B brotli. joinFuture returns on a lane's transaction, gated on the lane engine (bundles without lanes pay 0 B). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: "32.48 KB", // An Errored heals when the last reader that caught its error is disposed (#4373, #4384, 2026-10-28, re-recorded over next @ cbc0eebd): recorded minified 96,989 -> 97,047 B (+58 B minified over next's record), measured locally (linux) at 31,811 B brotli. Recorded minified = measured; CI re-bases. // Boundary readers keyed by the source they wait on (#4373), with enterLane's tail folded into one else-chain as an offset (-29 B on lane pages) (#4384, 2026-10-28, re-recorded over next @ 1b32ff2e): recorded minified 97,024 -> 97,045 B (+21 B minified over next's record), measured locally (linux) at 31,798 B brotli. Recorded minified = measured; CI re-bases. // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 97,045 -> 97,426 B (+240 B minified over next), measured locally (linux) at 31,976 B brotli (+109 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 98432, + capMinified: 98463, alias }, { @@ -5936,11 +5938,12 @@ module.exports = [ // #4428 fallback memo lazy (+7 B over next @ ab3d2add, which sits +15 over this record; 2026-10-30): 42.73 KB -> 42.75 KB, recorded minified 125,518 -> 125,540 B (+22 B), measured locally (linux) at 42,735 B brotli. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A staged error reaches the memos and derived stores that derive from it (#4456, 2026-10-30, re-measured over next @ b773146): 42.75 KB -> 42.79 KB, recorded minified 125,540 -> 125,655 B (+115 B), measured locally (linux) at 42,777 B brotli. The settle walk marks a derivation of a staged error with it, and a derived store's family hears it (D-41), with the verdict engine alone. Correctness; Size-Exception in #4456. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A verdict reader born into a hold joins it at its re-pass (#4471, #4467, 2026-10-30, re-measured over next @ 749b0d7): 42.79 KB -> 42.83 KB, recorded minified 125,655 -> 125,684 B (+29 B), measured locally (linux) at 42,817 B brotli. Correctness (D-25, D-13); Size-Exception in #4471 for the floor. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. - limit: "42.83 KB", + // A lane's held reader never makes the flush join the lane (D-37, #4440, 2026-10-30, over next @ 663ecb0a): 42.83 KB -> 42.87 KB, recorded minified 125,684 -> 125,702 B (+18 B), measured locally (linux) at 42,855 B brotli. joinFuture returns on a lane's transaction, gated on the lane engine (bundles without lanes pay 0 B). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "42.87 KB", // An Errored heals when the last reader that caught its error is disposed (#4373, #4384, 2026-10-28, re-recorded over next @ cbc0eebd): recorded minified 123,191 -> 123,249 B (+58 B minified over next's record), measured locally (linux) at 41,899 B brotli. Recorded minified = measured; CI re-bases. // Boundary readers keyed by the source they wait on (#4373), with enterLane's tail folded into one else-chain as an offset (-29 B on lane pages) (#4384, 2026-10-28, re-recorded over next @ 1b32ff2e): recorded minified 123,203 -> 123,224 B (+21 B minified over next's record), measured locally (linux) at 41,966 B brotli. Recorded minified = measured; CI re-bases. // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 123,224 -> 123,733 B (+403 B minified over next), measured locally (linux) at 42,119 B brotli (+169 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 125684, + capMinified: 125702, alias: pageAlias }, { @@ -6344,11 +6347,12 @@ module.exports = [ // D-28's verdict-seat reset compares holds, not lane objects: a seated leaf reading a merged transaction's verdict lane stays the hold's verdict reader (`laneRead`) (#4427, #4455, 2026-10-30, over next @ cddaa76): cap unchanged at 48.44 KB, recorded minified 142,735 -> 142,780 B (+45 B), measured locally (linux) at 48,394 B brotli. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A staged error reaches the memos and derived stores that derive from it (#4456, 2026-10-30, re-measured over next @ b773146): 48.44 KB -> 48.51 KB, recorded minified 142,780 -> 142,918 B (+138 B), measured locally (linux) at 48,498 B brotli. The settle walk marks a derivation of a staged error with it, and a derived store's family hears it (D-41), with the verdict engine alone. Correctness; Size-Exception in #4456. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A verdict reader born into a hold joins it at its re-pass (#4471, #4467, 2026-10-30, re-measured over next @ 749b0d7): cap unchanged at 48.51 KB, recorded minified 142,918 -> 142,947 B (+29 B), measured locally (linux) at 48,462 B brotli. Correctness (D-25, D-13); Size-Exception in #4471 for the floor. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + // A lane's held reader never makes the flush join the lane (D-37, #4440, 2026-10-30, over next @ 663ecb0a): cap unchanged at 48.51 KB, recorded minified 142,947 -> 142,965 B (+18 B), measured locally (linux) at 48,457 B brotli. joinFuture returns on a lane's transaction, gated on the lane engine (bundles without lanes pay 0 B). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: "48.51 KB", // An Errored heals when the last reader that caught its error is disposed (#4373, #4384, 2026-10-28, re-recorded over next @ cbc0eebd): recorded minified 140,451 -> 140,509 B (+58 B minified over next's record), measured locally (linux) at 47,516 B brotli. Recorded minified = measured; CI re-bases. // Boundary readers keyed by the source they wait on (#4373), with enterLane's tail folded into one else-chain as an offset (-29 B on lane pages) (#4384, 2026-10-28, re-recorded over next @ 1b32ff2e): recorded minified 140,463 -> 140,485 B (+22 B minified over next's record), measured locally (linux) at 47,547 B brotli. Recorded minified = measured; CI re-bases. // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 140,485 -> 140,983 B (+405 B minified over next), measured locally (linux) at 47,722 B brotli (+162 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 142947, + capMinified: 142965, alias: pageAlias, conditions: solidConditions, compile: { hydratable: true } From 94eab76edb78922e3c84823024c1455bf460dcde Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 30 Oct 2026 18:14:50 +0000 Subject: [PATCH 7/7] chore(size): re-record over next @ d0fc2851 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015hPxMkC3jg3Uivh65gvaf2 --- scripts/size/scenarios.js | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js index 7bcbb47f12..9be61e7fc5 100644 --- a/scripts/size/scenarios.js +++ b/scripts/size/scenarios.js @@ -1446,9 +1446,10 @@ module.exports = [ // A staged error reaches the memos and derived stores that derive from it (#4456, 2026-10-30, re-measured over next @ b773146): 11.12 KB -> 11.17 KB, recorded minified 30,641 -> 30,771 B (+130 B), measured locally (linux) at 11,153 B brotli. The settle walk marks a derivation of a staged error with it, and a derived store's family hears it (D-41), with the verdict engine alone. Correctness; Size-Exception in #4456. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A verdict reader born into a hold joins it at its re-pass (#4471, #4467, 2026-10-30, re-measured over next @ 749b0d7): cap unchanged at 11.17 KB, recorded minified 30,771 -> 30,800 B (+29 B), measured locally (linux) at 11,166 B brotli. Correctness (D-25, D-13); Size-Exception in #4471 for the floor. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A derived store with no live leaf skips its flight's observe (#4479, 2026-10-30, re-measured over next @ 663ecb0): 11.17 KB -> 11.19 KB, recorded minified 30,800 -> 30,822 B (+22 B), measured locally (linux) at 11,177 B brotli. Correctness (F-3, D-11); Size-Exception in #4479 for the floor. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + // A lane's held reader never makes the flush join the lane (D-37, #4440, 2026-10-30, over next @ d0fc2851): cap unchanged at 11.19 KB, recorded minified 30,822 -> 30,840 B (+18 B), measured locally (linux) at 11,185 B brotli. joinFuture returns on a lane's transaction, gated on the lane engine (bundles without lanes pay 0 B). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: "11.19 KB", // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 28,693 -> 29,086 B (+343 B minified over next), measured locally (linux) at 10,565 B brotli (+135 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 30822, + capMinified: 30840, alias }, { @@ -2741,11 +2742,12 @@ module.exports = [ // A held memo's parked reader re-derives at the seam (#4439, 2026-10-30, over next @ b249ad96): 32.42 KB -> 32.45 KB, recorded minified 98,607 -> 98,689 B (+82 B), measured locally (linux) at 32,433 B brotli. `laneSeams` also re-derives a reader whose pass read a held node, so `isPending` of a memo parked behind a held one turns true. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // Batch re-record (2026-10-30, over next @ 563b6b0): cap unchanged, recorded minified 98,689 -> 98,387 B (-302 B), measured locally (linux) at 32,372 B brotli. Growth is the 2026-10-30 merges (#4454, #4457, #4461). Recorded minified = measured. // D-28's verdict-seat reset compares holds, not lane objects: a seated leaf reading a merged transaction's verdict lane stays the hold's verdict reader (`laneRead`) (#4427, #4455, 2026-10-30, over next @ cddaa76): 32.45 KB -> 32.48 KB, recorded minified 98,387 -> 98,432 B (+45 B), measured locally (linux) at 32,465 B brotli. Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + // A lane's held reader never makes the flush join the lane (D-37, #4440, 2026-10-30, over next @ d0fc2851): cap unchanged at 32.48 KB, recorded minified 98,432 -> 98,463 B (+31 B), measured locally (linux) at 32,466 B brotli. joinFuture returns on a lane's transaction, gated on the lane engine (bundles without lanes pay 0 B). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: "32.48 KB", // An Errored heals when the last reader that caught its error is disposed (#4373, #4384, 2026-10-28, re-recorded over next @ cbc0eebd): recorded minified 96,989 -> 97,047 B (+58 B minified over next's record), measured locally (linux) at 31,811 B brotli. Recorded minified = measured; CI re-bases. // Boundary readers keyed by the source they wait on (#4373), with enterLane's tail folded into one else-chain as an offset (-29 B on lane pages) (#4384, 2026-10-28, re-recorded over next @ 1b32ff2e): recorded minified 97,024 -> 97,045 B (+21 B minified over next's record), measured locally (linux) at 31,798 B brotli. Recorded minified = measured; CI re-bases. // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 97,045 -> 97,426 B (+240 B minified over next), measured locally (linux) at 31,976 B brotli (+109 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 98432, + capMinified: 98463, alias }, { @@ -5939,11 +5941,12 @@ module.exports = [ // A staged error reaches the memos and derived stores that derive from it (#4456, 2026-10-30, re-measured over next @ b773146): 42.75 KB -> 42.79 KB, recorded minified 125,540 -> 125,655 B (+115 B), measured locally (linux) at 42,777 B brotli. The settle walk marks a derivation of a staged error with it, and a derived store's family hears it (D-41), with the verdict engine alone. Correctness; Size-Exception in #4456. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A verdict reader born into a hold joins it at its re-pass (#4471, #4467, 2026-10-30, re-measured over next @ 749b0d7): 42.79 KB -> 42.83 KB, recorded minified 125,655 -> 125,684 B (+29 B), measured locally (linux) at 42,817 B brotli. Correctness (D-25, D-13); Size-Exception in #4471 for the floor. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A derived store with no live leaf skips its flight's observe (#4479, 2026-10-30, re-measured over next @ 663ecb0): cap unchanged at 42.83 KB, recorded minified 125,684 -> 125,706 B (+22 B), measured locally (linux) at 42,822 B brotli. Correctness (F-3, D-11); Size-Exception in #4479 for the floor. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. - limit: "42.83 KB", + // A lane's held reader never makes the flush join the lane (D-37, #4440, 2026-10-30, over next @ d0fc2851): 42.83 KB -> 42.87 KB, recorded minified 125,706 -> 125,724 B (+18 B), measured locally (linux) at 42,860 B brotli. joinFuture returns on a lane's transaction, gated on the lane engine (bundles without lanes pay 0 B). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + limit: "42.87 KB", // An Errored heals when the last reader that caught its error is disposed (#4373, #4384, 2026-10-28, re-recorded over next @ cbc0eebd): recorded minified 123,191 -> 123,249 B (+58 B minified over next's record), measured locally (linux) at 41,899 B brotli. Recorded minified = measured; CI re-bases. // Boundary readers keyed by the source they wait on (#4373), with enterLane's tail folded into one else-chain as an offset (-29 B on lane pages) (#4384, 2026-10-28, re-recorded over next @ 1b32ff2e): recorded minified 123,203 -> 123,224 B (+21 B minified over next's record), measured locally (linux) at 41,966 B brotli. Recorded minified = measured; CI re-bases. // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 123,224 -> 123,733 B (+403 B minified over next), measured locally (linux) at 42,119 B brotli (+169 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 125706, + capMinified: 125724, alias: pageAlias }, { @@ -6348,11 +6351,12 @@ module.exports = [ // A staged error reaches the memos and derived stores that derive from it (#4456, 2026-10-30, re-measured over next @ b773146): 48.44 KB -> 48.51 KB, recorded minified 142,780 -> 142,918 B (+138 B), measured locally (linux) at 48,498 B brotli. The settle walk marks a derivation of a staged error with it, and a derived store's family hears it (D-41), with the verdict engine alone. Correctness; Size-Exception in #4456. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A verdict reader born into a hold joins it at its re-pass (#4471, #4467, 2026-10-30, re-measured over next @ 749b0d7): cap unchanged at 48.51 KB, recorded minified 142,918 -> 142,947 B (+29 B), measured locally (linux) at 48,462 B brotli. Correctness (D-25, D-13); Size-Exception in #4471 for the floor. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. // A derived store with no live leaf skips its flight's observe (#4479, 2026-10-30, re-measured over next @ 663ecb0): cap unchanged at 48.51 KB, recorded minified 142,947 -> 142,969 B (+22 B), measured locally (linux) at 48,496 B brotli. Correctness (F-3, D-11); Size-Exception in #4479 for the floor. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. + // A lane's held reader never makes the flush join the lane (D-37, #4440, 2026-10-30, over next @ d0fc2851): cap unchanged at 48.51 KB, recorded minified 142,969 -> 142,987 B (+18 B), measured locally (linux) at 48,491 B brotli. joinFuture returns on a lane's transaction, gated on the lane engine (bundles without lanes pay 0 B). Correctness. Cap at measured + 10 B rounded up to 0.01 KB; recorded minified = measured. limit: "48.51 KB", // An Errored heals when the last reader that caught its error is disposed (#4373, #4384, 2026-10-28, re-recorded over next @ cbc0eebd): recorded minified 140,451 -> 140,509 B (+58 B minified over next's record), measured locally (linux) at 47,516 B brotli. Recorded minified = measured; CI re-bases. // Boundary readers keyed by the source they wait on (#4373), with enterLane's tail folded into one else-chain as an offset (-29 B on lane pages) (#4384, 2026-10-28, re-recorded over next @ 1b32ff2e): recorded minified 140,463 -> 140,485 B (+22 B minified over next's record), measured locally (linux) at 47,547 B brotli. Recorded minified = measured; CI re-bases. // latest() read inline and through a memo show the same screen (#4284 through a memo; a plain write beside an async memo), 2026-10-29, over next @ 7ebd4a32: recorded minified 140,485 -> 140,983 B (+405 B minified over next), measured locally (linux) at 47,722 B brotli (+162 B over next). A render effect a verdict memo's change re-runs reads as its verdict reader for that pass (`laneDirty`), a pass that read a staging before the frame had a transaction re-derives once as a verdict reader only if the frame parks, `latest()` of a first load in flight in a verdict lane is loading (also through an identity memo, a derived store and `isPending`), a lane's dissolution leaves such a load and the nodes pending on it uninitialized instead of committing `undefined`, a verdict lane born at a seam is judged at it, a pass born in a staged reader stays the frame's on a verdict-memo read (C4, #4010), a plain write beside `latest()` computes once (the seam re-derives a pre-transaction staged reader only if the frame parks), a verdict reader's plain read of a staging in a transaction only a `latest()` opened is the frame's read, so a memo of `latest()` computes once too (D-22; not a pass with no value yet, D-6), and an error stays the display while the memo it came through re-asks, a Loading fallback behind it included (D-39, async-gen 91501 #1831). recompute's CONFIG_VERDICT clear now sits behind the lane engine: -21 B minified on every floor. Correctness; the maintainer: "only flag me if brotli goes more than 20kb" (2026-10-29). Cap unchanged; recorded minified = measured. - capMinified: 142969, + capMinified: 142987, alias: pageAlias, conditions: solidConditions, compile: { hydratable: true }