* fix(solid-router): make the global loading boundary opt-in and server/client-symmetric
`Matches` wrapped the match tree in a client-only `Solid.Loading`
boundary unless `disableGlobalCatchBoundary`, `isServer`, or
`router.ssr` was set, while the server side always rendered
`SafeFragment`. Apps that server-render without the `$_TSR` stream
protocol (own server entry: memory history, awaited `router.load()`,
`renderToStream`) never set `router.ssr`, so the client hydrated a
boundary the server never rendered. That desyncs Solid's positional
node claiming and surfaces as an opaque `reconcileArrays` crash
(`NotFoundError: insertBefore`).
The wrapper is now opt-in and the decision is evaluated identically on
the server and the client. It renders only when all of these hold:
- the app configured root pending UI (root `pendingComponent` or
`defaultPendingComponent`) — new;
- `router.ssr` is not set (the `$_TSR` protocol short-circuit,
unchanged and pinned by tests);
- `disableGlobalCatchBoundary` is not set (unchanged).
There is no `isServer` arm, no hydration probe, and no match-state
inspection — the decision reads only router configuration, so the
server tree and the hydrating client tree cannot disagree.
With nothing configured there is no wrapper at all: pending propagates
as ordinary Solid 2 async. The previous behavior there was an invisible
`Solid.Loading` with a `null` fallback, which also converted errors to
pending. With pending UI configured, the boundary now renders on both
sides, so external SSR hydrates cleanly (server nodes claimed and
reused, no pending flash) and the pending UI keeps working for
post-hydration navigations — a client-only wrapper, even a settled one,
shifts hydration-key derivation and leaves the server nodes unclaimed.
Tests: matches-hydration-boundary.test.tsx pins the opt-in decision,
the protocol short-circuit, `disableGlobalCatchBoundary`, and that the
decision is identical whether or not a hydration pass is in flight (a
hydration-keyed decision would freeze `SafeFragment` into hydrated apps
permanently); server-mode matchesLoadingBoundary.test.tsx pins the
symmetric server output. Verified additionally against a real
`renderToString` -> `hydrate` round trip: zero hydration errors, zero
unclaimed nodes, server DOM reused by identity.
Co-authored-by: Cursor <cursoragent@cursor.com>
* ci: apply automated fixes
---------
Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
The frame decoder dropped consumed chunks from its buffer with
bufferList.shift(), which is O(n). When a single large frame (e.g. a big
RawStream payload) is assembled from many small network reads, the
extract loop calls shift() once per chunk, making reassembly O(n^2).
Track the first un-consumed chunk with a head pointer and advance it in
O(1) instead of shifting. Consumed slots are released for GC, and the
buffer is compacted when fully drained (O(1) reset) or once the consumed
prefix grows past a small threshold (amortized O(1) per chunk).
A micro-benchmark draining 1000 small chunks is ~11x faster.
Co-authored-by: Yagiz Nizipli <yagiz@nizipli.com>
* perf(router-core): faster enumerable-key collection in structural sharing
getEnumerableOwnKeys (used by replaceEqualDeep) called
Object.getOwnPropertyNames and then invoked propertyIsEnumerable once per
key to verify every own string prop is enumerable. Replace that O(n) loop
of JS method calls with Object.keys (native, enumerable-only) plus a
single length comparison against getOwnPropertyNames to detect
non-enumerable string props. Symbol handling is unchanged.
Behavior is identical (verified against the existing suite + fuzzing): the
function still returns the enumerable own keys in the same order and still
bails (returns false) for objects with any non-enumerable own string or
symbol property.
replaceEqualDeep runs on every selector result on every state update when
defaultStructuralSharing is enabled, so this is a hot client path for
selector-heavy apps. Measured ~1.3-1.5x faster on typical router state.
* style(router-core): address enumerable key review
---------
Co-authored-by: Yagiz Nizipli <yagiz@nizipli.com>
* perf(react-router): bail out of Link re-renders when href and active state are unchanged
useLinkProps subscribes to the location store with an identity selector and an
href comparator, then derives href and isActive from the published location in
downstream memos. The comparator can only ask "is this a different URL?", never
"does this link care?", so every Link on the page re-renders on every navigation.
Move the location-derived values into the selector and compare them, so a link
whose resolved href and active state are unaffected by a navigation bails out.
buildLocation still runs once per link per location change; what goes away is the
React render and the host reconciliation under it.
doPreload no longer pre-supplies _builtLocation, because the built location is no
longer kept in render state. preloadRoute already falls back to building it, which
is what handleClick has always relied on for router.navigate.
The isActive and externalLink bodies move to module-level helpers unchanged so the
selector stays readable; activeOptions is spread into its four primitive fields in
the dependency list because callers routinely pass an inline object literal.
* refactor: trim redundant comments and brace single-line bodies
The comments explained the bail-out rationale twice — once on the LinkState type
and again above the selector — and two helper docblocks restated their function
names. The rationale now appears once, where a reader meets the selector; the
detail belongs in the PR description rather than the source.
Also braces the three single-line if bodies, per the AGENTS.md rule that if/else
bodies always use curly braces.
* refactor: publish link state as a tuple
The type is erased either way, but the object literal's property names survive
minification and a tuple's positions don't — so this drops three property names
from the selector's return plus the three property reads in compareLinkState.
Measured on the unminified build: -54 bytes in dist/esm/link.js and the same in
dist/cjs/link.cjs.
* test: assert the published link state, and drop a redundant cast
The render-count assertions proved the bail-out but not that the selector still
publishes correct values, so a selector returning a constant could have passed.
The test now also asserts that the link gaining active state carries
`data-status="active"` afterwards (and does not beforehand), and that the
unaffected link keeps its href and stays inactive.
Checked by sabotaging the selector: returning a constant tuple with a wrong href
but a correct active state now fails, where previously it passed.
Also drops `as any` from `new URL(to)` in resolveExternalLink — the guard above
already narrows `to` to string.
* refactor: pass activeOptions through instead of destructuring
Depends on the four fields rather than the object, with an exhaustive-deps
disable: callers routinely pass an inline literal, which would otherwise rebuild
the selector every render. resolveIsActive reads only those four fields, so the
disable is not hiding a live dependency.
-269 bytes on each of dist/esm/link.js and dist/cjs/link.cjs (unminified).
* perf: memoize the href derivation on the built href
The `useMemo` chain this replaced keyed `getHrefOption` and the external-link
resolution on the href string, so a navigation that left a link's href alone
skipped both. Deriving everything in the selector ran them on every location
notification instead, which showed up as a ~10% regression on the client-nav
rewrites benchmark, where rewrite handling makes `getHrefOption` expensive.
Cache both on the built href inside the selector closure. Measured on a
five-link root layout, per navigation: getHrefOption drops from 5 calls back to
0, matching the pre-change profile, with buildLocation and the active-state
derivation unchanged at 5.
* perf: keep _options referentially stable while its contents are equal
Links commonly pass inline `params` / `search` object literals. Those change
identity on every parent render, which rebuilt `_options`, which changed the
store selector's identity, which discarded useSyncExternalStoreWithSelector's
memoized selection. buildLocation then ran twice per navigation: once in the
notification check and once in the render-phase selection.
Measured on a replica of the client-nav rewrites scenario (six links, root
subscribed to the pathname via useLocation), buildLocation per navigation:
base 7, before this commit 12, after 7.
* revert: drop the href memoization, it measured no benefit
Reverts 409371b. It did cut getHrefOption from 5 calls per navigation to 0,
matching the pre-change profile, but that is not where the time went: on the
rewrites scenario it moved the number by 0.05% (medians 245.33 vs 245.21 hz over
four interleaved rounds). Not worth ~15 lines of mutable closure state.
The rewrites regression is fixed by the _options stabilisation instead.
* docs: explain why useValueStable exists
Replaces a leftover scratch note.
* perf: cut the bundle cost of the link state selector
Stabilise `activeOptions` with the same helper used for `search` / `params`,
so the selector depends on one value instead of four destructured fields. That
also makes the dependency array honest, so the exhaustive-deps disable goes.
Drop the reference-equality guard in useValueStable: deepEqual already
short-circuits on `a === b`, so the guard only saved a function call that
returns immediately.
Measured with benchmarks/bundle-size against this branch's base, gzip delta
across the eight React scenarios moves from +27/-7 to +11/-24, and raw bytes go
uniformly negative (-37 to -45 on every scenario).
* perf: pass _options to preloadRoute without the shallow clone
The spread existed to add _builtLocation, which is gone, and nothing on the
preload path mutates the options object: preloadRoute only reads
opts._builtLocation, build() only reads dest fields, and the search middleware
chain only reads dest.search. Search middlewares themselves receive
{ search, next }, never dest.
Saves an object allocation per hover. Bytes are unchanged on gzip, -5 raw.
* fix: do not collapse explicit-undefined params when stabilising link options
useValueStable compared with deepEqual's default ignoreUndefined: true, which
skips undefined-valued keys on both sides, so `{}` and `{ category: undefined }`
compared equal. Those build different locations: an explicit undefined clears an
inherited optional param while an empty object inherits it. A Link whose params
changed from one to the other kept publishing the stale href, and click and
preload used the stale options too.
Compare with ignoreUndefined: false. Adds a regression test covering the
/posts/tech -> /posts transition, which fails before this commit and passes
after, and passes on the pre-PR baseline.
* chore: empty commit to re-trigger CI
* chore: add changeset
---------
Co-authored-by: Flo <me@florianpellet.com>
* perf(start-client-core): compact frame decoder result keys
* docs: record compact frame result evidence
* docs: record frame result attribution and e2e
* Delete RESULT-optimization-frame-decoder-compact-result.md
* changeset
onMount is gone in Solid 2 — record the pending/target mount events via
onSettled instead. Also picks up routeTree.gen.ts regeneration churn.
Verified with the selective-ssr e2e suite (11/11 passing).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Solid 2's streaming renderer resolves the modules behind server-rendered
lazy() boundaries through its `manifest` render option: it emits stylesheet
links and modulepreloads for the lazy chunk and serializes the module→asset
map the client needs to preload it before hydration. TanStack Start never
provided that manifest — its own start manifest is route-keyed and
intentionally excludes dynamic-import chunks — so direct visits to routes
with SSR'd lazy() components rendered without the lazy chunk's CSS and
logged "Asset manifest returned no client assets" on every request.
(Pre-merge this was masked: the old Match tree re-rendered the boundary
client-side after the failed hydration, fetching the CSS late via Vite's
dynamic-import helper.)
Wire up vite-plugin-solid's `virtual:solid-manifest` (dev module-graph
resolver in dev, the client build's `.vite/manifest.json` in builds), kept
entirely inside the solid packages:
- solid-router ships an inert `ssr/clientAssetsManifest` stub that the
renderers prefer over the route-keyed manifest when non-undefined
- solid-start's vite plugin swaps the stub for `virtual:solid-manifest` in
the server environment (with `isEntry` neutralized so Solid doesn't
duplicate the entry stylesheet Start already emits) and enables
`build.manifest` for the client build
- bundlers without the plugin (rsbuild) keep the stub and current behavior
Fixes the two shared-widget lazy-CSS tests in the solid-start
start-manifest e2e (10/10 passing; selective-ssr and basic suites verified
unaffected).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Solid 2 derives hydration keys from the reactive owner tree, and its server
onSettled stub consumes a child-id slot to mirror the client's effect owner.
The server early-return in Transitioner skipped that registration, shifting
every subsequent hydration key by one and causing a root-level hydration
mismatch that discarded the server-rendered HTML (breaking deferred/streaming
content and redirects in the solid-start e2e suites).
Run the same code on both sides again: the onSettled callback never executes
on the server, so only the owner-tree structure is shared.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Use the Start storage context for request cancellation and focused server entrypoints to keep unrelated route dependencies out of the RSC module graph. Add emitted-build regression coverage for the boundary.
fixes#7938
* Upgrade solidjs beta 29
Upgrade `solid-js`, `@solidjs/web` and `babel-preset-solid` to
`2.0.0-beta.29`, and `vite-plugin-solid` to `3.0.0-next.20`
(peer-requires `>=2.0.0-beta.28`).
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* Upgrade vite-plugin-solid to 3.0.0-next.21
Peer-requires `>=2.0.0-beta.29` (already satisfied) and ships
`@dom-expressions/compiler@0.50.0-next.34`.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
* Upgrade @tanstack/solid-query to 6.0.0-beta.7
Bump `@tanstack/solid-query` and `@tanstack/solid-query-devtools` to
`6.0.0-beta.7`. The devtools package peer-requires
`@tanstack/solid-query: ^6.0.0-beta.7`, so the two must move together.
`@tanstack/solid-query` is pinned through the `catalog:` entry in
pnpm-workspace.yaml and forced repo-wide via `overrides`, so the catalog
value is bumped alongside the package.json ranges — editing the
package.json ranges alone has no effect on resolution.
Both packages are added to `minimumReleaseAgeExclude`; the repo gates on
`minimumReleaseAge: 1440` and these betas are newer than that.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>