Uh oh!
There was an error while loading. Please reload this page.
feat(solid-query): built-in single-flight consumer via FLIGHT_DATA_SOURCE - #11326
Merged
brenelz merged 3 commits intoSep 2, 2026
Merged
Conversation
…URCE
Solid's single-flight channel is becoming multi-source (solidjs/solid
653dd41e): mutation responses carry a keyed envelope of per-cache
slices, each routed to the consumer subscribed under its source id, so
independent caches (Solid Router's route data, the query cache) refresh
from one round trip without competing for the single legacy slot.
QueryClientProvider now subscribes the query cache's consumer under the
exported FLIGHT_DATA_SOURCE id ("sq", matching the sq: hydration-registry
namespace): a mutation response carrying that slice — a DehydratedState
produced by a server collector registered with
registerFlightDataSource(FLIGHT_DATA_SOURCE, hook) — hydrates the
provider's client before the mutation's promise resolves. Mounted
queries on those keys update with no follow-up refetches, and apps
delete the hand-rolled subscribeFlightData/hydrate wiring entirely.
Subscribing is inert when no server collector exists (the server folds
nothing), client-only (the server registry is cross-request module
state), and torn down with the provider.
Requires the @solidjs/web release following 2.0.0-rc.4 for the
named-source protocol; a typed shim bridges the installed declarations
until the peer range bumps.
Co-authored-by: Cursor <cursoragent@cursor.com>Contributor
Important Review skippedAuto reviews are disabled on base/target branches other than the default branch. Please check the settings in the CodeRabbit UI or the ⚙️ Run configurationConfiguration used: defaults Review profile: CHILL Plan: Team Run ID: You can disable this status message by setting the Use the checkbox below for a quick retry:
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
This was referenced Aug 29, 2026
…ering Fills the gaps the router-ssr-query transport used to cover, natively: - dehydrateSettled(client): the extraction half of a single-flight collector — waits for every in-flight fetch (chased to quiescence) so loaders' fire-and-forget prefetches land before dehydrating. - SSR teardown: the provider cancels and clears the per-request cache on render disposal, so user-configured finite gcTime timers cannot pin the client after the response. - The registry serializer now respects defaultOptions.dehydrate .shouldDehydrateQuery, the same knob apps use on any other transport. Co-authored-by: Cursor <cursoragent@cursor.com>
ryansolid added a commit
to solidjs/solid
that referenced
this pull request
Sep 1, 2026
…ainst workspace-built core Core-side suites structurally cannot represent the adapter's composed shapes — rc.5 shipped a settle-walk regression (#3181's fix waking parked readers into uninitialized projections) that only the adapter's own suite could see: premature wakes are self-healing for ordinary async nodes and corrupt only through an empty-seed projection over a stable chained promise with boundary-parked readers. The gate packs signals/solid/web from the tree, downloads the adapter repo, forces resolution through pnpm-workspace.yaml overrides (pnpm 11 ignores package.json pnpm.overrides), asserts the tarballs actually resolved via file+ store realpaths (a version compare cannot tell tarball from registry), builds the TS reference graph, and runs the full suite. Wired into scripts/release.mjs before publish so a candidate that breaks the flagship adapter fails on the runner, not on npm. Tracks the PR head carrying the Solid 2.0 pairing until TanStack/query#11326 merges to main. Co-authored-by: Cursor <cursoragent@cursor.com>
ryansolid added a commit
to ryansolid/tanstack-router
that referenced
this pull request
Sep 2, 2026
Solid's single-flight channel is becoming multi-source (solidjs/solid 653dd41e): mutation responses carry a keyed envelope of per-cache slices, each routed to the consumer subscribed under its source id. Today Start claims the single unnamed slot on both halves, which means any other cache wanting mutation-response data (e.g. solid-query, whose provider subscribes under "sq" in TanStack/query#11326) displaces the router's — whichever registers last wins, silently. The router's flight data now rides its own source id ("tsr"): the server collector registers additively with registerFlightDataSource and the client subscribes its consumer under the same id, so router loader/match state and other caches' slices coexist on one round trip. A user-supplied collectFlightData hook keeps the unnamed slot to itself, adding data alongside the router's instead of displacing it. Both halves feature-detect the protocol on the installed @solidjs/web (it ships in the release after 2.0.0-rc.4) and fall back to the exact previous unnamed-slot behavior on older versions; since client and server resolve the same install, the halves cannot disagree. Co-authored-by: Cursor <cursoragent@cursor.com>
ryansolid added a commit
to ryansolid/tanstack-router
that referenced
this pull request
Sep 2, 2026
Solid's single-flight channel is becoming multi-source (solidjs/solid 653dd41e): mutation responses carry a keyed envelope of per-cache slices, each routed to the consumer subscribed under its source id. Today Start claims the single unnamed slot on both halves, which means any other cache wanting mutation-response data (e.g. solid-query, whose provider subscribes under "sq" in TanStack/query#11326) displaces the router's — whichever registers last wins, silently. The router's flight data now rides its own source id ("tsr"): the server collector registers additively with registerFlightDataSource and the client subscribes its consumer under the same id, so router loader/match state and other caches' slices coexist on one round trip. A user-supplied collectFlightData hook keeps the unnamed slot to itself, adding data alongside the router's instead of displacing it. Both halves feature-detect the protocol on the installed @solidjs/web (it ships in the release after 2.0.0-rc.4) and fall back to the exact previous unnamed-slot behavior on older versions; since client and server resolve the same install, the halves cannot disagree. Co-authored-by: Cursor <cursoragent@cursor.com>
… bridge rc.6 publishes the named flight-data source API with real types, so the subscribeFlightData cast goes away; the peer floor moves to rc.6 because rc.5's settle-walk regression breaks query hydration. Also adds the missing changeset for dehydrateSettled and the SSR teardown work. Co-authored-by: Cursor <cursoragent@cursor.com>
Review the following changes in direct dependencies. Learn more about Socket for GitHub.
|
ryansolid
marked this pull request as ready for review
September 2, 2026 21:24
View your CI Pipeline Execution ↗ for commit 5f2f3fe
☁️ Nx Cloud last updated this comment at |
brenelz
approved these changes
Sep 2, 2026
Uh oh!
There was an error while loading. Please reload this page.
brenelz pushed a commit
to TanStack/router
that referenced
this pull request
Sep 2, 2026
…-agnostic trigger (#8192) * refactor(solid): retire solid-router-ssr-query — Solid's native channels carry the Router + Query pairing solid-query v6's QueryClientProvider serializes the request's cache into Solid's hydration registry during SSR and primes the client cache from it, so running the ssr-query transport alongside it ships every query payload twice. The package's two runtime conveniences are each a few lines of userland composition on public APIs: the provider wrap via the router's Wrap option, and cache-driven redirect() errors handed to router.navigate from the caches' config.onError. Converts the three Solid Start e2e apps to the composition (all suites green, including the redirect-from-query tests) and marks the package deprecated for the v2 line. Co-authored-by: Cursor <cursoragent@cursor.com> * chore: changeset for the solid-router-ssr-query deprecation notice Co-authored-by: Cursor <cursoragent@cursor.com> * feat(solid-start): named single-flight source for router flight data Solid's single-flight channel is becoming multi-source (solidjs/solid 653dd41e): mutation responses carry a keyed envelope of per-cache slices, each routed to the consumer subscribed under its source id. Today Start claims the single unnamed slot on both halves, which means any other cache wanting mutation-response data (e.g. solid-query, whose provider subscribes under "sq" in TanStack/query#11326) displaces the router's — whichever registers last wins, silently. The router's flight data now rides its own source id ("tsr"): the server collector registers additively with registerFlightDataSource and the client subscribes its consumer under the same id, so router loader/match state and other caches' slices coexist on one round trip. A user-supplied collectFlightData hook keeps the unnamed slot to itself, adding data alongside the router's instead of displacing it. Both halves feature-detect the protocol on the installed @solidjs/web (it ships in the release after 2.0.0-rc.4) and fall back to the exact previous unnamed-slot behavior on older versions; since client and server resolve the same install, the halves cannot disagree. Co-authored-by: Cursor <cursoragent@cursor.com> * feat(solid-router): loadFlightTarget, the cache-agnostic single-flight trigger The router's half of flight collection as a public primitive: derive the flight request for the mutation's target, run the matched routes' data functions, hand the loaded router to the caller's collect() — any cache (the router's own state, a query client) composes its extraction on top. Start's collector now consumes it; errors are contained per Solid Router's collector convention (flight data is an optimization, never a mutation error). Co-authored-by: Cursor <cursoragent@cursor.com> * refactor(solid-start): require named flight sources, drop the pre-rc.5 fallback @solidjs/web 2.0.0-rc.5 ships the multi-source single-flight protocol, so the feature detection and cast shims bridging unreleased types come out: the client subscribes directly under SOLID_START_FLIGHT_SOURCE, the server registers its collector via registerFlightDataSource unconditionally (the unnamed collectFlightData slot now always belongs to the user), and the @solidjs/web peer floor moves to rc.5. Co-authored-by: Cursor <cursoragent@cursor.com> * test(e2e): expect the named single-flight source header With the pre-rc.5 fallback stripped, the client advertises its named source and the server echoes what it folded: X-Single-Flight is "tsr" on both sides, not the legacy "true". Co-authored-by: Cursor <cursoragent@cursor.com> * chore(solid): bump solid-js, @solidjs/web, @solidjs/signals to 2.0.0-rc.6 Repo-wide (packages, examples, e2e apps, benchmarks) — a scoped bump leaves the workspace mixed, and examples/benchmarks then build workspace solid-start dists (which import registerFlightDataSource, rc.5+) against their own @solidjs/web rc.4 resolution. rc.6 ships the named flight-data source API this branch requires plus the settle-walk fix that unblocks the Solid Query pairing. @tanstack/solid-start's peer floor moves to rc.6. The SSR bench helpers move onto rc.6's wire shape: scripted callers use the data address (`<endpoint>/data/<id>`) — the bare address now answers document traffic with the no-JS convention. Co-authored-by: Cursor <cursoragent@cursor.com> * ci: apply automated fixes --------- Co-authored-by: Cursor <cursoragent@cursor.com> Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
brenelz added a commit
to TanStack/router
that referenced
this pull request
Sep 2, 2026
…t, provider-owned dispatch (#8213) * refactor(solid): retire solid-router-ssr-query — Solid's native channels carry the Router + Query pairing solid-query v6's QueryClientProvider serializes the request's cache into Solid's hydration registry during SSR and primes the client cache from it, so running the ssr-query transport alongside it ships every query payload twice. The package's two runtime conveniences are each a few lines of userland composition on public APIs: the provider wrap via the router's Wrap option, and cache-driven redirect() errors handed to router.navigate from the caches' config.onError. Converts the three Solid Start e2e apps to the composition (all suites green, including the redirect-from-query tests) and marks the package deprecated for the v2 line. Co-authored-by: Cursor <cursoragent@cursor.com> * chore: changeset for the solid-router-ssr-query deprecation notice Co-authored-by: Cursor <cursoragent@cursor.com> * feat(solid-start): named single-flight source for router flight data Solid's single-flight channel is becoming multi-source (solidjs/solid 653dd41e): mutation responses carry a keyed envelope of per-cache slices, each routed to the consumer subscribed under its source id. Today Start claims the single unnamed slot on both halves, which means any other cache wanting mutation-response data (e.g. solid-query, whose provider subscribes under "sq" in TanStack/query#11326) displaces the router's — whichever registers last wins, silently. The router's flight data now rides its own source id ("tsr"): the server collector registers additively with registerFlightDataSource and the client subscribes its consumer under the same id, so router loader/match state and other caches' slices coexist on one round trip. A user-supplied collectFlightData hook keeps the unnamed slot to itself, adding data alongside the router's instead of displacing it. Both halves feature-detect the protocol on the installed @solidjs/web (it ships in the release after 2.0.0-rc.4) and fall back to the exact previous unnamed-slot behavior on older versions; since client and server resolve the same install, the halves cannot disagree. Co-authored-by: Cursor <cursoragent@cursor.com> * feat(solid-router): loadFlightTarget, the cache-agnostic single-flight trigger The router's half of flight collection as a public primitive: derive the flight request for the mutation's target, run the matched routes' data functions, hand the loaded router to the caller's collect() — any cache (the router's own state, a query client) composes its extraction on top. Start's collector now consumes it; errors are contained per Solid Router's collector convention (flight data is an optimization, never a mutation error). Co-authored-by: Cursor <cursoragent@cursor.com> * refactor(solid-start): require named flight sources, drop the pre-rc.5 fallback @solidjs/web 2.0.0-rc.5 ships the multi-source single-flight protocol, so the feature detection and cast shims bridging unreleased types come out: the client subscribes directly under SOLID_START_FLIGHT_SOURCE, the server registers its collector via registerFlightDataSource unconditionally (the unnamed collectFlightData slot now always belongs to the user), and the @solidjs/web peer floor moves to rc.5. Co-authored-by: Cursor <cursoragent@cursor.com> * test(e2e): expect the named single-flight source header With the pre-rc.5 fallback stripped, the client advertises its named source and the server echoes what it folded: X-Single-Flight is "tsr" on both sides, not the legacy "true". Co-authored-by: Cursor <cursoragent@cursor.com> * chore(solid): bump solid-js, @solidjs/web, @solidjs/signals to 2.0.0-rc.6 Repo-wide (packages, examples, e2e apps, benchmarks) — a scoped bump leaves the workspace mixed, and examples/benchmarks then build workspace solid-start dists (which import registerFlightDataSource, rc.5+) against their own @solidjs/web rc.4 resolution. rc.6 ships the named flight-data source API this branch requires plus the settle-walk fix that unblocks the Solid Query pairing. @tanstack/solid-start's peer floor moves to rc.6. The SSR bench helpers move onto rc.6's wire shape: scripted callers use the data address (`<endpoint>/data/<id>`) — the bare address now answers document traffic with the no-JS convention. Co-authored-by: Cursor <cursoragent@cursor.com> * spike(solid-router): Phase 1 — registry match transfer + hydration-claiming boot Proves the RFC's Phase 1 claims on the external-SSR harness, against published core (web 2.0.0-rc.5): - Server render serializes each match's loaderData/status into Solid's hydration registry, content-addressed (`tsr:<matchId>`), the identical mechanism solid-query v6 ships queries through — no `__TSR_SSR__` script channel. - The client boot matches synchronously, primes match state from the registry (populated at document parse), and commits — no `router.load()` before hydrate, loaders do not re-run (0 client runs), hydration claims the server DOM identically, and post-hydration navigation with an unresolved chunk still shows pending UI and settles under its boundary. Spike-level notes: the commit must happen before hydrate() (store writes inside the hydration render are owned-scope writes), the transfer covers settled matches (promise-valued entries for pending loaders are the same serialize call, next step), and the serialization-context guard keys on `ctx.serialize` presence (`ctx.async` is not set under this web version's renderToString). Co-authored-by: Cursor <cursoragent@cursor.com> * feat(solid-router): native SSR match transfer + hydration-claiming boot (Phase 1) Grows the spike into the adapter. RouterProvider serializes each settled match's state (loaderData, status, error, notFound, beforeLoadContext, ssr) into Solid's hydration registry during server render — content-addressed (`tsr:<matchId>`), the same channel solid-query v6 ships queries through, no `__TSR_SSR__` script injection. The Router constructor owns the client half: when the registry holds entries for the synchronously matched routes, it primes and commits match state at creation — always outside a render, after the document (and therefore the entries) parsed, before hydrate(). No load pass before hydration, no loader re-runs; route chunks resolve at the read point under the boundaries the server rendered. Both halves are inert outside the bare pairing: the server skips when `router.serverSsr` marks the Start contract, and the boot falls through on the first missing entry (SPA pages, Start's own channel). Placement is load-bearing: committing inside the hydration render — even with writes moved off the owner — leaves the claiming walk's registry bookkeeping desynced (nodes reuse correctly but audit as unclaimed). Router creation is the client's natural pre-render moment, and the harness A/B proved it clean. Validated: external-SSR harness green end to end (registry primed, zero client loader runs, identical DOM claimed, pending UI on post-hydration nav), solid-router unit suite 865 tests green, and all 37 Solid Start e2e tests green against the rc.6-candidate core (workspace tarballs) with the named-source strips in place. The harness now contains zero transfer code. Pending matches are skipped, not deferred — promise-valued entries (streaming SSR) are the next increment. Co-authored-by: Cursor <cursoragent@cursor.com> * docs(rfc): record Phase 1 landed state — transfer + boot in the adapter, boundary bullet corrected Co-authored-by: Cursor <cursoragent@cursor.com> * feat(solid-router): provider-owned server dispatch + streamed loaderData RouterProvider now owns router.load() on the server, parking the render on it through an async memo — no more explicit await router.load() in entries; blocking semantics ride Solid's async SSR. The bare-pairing harness moves to renderToStream and proves deferred loaderData promises stream natively (fallback in the shell chunk, value in a later chunk, settled through hydration without <Await>). Co-authored-by: Cursor <cursoragent@cursor.com> * chore: changeset for Phase 1 native SSR transfer Co-authored-by: Cursor <cursoragent@cursor.com> * ci: apply automated fixes * fix(solid): unbreak CI after the solid-js rc.6 bump Two things were failing the Test job: - @tanstack/solid-router test:eslint: the repro-external-ssr harness is not part of the package tsconfig, so the typed parser rejected its .tsx files. Ignore the harness in the package eslint config; it is a standalone vite script, not shipped code. - Four example builds (basic-solid-query, basic-solid-query-file-based, kitchen-sink-file-based, kitchen-sink-solid-query) run tsc, and the rc.6 types no longer accept the one-argument createEffect form. Convert the eleven call sites to the two-argument createEffect(source, effect) form already used by the sibling examples and e2e apps. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> --------- Co-authored-by: Cursor <cursoragent@cursor.com> 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: Claude Fable 5.1 <noreply@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Draft — depends on the unreleased
@solidjs/webmulti-source single-flight protocol (solidjs/solid@653dd41e). Ready to land once that ships and the peer range bumps.Summary
Solid's single-flight channel is becoming multi-source: a mutation response can carry a keyed envelope of per-cache slices, each routed to the consumer subscribed under its source id. Independent caches — Solid Router's route data and the TanStack Query cache — refresh from one round trip without competing for the single legacy consumer slot (which previously meant whichever library subscribed last silently displaced the other).
This PR internalizes the query cache's half:
QueryClientProvidersubscribes a consumer under the new exportedFLIGHT_DATA_SOURCEid ("sq", matching thesq:hydration-registry namespace). A mutation response carrying that slice — aDehydratedState— hydrates the provider's client before the mutation's promise resolves: mounted queries on those keys update in the same beat, with no follow-up refetches.Apps delete their hand-rolled
subscribeFlightData(...)+hydrate(...)client wiring entirely. Subscribing is inert when no server collector exists (the server folds nothing for the source), client-only (the server-side consumer registry is module state shared across requests), and torn down with the provider.New:
dehydrateSettled, SSR teardown, dehydrate filteringThree additions that complete the native SSR/flight story (covering everything
router-ssr-query-core's transport provided, on the query side):dehydrateSettled(client, options?)— the extraction half of a flight collector. Route loaders commonly fire prefetches without awaiting them; plaindehydrate()would snapshot those mid-fetch and ship nothing. Waits for every in-flight fetch, chased to quiescence (a settled batch can dispatch dependent fetches), then dehydrates.gcTimetoInfinityon the server, but any app setting a finitegcTimeindefaultOptionswould otherwise pin the per-request client (and everything its queries closed over) until the timers fire.defaultOptions.dehydrate.shouldDehydrateQuery, so apps keep sensitive or oversized queries out of the HTML payload with the same knob they'd pass any other transport. Consulted per cache event until it passes, so a filter rejecting pending queries still admits the settled value if it lands while the request's serialization context is live.Before landing (once
@solidjs/web2.0.0-rc.5 ships)subscribeFlightSourcetyped shim inQueryClientProvider.tsx— call the named-sourcesubscribeFlightData(FLIGHT_DATA_SOURCE, ...)overload directly.@solidjs/webpeer floor to rc.5.This PR deliberately waits for the release rather than landing with the shim: the whole stack (this, TanStack/router#8192, solidjs/templates#287) ships in lockstep, so landing early buys nothing and leaves cleanup to forget.
Notes
@solidjs/webdeclarations until the named-source overload ships and the peer range bumps; it should be removed at that point.@solidjs/web's suite.sq:<queryHash>), post-mutation transfer is source-addressed through the flight envelope (sq) — the same recognition model at two moments.Verification
flightData.test.tsx(consumer) anddehydrateSettled.test.tsx(settling, quiescence-chasing, failure settling + option forwarding) passing; the SSR fixture suite gained teardown (cacheEmptyAfterDisposeon both string and streaming renders) and filter assertions (the filtered query's registry entry stays off the wire while others — including a never-rendered prefetch — still ship).@solidjs/webcarrying the protocol.Made with Cursor