This reverts commit ff9f753c09.
#8643 introduced a React hydration mismatch for `ssr: false` and
`ssr: 'data-only'` routes without a pending component: the client load can
commit before React hydrates the route's Suspense boundary, which then
hydrates the route component against the server's pending UI. Revert while a
proper fix is worked on.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix: keep server-rendered pending UI of no-SSR routes through hydration
Fixes#8640. The server rendered a no-SSR match's pending UI in a
ClientOnly fallback, while the hydrating client renders the presented
pending match through MatchInner. After hydration the switch replaced
(React: hid and duplicated) the server node. Render the server pending UI
through the same MatchInner pending path and drop the ClientOnly wrapper.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test: cover terminal no-SSR boundaries through hydration
Add error, notFound and URL not-found cases for `ssr: 'data-only'` and
`ssr: false` boundaries (plus a terminal child below a data-only boundary)
in React, Solid and Vue. Each case asserts the server payload, that the
server skeleton is the only one and is held for `pendingMinMs`, and that no
hydration mismatch is reported. The hold check catches mismatches that React
and Solid error boundaries replace silently.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): let mergeProps memoize the Link's own props
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* test(solid-router): pin how Link element props, state props and handlers reach the anchor
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* ci: retrigger benchmarks against refreshed main baselines
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
* test(benchmarks): add departing and retained Link navigation cases
Add lane-* cases to the React Link performance harness, with per-navigation
sync, onLoad and total timings in the paired runner.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* perf(react-router): share one location subscription per route's Links
Links subscribe to a scope owned by their match context instead of each
subscribing to the location store. A scope skips a location publication
whose navigation leaves its route, so Links that are about to unmount do
no work. Clicks and preloads resolve from the location a Link displays,
and mask builds use the same source location as their destination.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* test(benchmarks): add Solid departing and retained Link navigation harness
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): hold the location of Links in a departing match
Each Match owns one memo that keeps its Links' source location when the
publishing navigation leaves the route, so those Links do no work.
Clicks and preloads resolve from that source.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(react-router): trim the Link scope's bundle cost
Key each router's link scopes by route id instead of carrying them in a
`[routeId, linkScope]` match context tuple. `matchContext` provides the
route id again, so `Match`, `Outlet`, `useMatch` and `useParentMatches` /
`useChildMatches` match main, and the outside-every-match holder becomes
the `undefined` key of the same registry. A scope without links still
releases its location, so keeping one per route id holds none.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(benchmarks): add Vue departing and retained Link navigation harness
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(vue-router): hold the location of Links in a departing match
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(benchmarks): add a real-browser Link INP harness
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): gate departing Links in their own location memo
Drop the per-Match memo and the third match-context slot. Each Link reads
its route id once at setup and, while the publishing navigation leaves
that route, keeps its previous location in the memo it already owns.
Links mounting in an already-departing route read the pending location.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(benchmarks): add Vue to the real-browser Link INP harness
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(solid-router): build Link navigations from the live location state
The Link location memo deduplicated by href, so a same-href navigation that only changed history state left clicks and preloads building from the previous location's state.
Compare by identity instead; downstream href and active memos still compare by value, so unchanged Links do not touch the DOM.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(react-router): drop the Link scope's reentrant publication re-check
A listener that publishes a new location while a route's Links derive is not a
supported use case, so the scope no longer re-reads the store after notifying.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(react-router, router-core): follow-up Link improvements (#8607)
* perf(router-core): cache location-independent masked destinations
A mask that reads the current location already marks the result as
source-dependent through the shared usedCurrent flag, and route masks
belong to the route tree and options whose updates replace the cache.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(react-router): hydrate hash-sensitive Links through the scope's server snapshot
The Link's location subscription already has a server-snapshot slot.
Reporting an active hash-sensitive Link as inactive there replaces the
per-Link useHydrated subscription with identical hydration output.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(react-router): follow href and reloadDocument changes of a mounted Link
The destination memo did not depend on href, so a Link whose href alone
changed kept displaying, preloading and navigating to the old target.
Clicks also navigated with the memo's copy of the options, so a changed
reloadDocument only applied once another destination prop changed.
Navigate with the current options and the displayed source location.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(react-router): hold a Link's intent preload timer on its own ref
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(history): avoid copying navigation arguments when checking blockers
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(benchmarks): opt-in intent preloading for the Link lane cases
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore: changeset
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router, vue-router): follow-up Link improvements (#8609)
* test(benchmarks): measure Solid and Vue Link lanes with intent preloading
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): reuse a Link-owned destination so fixed Links hit the location cache
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): pass navigation controls through the Link-owned options
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(solid-router): cover Link clicks after a state-only navigation
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): read Link options directly with a single splitProps
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): keep the Link preload timer in a closure
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): let the Link observer read the preload mode directly
The internal useIntersectionObserver no longer returns an unused accessor and
takes the preload mode instead of two predicates (its unit test is updated).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): create the Link hydration signal only for SSR routers
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): let element insertion track Link children without a memo
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(solid-router): call a Link's ref once per element
The ref no longer comes from the props memo, so href/active changes do not
re-run the element's ref effect. Drops the mergeRefs import.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): derive a Link's href and active state in one computation
The destination build, href, external/blocked classification and active state
share one memo whose unchanged result keeps its identity, so a navigation that
leaves a Link as it was notifies nothing downstream. Presentation props only
rerun the props memo. The server derives the same values once, without memos.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(benchmarks): use the t quantile for the lane comparison's round count
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(solid-router): split a Link's props once
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(vue-router): reuse a Link-owned destination so fixed Links hit the location cache
Navigation controls travel on the same object, so clicks no longer re-list them.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(vue-router): pick a Link's element props with one shared key set
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(vue-router): derive a Link's href and active state in one computed
The preload effects read a location-independent mode, so a navigation no
longer queues them for every Link. A Link whose destination updater navigates
while it derives derives again for the newer location.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(vue-router): keep the Link preload timer in a closure
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(vue-router): drop the unused IntersectionObserver ref per Link
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(vue-router): return plain empty Link props without a router
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(vue-router): render server Links without reactive wrappers
The server returns shallow refs and reads Link props directly, without the
attrs snapshot, its update hook, the props computed or a template ref.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(vue-router): drop the deferred re-derivation for updaters that navigate
A search updater that navigates while a Link derives is not a supported use
case; remove the retry that existed only for it, and its test.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore: add changeset for the Solid and Vue Link follow-up
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* chore(benchmarks): remove the real-browser Link INP harness
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(solid-router, vue-router): rebuild masks whose options are stores
Router core now reuses masked locations built from the same options object
when the mask does not read the current location. Solid and Vue Links keep
one destination object while their navigation options keep their identity,
and only a store/reactive option value forced a fresh object per location.
A plain mask object holding a store (e.g. `mask={{ to, params: store }}`)
therefore kept the mask built from the store's first value. The mask's own
values are destination options too, so check them for stores as well.
React has no in-place reactive values: a changed mask prop changes identity
and rebuilds. Add the equivalent React coverage for prop and inherited masks.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(benchmarks): remove the ad-hoc Link lane harnesses
The link-churn scenario covers this work in CodSpeed. Removes the Solid and
Vue lane harnesses and restores link-performance to its main content.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* style: name tuple indexes in Link code
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(react-router): stop treating _fromLocation as a Link prop
`_fromLocation` is an internal router option, not a Link prop: the Link
always builds from its own scope's location. It stays among the stripped
router option keys so code that still passes it does not leak an attribute
to the element.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(solid-router): stop treating _fromLocation as a Link prop
`_fromLocation` is an internal router option, not a Link prop: the Link
always builds from the location its match presents.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(vue-router): stop treating _fromLocation as a Link prop
`_fromLocation` is an internal router option, not a Link prop: the Link
always builds from the location its match presents.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(react-router): drop _fromLocation from the Link's option keys
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
Tests written for #8602 that already pass on main: rewrites of Link tests
that asserted on a detached anchor after its route unmounted, and Link
destination tests for Solid, Vue and React (in-place store/reactive inputs,
inherited params, masks, frozen options, state-only navigations).
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
`deepEqual(a, b, partial?, explicitUndefined?)` replaces the options
object. The hot callers (Link option stabilization and active-state checks,
matchRoute) no longer allocate `{ partial }` / `{ ignoreUndefined: false }`
per comparison, and the comparator reads two booleans instead of an options
parameter that saw four object shapes. `explicitUndefined` (falsy default)
replaces `ignoreUndefined: false` and reuses the `activeOptions` vocabulary.
deepEqual is an internal helper; two-argument callers are unaffected.
react-router.minimal shrinks by 48 B gzip (129 raw) on top of the previous
commit; the Link stabilization micro-benchmark improves by ~10% and the
paired Link component runner resolves three cases as faster.
(cherry picked from commit d6f2c1ca55a4900b33868cfc115ac7120d68d26b)
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* chore(benchmarks): remove TSR_LINK_PERF opt-in flag
The router-core Link/path benchmarks and the react-link-performance
project are never part of the CodSpeed matrix or the client-nav/SSR
aggregate projects, so the env-var gate only added friction. Rely on
standard vitest name filtering (-t) to narrow runs instead.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* fix(router-core): treat 0 and false as provided _splat values
Splat interpolation used a falsy check, so _splat: 0 was omitted like a
missing param while $id: 0 interpolated to '/0'. Only undefined, null,
and '' now omit a splat segment, matching how other path params are
stringified.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* test(router-core): use path-derived ids in original-param-names fixtures
The matcher only uses route ids as routesById keys and for the pathless
'_' check, so unrelated ids worked but never occur in a real router.
Align the fixtures with the sibling test file's convention where each
id mirrors its fullPath.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(solid-router): shorten conditional Link class and style spreads
Spread `cond && { value }` instead of `cond ? { value } : undefined`,
matching the neighbouring `active && STATIC_ACTIVE_ATTRIBUTES` spread.
Falsy operands spread to nothing, so the emitted props are unchanged.
Measured with the bundle-size benchmark on solid-router.full:
gzip 39205 -> 39198 (-7), raw -12, brotli -33.
Covered by the existing `six-adults-open` changeset.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* test(router-core): drop the unused server axis from interpolatePath tests
The `interpolatePath (server: $server)` block never read its `server`
argument since interpolation stopped taking a server flag, so it ran every
case twice under a misleading label. The remaining diff is re-indentation;
review with `git show -w`.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* test(router-core): interpolate paths through the production API in tests
`interpolateTestPath` only survived as a compatibility layer from the
segment-reuse refactor: it emulated the removed
`(path, params, decoder, usedParams, keys, metadata)` signature by parsing
the template, re-implementing the param-name loop and folding
`hasMissingPathParams` into a metadata flag.
Call the real functions instead. Tests now parse templates with
`parseSegments(false, { fullPath }, 0)` exactly like `buildLocation` does
for templates without a processed route, pass the segments to
`interpolatePath`, and read names and availability from `getParamNames`
and `hasMissingPathParams`. The prepared-route tests compare route-owned
segments against that standalone parse directly, and the interpolation
bench derives its reference values the same way.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): reuse location-independent Link destinations
Most mounted Links point at a destination that does not depend on where
the user currently is: an absolute `to`, literal params for every template
key, a literal (or no) search, hash and state. Until now every navigation
rebuilt all of them anyway, because `buildLocation` always started from the
current location.
`buildLocation` now tracks whether a build read the current location at
all. Every such read goes through `current()` / `currentMatch()`, which set
one flag; a build that finishes without it depends only on its options and
the route tree. When the caller passed `_fromLocation` (what Links do) and
no mask is involved, the resulting location is kept in a WeakMap keyed by
the options object, and the next `buildLocation` with that same object
returns it directly. `update()` and `setRoutes()` replace the map, so router
option changes and HMR route-tree rebuilds invalidate everything.
To make that flag meaningful the reads became demand-driven instead of
unconditional: an absolute `to` resolves without a base path, params that
cover the template skip the inherited-params merge, a literal search/hash/
state never touches the current values, and stringifiers fetch inherited
params only when a route defines one. Structural sharing with the current
search/state stays, as it only affects identity.
Contract: the same options object yields the same location until router
options or the route tree change. Callers own invalidation by passing a new
object when their values change (the follow-up react-router commit does
that with deepEqual-stabilized copies of `params`/`search`).
Once whole locations are reused, the per-route SIEVE pathname cache
(`_pathCache`, `InterpolationPlan`, `createPathInterpolator` and its router
plumbing) is redundant and is removed; templates are interpolated directly
from the route's parsed segments.
Tests: path, route-tree-caches, path-decoder and the interpolation bench
assert canonical pathnames through `buildLocation` instead of cache
internals.
Performance (Apple M4, Node 24, fresh production bundles, 3 runs each;
measured on a tree that also carried the replaceEqualDeep changes now
proposed separately in #8362, #8363 and #8364):
- Measured alone, with the React Link still spreading a fresh options
object per navigation so nothing hits the cache: links/react 341.3 ->
290 hz (-15%); paired link-perf client vs stack HEAD: encoding +30%,
splats +24% slower (HEAD's pathname cache targeted exactly those), the
other cases within noise. This commit is the first half of a two-part
change and regresses on its own.
- With the follow-up react-router commit (stable options object, so 160 of
161 builds per navigation become 13 ns cache hits; a full build costs
680-970 ns): links/react 622 hz (+82% vs stack HEAD, rme +-0.4%).
Paired link-perf client vs origin/main: shared-params -34%, unique-params
-36%, splats -41%, encoding -54%, active -44%, middleware -14%,
relative -9%. SSR vs origin/main: -12..-32% on every measured case
(encoding -23%, splats -18%); vs stack HEAD only SSR encoding is slower
(+31%).
- Bundle (react-router.minimal gzip, this tree): 85925 -> 85992 (+67) for
this commit, 1 byte below origin/main (85993); 86038 with the Link commit.
With #8362, #8363 and #8364 applied as well the tree measures 85983.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(react-router): keep one options object per Link so locations are reused
`buildLocation` now returns a cached location for an options object whose
previous build never read the current location (06e4504605). The React
Link built a fresh `{ _fromLocation, ..._options }` on every navigation, so
it never hit that cache.
Each Link now owns one `dest` object, memoized on `_options`. The location
selector sets `dest._fromLocation` in place (unless the caller supplied one)
and passes the same object to `router.buildLocation`, so a Link whose
destination does not depend on the current location costs a WeakMap lookup
per navigation instead of a full build. `navigate` and `preloadRoute` still
receive `_options`, so the in-place field never reaches a navigation.
Because object identity is now the router's invalidation signal,
`useValueStable` keeps a shallow copy of `params`/`search`/`activeOptions`
rather than the caller's object. `deepEqual` therefore never short-circuits
on reference equality, and a params object that was mutated in place, or is
backed by accessors, yields a new reference (hence a new `dest`) on the
render that observes the change. A mutation that no render observes is no
longer picked up by a navigation alone; that matches how every other Link
input already behaves.
The server branch had its own inline copy of the active-state, class and
style derivation while the client used `resolveIsActive`. Both now share
`resolveIsActive` and a `resolveStateProps` helper; the results are
identical (`exactPathTest` is the same trailing-slash comparison,
`deepEqual` already treats two key-less search objects as equal, and the
hash check yields `false` on the server because it is never hydrated
there). The two `blockedLink` spreads that position state props before or
after `ref`/handlers are documented in place.
Tests (`link-destination.test.tsx`): the middleware test follows the HMR
sequence (`route.update()` then `router.setRoutes(router.buildRouteTree())`)
instead of expecting a bare `route.update()` to be observed; the test for
an impure `stringifySearch` closing over a mutable variable is dropped
along with that contract; the mutation and accessor tests re-render the
fixture and assert the updated location survives further navigations.
Performance (Apple M4, Node 24, fresh production bundles, 3 runs each;
measured on a tree that also carried the replaceEqualDeep changes now
proposed separately in #8362, #8363 and #8364):
- links/react (200 mounted Links, 8 navigations per lap): 290 -> 622 hz
against the parent commit, +82% against stack HEAD (341 hz). 160 of the
161 `buildLocation` calls per navigation become 13 ns cache hits; a full
build of these Links costs 680-970 ns.
- Paired link-perf client vs the parent commit: shared-params -24%,
splats -35%, encoding -49%, active -36%, unique-params -25% (wide
interval), middleware unchanged (never cacheable).
- Combined with the parent, vs origin/main: client shared-params -34%,
unique-params -36%, splats -41%, encoding -54%, active -44%,
middleware -14%, relative -9%; SSR -12..-32% on every measured case.
- Bundle (react-router.minimal gzip, this tree): 85992 -> 86038 (+46);
+113 vs stack HEAD, +45 vs origin/main (85993). With #8362, #8363 and
#8364 applied as well the tree measures 85983, 10 bytes below origin/main.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* refactor: stop exporting isPlainObject and isPlainArray
Nothing in the repository imports these two helpers from a package entry
point; they are only called inside `utils.ts` by `deepEqual` and
`replaceEqualDeep`, and `isPlainArray` is unit-tested via `../src/utils`.
#8363 tightens `isPlainObject` to a constructor check that is meant
for the router's own structural sharing, so the helpers are no longer
exported from `@tanstack/router-core`, `@tanstack/react-router`,
`@tanstack/solid-router` or `@tanstack/vue-router`.
No bundle change in react-router.minimal (unused exports were already
tree-shaken): 85983 before and after.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* chore: add changesets for Link location reuse and the removed helpers
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): reuse parsed route segments for interpolation
Capture original template segments during the existing route-tree parse.
Interpolation only substitutes current values and produces fresh metadata;
it never reparses known routes, including first use and trailing-slash
variants. Rebuild the captured data with the tree for HMR. Parse unknown
templates once per bounded entry and reuse their segments across decoder
changes. Update Devtools and internal test consumers.
Remove internal undefined-path/server-flag compatibility and the divergent
SSR scanner. Both runtimes follow the canonical splat grammar. Keep the
128-result route cache after measuring its removal rather than adding an
unproven configuration option.
Measured against 41e42009be with frozen production bundles:
- 26 client/SSR Link cases, 4 paired replicas each: client unique params
-3.94% CPU [95% CI -6.30,-1.52], optionals -2.58% [-4.34,-0.78].
Other cases inconclusive; no supported end-to-end slowdown.
- 1000-route client high-cardinality interpolation -18.55..-24.83%;
matching with fresh metadata -14.69..-19.12% (5 process samples).
- 1000-route client setup costs an extra 0.084..0.192 ms; sparse first use
costs about 0.23..0.28 us/call. Retained segment data adds about 200..298 B
per dynamic route in the measured fixtures.
- All 18 bundle cases add 303..392 gzip B; React minimal/full +311/+326 B.
- Cache-off saves 0.8..0.9 MiB per 1000 used routes and 1.2..1.5 MiB after
growth, but client encoding/splat Links regress 25.31%/12.71% and SSR
encoding/splats regress 21.76%/25.37%; retain result caching.
- Shared-value sampled allocations rise 2.18% client/5.23% SSR without that
cache. Native Vue peaks remain effectively unchanged (macOS captures,
not a new Linux CodSpeed CI run). Benchmark counts/JIT/GC flags unchanged.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): avoid temporary route initialization joins
Build route IDs and full paths with direct string assembly and the existing
cleanPath normalizer. Avoid temporary filter/join arrays and the second ID
normalization. Pathless layouts keep the parent's fullPath unchanged.
Add a focused construction benchmark with fresh route objects and separate
processing-only / allocation-plus-processing cases at 100/1000/10000 routes.
Document why client-nav route-tree-scale is not a construction benchmark.
Standalone attribution against 41e42009be, otherwise unchanged Uint16Array
parser, 7 fresh process replicas and 1000 routes per tree:
- Client processRouteTree+route.init CPU improves 11.48-19.57% across
static, dynamic, nested and mixed trees (all 95% intervals below zero).
- Server CPU improves 9.39-22.29% (all 95% intervals below zero).
- React Router minimal gzip +6 bytes; the composed parse-once implementation
is measured separately against the required original bundle budget.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): reuse stable path parameter decoders
Compare allowed-character values rather than recompiling the decoder on
every provider-style options update. Equivalent arrays retain warm route
paths; in-place edits and option removal update encoding correctly.
Publish the configuration key only after successful compilation, and
declare optional state without forcing an unused instance field.
Isolated against 3e0b23f46c with the same path-decoder.bench.ts, seven
alternating independent process pairs (200 locations per batch):
- Stable provider updates: 143.3707 -> 122.5572 us, -14.52%
(95% process interval -15.51% to -13.52%).
- No-update control: 119.1170 -> 118.8155 us, -0.25%
(interval -1.05% to +0.55%).
- Deliberately changing configuration every batch: 143.8213 -> 147.7340 us,
+2.72% (interval +1.38% to +4.08%). Reconfiguration remains the cold path.
These are decoder/update mechanism measurements, not a claim about every
React Link render. Standalone React minimal gzip: 86121 -> 86142 bytes
(+21); raw +48 bytes, Brotli +10 bytes.
Add coverage for equivalent options, mutation, removal, direct overrides
and retrying failed compilation.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): simplify route-owned path interpolation
Share one canonical scanner between tree processing and unknown templates.
Retain compact dynamic records and derive original parameter names lazily,
instead of reconstructing them during matching. Keep initialization/indexing
and traversal in processRouteTree, including existing nested-mask behavior.
Make pathParamsAllowedCharacters initialization-only, as requested. Compile
the readonly decoder once, remove decoder keys/stamps/update invalidation,
and keep path results on each route. Preserve the shared bounded unmatched
template cache across SSR requests; lightweight matching stays router-local.
Do not add an encoding-specific cache, router-level route map or bulk clear.
Move Devtools-only navigation availability outside the hot formatter.
Preserve legacy standalone fallback match identity and cache behavior,
including inherited params and route-tree replacement. Retain useful encoding
comments and explicit tuple-slot labels.
Final measurements (Node 24.8.0, built production JS, unchanged workloads):
- Original React client-nav Link loop versus 41e42009be, four balanced
fresh-process pairs: CPU 2.5015016 -> 2.4370936 ms per 8-navigation batch,
-2.57% (95% process interval -3.72% to -1.42%). Wall -2.58%.
- Fresh 1000-route client processing/init: static -12.39%, dynamic -5.34%,
nested -6.54%, mixed -2.59%. Server static -9.12%; remaining intervals
are reported separately and the mixed-server result is inconclusive.
- All 18 gzip fixtures are below 41e by 47-88 bytes. React minimal:
85801 -> 85731; full: 89392 -> 89318. Raw JS -533..-697 bytes;
Brotli varies by fixture rather than uniformly shrinking.
- Full 26-case paired client/SSR Link suite: no supported regressions;
most small changes are inconclusive, not claimed as universal speedups.
- Warm retained path-cache heap saves about 7.8 KiB per 1000 routes in
default/custom configurations. Native Vue peaks remain near baseline;
peak, allocation totals and end outstanding are measured separately.
Existing literal grammar/URL/matching expectations are preserved. The
independent oracle covers 49638 segment cases and 338 matching/mask traces
within the old offset range. Initialization-only encoding deliberately
supersedes the previous live-update contract.
Detailed measurements and rejected experiments remain in uncommitted
session reports and LOG.md.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): initialize routes directly during tree processing
Remove the optional initRoute callback and unconditionally call
route.init({ originalIndex: index }) at the start of the parent-first visit,
before indexing or parsing the route. Require init on this function's input
without imposing it on masks or the shared template-scanning RouteLike type.
Remove the Router and construction-benchmark forwarding wrappers. Adapt
preinitialized matcher fixtures through one test-only helper with a
non-enumerable no-op init; do not normalize their paths/IDs or change their
expected grammar/matching results. Add real-route initialization order,
index and exactly-once coverage.
Performance versus bc71b06207, seven independent process pairs per
shape/mode using the same built-JS entry and fresh route objects:
- Server static 1000-route processing/init: 0.7781686 -> 0.7623686 ms/tree,
CPU -2.06% (95% interval -3.26% to -0.84%); wall -2.10%.
- Other construction cells are inconclusive, with no supported slowdown.
- All 18 gzip fixtures improve by 10-26 bytes. React minimal:
85731 -> 85712 bytes (-19). Raw -20 bytes (-59 for Rsbuild);
Brotli remains fixture-dependent.
Object creation and forced GC are outside processing timers. The common
measurement entry's obsolete third argument is ignored by the new code,
so once-per-tree callback allocation savings are not overstated.
Full measurements and logs remain in the session's
direct-route-init-20260909 artifacts and uncommitted LOG.md.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): pass route initialization indexes directly
Change the internal initializer to route.init(originalIndex). Update the
Route interface, BaseRoute implementation, processRouteTree contract and
both production call sites, including the standalone legacy fallback.
Remove object-literal arguments without adding compatibility wrappers.
Keep route ordering and stored indexes unchanged. Cover primitive arguments,
index zero and the large legacy fallback index explicitly.
Performance versus f2c2d55f99:
- Seven independent fresh-process construction comparisons per shape/mode
(100, 1000 and 10000 routes; static/dynamic/nested/mixed) show no
statistically supported timing difference. Do not claim an unproven
CPU or heap-byte improvement from the removed object literals.
- All 18 gzip fixtures improve by 7-13 bytes. React minimal:
85712 -> 85702 (-10); full: 89303 -> 89291 (-12).
- Raw JS decreases by 46 bytes in every fixture. Brotli varies.
The same production-JS phase entry and workloads are used on both sides.
Object creation and forced GC are outside processing timers. Detailed
samples, intervals and logs remain in numeric-route-init-20260909 session
artifacts and uncommitted LOG.md.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* update route trees
* ci: apply automated fixes
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* refactor(router-core): consolidate path interpolation
Remove the object-returning internal wrapper and keep one interpolatePath returning a pathname with optional metadata outputs. Migrate router, devtools, tests, and benchmarks while leaving parsing and cache limits unchanged.
Devtools requests only missing-param status. Tests use direct expected paths and explicit metadata; cache benchmarks no longer carry obsolete factory compatibility dispatch.
React Router minimal/full gzip are 85829/89413 bytes (+5/+4 from 8a9f57e638, still 14/4 below measured main). Full units/types/exports and 76 browser cases pass; eight paired client/SSR workloads show no supported timing change.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): keep derived caches on routes
Store branches and interpolation plans directly on route objects. Use the already-resolved destination route, remove the fixed outer limit for registered templates, and retain128 results per route. Keep a bounded32-template fallback for arbitrary templates and masks.
Build/install route-tree indexes and string caches as one bundle for existing SSR reuse. Reinitialization clears ancestor branches; interpolation plans validate their exact template and decoder without unconditional resets. Loaded match data remains request-local.
Against29509b9b98, paired core buildLocation batches over64/256 templates use40-43% less CPU; four fresh server routers generating200 hrefs each use8-9% less. Reversed import order corroborates these scoped results. Four real client/SSR Link cases remain statistically inconclusive.
All18 bundle fixtures shrink19-37 gzip bytes versus the consolidation baseline. React Router minimal/full are85797/89379 bytes,46/38 below measured main. Tests cover SSR request cleanup, route reuse, decoder/trailing variants, reparenting, result bounds and fallback capacity.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* test(router-core): add opt-in matching interpolation benchmarks
Cover client/server matching with cold and Link-primed route plans, nested params, high-cardinality misses, optional params, and splats. Gate all additional cases behind TSR_LINK_PERF=1.
Evaluate six matching-cache prototypes without retaining production changes. Eager variants regress repeated misses by24-64%. Read-through reuse improves warm matching microcases but adds65 gzip bytes; all26 application Link/SSR comparisons show no supported speedup, with one relative-Link slowdown. Real HTTP SSR ABBA means differ by only -0.41%, within observed variation.
Restore production and all18 bundle metrics exactly to ec05cc6bec. Preserve detailed measurements and rejected prototypes in session artifacts and uncommitted LOG.md.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router): compact Solid and Vue Link state props
Port the React Link bundle-size reductions to Solid and Vue: share exact/fuzzy pathname normalization, resolve only the selected active/inactive props, concatenate classes without temporary arrays, and avoid style allocation when neither source supplies styles. Vue forwards and visits one selected props object in both client and SSR paths.
Keep framework-specific behavior: Solid retains its default-styling fast path and base href/handler precedence; Vue retains state-prop overrides and zero-argument callbacks. Both keep style snapshots so mutable Solid stores and Vue proxies remain reactive, including additions to empty style objects. No public API or unrelated production code changes.
Official gzip measurements versus d4cc307869:
- Solid minimal: 34017 -> 33973 (-44 bytes).
- Solid full: 38973 -> 38930 (-43 bytes).
- Vue minimal: 50731 -> 50646 (-85 bytes).
- Vue full: 56484 -> 56395 (-89 bytes).
All nine Solid/Vue Router/Start fixtures shrink by 26-104 gzip bytes; all nine React fixtures remain byte-identical.
Independent hunk attribution: active pathname checks save 36/41 Solid and 37/34 Vue bytes. State-prop changes alone save 0/2 Solid and 46/53 Vue bytes. Combined gzip deltas are not additive.
Existing 200-Link/eight-navigation workloads were compared with frozen parent, props-only, and final bundles. Standalone wall-time runs were too variable for a speed claim. Interleaved fixed-seed checks, repeated with reversed module order, showed effectively flat rendering cost: Solid mean CPU -1.49% / +0.33%, Vue -0.23% / -0.29%; corresponding wall changes -1.81% / +0.50% and -0.12% / -0.33%. No incremental rendering speedup is claimed. Raw results and experiments remain in uncommitted LOG.md and session artifacts.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* fix(router): honor Link state props and Vue class bindings
Apply selected active/inactive props after ordinary base props in Solid and React, including React server output. Preserve the dedicated class concatenation and style merge handling. Add client/server regressions for supported refs and event handlers; do not widen the state-prop API to router navigation options.
Keep Vue object and nested-array class values intact instead of interpolating them into strings. Compose base/state values with Vue-compatible arrays, retain omitted-class behavior, and clone props at VNode creation because Vue normalizes class values in place. This preserves cached bindings and later reactive class changes. Vue ordinary state-attribute precedence was already correct and is left unchanged.
The regressions were run on the pre-fix implementations and failed for the reported behaviors, then passed after the fixes. Full framework unit/type/lint/package and Chromium coverage passes. Bundle impact remains small: React/Solid raw bytes unchanged; Vue Router minimal/full are 14/10 gzip bytes smaller. Detailed red/green evidence and measurements are kept in uncommitted LOG.md and session artifacts.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* fix(solid-router): preserve computed Link routing props
Restore the computed href, target, and disabled values after active/inactive state props. Keep state-prop ref/event overrides, class/style composition, and the default styling fast path unchanged for client and SSR rendering.
Reproduce the history/rewrite href failures and extend existing state-prop regressions to cover conflicting routing fields. Full validation passes 922 client tests (one skipped), 33 server tests, type/lint/export checks, and 24 Chromium cases.
The full bundle matrix adds 16/13 gzip bytes to Solid Router minimal/full and 13-17 bytes to Solid Start fixtures. React and Vue bundles are unchanged; no extra allocations or href recomputation are introduced.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(solid-router): skip client setup for all server links
* test(solid-router): preserve caller props for internal SSR links
* Merge branch 'main' into codex/solid-link-server-all [Self-Healing CI Rerun]
---------
Co-authored-by: nx-cloud[bot] <71083854+nx-cloud[bot]@users.noreply.github.com>