From 0378c1c91736cc020068918119147484b3dfb6c5 Mon Sep 17 00:00:00 2001 From: Brenley Dueck Date: Thu, 15 Oct 2026 21:54:22 -0500 Subject: [PATCH 1/6] fix(signals): a held error reaches a derivation of latest when a value would --- packages/signals/src/core/async.ts | 5 +- packages/signals/src/core/lanes.ts | 5 +- packages/signals/src/core/verdict.ts | 5 +- .../latest-derived-held-error-4106.test.ts | 118 ++++++++++++++++++ 4 files changed, 129 insertions(+), 4 deletions(-) create mode 100644 packages/signals/tests/latest-derived-held-error-4106.test.ts diff --git a/packages/signals/src/core/async.ts b/packages/signals/src/core/async.ts index 9dd92492c2..7b0213d8b9 100644 --- a/packages/signals/src/core/async.ts +++ b/packages/signals/src/core/async.ts @@ -302,8 +302,9 @@ export function settlePendingSource(el: Computed, source: Computed = e // A19: a verdict reader holds no pending of its own (it was re-derived // when the source went pending, `propagateStatus`), and a landing // equal to the committed value notifies nobody — the source settling - // is its verdict changing: it runs again. - return node._config & CONFIG_VERDICT && enqueueSub(node); + // is its verdict changing: it runs again. A staged error schedules no + // flush of its own (#4106). + return node._config & CONFIG_VERDICT && (enqueueSub(node), (scheduled = true)); visited.add(node); node._time = clock; const remaining = node._x?._pendingSources?.values().next().value; diff --git a/packages/signals/src/core/lanes.ts b/packages/signals/src/core/lanes.ts index 5317787513..a51efd5d99 100644 --- a/packages/signals/src/core/lanes.ts +++ b/packages/signals/src/core/lanes.ts @@ -54,6 +54,7 @@ import { REACTIVE_RECOMPUTING_DEPS, REACTIVE_SCREEN_READ, REACTIVE_STAGED_READ, + STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED } from "./constants.js"; @@ -547,9 +548,11 @@ function dissolveLane(l: Transaction, into: Transaction | null, except?: Signal< export function laneRead(c: Computed | null, el: Signal | Computed): unknown { const guess = el._config & CONFIG_GUESS; if (c !== null && c._config & CONFIG_AUTHORITATIVE) return GlobalQueue._truth!(el); + const status = (el as Computed)._statusFlags; + // A lane pass that errored left no lane value: the error is its answer (#4106). + if (!guess && status & STATUS_ERROR) return NOT_PENDING; if (c === null) return laneValueOf(el); const l = txOf(el); - const status = (el as Computed)._statusFlags; if (!tracking || c._config & CONFIG_CHILDREN_FORBIDDEN) { // An untracked read inside lane work derives from the lane like a // tracked one, minus the subscription — `untrack` is about diff --git a/packages/signals/src/core/verdict.ts b/packages/signals/src/core/verdict.ts index 587e22b079..4f00fe0653 100644 --- a/packages/signals/src/core/verdict.ts +++ b/packages/signals/src/core/verdict.ts @@ -379,7 +379,10 @@ function verdictValue(el: Signal | Computed, c: Computed | null): probeFound = true; if (tracked && flushTransaction !== null) verdictRead(c!, flushTransaction); } - if (el._config & CONFIG_OVERRIDE) { + if ( + el._config & CONFIG_OVERRIDE && + !(owner._statusFlags & STATUS_ERROR && !(el._config & CONFIG_GUESS)) + ) { const l = txOf(el); if (tracked) verdictRead(c!, l._parent ?? l); const flying = (owner._statusFlags & STATUS_PENDING) !== 0 && !quietPending(owner); diff --git a/packages/signals/tests/latest-derived-held-error-4106.test.ts b/packages/signals/tests/latest-derived-held-error-4106.test.ts new file mode 100644 index 0000000000..2dd53b6ceb --- /dev/null +++ b/packages/signals/tests/latest-derived-held-error-4106.test.ts @@ -0,0 +1,118 @@ +/** + * #4106: a memo over `latest(source)` is display-ahead (F-6, D-22) — a held + * landing on `source` reaches it before the frame reveals. A rejection is an + * answer like a value (D-41), so it reaches the derivation at the same point: + * `latest(derived)`, the plain read and the effect's error arm see it while + * the sibling still holds the frame, as they see a fulfilled value. + */ +import { expect, it } from "vitest"; +import { + createEffect, + createMemo, + createRenderEffect, + createRoot, + createSignal, + flush, + latest +} from "../src/index.js"; + +function deferred() { + let resolve!: (value: T) => void; + let reject!: (error: unknown) => void; + const promise = new Promise((res, rej) => { + resolve = res; + reject = rej; + }); + return { promise, resolve, reject }; +} +const tick = async () => { + await new Promise(r => setTimeout(r, 0)); + flush(); +}; +const read = (fn: () => unknown) => { + try { + return fn(); + } catch (e) { + return e instanceof Error ? e.message : e; + } +}; + +async function scene() { + let request = deferred(); + let sibling = deferred(); + const [round, setRound] = createSignal(1); + const log: unknown[] = []; + const screen = { round: 0 }; + let source!: () => number; + let derived!: () => number; + createRoot(() => { + source = createMemo(() => { + round(); + return request.promise; + }); + derived = createMemo(() => latest(source)); + const slow = createMemo(() => { + round(); + return sibling.promise; + }); + createRenderEffect( + () => [round(), slow()], + ([r]) => void (screen.round = r), + { schedule: true } + ); + createEffect(derived, { + effect: v => void log.push(v), + error: e => void log.push((e as Error).message) + }); + }); + request.resolve(1); + sibling.resolve(1); + await tick(); + expect(log).toEqual([1]); + expect(screen.round).toBe(1); + request = deferred(); + sibling = deferred(); + setRound(2); + flush(); + return { + log, + screen, + request: () => request, + sibling: () => sibling, + // [latest(source), latest(derived), derived(), source()], read unowned + reads: () => [ + read(() => latest(source)), + read(() => latest(derived)), + read(derived), + read(source) + ] + }; +} + +it("a held value reaches a derivation of latest before the reveal", async () => { + const s = await scene(); + s.request().resolve(2); + await tick(); + expect(s.screen.round).toBe(1); + expect(s.reads()).toEqual([2, 2, 2, 1]); + expect(s.log).toEqual([1, 2]); + s.sibling().resolve(2); + await tick(); + expect(s.screen.round).toBe(2); + expect(s.reads()).toEqual([2, 2, 2, 2]); + expect(s.log).toEqual([1, 2]); +}); + +it("a held error reaches a derivation of latest at the same point as a value", async () => { + const s = await scene(); + s.request().reject(new Error("boom")); + await tick(); + expect(s.screen.round).toBe(1); + expect(s.reads()).toEqual(["boom", "boom", "boom", 1]); + expect(s.log).toEqual([1, "boom"]); + s.sibling().resolve(2); + await tick(); + expect(s.screen.round).toBe(2); + expect(s.reads()).toEqual(["boom", "boom", "boom", "boom"]); + expect(s.log).toEqual([1, "boom"]); +}); From 7c263900ed11b6fd502ca9c0317d86759a03d596 Mon Sep 17 00:00:00 2001 From: Brenley Dueck Date: Thu, 15 Oct 2026 21:57:38 -0500 Subject: [PATCH 2/6] fix(signals): schedule the verdict wake from stageError only --- packages/signals/src/core/async.ts | 9 ++-- packages/signals/src/core/lanes.ts | 2 +- .../latest-derived-held-error-4106.test.ts | 43 +++++++++++++++++++ 3 files changed, 49 insertions(+), 5 deletions(-) diff --git a/packages/signals/src/core/async.ts b/packages/signals/src/core/async.ts index 7b0213d8b9..1bde9e9eaf 100644 --- a/packages/signals/src/core/async.ts +++ b/packages/signals/src/core/async.ts @@ -201,8 +201,10 @@ export function stageError(el: Computed, error: any, inPass?: boolean): boo setPendingError(el); el._pendingValue = error instanceof StatusError ? error : new StatusError(el, error); el._config |= CONFIG_STAGED | CONFIG_STAGED_ERROR; - // Readers parked on the flight re-run and derive from the staging. + // Readers parked on the flight re-run and derive from the staging; the + // verdict readers the walk wakes need a flush (#4106). settlePendingSource(el); + schedule(); return true; } @@ -302,9 +304,8 @@ export function settlePendingSource(el: Computed, source: Computed = e // A19: a verdict reader holds no pending of its own (it was re-derived // when the source went pending, `propagateStatus`), and a landing // equal to the committed value notifies nobody — the source settling - // is its verdict changing: it runs again. A staged error schedules no - // flush of its own (#4106). - return node._config & CONFIG_VERDICT && (enqueueSub(node), (scheduled = true)); + // is its verdict changing: it runs again. + return node._config & CONFIG_VERDICT && enqueueSub(node); visited.add(node); node._time = clock; const remaining = node._x?._pendingSources?.values().next().value; diff --git a/packages/signals/src/core/lanes.ts b/packages/signals/src/core/lanes.ts index a51efd5d99..dc02b984ef 100644 --- a/packages/signals/src/core/lanes.ts +++ b/packages/signals/src/core/lanes.ts @@ -549,7 +549,7 @@ export function laneRead(c: Computed | null, el: Signal | Computed)._statusFlags; - // A lane pass that errored left no lane value: the error is its answer (#4106). + // An errored member's lane value predates its error; the error is the answer (#4106). if (!guess && status & STATUS_ERROR) return NOT_PENDING; if (c === null) return laneValueOf(el); const l = txOf(el); diff --git a/packages/signals/tests/latest-derived-held-error-4106.test.ts b/packages/signals/tests/latest-derived-held-error-4106.test.ts index 2dd53b6ceb..b9db88a3d9 100644 --- a/packages/signals/tests/latest-derived-held-error-4106.test.ts +++ b/packages/signals/tests/latest-derived-held-error-4106.test.ts @@ -116,3 +116,46 @@ it("a held error reaches a derivation of latest at the same point as a value", a expect(s.reads()).toEqual(["boom", "boom", "boom", "boom"]); expect(s.log).toEqual([1, "boom"]); }); + +it("a tracked latest of the derivation sees the held error when it would see a value", async () => { + for (const reject of [false, true]) { + let request = deferred(); + let sibling = deferred(); + const [round, setRound] = createSignal(1); + const log: unknown[] = []; + let outer!: () => number; + createRoot(() => { + const source = createMemo(() => { + round(); + return request.promise; + }); + const derived = createMemo(() => latest(source)); + outer = createMemo(() => latest(derived)); + const slow = createMemo(() => { + round(); + return sibling.promise; + }); + createRenderEffect(slow, () => {}, { schedule: true }); + createEffect(outer, { + effect: v => void log.push(v), + error: e => void log.push((e as Error).message) + }); + }); + request.resolve(1); + sibling.resolve(1); + await tick(); + request = deferred(); + sibling = deferred(); + setRound(2); + flush(); + if (reject) request.reject(new Error("boom")); + else request.resolve(2); + await tick(); + const answer = reject ? "boom" : 2; + expect([read(outer), read(() => latest(outer))]).toEqual([answer, answer]); + expect(log).toEqual([1, answer]); + sibling.resolve(2); + await tick(); + expect(log).toEqual([1, answer]); + } +}); From 66e3c19889243c7fb086561728ec4b860f03a877 Mon Sep 17 00:00:00 2001 From: Brenley Dueck Date: Thu, 15 Oct 2026 21:59:44 -0500 Subject: [PATCH 3/6] chore: add changeset for #4106 --- .changeset/latest-derived-held-error-4106.md | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 .changeset/latest-derived-held-error-4106.md diff --git a/.changeset/latest-derived-held-error-4106.md b/.changeset/latest-derived-held-error-4106.md new file mode 100644 index 0000000000..c7b5ef36e0 --- /dev/null +++ b/.changeset/latest-derived-held-error-4106.md @@ -0,0 +1,5 @@ +--- +"@solidjs/signals": patch +--- + +A memo over `latest(source)` now sees a held rejection at the same point it sees a held value (#4106). Such a memo is display-ahead (F-6): when a held flight on `source` resolves, the memo re-runs in the hold's verdict lane and its new value shows at once, while a sibling still holds the frame. A rejection did not reach it the same way. `stageError` woke the memo but scheduled no flush, so the memo kept its old value until the reveal. After the memo did re-run, its lane pass errored, but `latest(memo)` and `memo()` kept serving the lane value from before the error, while the memo's effect had already received the error. Now `stageError` schedules the flush, and a read of an errored lane member that is not a written guess throws its error. `latest(memo)`, `memo()` and the effect's error arm now show `boom` before the reveal, just as they show `2` when the source resolves. From 6c302c20252f55aae5e866fd47a96f5d17b89107 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 17 Oct 2026 04:28:34 +0000 Subject: [PATCH 4/6] chore(size): raise the four caps #4113's held-error reads cost The maintainer accepted the cost (2026-10-17): +55 B minified on the three live page scenarios (one a frozen floor, under Size-Exception) and +32 B on the hydrating store app. Caps at measured + 10 B rounded up to 0.01 KB. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_018LY7F9czoRqdMEvk2QwPr1 --- scripts/size/floor-caps.json | 4 ++-- scripts/size/scenarios.js | 16 ++++++++++------ 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/scripts/size/floor-caps.json b/scripts/size/floor-caps.json index 8e279c63d0..4ea135dcb6 100644 --- a/scripts/size/floor-caps.json +++ b/scripts/size/floor-caps.json @@ -16,8 +16,8 @@ "minified": 106829 }, "page: live server components (base + live/GET + action + isPending/latest)": { - "cap": "39.01 KB", - "minified": 120185 + "cap": "39.05 KB", + "minified": 120240 }, "server: floor (getRequestEvent + isServer)": { "cap": "1.34 KB", diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js index 845b5307d6..96e008463c 100644 --- a/scripts/size/scenarios.js +++ b/scripts/size/scenarios.js @@ -2587,8 +2587,9 @@ module.exports = [ // Lower only: cap at measured + 10 B rounded up to 0.01 KB; recorded // minified never raised. // mapArray window-staged commit (perf, #4114, 2026-10-16, merged over next @ dbc5d0005 after #4104's ratchet and #4108's observe raises): 29.91 -> 30.09 KB, measured at 30,075 B brotli / 94,579 B minified (+165 B brotli over the cap, +646 B minified over the recorded size): updateKeyedMap stages only the changed window, commits its bookkeeping arrays in place and takes a Map-free pure-removal path. Local measurement; CI's bytes re-base this cap. - limit: "30.09 KB", - capMinified: 94579, + // A held error reaches a derivation of `latest` (#4113, #4106, 2026-10-17, merged over next @ f3973eae): 30.09 -> 30.14 KB, measured locally at 30,125 B brotli / 94,611 B minified (+32 B minified over the recorded size): `laneRead` and `verdictValue` hand a held error to an override/derived read the way they hand a value, and `stageError` schedules the verdict wake. Cap at measured + 10 B rounded up to 0.01 KB. Accepted by the maintainer (2026-10-17). + limit: "30.14 KB", + capMinified: 94611, alias }, { @@ -5135,6 +5136,7 @@ module.exports = [ // display through its retry, `latest` throws a staged error. Cap set at // measured + 10 B rounded up to 0.01 KB. Accepted by the maintainer // 2026-10-15 (golf first, then raise by what is left). + // Size-Exception: A held error reaches a derivation of `latest` (#4113, #4106, 2026-10-17, merged over next @ f3973eae): 39.01 -> 39.05 KB, measured locally at 39,040 B brotli / 120,240 B minified (+55 B minified over the recorded size): `laneRead` and `verdictValue` hand a held error to an override/derived read the way they hand a value, and `stageError` schedules the verdict wake. Cap at measured + 10 B rounded up to 0.01 KB. Accepted by the maintainer (2026-10-17). limit: floorCaps["page: live server components (base + live/GET + action + isPending/latest)"], capMinified: floorMinified["page: live server components (base + live/GET + action + isPending/latest)"], @@ -5327,8 +5329,9 @@ module.exports = [ // minified). Lower only: cap at measured + 10 B rounded up to 0.01 KB; // recorded minified never raised. // mapArray window-staged commit (perf, #4114, 2026-10-16, merged over next @ dbc5d0005 after #4104's ratchet and #4108's observe raises): 41.21 -> 41.77 KB, measured at 41,758 B brotli / 124,658 B minified (+544 B brotli over the cap, +648 B minified over the recorded size): updateKeyedMap stages only the changed window, commits its bookkeeping arrays in place and takes a Map-free pure-removal path. Local measurement; CI's bytes re-base this cap. - limit: "41.77 KB", - capMinified: 124658, + // A held error reaches a derivation of `latest` (#4113, #4106, 2026-10-17, merged over next @ f3973eae): 41.77 -> 41.83 KB, measured locally at 41,818 B brotli / 124,713 B minified (+55 B minified over the recorded size): `laneRead` and `verdictValue` hand a held error to an override/derived read the way they hand a value, and `stageError` schedules the verdict wake. Cap at measured + 10 B rounded up to 0.01 KB. Accepted by the maintainer (2026-10-17). + limit: "41.83 KB", + capMinified: 124713, alias: pageAlias }, { @@ -5612,8 +5615,9 @@ module.exports = [ // Re-based on the measurement: cap at measured + 10 B rounded up to // 0.01 KB, recorded minified 144,773. // mapArray window-staged commit (perf, #4114, 2026-10-16, from CI run 38867513870 — a local bundle of this scenario resolves the router differently and measures ~7 KB smaller, so CI's bytes set this cap): 48.16 -> 48.46 KB, measured at 48,444 B brotli / 145,422 B minified (+294 B brotli over base, +284 B over the cap, +649 B minified over the recorded size): the same window-staged commit as the other list scenarios. - limit: "48.46 KB", - capMinified: 145422, + // A held error reaches a derivation of `latest` (#4113, #4106, 2026-10-17, merged over next @ f3973eae): 48.46 -> 48.54 KB, measured locally at 48,527 B brotli / 145,477 B minified (+55 B minified over the recorded size): `laneRead` and `verdictValue` hand a held error to an override/derived read the way they hand a value, and `stageError` schedules the verdict wake. Cap at measured + 10 B rounded up to 0.01 KB. Accepted by the maintainer (2026-10-17). + limit: "48.54 KB", + capMinified: 145477, alias: pageAlias, conditions: solidConditions, compile: { hydratable: true } From 03a0a9a04a8cf2f96f626e0121d41a6448dafd28 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 17 Oct 2026 08:03:34 +0000 Subject: [PATCH 5/6] test(signals): pin a guess-lane derivation throwing its mainline error (#4106) Ruled with the maintainer (2026-10-17): a derivation in an optimistic guess lane that is not itself a written guess throws the mainline error its effect receives (D-41), instead of serving the lane's pre-error value. Fails on next (21), passes here. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_018LY7F9czoRqdMEvk2QwPr1 --- ...derived-held-error-guess-lane-4106.test.ts | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 packages/signals/tests/latest-derived-held-error-guess-lane-4106.test.ts diff --git a/packages/signals/tests/latest-derived-held-error-guess-lane-4106.test.ts b/packages/signals/tests/latest-derived-held-error-guess-lane-4106.test.ts new file mode 100644 index 0000000000..4ed25cdc07 --- /dev/null +++ b/packages/signals/tests/latest-derived-held-error-guess-lane-4106.test.ts @@ -0,0 +1,73 @@ +/** + * #4106 follow-up: a derivation inside an optimistic guess lane that is not + * itself a written guess has no override of its own to show. When a mainline + * source it reads errors, the error is its answer (D-41: "a derivation that + * reads a staged error throws it, as it would read a staged value"), so its + * reads throw the error its effect receives. Serving the lane's pre-error + * value to reads while the effect gets the error would tear (F-1). + */ +import { expect, it } from "vitest"; +import { + action, + createEffect, + createMemo, + createOptimistic, + createRoot, + createSignal, + flush, + latest +} from "../src/index.js"; + +const tick = async () => { + await new Promise(r => setTimeout(r, 0)); + flush(); +}; +const read = (fn: () => unknown) => { + try { + return fn(); + } catch (e) { + return e instanceof Error ? e.message : e; + } +}; + +it("a guess-lane derivation's reads throw the mainline error its effect receives", async () => { + const [fail, setFail] = createSignal(false); + const log: unknown[] = []; + let derived!: () => number; + let guess!: (v: number) => void; + createRoot(() => { + const [count, setCount] = createOptimistic(10); + guess = v => setCount(v); + const mainline = createMemo(() => { + if (fail()) throw new Error("boom"); + return 1; + }); + derived = createMemo(() => count() + mainline()); + createEffect(derived, { + effect: v => void log.push(v), + error: e => void log.push((e as Error).message) + }); + }); + flush(); + expect(log).toEqual([11]); + + let release!: () => void; + const save = action(function* () { + guess(20); + yield new Promise(r => (release = r)); + }); + const done = save(); + flush(); + expect(read(derived)).toBe(21); + + setFail(true); + flush(); + expect(log.at(-1)).toBe("boom"); + expect(read(derived)).toBe("boom"); + expect(read(() => latest(derived))).toBe("boom"); + + release(); + await done; + await tick(); + expect(read(derived)).toBe("boom"); +}); From 2b6b367ff4d973c8f190f33c12ab8d772c02390b Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 17 Oct 2026 08:45:50 +0000 Subject: [PATCH 6/6] chore(size): re-raise the two caps #4113's held-error reads cost over #4124's ratchet Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_018LY7F9czoRqdMEvk2QwPr1 --- scripts/size/floor-caps.json | 4 ++-- scripts/size/scenarios.js | 18 ++++++++++++++++-- 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/scripts/size/floor-caps.json b/scripts/size/floor-caps.json index 5382748378..80bd7135c2 100644 --- a/scripts/size/floor-caps.json +++ b/scripts/size/floor-caps.json @@ -16,8 +16,8 @@ "minified": 102617 }, "page: live server components (base + live/GET + action + isPending/latest)": { - "cap": "37.52 KB", - "minified": 115976 + "cap": "37.57 KB", + "minified": 116027 }, "server: floor (getRequestEvent + isServer)": { "cap": "1.34 KB", diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js index 9c468bf783..969bdf1d71 100644 --- a/scripts/size/scenarios.js +++ b/scripts/size/scenarios.js @@ -5196,6 +5196,13 @@ module.exports = [ // measured locally (linux) at 37,510 B (115,976 B minified). Lower only: // cap at measured + 10 B rounded up to 0.01 KB; recorded minified never // raised. + // Size-Exception (a held error reaches a derivation of `latest`, #4113, + // #4106, 2026-10-17, merged over next @ 7010268d): 37.52 -> 37.57 KB, + // measured locally at 37,558 B brotli / 116,027 B minified (+51 B + // minified): `laneRead` and `verdictValue` hand a held error to an + // override/derived read the way they hand a value, and `stageError` + // schedules the verdict wake. Cap at measured + 10 B rounded up to + // 0.01 KB. Accepted by the maintainer (2026-10-17). limit: floorCaps["page: live server components (base + live/GET + action + isPending/latest)"], capMinified: floorMinified["page: live server components (base + live/GET + action + isPending/latest)"], @@ -5725,8 +5732,15 @@ module.exports = [ // measured locally (linux) at 47,001 B (141,204 B minified). Lower only: // cap at measured + 10 B rounded up to 0.01 KB; recorded minified never // raised. - limit: "47.02 KB", - capMinified: 141204, + // A held error reaches a derivation of `latest` (#4113, #4106, 2026-10-17, + // merged over next @ 7010268d): 47.02 -> 47.05 KB, measured locally at + // 47,040 B brotli / 141,255 B minified (+51 B minified): `laneRead` and + // `verdictValue` hand a held error to an override/derived read the way + // they hand a value, and `stageError` schedules the verdict wake. Cap at + // measured + 10 B rounded up to 0.01 KB. Accepted by the maintainer + // (2026-10-17). + limit: "47.05 KB", + capMinified: 141255, alias: pageAlias, conditions: solidConditions, compile: { hydratable: true }