diff --git a/.agents/skills/data-client-manager/SKILL.md b/.agents/skills/data-client-manager/SKILL.md
index b5a4193d09a1..2be2a36335e4 100644
--- a/.agents/skills/data-client-manager/SKILL.md
+++ b/.agents/skills/data-client-manager/SKILL.md
@@ -31,6 +31,8 @@ Minimal working examples for each use case live in [references/managers.md](refe
 | Custom transport subscriptions              | "Reading and Consuming Actions" in [Manager.md](references/Manager.md)            | consume `SUBSCRIBE`/`UNSUBSCRIBE` without calling `next`                                                                                                             |
 | Auth: logout on 401, reset store on deauth  | [LogoutManager.md](references/LogoutManager.md)                                   | `handleLogout(controller)` + `controller.resetEntireStore()`                                                                                                         |
 
+Do not start channel work before `SUBSCRIBE`; do not treat `SUBSCRIBE` as SSR hydration (see `references/ssr.md` in skill "data-client-react").
+
 ## References
 
 For detailed API documentation, see the [references](references/) directory:
@@ -158,7 +160,7 @@ export default class CustomSubsManager implements Manager {
 import { DataProvider, getDefaultManagers } from '@data-client/react';
 import ReactDOM from 'react-dom';
 
-const managers = [...getDefaultManagers(), new MyManager()];
+const managers = () => [...getDefaultManagers(), new MyManager()];
 
 ReactDOM.createRoot(document.body).render(
   <DataProvider managers={managers}>
@@ -166,3 +168,5 @@ ReactDOM.createRoot(document.body).render(
   </DataProvider>,
 );
 ```
+
+Pass `managers` as a function: it runs once per provider (and once per request with `@data-client/react/nextjs`). Arrays are still accepted by the browser `DataProvider` but are transitional and will be removed; migrate existing `managers={[...]}` to `managers={() => [...]}`.
diff --git a/.agents/skills/data-client-react/SKILL.md b/.agents/skills/data-client-react/SKILL.md
index cd689281727a..8983b4af26e5 100644
--- a/.agents/skills/data-client-react/SKILL.md
+++ b/.agents/skills/data-client-react/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: data-client-react
-description: Use @data-client/react hooks for data fetching, mutations, and rendering - useSuspense, useFetch, useQuery, useCache, useLive, useDLE, useSubscription, useController, DataProvider, AsyncBoundary, useLoading, useDebounce. Use when reading/rendering remote data, triggering mutations, doing optimistic updates, real-time subscriptions, or wiring Suspense/error boundaries in React.
+description: Use @data-client/react hooks for data fetching, mutations, and rendering - useSuspense, useFetch, useQuery, useCache, useLive, useDLE, useSubscription, useController, DataProvider, AsyncBoundary, useLoading, useDebounce. Use when reading/rendering remote data, triggering mutations, doing optimistic updates, real-time subscriptions, wiring Suspense/error boundaries, or SSR/Next.js hydration in React.
 license: Apache 2.0
 ---
 ## Rendering
@@ -30,6 +30,8 @@ const comments = use(commentsPromise);
 
 For API definitions (like TodoResource), apply the skill "data-client-rest".
 
+Under SSR the hooks are identical; only the provider entry and how the store is seeded differ. Read [ssr](references/ssr.md) when wiring server rendering or debugging hydration.
+
 ## Mutations
 
 ```ts
@@ -151,6 +153,7 @@ For detailed API documentation, see the [references](references/) directory:
 - [useLoading](references/useLoading.md);[_useLoading.md](references/_useLoading.md) - Track async mutation state
 - [useDebounce](references/useDebounce.md) - Debounce values
 - [DataProvider](references/DataProvider.md) - Root provider
+- [ssr](references/ssr.md) - SSR entries and hydration (Next.js, `renderToPipeableStream`)
 - [data-dependency](references/data-dependency.md) - Rendering guide
 - [mutations](references/mutations.md);[_VoteDemo.md](references/_VoteDemo.md) - Mutations guide
 - [Actions](references/Actions.md) - Store action types (FETCH, SET, etc.)
diff --git a/.agents/skills/data-client-react/references/ssr.md b/.agents/skills/data-client-react/references/ssr.md
new file mode 100644
index 000000000000..730ac70216dc
--- /dev/null
+++ b/.agents/skills/data-client-react/references/ssr.md
@@ -0,0 +1,122 @@
+# SSR and streamed hydration
+
+Only what differs from a browser-only app. Components, hooks, Managers, and mutations are unchanged: `useSuspense` / `useLive` stay in the component that renders the data. The difference is how the store is seeded.
+
+## Contents
+
+- [Which entry](#which-entry)
+- [Next.js App Router](#nextjs-app-router)
+- [renderToPipeableStream (Express, Anansi)](#rendertopipeablestream-express-anansi)
+- [Next.js Pages Router](#nextjs-pages-router)
+- [Not shipped](#not-shipped)
+
+## Which entry
+
+| Host | Import | How the store is seeded |
+| --- | --- | --- |
+| Browser SPA | `@data-client/react` | Public `DataProvider`; hooks read `StateContext` |
+| Next.js App Router | `@data-client/react/nextjs` | Adapter-owned streamed snapshot: inert baseline in the shell, then a `StateDelta` per committed server revision |
+| `renderToPipeableStream` (Express, Anansi) | `@data-client/react/ssr` | One-shot snapshot passed as `initialState`. Unstable `__INTERNAL__.StreamingDataProvider` if the host already owns a snapshot store |
+| Next.js Pages Router | `@data-client/ssr/nextjs` | One-shot snapshot |
+
+Do not dispatch a root `HYDRATE` action. Stream publication is adapter-internal.
+
+## Next.js App Router
+
+```tsx title="app/layout.tsx"
+import { DataProvider } from '@data-client/react/nextjs';
+import { AsyncBoundary } from '@data-client/react';
+
+export default function RootLayout({ children }) {
+  return (
+    <html>
+      <body>
+        <DataProvider>
+          <AsyncBoundary>{children}</AsyncBoundary>
+        </DataProvider>
+      </body>
+    </html>
+  );
+}
+```
+
+Differences from the browser `DataProvider`:
+
+- No `initialState` prop. The store is seeded from the stream; do not pass or replace state per delta.
+- `managers` must be a **function**. The server builds a store per request, so an array is rejected. Server-side `cleanup()` is not run per request; do not hold resources in server managers. A function cannot cross the RSC boundary, so custom managers go in a `'use client'` wrapper:
+
+```tsx title="app/Provider.tsx"
+'use client';
+import { getDefaultManagers } from '@data-client/react';
+import { DataProvider } from '@data-client/react/nextjs';
+
+const managers = () => [...getDefaultManagers(), new MyManager()];
+
+export default function Provider({ children }: { children: React.ReactNode }) {
+  return <DataProvider managers={managers}>{children}</DataProvider>;
+}
+```
+
+- `nonce` prop: state is streamed in inline `<script>` tags; pass your CSP nonce through.
+- One `DataProvider` per document. Nested or sibling providers share the same streamed state.
+- `gcPolicy` applies in the browser only.
+
+How hydration flows:
+
+1. The shell carries an inert baseline; first paint does not wait for Data Client.
+2. Each later committed server revision emits a `StateDelta` via `useServerInsertedHTML()`. The Next.js adapter folds queued deltas into its snapshot and publishes them into the live store from a layout effect.
+3. If that fold already happened when a Client Component renders, `useSuspense` hits. If RSC starts the island first, a miss fetches like any client render. `useServerInsertedHTML` writes to the HTML stream; it does not order RSC.
+4. `SUBSCRIBE` from `useLive` / `useSubscription` is not proof the server delta arrived.
+
+Scope:
+
+- Only the initial document is transferred. Client-side navigation and `router.refresh()` fetch in the browser.
+- Partial Prerendering: the static shell's state is transferred; data fetched while resuming dynamic holes is fetched again in the browser.
+- Server Components may `await TodoResource.getList(params)` directly. That result is rendered on the server and is not placed in the store.
+- Production builds mangle class names: set `static key = 'User'` on every `Entity` (skill "data-client-schema").
+
+## renderToPipeableStream (Express, Anansi)
+
+One-shot snapshot. The server fetches into a per-request store, then serializes it once the tree is ready.
+
+```tsx
+import { renderToPipeableStream } from 'react-dom/server';
+import { createPersistedStore, createServerDataComponent } from '@data-client/react/ssr';
+
+const [ServerDataProvider, useReadyCacheState, controller] = createPersistedStore();
+const ServerDataComponent = createServerDataComponent(useReadyCacheState);
+
+controller.fetch(NeededForPage, { id: 5 });
+renderToPipeableStream(
+  <Document scripts={[<ServerDataComponent key="server-data" />]}>
+    <ServerDataProvider>{children}</ServerDataProvider>
+  </Document>,
+  { onCompleteShell() { pipe(res); } },
+);
+```
+
+```tsx
+import { awaitInitialData } from '@data-client/react/ssr';
+
+awaitInitialData().then(initialState => {
+  hydrateRoot(root, <DataProvider initialState={initialState}>{children}</DataProvider>);
+});
+```
+
+A stable streamed baseline + deltas API is not available on this entry. Hosts that already own a snapshot store can compose `__INTERNAL__.StreamingDataProvider` from `@data-client/react/ssr`; that namespace is unstable and is not a user-facing component.
+
+## Next.js Pages Router
+
+`pages/_document.tsx` exports `DataClientDocument`; `pages/_app.tsx` wraps in `AppDataProvider`, both from `@data-client/ssr/nextjs`. One-shot snapshot. Override `DataClientDocument.getNonce(ctx)` for CSP. Pages reading `useRouter().query` need `getServerSideProps` (even `() => ({ props: {} })`) or the query is empty on first render.
+
+## Not shipped
+
+Do not describe these as current behavior:
+
+- Per-key `useSuspense` waiters (suspend on a pending stream key instead of dispatching `FETCH`).
+- Fold-on-script-arrival independent of the receiver layout effect.
+- A render-pure revision-visibility protocol: progressively revealed islands still cannot read their server revision through `StateContext` without a live store identity change.
+- Schema-aware live merge of streamed slots (`writeDelta` is whole-slot skip/replace) and reset-aware snapshot overlay (`lastReset`).
+- A stable streamed baseline + deltas export on `@data-client/react/ssr`.
+
+Consequence today: an RSC-first miss fetches like any client render. Per-delta live publication remains `flushSync` from the receiver. Missing-baseline still suspends while the document is loading. Do not work around these by replacing `initialState`, buffering the shell until all endpoints are known, adding endpoint/schema options for streaming, or dispatching a root hydrate action. A document-wide `DOMContentLoaded` wait is an acceptable interim, not the contract.
diff --git a/.changeset/dataprovider-managers-factory.md b/.changeset/dataprovider-managers-factory.md
new file mode 100644
index 000000000000..d355ae5ccc22
--- /dev/null
+++ b/.changeset/dataprovider-managers-factory.md
@@ -0,0 +1,23 @@
+---
+'@data-client/react': minor
+---
+
+Add `managers` factory support to `DataProvider`; arrays are now transitional
+
+`managers` accepts a function that creates the managers. It is called once when the provider
+mounts, so the same definition works for the Next.js provider (which only accepts a function) and
+each `DataProvider` on a page gets its own instances instead of sharing one hoisted array.
+
+```tsx
+// Before:
+const managers = [...getDefaultManagers(), new MyManager()];
+// After:
+const managers = () => [...getDefaultManagers(), new MyManager()];
+
+<DataProvider managers={managers}>
+  <App />
+</DataProvider>;
+```
+
+Passing an array still works, but the function form is the long-term API and arrays will be
+removed in a future release. Migrate when you can.
diff --git a/.changeset/nextjs-managers-factory.md b/.changeset/nextjs-managers-factory.md
new file mode 100644
index 000000000000..105cff93e693
--- /dev/null
+++ b/.changeset/nextjs-managers-factory.md
@@ -0,0 +1,42 @@
+---
+'@data-client/react': minor
+---
+
+BREAKING CHANGE: `managers` of the Next.js `DataProvider` is now a function
+
+The server renders every request with its own store, so manager instances cannot be shared
+between requests. Passing an array only ever applied to the browser; the server silently kept
+its defaults, so a custom `Manager` ran on one side but not the other. `@data-client/react/nextjs`
+now takes a function that is called once per request on the server and once in the browser, and
+throws with a migration hint when given an array.
+
+The browser `DataProvider` from `@data-client/react` accepts the same factory;
+arrays still work there as a transitional API.
+
+#### Before
+
+```tsx title="app/Provider.tsx"
+'use client';
+import { getDefaultManagers } from '@data-client/react';
+import { DataProvider } from '@data-client/react/nextjs';
+
+const managers = [...getDefaultManagers(), new MyManager()];
+
+export default function Provider({ children }) {
+  return <DataProvider managers={managers}>{children}</DataProvider>;
+}
+```
+
+#### After
+
+```tsx title="app/Provider.tsx"
+'use client';
+import { getDefaultManagers } from '@data-client/react';
+import { DataProvider } from '@data-client/react/nextjs';
+
+const managers = () => [...getDefaultManagers(), new MyManager()];
+
+export default function Provider({ children }) {
+  return <DataProvider managers={managers}>{children}</DataProvider>;
+}
+```
diff --git a/.changeset/peerdeps-019.md b/.changeset/peerdeps-019.md
new file mode 100644
index 000000000000..32ec13e0c912
--- /dev/null
+++ b/.changeset/peerdeps-019.md
@@ -0,0 +1,6 @@
+---
+'@data-client/img': patch
+'@data-client/test': patch
+---
+
+Bump `@data-client/react` peer dependency range to include `^0.19.0`.
diff --git a/.changeset/ssr-escape-json.md b/.changeset/ssr-escape-json.md
new file mode 100644
index 000000000000..d05ac0920fc8
--- /dev/null
+++ b/.changeset/ssr-escape-json.md
@@ -0,0 +1,10 @@
+---
+'@data-client/react': patch
+---
+
+Fix serialized SSR state breaking out of its `<script>` tag
+
+`ServerData` (used by `createServerDataComponent` and the Next.js provider) wrote the store as-is
+into a `<script type="application/json">`. An API response containing `</script>` ended the tag
+early, corrupting the page and allowing markup injection. `<`, `>`, `&` and the U+2028/U+2029 line
+terminators are now escaped; the payload stays valid JSON.
diff --git a/.changeset/streamed-ssr-hydration.md b/.changeset/streamed-ssr-hydration.md
new file mode 100644
index 000000000000..4a9208905029
--- /dev/null
+++ b/.changeset/streamed-ssr-hydration.md
@@ -0,0 +1,24 @@
+---
+'@data-client/core': minor
+'@data-client/react': minor
+'@data-client/vue': patch
+---
+
+Stream SSR store state incrementally through adapter-owned composition.
+
+The shell carries an inert baseline. Each later committed server revision emits a
+StateDelta. Next.js App Router folds that piece into an adapter-owned snapshot
+and publishes it from the receiver layout effect. Several components in one
+flush share one delta; a nested child can become readable before its parent; a
+later delta may overlap an entity already in the store (three-way merge).
+SUBSCRIBE after commit starts live updates and does not gate REST.
+
+Public DataProvider keeps the master store and StateContext reads. Streaming
+reducers and snapshot stores stay in ./nextjs and an unstable
+`@data-client/react/ssr` `__INTERNAL__` composition seam. HTML insertion order
+is not an RSC clock; a Client Component may start before its delta script runs,
+and a miss then fetches like any client render. Per-key waiters, revision
+visibility, schema-aware streamed merge, and reset-aware overlay are not in this
+release.
+
+New exports: StateDelta, StateBaseline, NextDataProviderProps.
diff --git a/docs/core/api/Controller.md b/docs/core/api/Controller.md
index 76d2b7ecea0b..a04e56dbd7e1 100644
--- a/docs/core/api/Controller.md
+++ b/docs/core/api/Controller.md
@@ -316,7 +316,7 @@ import { unAuth } from '../authentication';
 
 const testKey = (key: string) => key.startsWith(`GET ${myDomain}`);
 
-const managers = [
+const managers = () => [
   new LogoutManager({
     handleLogout(controller) {
       // call custom unAuth function we defined
diff --git a/docs/core/api/DataProvider.md b/docs/core/api/DataProvider.md
index 7988ce2220d3..fd582bae90fe 100644
--- a/docs/core/api/DataProvider.md
+++ b/docs/core/api/DataProvider.md
@@ -21,7 +21,7 @@ in the React tree.
 ```typescript
 interface ProviderProps {
   children: ReactNode;
-  managers?: Manager[];
+  managers?: Manager[] | (() => Manager[]);
   initialState?: State<unknown>;
   Controller?: typeof Controller;
   devButton?:
@@ -71,12 +71,36 @@ export interface State<T> {
 Instead of starting with an empty cache, you can provide your own initial state. This can
 be useful for testing, or rehydrating the cache state when using server side rendering.
 
-### managers?: Manager[] {#managers}
+Hooks read that state through `StateContext`. The Next.js App Router provider from
+`@data-client/react/nextjs` fills this in from the stream; see the
+[SSR guide](../guides/ssr.md#nextjs) for its props.
 
-List of [Manager](./Manager.md)s use. This is the main extensibility point of the provider.
+### managers?: Manager[] | (() => Manager[]) {#managers}
+
+List of [Manager](./Manager.md)s to use, or a function that creates them. This is the main
+extensibility point of the provider.
 
 [getDefaultManagers()](./getDefaultManagers.md) can be used to extend the default managers.
 
+Both forms are resolved once when the provider mounts. Prefer the function: the same definition
+works with the [Next.js provider](../guides/ssr.md#managers), which only accepts a function, and
+each `DataProvider` on a page gets its own instances (managers keep a reference to the store they
+were attached to).
+
+:::warning Arrays are transitional
+
+Passing `Manager[]` keeps working for now but will be removed in a future release. Migrate to the
+function form when you can:
+
+```tsx
+// Before:
+const managers = [...getDefaultManagers(), new MyManager()];
+// After:
+const managers = () => [...getDefaultManagers(), new MyManager()];
+```
+
+:::
+
 Default Production:
 
 ```typescript
diff --git a/docs/core/api/DevToolsManager.md b/docs/core/api/DevToolsManager.md
index 921615825e0c..8112990e81f1 100644
--- a/docs/core/api/DevToolsManager.md
+++ b/docs/core/api/DevToolsManager.md
@@ -37,10 +37,11 @@ import {
 } from '@data-client/react';
 import ReactDOM from 'react-dom';
 
-const managers = getDefaultManagers({
-  // highlight-next-line
-  devToolsManager: { trace: true },
-});
+const managers = () =>
+  getDefaultManagers({
+    // highlight-next-line
+    devToolsManager: { trace: true },
+  });
 
 ReactDOM.createRoot(document.body).render(
   <DataProvider managers={managers}>
@@ -65,7 +66,7 @@ import {
 } from '@data-client/react';
 import ReactDOM from 'react-dom';
 
-const managers =
+const managers = () =>
   process.env.NODE_ENV !== 'production'
     ? [
         // highlight-start
diff --git a/docs/core/api/LogoutManager.md b/docs/core/api/LogoutManager.md
index 7e96a1b06b84..a2f3dc0d578f 100644
--- a/docs/core/api/LogoutManager.md
+++ b/docs/core/api/LogoutManager.md
@@ -40,7 +40,7 @@ import {
 import ReactDOM from 'react-dom';
 
 // highlight-next-line
-const managers = [new LogoutManager(), ...getDefaultManagers()];
+const managers = () => [new LogoutManager(), ...getDefaultManagers()];
 
 ReactDOM.createRoot(document.body).render(
   <DataProvider managers={managers}>
@@ -62,7 +62,7 @@ import {
 import { AppRegistry } from 'react-native';
 
 // highlight-next-line
-const managers = [new LogoutManager(), ...getDefaultManagers()];
+const managers = () => [new LogoutManager(), ...getDefaultManagers()];
 
 const Root = () => (
   <DataProvider managers={managers}>
@@ -82,7 +82,7 @@ import { LogoutManager, getDefaultManagers } from '@data-client/react';
 import { DataProvider } from '@data-client/react/nextjs';
 
 // highlight-next-line
-const managers = [new LogoutManager(), ...getDefaultManagers()];
+const managers = () => [new LogoutManager(), ...getDefaultManagers()];
 
 export default function Provider({
   children,
@@ -124,7 +124,7 @@ import {
 import { useColorScheme } from '@/hooks/useColorScheme';
 
 // highlight-next-line
-const managers = [new LogoutManager(), ...getDefaultManagers()];
+const managers = () => [new LogoutManager(), ...getDefaultManagers()];
 
 export default function Provider({
   children,
@@ -175,7 +175,7 @@ export default function RootLayout() {
 ```ts
 import { unAuth } from '../authentication';
 
-const managers = [
+const managers = () => [
   new LogoutManager({
     handleLogout(controller) {
       // call custom unAuth function we defined
@@ -198,7 +198,7 @@ import { unAuth } from '../authentication';
 // highlight-next-line
 const testKey = (key: string) => key.startsWith(`GET ${myDomain}`);
 
-const managers = [
+const managers = () => [
   new LogoutManager({
     handleLogout(controller) {
       // call custom unAuth function we defined
diff --git a/docs/core/api/Manager.md b/docs/core/api/Manager.md
index 57fa120c4878..f0f771a0eb96 100644
--- a/docs/core/api/Manager.md
+++ b/docs/core/api/Manager.md
@@ -65,9 +65,18 @@ Provides any cleanup of dangling resources after manager is no longer in use.
 
 ## Adding managers to Reactive Data Client {#adding}
 
-Use the [managers](../api/DataProvider.md#managers) prop of [DataProvider](../api/DataProvider.md). Be
-sure to hoist to _module level_ or wrap in a _useMemo()_ to ensure they are not recreated. Managers
-have internal state, so it is important to not constantly recreate them.
+Use the [managers](../api/DataProvider.md#managers) prop of [DataProvider](../api/DataProvider.md)
+with a function that creates them. The provider calls it once when it mounts, so each store gets
+its own instances and the same definition works for the [Next.js provider](../guides/ssr.md#managers).
+
+:::note Migrating from arrays
+
+`managers` also still accepts an array of instances. This form is transitional and will be removed
+in a future release; change `managers={[...]}` to `managers={() => [...]}` when you can. Managers
+have internal state, so an array must be hoisted to _module level_ or wrapped in _useMemo()_ to
+avoid recreating them.
+
+:::
 
 <Tabs
 defaultValue="web"
@@ -85,7 +94,7 @@ values={[
 import { DataProvider, getDefaultManagers } from '@data-client/react';
 import ReactDOM from 'react-dom';
 
-const managers = [...getDefaultManagers(), new MyManager()];
+const managers = () => [...getDefaultManagers(), new MyManager()];
 
 ReactDOM.createRoot(document.body).render(
   <DataProvider managers={managers}>
@@ -102,7 +111,7 @@ ReactDOM.createRoot(document.body).render(
 import { DataProvider, getDefaultManagers } from '@data-client/react';
 import { AppRegistry } from 'react-native';
 
-const managers = [...getDefaultManagers(), new MyManager()];
+const managers = () => [...getDefaultManagers(), new MyManager()];
 
 const Root = () => (
   <DataProvider managers={managers}>
@@ -116,13 +125,16 @@ AppRegistry.registerComponent('MyApp', () => Root);
 
 <TabItem value="nextjs">
 
+The server renders every request with its own store, so the Next.js provider takes a function
+instead of instances: it runs once per request on the server and once in the browser.
+
 ```tsx title="app/Provider.tsx"
 'use client';
 import { getDefaultManagers } from '@data-client/react';
 import { DataProvider } from '@data-client/react/nextjs';
 
 // highlight-next-line
-const managers = [...getDefaultManagers(), new MyManager()];
+const managers = () => [...getDefaultManagers(), new MyManager()];
 
 export default function Provider({
   children,
@@ -160,7 +172,7 @@ import {
 import { useColorScheme } from '@/hooks/useColorScheme';
 
 // highlight-next-line
-const managers = [...getDefaultManagers(), new MyManager()];
+const managers = () => [...getDefaultManagers(), new MyManager()];
 
 export default function Provider({
   children,
diff --git a/docs/core/api/PollingSubscription.md b/docs/core/api/PollingSubscription.md
index f33adb0edf32..7790497b894f 100644
--- a/docs/core/api/PollingSubscription.md
+++ b/docs/core/api/PollingSubscription.md
@@ -25,7 +25,7 @@ import {
 } from '@data-client/react';
 import ReactDOM from 'react-dom';
 
-const managers = [
+const managers = () => [
   new NetworkManager(),
   new SubscriptionManager(PollingSubscription)
 ]
diff --git a/docs/core/api/getDefaultManagers.md b/docs/core/api/getDefaultManagers.md
index 28f3fdb665d0..324cc351479f 100644
--- a/docs/core/api/getDefaultManagers.md
+++ b/docs/core/api/getDefaultManagers.md
@@ -27,10 +27,11 @@ import {
 import ReactDOM from 'react-dom';
 
 // highlight-start
-const managers = getDefaultManagers({
-  // set fallback expiry time to an hour
-  networkManager: { dataExpiryLength: 1000 * 60 * 60 },
-});
+const managers = () =>
+  getDefaultManagers({
+    // set fallback expiry time to an hour
+    networkManager: { dataExpiryLength: 1000 * 60 * 60 },
+  });
 // highlight-end
 
 ReactDOM.createRoot(document.body).render(
@@ -86,7 +87,8 @@ A class that implements `SubscriptionConstructable` like [PollingSubscription](.
 For example, we can enable the [trace](https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md#trace) option to help track down where actions are dispatched from. This has a large performance impact, so it is normally disabled.
 
 ```ts
-const managers = getDefaultManagers({
+const managers = () =>
+  getDefaultManagers({
   // highlight-next-line
   devToolsManager: { trace: true },
 });
@@ -99,7 +101,8 @@ Sending manager instances allows us to customize managers using inheritance.
 ```ts
 import { IdlingNetworkManager } from '@data-client/react';
 
-const managers = getDefaultManagers({
+const managers = () =>
+  getDefaultManagers({
   networkManager: new IdlingNetworkManager(),
 });
 ```
@@ -112,7 +115,8 @@ until animations are complete. This works in web using [requestIdleCallback](htt
 Using `null` will remove managers completely. [NetworkManager](./NetworkManager.md) cannot be removed this way.
 
 ```ts
-const managers = getDefaultManagers({
+const managers = () =>
+  getDefaultManagers({
   devToolsManager: null,
   subscriptionManager: null,
 });
diff --git a/docs/core/concepts/managers.md b/docs/core/concepts/managers.md
index d2f0049d9308..4489764c9004 100644
--- a/docs/core/concepts/managers.md
+++ b/docs/core/concepts/managers.md
@@ -258,6 +258,7 @@ export default class PersistManager implements Manager {
 ```tsx
 import { get } from 'idb-keyval';
 
+const managers = () => [...getDefaultManagers(), new PersistManager()];
 const initialState = await get('data-client');
 
 createRoot(document.body).render(
diff --git a/docs/core/diagrams/_streamed_hydration.mdx b/docs/core/diagrams/_streamed_hydration.mdx
new file mode 100644
index 000000000000..5eae41e70b0f
--- /dev/null
+++ b/docs/core/diagrams/_streamed_hydration.mdx
@@ -0,0 +1,142 @@
+Thick-border nodes on the overview are black boxes. Each zoom opens **one** box.
+
+```mermaid
+flowchart LR
+  Baseline["Baseline<br/>shell paints now"]
+  subgraph pieces["Pieces arrive"]
+    direction TB
+    FirstFlush["First flush"]
+    NestedIsland["Nested island"]
+    LaterOverlap["Later overlap"]
+  end
+  Hydrate["Island hydrates"]
+  Subscribe["Subscribe for live updates"]
+  Insertion["RSC vs renderToPipeableStream"]
+
+  Baseline --> pieces
+  Insertion -.-> pieces
+  pieces --> Hydrate
+  Hydrate --> Subscribe
+
+  style FirstFlush stroke-width:3px
+  style NestedIsland stroke-width:3px
+  style LaterOverlap stroke-width:3px
+  style Hydrate stroke-width:3px
+  style Insertion stroke-width:3px
+```
+
+| Piece | Server revision | Endpoints in the piece | Entities | Who hydrates from it |
+| --- | --- | --- | --- | --- |
+| **Baseline** | empty request store | — | — | nobody; shell only |
+| **First flush** | one flush, two islands | `getTickers`, `getSymbolInfo(BTC)` | `Ticker:BTC`, `Ticker:ETH`, `Symbol:BTC` | Watchlist + SymbolHeader |
+| **Nested island** | nested child first | `getTrades(BTC)` | `Trade:…` | Tape, before parent Book exists |
+| **Later overlap** | disjoint parent later | `getOrderBook(BTC)` | `Book:BTC`, plus `Ticker:BTC` again (constructed nested ticker) | Book; live three-way merge vs tick |
+
+### Island hydrates
+
+Opens **Island hydrates**. Shared path for every piece.
+
+```mermaid
+flowchart TB
+  Server["Request store"]
+  Baseline["Baseline"]
+  Delta["StateDelta"]
+  Snapshot["Hydration snapshot"]
+  LiveStore["Live store"]
+  Island["Island"]
+  SubMgr["SubscriptionManager"]
+
+  Server --> Baseline
+  Server --> Delta
+  Baseline -->|"seed once"| Snapshot
+  Delta -->|"fold this piece"| Snapshot
+  Snapshot -->|"HYDRATE"| LiveStore
+  Island -->|"useSuspense"| Snapshot
+  Snapshot -->|"cache hit"| Island
+  Island -->|"after commit SUBSCRIBE"| SubMgr
+  SubMgr -->|"ticks"| LiveStore
+```
+
+### First flush
+
+Opens **First flush**. One server revision, two islands, one `StateDelta`.
+
+```mermaid
+flowchart LR
+  Revision["One server revision"]
+  Delta["One StateDelta"]
+  Watchlist["Watchlist<br/>getTickers"]
+  SymbolHeader["SymbolHeader<br/>getSymbolInfo"]
+  Market["Market still pending"]
+
+  Revision -->|"SET_RESPONSE ×2"| Delta
+  Delta --> Watchlist
+  Delta --> SymbolHeader
+  Watchlist -.-> Market
+  SymbolHeader -.-> Market
+```
+
+### Nested island
+
+Opens **Nested island**. Tree order is not stream order.
+
+```mermaid
+flowchart TB
+  Market["Market"]
+  Book["Book — still pending"]
+  Tape["Tape / Trades"]
+  Delta["Trades StateDelta"]
+
+  Market --- Book
+  Market --- Tape
+  Delta --> Tape
+```
+
+### Later overlap
+
+Opens **Later overlap**. A later disjoint piece writes an entity the first flush already put in the store.
+
+```mermaid
+flowchart LR
+  FirstFlush["First flush wrote Ticker:BTC"]
+  LiveTick["Live tick may already own that slot"]
+  BookPiece["Later book piece writes Book:BTC<br/>and Ticker:BTC again"]
+  Merge["Three-way merge"]
+  LiveStore["Live store"]
+
+  FirstFlush --> LiveStore
+  FirstFlush --> LiveTick
+  LiveTick --> Merge
+  BookPiece --> Merge
+  Merge --> LiveStore
+```
+
+### RSC vs renderToPipeableStream
+
+Opens **RSC vs renderToPipeableStream**. Two clocks, not two products.
+
+```mermaid
+flowchart TB
+  subgraph htmlStream["Streaming HTML"]
+    Insert["useServerInsertedHTML"]
+    RTP["renderToPipeableStream"]
+    Chunk["HTML chunk<br/>baseline, then StateDelta + island markup"]
+    Insert -->|"Next App Router"| Chunk
+    RTP -->|"state piece colocated<br/>with the revealing Suspense"| Chunk
+  end
+  subgraph rsc["RSC"]
+    Payload["RSC payload"]
+    Client["Client Component can start<br/>before the HTML delta runs"]
+    Payload --> Client
+  end
+  Snapshot["Hydration snapshot"]
+  Chunk --> Snapshot
+  Client -->|"useSuspense"| Snapshot
+```
+
+| Wire | Host | How a piece gets on the wire | What it cannot promise |
+| --- | --- | --- | --- |
+| **Streaming HTML + RSC** | `@data-client/react/nextjs` | `useServerInsertedHTML()` writes the inert baseline, then a `StateDelta` script per flush, into the **HTML** stream | It cannot order that script against **RSC**. A Client Component may start before the delta that describes it has executed. |
+| **`renderToPipeableStream`** | `@data-client/react/ssr` (Express, Anansi) | Intended: a state-piece colocated in the revealing Suspense/island so React emits the delta and the dependent markup as one ordered subtree | Not shipped in this release — generic `/ssr` remains a one-shot snapshot. Parser/hydration order is still not a contract. |
+
+The figures are the **intended** client clock. This release does not throw per-key waiters or fold independently of the receiver layout effect.
diff --git a/docs/core/getting-started/debugging.md b/docs/core/getting-started/debugging.md
index 9d8e40914114..706e1545b6ce 100644
--- a/docs/core/getting-started/debugging.md
+++ b/docs/core/getting-started/debugging.md
@@ -134,10 +134,11 @@ import {
 } from '@data-client/react';
 import ReactDOM from 'react-dom';
 
-const managers = getDefaultManagers({
-  // highlight-next-line
-  devToolsManager: { trace: true },
-});
+const managers = () =>
+  getDefaultManagers({
+    // highlight-next-line
+    devToolsManager: { trace: true },
+  });
 
 ReactDOM.createRoot(document.body).render(
   <DataProvider managers={managers}>
diff --git a/docs/core/guides/ssr.md b/docs/core/guides/ssr.md
index e3dda2158484..e58d8ad8522e 100644
--- a/docs/core/guides/ssr.md
+++ b/docs/core/guides/ssr.md
@@ -6,6 +6,7 @@ sidebar_label: Server Side Rendering
 
 import PkgTabs from '@site/src/components/PkgTabs';
 import StackBlitz from '@site/src/components/StackBlitz';
+import StreamedHydration from '../diagrams/\_streamed_hydration.mdx';
 
 <head>
   <meta name="docsearch:pagerank" content="10"/>
@@ -18,6 +19,44 @@ Client takes this one step further by pre-populating the data store. Unlike othe
 Reactive Data Client becomes interactive the moment the page is visible, making [data mutations](../getting-started/mutations.md) instantaneous. Additionally there is no need for additional data fetches that increase server
 load and slow client hydration, potentially causing application stutters.
 
+## Incremental streamed hydration {#streamed-hydration}
+
+The store is not a second document that waits for the page. It is the same stream, in generations:
+
+1. The shell carries an **inert baseline**. First paint is not delayed for Data Client.
+2. Each later committed server revision emits a **StateDelta**. The Next.js adapter folds queued pieces into its own snapshot and publishes them into the live store from the receiver layout effect. Public [`DataProvider`](../api/DataProvider.md) reads stay on [`StateContext`](../api/DataProvider.md); streaming is adapter-owned.
+3. Several islands that finish in one flush share one delta. A nested child may become readable before its parent. A later island may write an entity already present from an earlier delta; the three-way merge keeps slots the client already changed.
+4. If that fold has already happened, [`useSuspense()`](../api/useSuspense.md) hits. If **RSC** starts the island first, a miss fetches like any client render.
+5. After the island commits, [`useLive()`](../api/useLive.md) / [`useSubscription()`](../api/useSubscription.md) dispatch [`SUBSCRIBE`](../api/Actions.md#subscribe) so WebSocket or polling may start. Subscription is not proof the server delta arrived.
+
+Next.js App Router emits this protocol. Pages Router (`@data-client/ssr/nextjs`) and generic `@data-client/react/ssr` (Express, Anansi, [`renderToPipeableStream`](https://react.dev/reference/react-dom/server/renderToPipeableStream)) remain a one-shot document snapshot, plus an unstable internal composition seam for hosts that already own a snapshot store.
+
+[`useServerInsertedHTML()`](https://nextjs.org/docs/app/api-reference/functions/use-server-inserted-html) writes into the **HTML** stream. It does not order **RSC**. A Client Component may start before its delta script runs and before the receiver layout effect. Script-before-HTML is insertion order, not a zero-refetch guarantee.
+
+```
+MarketPage
+├── Shell                         provider, chrome — no Data Client read
+├── Watchlist                     useLive(getTickers)
+├── SymbolHeader                  useLive(getSymbolInfo, { symbol: 'BTC' })
+└── Market                        Suspense (late)
+    ├── Book                      useLive(getOrderBook, { symbol: 'BTC' })
+    └── Tape                      nested Suspense
+        └── Trades                useLive(getTrades, { symbol: 'BTC' })
+```
+
+The figures below are **one concept each**: an overview with black boxes, then a zoom that opens that box. They describe the **intended** client clock (per-key waiters and fold-on-script). This release ships the wire (baseline + `StateDelta`) and an adapter-owned receiver. Live publication is still per-delta from a layout effect.
+
+<StreamedHydration/>
+
+### Open questions {#streamed-hydration-open}
+
+- **Per-key waiters** and **fold-on-script-arrival** (independent of `StreamedStateReceiver`’s layout effect) remain future client-clock work. Until they land, an RSC-first miss fetches like any client render.
+- A render-pure way for a progressively revealed island to read the server revision it was rendered from, without a live `StateContext` identity change that client-renders still-pending siblings, is not shipped.
+- Per-delta live publication (`flushSync` plus a live store write) is preserved adapter behavior, not the concurrent happy path.
+- Streamed deltas write whole entity/meta slots without schema merge (`writeDelta`). Overlay of a snapshot onto live state does not compare `lastReset`.
+- Incremental baseline-plus-delta for generic `renderToPipeableStream` / Anansi is not a stable public API. `@data-client/react/ssr` keeps one-shot helpers; hosts can compose an unstable internal `StreamingDataProvider` if they already own a snapshot store.
+- A document-wide [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event) wait is an acceptable interim, not the long-term contract. Missing-baseline still suspends while the document is loading.
+
 ## NextJS SSR {#nextjs}
 
 ### App Router
@@ -50,6 +89,101 @@ export default function RootLayout({ children }) {
 }
 ```
 
+Async Server Components anywhere between the provider and your Client Components are fine.
+Each committed server revision emits a `StateDelta` that the Next.js adapter folds into its
+snapshot and publishes into the live store from the receiver layout effect. HTML insertion
+order is not an RSC clock: a Client Component may start before its delta script runs, and a
+miss then fetches like any client render.
+
+```tsx title="app/[userId]/layout.tsx"
+export default async function UserLayout({ children, params }) {
+  // resolves after the shell has already been sent
+  const { userId } = await params;
+  return <section data-user={userId}>{children}</section>;
+}
+```
+
+#### Props
+
+```typescript
+interface NextDataProviderProps {
+  children: ReactNode;
+  managers?: () => Manager[];
+  nonce?: string;
+  Controller?: typeof Controller;
+  gcPolicy?: GCInterface;
+  devButton?: DevToolsPosition | null;
+}
+```
+
+`Controller` applies on both server and client. `gcPolicy` applies in the browser only: a
+request-scoped server store has nothing to collect.
+
+##### managers {#managers}
+
+The server builds a store per request, so [Managers](../api/Manager.md) must be created per
+request as well. It takes a **function**, called once per
+request on the server and once in the browser (the [browser DataProvider](../api/DataProvider.md#managers)
+accepts the same function; its array form is transitional):
+
+```tsx title="app/Provider.tsx"
+'use client';
+import { getDefaultManagers } from '@data-client/react';
+import { DataProvider } from '@data-client/react/nextjs';
+
+// highlight-next-line
+const managers = () => [...getDefaultManagers(), new MyManager()];
+
+export default function Provider({ children }: { children: React.ReactNode }) {
+  return <DataProvider managers={managers}>{children}</DataProvider>;
+}
+```
+
+Manager instances shared across requests would mix up users' data, so an array is rejected.
+Server-side managers should not hold resources: their `cleanup()` is not run per request.
+
+##### nonce {#nonce}
+
+State is streamed in inline `<script>` tags. When your
+[Content Security Policy](https://nextjs.org/docs/app/guides/content-security-policy) requires
+a nonce, pass it through:
+
+```tsx title="app/layout.tsx"
+import { headers } from 'next/headers';
+import { DataProvider } from '@data-client/react/nextjs';
+
+export default async function RootLayout({ children }) {
+  const nonce = (await headers()).get('x-nonce') ?? undefined;
+  return (
+    <html>
+      <body>
+        <DataProvider nonce={nonce}>{children}</DataProvider>
+      </body>
+    </html>
+  );
+}
+```
+
+#### Limitations
+
+- Use one `DataProvider` per document. Nested or sibling providers share the same streamed state.
+- Only the initial document is transferred. Client-side navigations and `router.refresh()` fetch
+  in the browser like any client render.
+- With [Partial Prerendering](https://nextjs.org/docs/app/getting-started/partial-prerendering) the
+  static shell's state is transferred; data fetched while resuming dynamic holes is fetched again
+  in the browser.
+- If the same entity is returned with different data by two requests during one render, the
+  browser hydrates with the latest one. Boundaries rendered from the earlier value are re-rendered
+  by React (a recoverable hydration mismatch in development). Likewise, data the browser fetched on
+  its own during streaming fills in anything the server never sent or removed, so a boundary the
+  server rendered without that data is re-rendered with it.
+- On React 18 (including the version bundled with Next.js 13 and 14), a store update while a
+  boundary is still hydrating - a streamed delta, a WebSocket manager, a mutation - can make React
+  client-render that boundary. The data is still correct and nothing is refetched, but the server
+  DOM nodes are replaced. React 19 keeps them and hydrates at a matching priority instead.
+- App-owned requests that bypass [`useSuspense()`](../api/useSuspense.md) (for example a direct
+  depth snapshot to resync WebSocket sequence numbers) are out of this contract.
+
 #### Client Components
 
 To keep your data fresh and performant, you can use client components and [useSuspense()](../api/useSuspense.md)
@@ -104,6 +238,9 @@ class User extends Entity {
 
 ### Pages Router
 
+Pages Router remains a one-shot document snapshot via `@data-client/ssr/nextjs`. It does not use
+the incremental baseline-plus-delta protocol above.
+
 With NextJS &lt; 14, you might be using the pages router. For this we have [Document](https://nextjs.org/docs/advanced-features/custom-document)
 and NextJS specific wrapper for [App](https://nextjs.org/docs/advanced-features/custom-app)
 
@@ -213,6 +350,11 @@ export default class MyDocument extends DataClientDocument {
 
 ## Express JS SSR
 
+Generic `@data-client/react/ssr` (Express, Anansi) remains a **one-shot** document snapshot.
+Incremental baseline-plus-delta is the Next.js App Router path in this release. Hosts that
+already own a snapshot store can compose the extra reducer through the unstable
+`__INTERNAL__.StreamingDataProvider` export; that is not a stable public component.
+
 When implementing your own server using express.
 
 ### Server side
diff --git a/examples/nextjs/README.md b/examples/nextjs/README.md
index ecb9e4a6be49..76fed8870f42 100644
--- a/examples/nextjs/README.md
+++ b/examples/nextjs/README.md
@@ -10,6 +10,28 @@ npm run dev
 
 Open [http://localhost:3000](http://localhost:3000) to see the result.
 
+## Verifying the streamed store
+
+The store hydrates incrementally: an inert baseline, then a `StateDelta` per committed server
+revision. A late island hydrates at **its** generation when that piece is already folded.
+RSC may start a Client Component before the HTML delta; script-before-HTML is not a
+zero-refetch guarantee. See the
+[SSR guide](https://dataclient.io/docs/guides/ssr#streamed-hydration) for what ships.
+
+`app/[userId]/page.tsx` waits 50ms before rendering its Client Component. The curl below is a
+**wire check** (baseline and a delta appear in the HTML stream), not the hydration contract:
+
+```bash
+npm run build && npm run start &
+curl --no-buffer -s http://localhost:3000/1 | grep -o 'data-client-data\|__DATA_CLIENT_DELTAS__\|delectus aut autem' | uniq
+```
+
+The baseline (`data-client-data`) and a delta script (`__DATA_CLIENT_DELTAS__`) are printed before
+the first todo title. Script-before-HTML does not by itself mean zero client requests.
+
+To try a local checkout of `@data-client/react`, run `yarn workspace @data-client/react pack` in the
+repository root and point this app's `package.json` at the resulting tarball.
+
 ## Stackblitz
 
 [Preview this demo in your browser](https://stackblitz.com/github/reactive/data-client/tree/master/examples/nextjs?file=components%2Ftodo%2FTodoList.tsx)
@@ -19,6 +41,7 @@ Open [http://localhost:3000](http://localhost:3000) to see the result.
 To learn more about running Data Client with Next.js, take a look at the following resources:
 
 - [NextJS + Reactive Data Client guide](https://dataclient.io/docs/guides/ssr#nextjs)
+- [Incremental streamed hydration](https://dataclient.io/docs/guides/ssr#streamed-hydration)
 - [Data Client Resources](https://dataclient.io/docs/getting-started/resource) - definining TypeSafe APIs.
 - [Data Dependencies](https://dataclient.io/docs/getting-started/data-dependency) - fetch & rendering data in ReactJS components.
 - [Reactive Mutations](https://dataclient.io/docs/getting-started/mutations) - building interactive data driven applications.
diff --git a/examples/nextjs/app/[userId]/page.tsx b/examples/nextjs/app/[userId]/page.tsx
index 062c8d34d399..55a5daacd8c4 100644
--- a/examples/nextjs/app/[userId]/page.tsx
+++ b/examples/nextjs/app/[userId]/page.tsx
@@ -4,5 +4,9 @@ export default async function TodoPage(props: {
   params: Promise<{ userId: string }>;
 }) {
   const params = await props.params;
+  // Stands in for slow server work (auth, a database call) between the root
+  // DataProvider and the Client Components below. The state TodoList fetches
+  // still streams to the browser ahead of the HTML rendered from it.
+  await new Promise(resolve => setTimeout(resolve, 50));
   return <TodoList userId={Number(params.userId)} />;
 }
diff --git a/jest.config.js b/jest.config.js
index 1dab51d128b7..4348c6a6b649 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -22,6 +22,8 @@ const baseConfig = {
     'cjs',
     'json',
   ],
+  // helpers shared by tests live next to them without being suites
+  testPathIgnorePatterns: ['/node_modules/', '/__tests__/fixtures/'],
   coveragePathIgnorePatterns: [
     'node_modules',
     '/__tests__',
@@ -39,6 +41,7 @@ const baseConfig = {
   /** TODO: Remove once we move to 'publishConfig' */
   moduleNameMapper: {
     '^__tests__/(.*)$': '<rootDir>/__tests__/$1',
+    '^@data-client/react/ssr$': '<rootDir>/packages/react/src/server',
     '@data-client/react/redux$': ['<rootDir>/packages/react/src/server/redux'],
     '@data-client/([^/]+)(/.*|[^/]*)$': ['<rootDir>/packages/$1/src$2'],
   },
diff --git a/packages/core/src/actions.ts b/packages/core/src/actions.ts
index 840304ef871b..aeb0a908aa00 100644
--- a/packages/core/src/actions.ts
+++ b/packages/core/src/actions.ts
@@ -21,6 +21,9 @@ import type {
   SET_RESPONSE,
 } from './actionTypes.js';
 import type { EndpointUpdateFunction } from './controller/types.js';
+import type { StateBaseline, StateDelta } from './state/stream/types.js';
+
+export type { StateDelta, StateBaseline } from './state/stream/types.js';
 
 type EndpointAndUpdate<E extends EndpointInterface> = EndpointInterface & {
   update?: EndpointUpdateFunction<E>;
diff --git a/packages/core/src/internal.ts b/packages/core/src/internal.ts
index dd10abf9e764..5cb78f8c656d 100644
--- a/packages/core/src/internal.ts
+++ b/packages/core/src/internal.ts
@@ -1,2 +1,12 @@
 export { MemoCache, INVALID } from '@data-client/normalizr';
-export { initialState } from './state/reducer/createReducer.js';
+export { initialState } from './state/reducer/initialState.js';
+export {
+  diffState,
+  applyStateDelta,
+  selectBaseline,
+  HYDRATE,
+  createHydrate,
+  hydrateReducer,
+  overlayState,
+} from './state/stream/index.js';
+export type { HydrateAction } from './state/stream/index.js';
diff --git a/packages/core/src/state/__tests__/stream.ts b/packages/core/src/state/__tests__/stream.ts
new file mode 100644
index 000000000000..7f991cc98771
--- /dev/null
+++ b/packages/core/src/state/__tests__/stream.ts
@@ -0,0 +1,390 @@
+import {
+  ArticleResource,
+  CoolerArticleResource,
+  IndexedUserResource,
+} from '__tests__/new';
+
+import { Controller } from '../..';
+import { GC } from '../../actionTypes';
+import {
+  createInvalidate,
+  createReset,
+  createSetResponse,
+} from '../../controller/actions';
+import type { State, StateDelta } from '../../types';
+import createReducer, { initialState } from '../reducer/createReducer';
+import {
+  applyStateDelta,
+  createHydrate,
+  diffState,
+  hydrateReducer,
+  mergeStateDelta,
+  overlayState,
+  selectBaseline,
+  HYDRATE,
+} from '../stream';
+
+/** What a JSON transport can carry: no `optimistic`, no `undefined` */
+const serializable = (state: State<unknown>) =>
+  JSON.parse(JSON.stringify({ ...state, optimistic: undefined }));
+
+/** Round trip through JSON like the browser receives it */
+const transport = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+
+describe('state streaming', () => {
+  const reducer = createReducer(new Controller());
+  const article = { id: 5, title: 'hi', content: 'body', tags: ['a'] };
+  const setArticle = createSetResponse(ArticleResource.get, {
+    args: [{ id: 5 }],
+    response: article,
+    fetchedAt: 1000,
+  });
+  const setOther = createSetResponse(ArticleResource.get, {
+    args: [{ id: 6 }],
+    response: { ...article, id: 6, title: 'other' },
+    fetchedAt: 2000,
+  });
+  const s1 = reducer(initialState, setArticle);
+  const s2 = reducer(s1, setOther);
+
+  describe('diffState + applyStateDelta', () => {
+    it('returns null when nothing changed', () => {
+      expect(diffState(initialState, initialState)).toBeNull();
+      expect(diffState(s1, s1)).toBeNull();
+    });
+
+    it('fold of the delta equals the serializable projection of state', () => {
+      const delta = diffState(initialState, s1);
+      expect(delta).not.toBeNull();
+      const folded = applyStateDelta(initialState, delta!);
+      expect(serializable(folded)).toEqual(serializable(s1));
+      expect(folded.optimistic).toEqual([]);
+    });
+
+    it('shares leaf references with the state it was produced from', () => {
+      const delta = diffState(initialState, s1)!;
+      const folded = applyStateDelta(initialState, delta);
+      const key = setArticle.key;
+      expect(folded.entities.Article!['5']).toBe(s1.entities.Article!['5']);
+      expect(folded.entitiesMeta.Article['5']).toBe(
+        s1.entitiesMeta.Article['5'],
+      );
+      expect(folded.endpoints[key]).toBe(s1.endpoints[key]);
+      expect(folded.meta[key]).toBe(s1.meta[key]);
+    });
+
+    it('only encodes slots that changed since the last emission', () => {
+      const emitted = applyStateDelta(
+        initialState,
+        diffState(initialState, s1)!,
+      );
+      const delta = diffState(emitted, s2)!;
+      expect(delta.entities.map(c => c.pk)).toEqual(['6']);
+      expect(delta.endpoints.map(c => c.key)).toEqual([setOther.key]);
+      expect(delta.reset).toBeUndefined();
+      expect(serializable(applyStateDelta(emitted, delta))).toEqual(
+        serializable(s2),
+      );
+    });
+
+    it('is idempotent', () => {
+      const delta = transport(diffState(s1, s2)!);
+      const once = applyStateDelta(s1, delta);
+      const twice = applyStateDelta(once, delta);
+      expect(serializable(twice)).toEqual(serializable(once));
+    });
+
+    it('encodes endpoint removal from invalidate while keeping its meta', () => {
+      const invalidated = reducer(
+        s1,
+        createInvalidate(ArticleResource.get, { args: [{ id: 5 }] }),
+      );
+      const delta = diffState(s1, invalidated)!;
+      expect(delta.entities).toEqual([]);
+      expect(delta.endpoints).toEqual([
+        {
+          key: setArticle.key,
+          value: { meta: invalidated.meta[setArticle.key] },
+        },
+      ]);
+      const folded = applyStateDelta(s1, transport(delta));
+      expect(folded.endpoints).not.toHaveProperty(setArticle.key);
+      expect(folded.meta[setArticle.key].invalidated).toBe(true);
+    });
+
+    it('detects in-place GC deletions when the emitted snapshot is owned', () => {
+      // GC mutates state in place, so an emitted snapshot that aliased
+      // `state` would never see the removal.
+      const server = reducer(s1, setOther);
+      const emitted = applyStateDelta(
+        initialState,
+        diffState(initialState, server)!,
+      );
+      const collected = reducer(server, {
+        type: GC,
+        entities: [{ key: 'Article', pk: '6' }],
+        endpoints: [setOther.key],
+      });
+      expect(collected).toBe(server);
+      const delta = diffState(emitted, collected)!;
+      expect(delta.entities).toEqual([{ key: 'Article', pk: '6' }]);
+      expect(delta.endpoints).toEqual([{ key: setOther.key }]);
+      const folded = applyStateDelta(emitted, transport(delta));
+      expect(folded.entities.Article).not.toHaveProperty('6');
+      expect(folded.entitiesMeta.Article).not.toHaveProperty('6');
+      expect(folded.endpoints).not.toHaveProperty(setOther.key);
+      expect(folded.meta).not.toHaveProperty(setOther.key);
+    });
+
+    it('encodes a reset as a restart from an empty store', () => {
+      const reset = reducer(s2, createReset());
+      const afterReset = reducer(reset, setOther);
+      const delta = diffState(s2, afterReset)!;
+      expect(delta.reset).toBe(afterReset.lastReset);
+      expect(delta.entities.map(c => c.pk)).toEqual(['6']);
+      const folded = applyStateDelta(s2, transport(delta));
+      expect(serializable(folded)).toEqual(serializable(afterReset));
+      expect(folded.entities.Article).not.toHaveProperty('5');
+    });
+
+    it('encodes index tables', () => {
+      const setUser = createSetResponse(IndexedUserResource.get, {
+        args: [{ id: 1 }],
+        response: { id: 1, username: 'bob' },
+      });
+      const withUser = reducer(initialState, setUser);
+      const delta = diffState(initialState, withUser)!;
+      expect(delta.indexes).toEqual([
+        { key: 'IndexedUser', index: 'username', value: { bob: '1' } },
+      ]);
+      const folded = applyStateDelta(initialState, transport(delta));
+      expect(folded.indexes.IndexedUser.username.bob).toBe('1');
+      const removed = applyStateDelta(folded, {
+        entities: [],
+        endpoints: [],
+        indexes: [{ key: 'IndexedUser', index: 'username' }],
+      });
+      expect(removed.indexes.IndexedUser).toEqual({});
+    });
+
+    it('does not carry optimistic actions', () => {
+      const withOptimistic: State<unknown> = {
+        ...s1,
+        optimistic: [setOther],
+      };
+      const delta = diffState(initialState, withOptimistic)!;
+      expect(JSON.stringify(delta)).not.toContain('optimistic');
+      expect(applyStateDelta(initialState, delta).optimistic).toEqual([]);
+    });
+  });
+
+  describe('mergeStateDelta', () => {
+    const delta = transport(diffState(s1, s2)!);
+
+    it('takes every slot the client has not touched', () => {
+      const baseline = selectBaseline(s1, delta);
+      const merged = mergeStateDelta(s1, delta, baseline);
+      expect(serializable(merged)).toEqual(serializable(s2));
+      expect(merged.entities.Article!['5']).toBe(s1.entities.Article!['5']);
+    });
+
+    it('keeps slots the client changed since the baseline', () => {
+      const baseline = selectBaseline(s1, delta);
+      const clientArticle = { ...article, id: 6, title: 'client wins' };
+      const live = reducer(
+        s1,
+        createSetResponse(ArticleResource.get, {
+          args: [{ id: 6 }],
+          response: clientArticle,
+          fetchedAt: 3000,
+        }),
+      );
+      const merged = mergeStateDelta(live, delta, baseline);
+      expect((merged.entities.Article!['6'] as any).title).toBe('client wins');
+      expect(merged.endpoints[setOther.key]).toBe(live.endpoints[setOther.key]);
+      expect(merged.meta[setOther.key]).toBe(live.meta[setOther.key]);
+    });
+
+    it('treats an entity and its meta as one slot', () => {
+      const baseline = selectBaseline(s1, delta);
+      const live: State<unknown> = {
+        ...s1,
+        entities: {
+          ...s1.entities,
+          Article: { ...s1.entities.Article, 6: { id: 6, title: 'touched' } },
+        },
+      };
+      const merged = mergeStateDelta(live, delta, baseline);
+      expect((merged.entities.Article!['6'] as any).title).toBe('touched');
+      expect(merged.entitiesMeta.Article['6']).toBeUndefined();
+    });
+
+    it('applies removals under the same rule', () => {
+      const removal: StateDelta = {
+        entities: [{ key: 'Article', pk: '6' }],
+        endpoints: [],
+        indexes: [],
+      };
+      const withSix = applyStateDelta(s1, delta);
+      const baseline = selectBaseline(withSix, removal);
+      expect(
+        mergeStateDelta(withSix, removal, baseline).entities.Article,
+      ).not.toHaveProperty('6');
+
+      const touched: State<unknown> = {
+        ...withSix,
+        entities: {
+          ...withSix.entities,
+          Article: { ...withSix.entities.Article, 6: { id: 6 } },
+        },
+      };
+      expect(
+        mergeStateDelta(touched, removal, baseline).entities.Article,
+      ).toHaveProperty('6');
+    });
+
+    it('a reset delta replaces client state', () => {
+      const reset = reducer(s2, createReset());
+      const afterReset = reducer(reset, setOther);
+      const resetDelta = transport(diffState(s2, afterReset)!);
+      const baseline = selectBaseline(s2, resetDelta);
+      const merged = mergeStateDelta(s2, resetDelta, baseline);
+      expect(merged.lastReset).toBe(afterReset.lastReset);
+      expect(merged.entities.Article).not.toHaveProperty('5');
+      expect(merged.entities.Article).toHaveProperty('6');
+    });
+
+    it('returns the same state when nothing is taken', () => {
+      const baseline = selectBaseline(initialState, delta);
+      // every slot differs from an empty baseline
+      expect(mergeStateDelta(s2, delta, baseline)).toBe(s2);
+    });
+  });
+
+  describe('selectBaseline', () => {
+    it('picks current values of the changed slots only', () => {
+      const delta = diffState(s1, s2)!;
+      const baseline = selectBaseline(s1, delta);
+      expect(baseline.lastReset).toBe(s1.lastReset);
+      expect(baseline.entities).toEqual({});
+      expect(baseline.endpoints).toEqual({});
+      const back = selectBaseline(s2, diffState(s2, s1)!);
+      expect(back.entities.Article!['6']).toBe(s2.entities.Article!['6']);
+      expect(back.entities.Article).not.toHaveProperty('5');
+      expect(back.endpoints[setOther.key]).toBe(s2.endpoints[setOther.key]);
+    });
+  });
+
+  describe('overlayState', () => {
+    it('prefers snapshot slots and falls back to live for the rest', () => {
+      const live = reducer(
+        s1,
+        createSetResponse(ArticleResource.get, {
+          args: [{ id: 5 }],
+          response: { ...article, title: 'client' },
+          fetchedAt: 9000,
+        }),
+      );
+      const view = overlayState(s1, reducer(live, setOther));
+      // server value wins where it exists
+      expect(view.entities.Article!['5']).toBe(s1.entities.Article!['5']);
+      expect(view.meta[setArticle.key]).toBe(s1.meta[setArticle.key]);
+      // live fills in what the server never sent
+      expect((view.entities.Article!['6'] as any).title).toBe('other');
+      expect(view.endpoints[setOther.key]).toBe('6');
+    });
+
+    it('returns live itself when the snapshot is live', () => {
+      expect(overlayState(s1, s1)).toBe(s1);
+    });
+
+    it('keeps live-only tables and adds snapshot-only tables', () => {
+      const setUser = createSetResponse(IndexedUserResource.get, {
+        args: [{ id: 1 }],
+        response: { id: 1, username: 'bob' },
+      });
+      const live = reducer(initialState, setUser);
+      const view = overlayState(s1, live);
+      expect(view.entities.IndexedUser).toBe(live.entities.IndexedUser);
+      expect(view.indexes.IndexedUser).toBe(live.indexes.IndexedUser);
+      expect(view.entities.Article).toEqual(s1.entities.Article);
+    });
+  });
+
+  describe('prototype safety', () => {
+    const hostile = transport({
+      entities: [
+        {
+          key: '__proto__',
+          pk: 'polluted',
+          value: { entity: { polluted: true } },
+        },
+        {
+          key: 'Article',
+          pk: '__proto__',
+          value: { entity: { polluted: true } },
+        },
+      ],
+      endpoints: [
+        { key: '__proto__', value: { endpoint: { polluted: true } } },
+      ],
+      indexes: [{ key: '__proto__', index: 'x', value: { a: 'b' } }],
+    });
+
+    it('ignores changes that would alter prototypes', () => {
+      const folded = applyStateDelta(s1, hostile);
+      expect(folded).toBe(s1);
+      expect(({} as any).polluted).toBeUndefined();
+      expect(Object.getPrototypeOf(folded.entities)).toBe(Object.prototype);
+      const merged = mergeStateDelta(s1, hostile, selectBaseline(s1, hostile));
+      expect(merged).toBe(s1);
+      expect(selectBaseline(s1, hostile).entities).toEqual({});
+    });
+  });
+
+  describe('hydrateReducer', () => {
+    const delta = transport(diffState(s1, s2)!);
+
+    it('merges when the client has not reset', () => {
+      const action = createHydrate(delta, selectBaseline(s1, delta));
+      expect(action.type).toBe(HYDRATE);
+      const next = hydrateReducer(s1, action);
+      expect(serializable(next)).toEqual(serializable(s2));
+    });
+
+    it('ignores deltas after the client reset', () => {
+      const live = reducer(s1, createReset());
+      const next = hydrateReducer(
+        live,
+        createHydrate(delta, selectBaseline(s1, delta)),
+      );
+      expect(next).toBe(live);
+    });
+
+    it('applies a server reset', () => {
+      const afterReset = reducer(reducer(s2, createReset()), setOther);
+      const resetDelta = transport(diffState(s2, afterReset)!);
+      const next = hydrateReducer(
+        s2,
+        createHydrate(resetDelta, selectBaseline(s2, resetDelta)),
+      );
+      expect(serializable(next)).toEqual(serializable(afterReset));
+    });
+
+    it('is handled without schemas', () => {
+      const setCooler = createSetResponse(CoolerArticleResource.get, {
+        args: [{ id: 7 }],
+        response: { id: 7, title: 'cool', content: '', tags: [] },
+      });
+      const server = reducer(initialState, setCooler);
+      const wire = transport(diffState(initialState, server)!);
+      const client = hydrateReducer(
+        initialState,
+        createHydrate(wire, selectBaseline(initialState, wire)),
+      );
+      expect(client.entities.CoolerArticle!['7']).toEqual(
+        transport(server.entities.CoolerArticle!['7']),
+      );
+    });
+  });
+});
diff --git a/packages/core/src/state/reducer/createReducer.ts b/packages/core/src/state/reducer/createReducer.ts
index 45411c37139a..ab790f43342a 100644
--- a/packages/core/src/state/reducer/createReducer.ts
+++ b/packages/core/src/state/reducer/createReducer.ts
@@ -1,5 +1,6 @@
 import { expireReducer } from './expireReducer.js';
 import { fetchReducer } from './fetchReducer.js';
+import { initialState } from './initialState.js';
 import { invalidateReducer } from './invalidateReducer.js';
 import { setReducer } from './setReducer.js';
 import { setResponseReducer } from './setResponseReducer.js';
@@ -17,6 +18,8 @@ import {
 import type Controller from '../../controller/Controller.js';
 import type { ActionTypes, State } from '../../types.js';
 
+export { initialState };
+
 export default function createReducer(controller: Controller): ReducerType {
   return function reducer(
     state: State<unknown> | undefined,
@@ -64,16 +67,6 @@ export default function createReducer(controller: Controller): ReducerType {
   } as any;
 }
 
-export const initialState: State<unknown> = {
-  entities: {},
-  endpoints: {},
-  indexes: {},
-  meta: {},
-  entitiesMeta: {},
-  optimistic: [],
-  lastReset: 0,
-};
-
 type ReducerType = (
   state: State<unknown> | undefined,
   action: ActionTypes,
diff --git a/packages/core/src/state/reducer/initialState.ts b/packages/core/src/state/reducer/initialState.ts
new file mode 100644
index 000000000000..7ee0b7375f17
--- /dev/null
+++ b/packages/core/src/state/reducer/initialState.ts
@@ -0,0 +1,11 @@
+import type { State } from '../../types.js';
+
+export const initialState: State<unknown> = {
+  entities: {},
+  endpoints: {},
+  indexes: {},
+  meta: {},
+  entitiesMeta: {},
+  optimistic: [],
+  lastReset: 0,
+};
diff --git a/packages/core/src/state/stream/applyStateDelta.ts b/packages/core/src/state/stream/applyStateDelta.ts
new file mode 100644
index 000000000000..9c00d2f6cbc1
--- /dev/null
+++ b/packages/core/src/state/stream/applyStateDelta.ts
@@ -0,0 +1,11 @@
+import type { StateDelta } from './types.js';
+import { writeDelta } from './writeDelta.js';
+import type { State } from '../../types.js';
+
+/** Folds a streamed delta into a snapshot, taking every change */
+export function applyStateDelta(
+  snapshot: State<unknown>,
+  delta: StateDelta,
+): State<unknown> {
+  return writeDelta(snapshot, delta);
+}
diff --git a/packages/core/src/state/stream/createHydrate.ts b/packages/core/src/state/stream/createHydrate.ts
new file mode 100644
index 000000000000..e192d7f5d467
--- /dev/null
+++ b/packages/core/src/state/stream/createHydrate.ts
@@ -0,0 +1,10 @@
+import { HYDRATE } from './hydrateAction.js';
+import type { HydrateAction } from './hydrateAction.js';
+import type { StateBaseline, StateDelta } from './types.js';
+
+export function createHydrate(
+  delta: StateDelta,
+  baseline: StateBaseline,
+): HydrateAction {
+  return { type: HYDRATE, delta, baseline };
+}
diff --git a/packages/core/src/state/stream/diffState.ts b/packages/core/src/state/stream/diffState.ts
new file mode 100644
index 000000000000..5b5551fb3335
--- /dev/null
+++ b/packages/core/src/state/stream/diffState.ts
@@ -0,0 +1,83 @@
+import type { StateDelta } from './types.js';
+import type { State } from '../../types.js';
+import { initialState } from '../reducer/initialState.js';
+
+function keysOf(...tables: (object | undefined)[]): Set<string> {
+  const keys = new Set<string>();
+  for (const table of tables) if (table) for (const k in table) keys.add(k);
+  return keys;
+}
+
+/**
+ * Describes every slot whose reference changed between `emitted` and `state`.
+ *
+ * Returns `null` when nothing changed. `optimistic` is never included: it is
+ * transient and holds non-serializable endpoints.
+ */
+export function diffState(
+  emitted: State<unknown>,
+  state: State<unknown>,
+): StateDelta | null {
+  const delta: StateDelta = { entities: [], endpoints: [], indexes: [] };
+  if (state.lastReset !== emitted.lastReset) {
+    delta.reset = state.lastReset;
+    emitted = initialState;
+  }
+
+  for (const key of keysOf(emitted.entities, state.entities)) {
+    const prev = emitted.entities[key];
+    const prevMeta = emitted.entitiesMeta[key];
+    const nextTable = state.entities[key];
+    const nextMeta = state.entitiesMeta[key];
+    if (prev === nextTable && prevMeta === nextMeta) continue;
+    for (const pk of keysOf(prev, nextTable)) {
+      const entity = nextTable?.[pk];
+      const meta = nextMeta?.[pk];
+      if (entity === prev?.[pk] && meta === prevMeta?.[pk]) continue;
+      delta.entities.push(
+        entity === undefined ?
+          { key, pk }
+        : { key, pk, value: { entity, meta } },
+      );
+    }
+  }
+
+  for (const key of keysOf(
+    emitted.endpoints,
+    state.endpoints,
+    emitted.meta,
+    state.meta,
+  )) {
+    const endpoint = state.endpoints[key];
+    const meta = state.meta[key];
+    if (endpoint === emitted.endpoints[key] && meta === emitted.meta[key])
+      continue;
+    delta.endpoints.push(
+      endpoint === undefined && meta === undefined ?
+        { key }
+      : { key, value: { endpoint, meta } },
+    );
+  }
+
+  for (const key of keysOf(emitted.indexes, state.indexes)) {
+    const prev = emitted.indexes[key];
+    const nextTable = state.indexes[key];
+    if (prev === nextTable) continue;
+    for (const index of keysOf(prev, nextTable)) {
+      const value = nextTable?.[index];
+      if (value === prev?.[index]) continue;
+      delta.indexes.push(
+        value === undefined ? { key, index } : { key, index, value },
+      );
+    }
+  }
+
+  return (
+      delta.reset !== undefined ||
+        delta.entities.length ||
+        delta.endpoints.length ||
+        delta.indexes.length
+    ) ?
+      delta
+    : null;
+}
diff --git a/packages/core/src/state/stream/hydrateAction.ts b/packages/core/src/state/stream/hydrateAction.ts
new file mode 100644
index 000000000000..1bdc7f2d57c2
--- /dev/null
+++ b/packages/core/src/state/stream/hydrateAction.ts
@@ -0,0 +1,11 @@
+import type { StateBaseline, StateDelta } from './types.js';
+
+export const HYDRATE = 'rdc/hydrate' as const;
+
+/** Merges state streamed from the server during SSR into the client store */
+export interface HydrateAction {
+  type: typeof HYDRATE;
+  delta: StateDelta;
+  /** What the client previously received for the slots in `delta`; slots the client changed since are left alone */
+  baseline: StateBaseline;
+}
diff --git a/packages/core/src/state/stream/hydrateReducer.ts b/packages/core/src/state/stream/hydrateReducer.ts
new file mode 100644
index 000000000000..6faf60209fd2
--- /dev/null
+++ b/packages/core/src/state/stream/hydrateReducer.ts
@@ -0,0 +1,13 @@
+import type { HydrateAction } from './hydrateAction.js';
+import { mergeStateDelta } from './mergeStateDelta.js';
+import type { State } from '../../types.js';
+
+export function hydrateReducer(
+  state: State<unknown>,
+  action: HydrateAction,
+): State<unknown> {
+  // the client reset since this baseline was captured, so the server's
+  // changes describe a store the user has already discarded
+  if (state.lastReset !== action.baseline.lastReset) return state;
+  return mergeStateDelta(state, action.delta, action.baseline);
+}
diff --git a/packages/core/src/state/stream/index.ts b/packages/core/src/state/stream/index.ts
new file mode 100644
index 000000000000..d2e42dddeb03
--- /dev/null
+++ b/packages/core/src/state/stream/index.ts
@@ -0,0 +1,16 @@
+export { diffState } from './diffState.js';
+export { applyStateDelta } from './applyStateDelta.js';
+export { mergeStateDelta } from './mergeStateDelta.js';
+export { selectBaseline } from './selectBaseline.js';
+export { HYDRATE } from './hydrateAction.js';
+export type { HydrateAction } from './hydrateAction.js';
+export { createHydrate } from './createHydrate.js';
+export { hydrateReducer } from './hydrateReducer.js';
+export { overlayState } from './overlayState.js';
+export type {
+  StateDelta,
+  StateBaseline,
+  EntityChange,
+  EndpointChange,
+  IndexChange,
+} from './types.js';
diff --git a/packages/core/src/state/stream/mergeStateDelta.ts b/packages/core/src/state/stream/mergeStateDelta.ts
new file mode 100644
index 000000000000..c09ad7e3c1c8
--- /dev/null
+++ b/packages/core/src/state/stream/mergeStateDelta.ts
@@ -0,0 +1,18 @@
+import type { StateBaseline, StateDelta } from './types.js';
+import { writeDelta } from './writeDelta.js';
+import type { State } from '../../types.js';
+
+/**
+ * Merges a streamed delta into live client state.
+ *
+ * A slot is taken from the delta only when the client still holds what it
+ * previously received for it (`baseline`); anything the client changed since
+ * wins.
+ */
+export function mergeStateDelta(
+  state: State<unknown>,
+  delta: StateDelta,
+  baseline: StateBaseline,
+): State<unknown> {
+  return writeDelta(state, delta, baseline);
+}
diff --git a/packages/core/src/state/stream/overlayState.ts b/packages/core/src/state/stream/overlayState.ts
new file mode 100644
index 000000000000..93d9bcf96128
--- /dev/null
+++ b/packages/core/src/state/stream/overlayState.ts
@@ -0,0 +1,37 @@
+import type { State } from '../../types.js';
+
+type Tables = { readonly [key: string]: object | undefined };
+
+function overlayTables<T extends Tables>(live: T, snapshot: T): T {
+  const result: { [key: string]: object | undefined } = { ...live };
+  for (const key in snapshot) {
+    const liveTable = live[key];
+    result[key] =
+      liveTable && snapshot[key] ?
+        { ...liveTable, ...snapshot[key] }
+      : snapshot[key];
+  }
+  return result as T;
+}
+
+/**
+ * State to hydrate with: every slot the server sent wins, anything else
+ * comes from the live store.
+ *
+ * Slots missing from the snapshot (a delta that never arrived) are then
+ * satisfied by a single client fetch instead of suspending on every retry.
+ */
+export function overlayState(
+  snapshot: State<unknown>,
+  live: State<unknown>,
+): State<unknown> {
+  if (snapshot === live) return live;
+  return {
+    ...live,
+    entities: overlayTables(live.entities, snapshot.entities),
+    entitiesMeta: overlayTables(live.entitiesMeta, snapshot.entitiesMeta),
+    indexes: overlayTables(live.indexes, snapshot.indexes),
+    endpoints: { ...live.endpoints, ...snapshot.endpoints },
+    meta: { ...live.meta, ...snapshot.meta },
+  };
+}
diff --git a/packages/core/src/state/stream/selectBaseline.ts b/packages/core/src/state/stream/selectBaseline.ts
new file mode 100644
index 000000000000..c25d203d2d7c
--- /dev/null
+++ b/packages/core/src/state/stream/selectBaseline.ts
@@ -0,0 +1,45 @@
+import type { StateBaseline, StateDelta } from './types.js';
+import { isUnsafeKey } from './writeDelta.js';
+import type { State } from '../../types.js';
+
+type Table<T> = { [key: string]: T };
+
+/** Picks, from the snapshot a delta is about to update, the current values of every slot the delta touches */
+export function selectBaseline(
+  snapshot: State<unknown>,
+  delta: StateDelta,
+): StateBaseline {
+  const entities: Table<Table<unknown>> = {};
+  const entitiesMeta: Table<Table<unknown>> = {};
+  const endpoints: Table<unknown> = {};
+  const meta: Table<unknown> = {};
+  const indexes: Table<Table<unknown>> = {};
+
+  for (const { key, pk } of delta.entities) {
+    if (isUnsafeKey(key) || isUnsafeKey(pk)) continue;
+    const entity = snapshot.entities[key]?.[pk];
+    if (entity !== undefined) (entities[key] ??= {})[pk] = entity;
+    const entityMeta = snapshot.entitiesMeta[key]?.[pk];
+    if (entityMeta !== undefined) (entitiesMeta[key] ??= {})[pk] = entityMeta;
+  }
+  for (const { key } of delta.endpoints) {
+    if (isUnsafeKey(key)) continue;
+    if (snapshot.endpoints[key] !== undefined)
+      endpoints[key] = snapshot.endpoints[key];
+    if (snapshot.meta[key] !== undefined) meta[key] = snapshot.meta[key];
+  }
+  for (const { key, index } of delta.indexes) {
+    if (isUnsafeKey(key) || isUnsafeKey(index)) continue;
+    const table = snapshot.indexes[key]?.[index];
+    if (table !== undefined) (indexes[key] ??= {})[index] = table;
+  }
+
+  return {
+    entities,
+    entitiesMeta,
+    endpoints,
+    meta,
+    indexes,
+    lastReset: snapshot.lastReset,
+  } as StateBaseline;
+}
diff --git a/packages/core/src/state/stream/types.ts b/packages/core/src/state/stream/types.ts
new file mode 100644
index 000000000000..cc788e039831
--- /dev/null
+++ b/packages/core/src/state/stream/types.ts
@@ -0,0 +1,50 @@
+import type { State } from '../../types.js';
+
+type EntityMeta = State<unknown>['entitiesMeta'][string][string];
+type EndpointMeta = State<unknown>['meta'][string];
+
+/** An entity that changed. Absent `value` means it was removed. */
+export interface EntityChange {
+  key: string;
+  pk: string;
+  value?: { entity?: unknown; meta?: EntityMeta };
+}
+
+/** An endpoint result that changed. Absent `value` means it was removed. */
+export interface EndpointChange {
+  key: string;
+  value?: { endpoint?: unknown; meta?: EndpointMeta };
+}
+
+/** An index lookup table that changed. Absent `value` means it was removed. */
+export interface IndexChange {
+  key: string;
+  index: string;
+  value?: { readonly [lookup: string]: string };
+}
+
+/**
+ * Serializable description of how State changed between two points in time.
+ *
+ * Streamed from server to client while rendering so the client can hydrate
+ * with exactly the data each piece of HTML was rendered from.
+ * @see https://dataclient.io/docs/guides/ssr#streamed-hydration
+ */
+export interface StateDelta {
+  entities: EntityChange[];
+  endpoints: EndpointChange[];
+  indexes: IndexChange[];
+  /** Set when the store was reset; the changes then apply on top of an empty store */
+  reset?: number;
+}
+
+/**
+ * Values the client previously received for the slots a StateDelta changes.
+ *
+ * Only the changed slots are populated. `lastReset` is what the server had
+ * when the delta was produced.
+ */
+export type StateBaseline = Pick<
+  State<unknown>,
+  'entities' | 'entitiesMeta' | 'endpoints' | 'meta' | 'indexes' | 'lastReset'
+>;
diff --git a/packages/core/src/state/stream/writeDelta.ts b/packages/core/src/state/stream/writeDelta.ts
new file mode 100644
index 000000000000..8c9b52dfe276
--- /dev/null
+++ b/packages/core/src/state/stream/writeDelta.ts
@@ -0,0 +1,100 @@
+import type { StateBaseline, StateDelta } from './types.js';
+import type { State } from '../../types.js';
+import { initialState } from '../reducer/initialState.js';
+
+type Writable<T> = { -readonly [K in keyof T]: T[K] };
+type Table<T> = { [key: string]: T };
+
+/** Assigning these as own keys of a plain object would alter its prototype chain */
+export function isUnsafeKey(key: string): boolean {
+  return key === '__proto__' || key === 'constructor' || key === 'prototype';
+}
+
+/**
+ * Copy-on-write application of `delta` to `state`.
+ *
+ * With a `baseline`, slots the client has changed since that baseline are
+ * left alone (three-way merge). Without one every change is taken.
+ */
+export function writeDelta(
+  state: State<unknown>,
+  delta: StateDelta,
+  baseline?: StateBaseline,
+): State<unknown> {
+  if (delta.reset !== undefined) {
+    state = { ...initialState, lastReset: delta.reset };
+    baseline = undefined;
+  }
+  const next: Writable<State<unknown>> = { ...state };
+  const copiedEntityTables = new Set<string>();
+  const copiedIndexTables = new Set<string>();
+  let changed = delta.reset !== undefined;
+
+  for (const { key, pk, value } of delta.entities) {
+    if (isUnsafeKey(key) || isUnsafeKey(pk)) continue;
+    if (
+      baseline &&
+      (state.entities[key]?.[pk] !== baseline.entities[key]?.[pk] ||
+        state.entitiesMeta[key]?.[pk] !== baseline.entitiesMeta[key]?.[pk])
+    )
+      continue;
+    changed = true;
+    if (!copiedEntityTables.has(key)) {
+      if (copiedEntityTables.size === 0) {
+        next.entities = { ...state.entities };
+        next.entitiesMeta = { ...state.entitiesMeta };
+      }
+      copiedEntityTables.add(key);
+      (next.entities as Table<any>)[key] = { ...state.entities[key] };
+      (next.entitiesMeta as Table<any>)[key] = { ...state.entitiesMeta[key] };
+    }
+    const entities = (next.entities as Table<any>)[key];
+    const entitiesMeta = (next.entitiesMeta as Table<any>)[key];
+    if (value?.entity !== undefined) entities[pk] = value.entity;
+    else delete entities[pk];
+    if (value?.meta !== undefined) entitiesMeta[pk] = value.meta;
+    else delete entitiesMeta[pk];
+  }
+
+  let copiedEndpoints = false;
+  for (const { key, value } of delta.endpoints) {
+    if (isUnsafeKey(key)) continue;
+    if (
+      baseline &&
+      (state.endpoints[key] !== baseline.endpoints[key] ||
+        state.meta[key] !== baseline.meta[key])
+    )
+      continue;
+    changed = true;
+    if (!copiedEndpoints) {
+      copiedEndpoints = true;
+      next.endpoints = { ...state.endpoints };
+      next.meta = { ...state.meta };
+    }
+    if (value?.endpoint !== undefined)
+      (next.endpoints as Table<any>)[key] = value.endpoint;
+    else delete (next.endpoints as Table<any>)[key];
+    if (value?.meta !== undefined) (next.meta as Table<any>)[key] = value.meta;
+    else delete (next.meta as Table<any>)[key];
+  }
+
+  for (const { key, index, value } of delta.indexes) {
+    if (isUnsafeKey(key) || isUnsafeKey(index)) continue;
+    if (
+      baseline &&
+      state.indexes[key]?.[index] !== baseline.indexes[key]?.[index]
+    )
+      continue;
+    changed = true;
+    if (!copiedIndexTables.has(key)) {
+      if (copiedIndexTables.size === 0) next.indexes = { ...state.indexes };
+      copiedIndexTables.add(key);
+      (next.indexes as Table<any>)[key] = { ...state.indexes[key] };
+    }
+    const table = (next.indexes as Table<any>)[key];
+    if (value !== undefined) table[index] = value;
+    else delete table[index];
+  }
+
+  return changed ? next : state;
+}
diff --git a/packages/img/package.json b/packages/img/package.json
index 6dfb4df261c2..d8f570af57f8 100644
--- a/packages/img/package.json
+++ b/packages/img/package.json
@@ -78,7 +78,7 @@
     "@data-client/endpoint": "workspace:^"
   },
   "peerDependencies": {
-    "@data-client/react": "^0.1.0 || ^0.2.0 || ^0.3.0 || ^0.4.0 || ^0.5.0 || ^0.7.0 || ^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0 || ^0.18.0",
+    "@data-client/react": "^0.1.0 || ^0.2.0 || ^0.3.0 || ^0.4.0 || ^0.5.0 || ^0.7.0 || ^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0 || ^0.18.0 || ^0.19.0",
     "@types/react": "^16.14.0 || ^17.0.0 || ^18.0.0-0 || ^19.0.0",
     "react": "^16.14.0 || ^17.0.0 || ^18.0.0-0 || ^19.0.0"
   },
diff --git a/packages/react/package.json b/packages/react/package.json
index 7a99917a1a76..1c7d1320f1c8 100644
--- a/packages/react/package.json
+++ b/packages/react/package.json
@@ -186,7 +186,8 @@
   "peerDependencies": {
     "@react-navigation/native": "^6.0.0 || ^7.0.0",
     "@types/react": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-0 || ^19.0.0",
-    "react": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-0 || ^19.0.0"
+    "react": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0-0 || ^19.0.0"
   },
   "peerDependenciesMeta": {
     "@react-navigation/native": {
@@ -194,6 +195,9 @@
     },
     "@types/react": {
       "optional": true
+    },
+    "react-dom": {
+      "optional": true
     }
   },
   "devDependencies": {
diff --git a/packages/react/src/components/DataProvider.tsx b/packages/react/src/components/DataProvider.tsx
index 0104e0244ab2..10675d632ed3 100644
--- a/packages/react/src/components/DataProvider.tsx
+++ b/packages/react/src/components/DataProvider.tsx
@@ -1,26 +1,23 @@
 'use client';
-import {
-  initialState as defaultState,
-  Controller as DataController,
-  applyManager,
-  initManager,
-} from '@data-client/core';
+import { createReducer } from '@data-client/core';
 import type { State, Manager, GCInterface } from '@data-client/core';
-import React, { useCallback, useMemo, useRef } from 'react';
+import { Controller as DataController } from '@data-client/core';
+import React from 'react';
 import type { JSX } from 'react';
 
-import DataStore from './DataStore.js';
+import DataProviderBase from './DataProviderBase.js';
 import type { DevToolsPosition } from './DevToolsButton.js';
-import { getDefaultManagers } from './getDefaultManagers.js';
 import { SSR } from './LegacyReact.js';
-import { renderDevButton } from './renderDevButton.js';
-import { ControllerContext } from '../context.js';
-import { DevToolsManager } from '../managers/index.js';
-import GCPolicy from '../state/GCPolicy.js';
 
 export interface ProviderProps {
   children: React.ReactNode;
-  managers?: Manager[];
+  /**
+   * Function creating the Managers for this store; called once when the
+   * provider mounts. Passing instances directly is transitional and will be
+   * removed in a future release.
+   * @see https://dataclient.io/docs/api/DataProvider#managers
+   */
+  managers?: Manager[] | (() => Manager[]);
   initialState?: State<unknown>;
   Controller?: typeof DataController;
   gcPolicy?: GCInterface;
@@ -31,14 +28,7 @@ export interface ProviderProps {
  * Manages state, providing all context needed to use the hooks.
  * @see https://dataclient.io/docs/api/DataProvider
  */
-export default function DataProvider({
-  children,
-  managers,
-  gcPolicy,
-  initialState = defaultState as State<unknown>,
-  Controller = DataController,
-  devButton = 'bottom-right',
-}: ProviderProps): JSX.Element {
+export default function DataProvider(props: ProviderProps): JSX.Element {
   /* istanbul ignore else */
   if (process.env.NODE_ENV !== 'production' && SSR) {
     console.warn(
@@ -46,48 +36,5 @@ export default function DataProvider({
 See https://dataclient.io/docs/guides/ssr.`,
     );
   }
-  const gcRef: React.RefObject<GCPolicy> = useRef<any>(gcPolicy);
-  if (!gcRef.current) gcRef.current = new GCPolicy();
-
-  // contents of this component expected to be relatively stable
-  const controllerRef: React.RefObject<DataController> = useRef<any>(undefined);
-  if (!controllerRef.current)
-    controllerRef.current = new Controller({ gcPolicy: gcRef.current });
-  //TODO: bind all methods so destructuring works
-
-  const managersRef: React.RefObject<Manager[]> = useRef<any>(managers);
-  if (!managersRef.current) managersRef.current = getDefaultManagers();
-
-  // run in a useEffect in DataStore
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  const mgrEffect = useCallback(
-    initManager(managersRef.current, controllerRef.current, initialState),
-    // we don't support initialState changes
-    managersRef.current,
-  );
-
-  // Makes manager middleware compatible with redux-style middleware (by a wrapper enhancement to provide controller API)
-  const middlewares = useMemo(
-    () => applyManager(managersRef.current, controllerRef.current),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    managersRef.current,
-  );
-
-  // only include if they have devtools integrated
-  const hasDevManager = !!managersRef.current.find(
-    manager => manager instanceof DevToolsManager,
-  );
-  return (
-    <ControllerContext.Provider value={controllerRef.current}>
-      <DataStore
-        mgrEffect={mgrEffect}
-        middlewares={middlewares}
-        initialState={initialState}
-        controller={controllerRef.current}
-      >
-        {children}
-      </DataStore>
-      {renderDevButton(devButton, hasDevManager)}
-    </ControllerContext.Provider>
-  );
+  return <DataProviderBase {...props} reducerFactory={createReducer} />;
 }
diff --git a/packages/react/src/components/DataProviderBase.tsx b/packages/react/src/components/DataProviderBase.tsx
new file mode 100644
index 000000000000..2ae7c7a3829c
--- /dev/null
+++ b/packages/react/src/components/DataProviderBase.tsx
@@ -0,0 +1,88 @@
+'use client';
+import {
+  initialState as defaultState,
+  Controller as DataController,
+  applyManager,
+  initManager,
+} from '@data-client/core';
+import type { State, Manager } from '@data-client/core';
+import React, { useCallback, useMemo, useRef } from 'react';
+import type { JSX } from 'react';
+
+import type { ProviderProps } from './DataProvider.js';
+import DataStore from './DataStore.js';
+import type { ReducerFactory } from './DataStore.js';
+import { getDefaultManagers } from './getDefaultManagers.js';
+import { renderDevButton } from './renderDevButton.js';
+import { ControllerContext } from '../context.js';
+import { DevToolsManager } from '../managers/index.js';
+import GCPolicy from '../state/GCPolicy.js';
+
+export interface DataProviderBaseProps extends ProviderProps {
+  reducerFactory: ReducerFactory;
+}
+
+/**
+ * Manager/controller/GC lifecycle shared by public DataProvider and
+ * streaming adapters. Adapters supply the reducer; this module has no
+ * snapshot prop or snapshot Context.
+ */
+export default function DataProviderBase({
+  children,
+  managers,
+  gcPolicy,
+  initialState = defaultState as State<unknown>,
+  Controller = DataController,
+  devButton = 'bottom-right',
+  reducerFactory,
+}: DataProviderBaseProps): JSX.Element {
+  const gcRef: React.RefObject<GCPolicy> = useRef<any>(gcPolicy);
+  if (!gcRef.current) gcRef.current = new GCPolicy();
+
+  // contents of this component expected to be relatively stable
+  const controllerRef: React.RefObject<DataController> = useRef<any>(undefined);
+  if (!controllerRef.current)
+    controllerRef.current = new Controller({ gcPolicy: gcRef.current });
+  //TODO: bind all methods so destructuring works
+
+  const managersRef: React.RefObject<Manager[]> = useRef<any>(undefined);
+  if (!managersRef.current)
+    managersRef.current =
+      typeof managers === 'function' ? managers() : (
+        (managers ?? getDefaultManagers())
+      );
+
+  // run in a useEffect in DataStore
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const mgrEffect = useCallback(
+    initManager(managersRef.current, controllerRef.current, initialState),
+    // we don't support initialState changes
+    managersRef.current,
+  );
+
+  // Makes manager middleware compatible with redux-style middleware (by a wrapper enhancement to provide controller API)
+  const middlewares = useMemo(
+    () => applyManager(managersRef.current, controllerRef.current),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    managersRef.current,
+  );
+
+  // only include if they have devtools integrated
+  const hasDevManager = !!managersRef.current.find(
+    manager => manager instanceof DevToolsManager,
+  );
+  return (
+    <ControllerContext.Provider value={controllerRef.current}>
+      <DataStore
+        mgrEffect={mgrEffect}
+        middlewares={middlewares}
+        initialState={initialState}
+        controller={controllerRef.current}
+        reducerFactory={reducerFactory}
+      >
+        {children}
+      </DataStore>
+      {renderDevButton(devButton, hasDevManager)}
+    </ControllerContext.Provider>
+  );
+}
diff --git a/packages/react/src/components/DataStore.tsx b/packages/react/src/components/DataStore.tsx
index 90e39ff2ccc4..5edc39055969 100644
--- a/packages/react/src/components/DataStore.tsx
+++ b/packages/react/src/components/DataStore.tsx
@@ -1,8 +1,6 @@
-// Server Side Component compatibility (specifying this cannot be used as such)
-// https://beta.nextjs.org/docs/rendering/server-and-client-components#third-party-packages
 'use client';
-import type { State, Manager } from '@data-client/core';
-import { createReducer, Controller } from '@data-client/core';
+import type { State } from '@data-client/core';
+import { Controller } from '@data-client/core';
 import useEnhancedReducer from '@data-client/use-enhanced-reducer';
 import type { Middleware as GenericMiddleware } from '@data-client/use-enhanced-reducer';
 import React, { useEffect, useMemo, memo } from 'react';
@@ -11,12 +9,20 @@ import BackupLoading from './BackupLoading.js';
 import UniversalSuspense from './UniversalSuspense.js';
 import { StateContext } from '../context.js';
 
+export type Reducer = (
+  state: State<unknown> | undefined,
+  action: any,
+) => State<unknown>;
+
+export type ReducerFactory = (controller: Controller) => Reducer;
+
 interface StoreProps {
   children: React.ReactNode;
   mgrEffect: () => void;
   middlewares: GenericMiddleware[];
   initialState: State<unknown>;
   controller: Controller;
+  reducerFactory: ReducerFactory;
 }
 /**
  * This part of the provider concerns only the parts that matter for store changes
@@ -28,8 +34,12 @@ function DataStore({
   middlewares,
   initialState,
   controller,
+  reducerFactory,
 }: StoreProps) {
-  const masterReducer = useMemo(() => createReducer(controller), [controller]);
+  const masterReducer = useMemo(
+    () => reducerFactory(controller),
+    [controller, reducerFactory],
+  );
 
   // we don't need `dispatch` here, since applyManager() assigns the dispatch to controller
   const [state] = useEnhancedReducer(masterReducer, initialState, middlewares);
diff --git a/packages/react/src/components/__tests__/provider.tsx b/packages/react/src/components/__tests__/provider.tsx
index da79b8920fa5..69ea12fb4177 100644
--- a/packages/react/src/components/__tests__/provider.tsx
+++ b/packages/react/src/components/__tests__/provider.tsx
@@ -4,7 +4,11 @@ import {
   Manager,
   Middleware,
   Controller,
+  createReducer,
+  actionTypes,
 } from '@data-client/core';
+import type { State } from '@data-client/core';
+import { Entity, Endpoint } from '@data-client/endpoint';
 import { act, render } from '@testing-library/react';
 import { CoolerArticleResource } from '__tests__/new';
 import nock from 'nock';
@@ -14,6 +18,7 @@ import { ControllerContext, StateContext } from '../../context';
 import { useController, useSuspense } from '../../hooks';
 import { payload } from '../../test-fixtures';
 import DataProvider from '../DataProvider';
+import DataProviderBase from '../DataProviderBase';
 import { getDefaultManagers } from '../getDefaultManagers';
 
 describe('<DataProvider />', () => {
@@ -211,4 +216,183 @@ describe('<DataProvider />', () => {
       ]
     `);
   });
+
+  describe('managers factory', () => {
+    class TrackingManager implements Manager {
+      declare controller: Controller;
+      initCalls = 0;
+      cleanupCalls = 0;
+
+      init() {
+        this.initCalls++;
+      }
+
+      cleanup() {
+        this.cleanupCalls++;
+      }
+
+      middleware: Middleware = controller => {
+        this.controller = controller;
+        return next => action => next(action);
+      };
+    }
+    let controller: Controller | undefined;
+    function Probe() {
+      controller = useController();
+      return null;
+    }
+
+    it('is stable across re-renders within a mount', () => {
+      const created: TrackingManager[] = [];
+      const factory = jest.fn(() => {
+        const tracking = new TrackingManager();
+        created.push(tracking);
+        return [new NetworkManager(), tracking];
+      });
+      const tree = (
+        <StrictMode>
+          <DataProvider managers={factory}>
+            <Probe />
+          </DataProvider>
+        </StrictMode>
+      );
+      const { rerender, unmount } = render(tree);
+      const callsAfterMount = factory.mock.calls.length;
+      // StrictMode 17/18 discards one render/useRef pass, so the factory runs
+      // twice. React 19 keeps one. Neither is a second production mount.
+      const reactMajor = Number(React.version.split('.')[0]);
+      expect(callsAfterMount).toBe(reactMajor >= 19 ? 1 : 2);
+
+      rerender(tree);
+      rerender(
+        <StrictMode>
+          <DataProvider managers={factory}>
+            <Probe />
+            <span />
+          </DataProvider>
+        </StrictMode>,
+      );
+      expect(factory).toHaveBeenCalledTimes(callsAfterMount);
+      expect(created).toHaveLength(callsAfterMount);
+
+      const tracking = created[created.length - 1];
+      // the created managers are the ones wired into the store
+      expect(tracking.controller).toBe(controller);
+      // StrictMode runs effects twice on mount; each init is matched by a cleanup
+      expect(tracking.initCalls).toBeGreaterThanOrEqual(1);
+      expect(tracking.cleanupCalls).toBe(tracking.initCalls - 1);
+      unmount();
+      expect(tracking.cleanupCalls).toBe(tracking.initCalls);
+    });
+
+    it('gives each provider its own instances, unlike a shared array', () => {
+      const trackers: TrackingManager[] = [];
+      const factory = () => {
+        const tracking = new TrackingManager();
+        trackers.push(tracking);
+        return [new NetworkManager(), tracking];
+      };
+      const controllers: Controller[] = [];
+      function CaptureController() {
+        controllers.push(useController());
+        return null;
+      }
+      render(
+        <>
+          <DataProvider managers={factory}>
+            <CaptureController />
+          </DataProvider>
+          <DataProvider managers={factory}>
+            <CaptureController />
+          </DataProvider>
+        </>,
+      );
+      expect(trackers).toHaveLength(2);
+      expect(controllers[0]).not.toBe(controllers[1]);
+      expect(trackers[0].controller).toBe(controllers[0]);
+      expect(trackers[1].controller).toBe(controllers[1]);
+
+      // a shared array leaves one instance bound to whichever store mounted last
+      const shared = new TrackingManager();
+      const sharedManagers = [new NetworkManager(), shared];
+      const sharedControllers: Controller[] = [];
+      function CaptureShared() {
+        sharedControllers.push(useController());
+        return null;
+      }
+      render(
+        <>
+          <DataProvider managers={sharedManagers}>
+            <CaptureShared />
+          </DataProvider>
+          <DataProvider managers={sharedManagers}>
+            <CaptureShared />
+          </DataProvider>
+        </>,
+      );
+      expect(shared.controller).toBe(sharedControllers[1]);
+      expect(shared.controller).not.toBe(sharedControllers[0]);
+    });
+  });
+});
+
+describe('<DataProviderBase /> reducer injection', () => {
+  it('uses the injected reducer for committed actions and optimistic replay', () => {
+    class Todo extends Entity {
+      id = '';
+      title = '';
+      pk() {
+        return this.id;
+      }
+    }
+    const updateTodo = new Endpoint(
+      async (todo: { id: string; title: string }) => todo,
+      {
+        schema: Todo,
+        name: 'updateTodo',
+        sideEffect: true,
+        getOptimisticResponse: (
+          _snap: unknown,
+          todo: { id: string; title: string },
+        ) => todo,
+      },
+    );
+
+    const seen: string[] = [];
+    const reducerFactory = (controller: Controller) => {
+      const master = createReducer(controller);
+      return (state: State<unknown> | undefined, action: any) => {
+        seen.push(action.type);
+        return master(state, action);
+      };
+    };
+
+    let ctrl: Controller | undefined;
+    function Probe() {
+      ctrl = useController();
+      return null;
+    }
+
+    render(
+      <DataProviderBase reducerFactory={reducerFactory} devButton={null}>
+        <Probe />
+      </DataProviderBase>,
+    );
+
+    act(() => {
+      ctrl!.setResponse(
+        CoolerArticleResource.get,
+        { id: 5 },
+        { id: 5, title: 'hi', content: 'more things here' },
+      );
+    });
+    expect(seen).toContain(actionTypes.SET_RESPONSE);
+
+    const beforeOptimistic = seen.length;
+    act(() => {
+      void ctrl!.fetch(updateTodo, { id: '1', title: 'opt' });
+    });
+    expect(seen.slice(beforeOptimistic)).toContain(actionTypes.FETCH);
+    expect(seen.slice(beforeOptimistic)).toContain(actionTypes.OPTIMISTIC);
+  });
 });
diff --git a/packages/react/src/hooks/useCacheState.ts b/packages/react/src/hooks/useCacheState.ts
index abbd4a442533..facec872d8ac 100644
--- a/packages/react/src/hooks/useCacheState.ts
+++ b/packages/react/src/hooks/useCacheState.ts
@@ -5,12 +5,11 @@ import React from 'react';
 import use from './useUniversal.js';
 import { StateContext, StoreContext } from '../context.js';
 
+const hasSyncExternalStore = Object.hasOwn(React, 'useSyncExternalStore');
+
 const useCacheState: () => State<unknown> =
   /* istanbul ignore if */
-  (
-    typeof window === 'undefined' &&
-    Object.hasOwn(React, 'useSyncExternalStore')
-  ) ?
+  typeof window === 'undefined' && hasSyncExternalStore ?
     /* istanbul ignore next */
     () => {
       const store = use(StoreContext);
diff --git a/packages/react/src/server/SSRDataProvider.tsx b/packages/react/src/server/SSRDataProvider.tsx
index 83d179bb338c..578f64441650 100644
--- a/packages/react/src/server/SSRDataProvider.tsx
+++ b/packages/react/src/server/SSRDataProvider.tsx
@@ -19,6 +19,7 @@ interface Props<S> extends Store<S> {
   children: React.ReactNode;
   devButton?: DevToolsPosition | null | undefined;
   hasDevManager: boolean;
+  Controller?: typeof Controller;
 }
 
 /**
@@ -31,8 +32,12 @@ export default function SSRDataProvider({
   getState,
   devButton,
   hasDevManager = true,
+  Controller: ControllerClass = Controller,
 }: Props<State<any>>) {
-  const controller = useMemo(() => new Controller({ dispatch }), [dispatch]);
+  const controller = useMemo(
+    () => new ControllerClass({ dispatch }),
+    [dispatch, ControllerClass],
+  );
   const store = useMemo(() => ({ subscribe, getState }), [subscribe, getState]);
 
   return (
diff --git a/packages/react/src/server/ServerData.tsx b/packages/react/src/server/ServerData.tsx
index 2b55fac0db25..958140409485 100644
--- a/packages/react/src/server/ServerData.tsx
+++ b/packages/react/src/server/ServerData.tsx
@@ -1,5 +1,7 @@
 import type { State } from '@data-client/core';
 
+import { escapeJsonForScript } from './escapeJsonForScript.js';
+
 export const ServerData = ({
   data,
   nonce,
@@ -10,7 +12,7 @@ export const ServerData = ({
   nonce?: string | undefined;
 }) => {
   try {
-    const encoded = JSON.stringify(data);
+    const encoded = escapeJsonForScript(JSON.stringify(data));
     return (
       <script
         id={id}
diff --git a/packages/react/src/server/StreamingDataProvider.tsx b/packages/react/src/server/StreamingDataProvider.tsx
new file mode 100644
index 000000000000..626983db180f
--- /dev/null
+++ b/packages/react/src/server/StreamingDataProvider.tsx
@@ -0,0 +1,36 @@
+'use client';
+import type { ProviderProps } from '../components/DataProvider.js';
+import DataProviderBase from '../components/DataProviderBase.js';
+import createStreamingReducer from './stream/createStreamingReducer.js';
+import StreamedStateReceiver from './stream/StreamedStateReceiver.js';
+import type { SnapshotStore } from './stream/types.js';
+
+export interface StreamingDataProviderProps extends Omit<
+  ProviderProps,
+  'initialState'
+> {
+  snapshotStore: SnapshotStore;
+}
+
+/**
+ * Generic streaming composition for hosts that own their own SnapshotStore.
+ *
+ * Unstable: import from `@data-client/react/ssr`'s `__INTERNAL__` namespace.
+ * Adds no transport. Does not replace `initialState` as deltas arrive.
+ */
+export default function StreamingDataProvider({
+  snapshotStore,
+  children,
+  ...props
+}: StreamingDataProviderProps) {
+  return (
+    <DataProviderBase
+      {...props}
+      initialState={snapshotStore.state}
+      reducerFactory={createStreamingReducer}
+    >
+      <StreamedStateReceiver snapshotStore={snapshotStore} />
+      {children}
+    </DataProviderBase>
+  );
+}
diff --git a/packages/react/src/server/__tests__/StreamingDataProvider.node.tsx b/packages/react/src/server/__tests__/StreamingDataProvider.node.tsx
new file mode 100644
index 000000000000..a42ecc960e61
--- /dev/null
+++ b/packages/react/src/server/__tests__/StreamingDataProvider.node.tsx
@@ -0,0 +1,116 @@
+jest.mock(
+  'next/navigation',
+  () => {
+    throw new Error('generic @data-client/react/ssr must not import Next');
+  },
+  { virtual: true },
+);
+
+import {
+  actions,
+  createReducer,
+  Controller,
+  initialState,
+} from '@data-client/core';
+import type { State } from '@data-client/core';
+import { Endpoint, Entity } from '@data-client/endpoint';
+import { useSuspense } from '@data-client/react';
+import { __INTERNAL__ } from '@data-client/react/ssr';
+import React, { Suspense } from 'react';
+import { renderToPipeableStream } from 'react-dom/server';
+import { Writable } from 'stream';
+
+const { StreamingDataProvider } = __INTERNAL__;
+type SnapshotStore =
+  import('@data-client/react/ssr').__INTERNAL__.SnapshotStore;
+type DeltaQueue = import('@data-client/react/ssr').__INTERNAL__.DeltaQueue;
+
+class Todo extends Entity {
+  id = '';
+  title = '';
+  pk() {
+    return this.id;
+  }
+}
+const fetchTodo = jest.fn(async ({ id }: { id: string }) => ({
+  id,
+  title: `todo ${id}`,
+}));
+const getTodo = new Endpoint(fetchTodo, { schema: Todo, name: 'getTodo' });
+
+const reducer = createReducer(new Controller());
+const seeded: State<unknown> = reducer(
+  initialState,
+  actions.createSetResponse(getTodo, {
+    args: [{ id: '1' }],
+    response: { id: '1', title: 'todo 1' },
+  }),
+);
+
+function TodoView() {
+  const todo = useSuspense(getTodo, { id: '1' });
+  return <p>{todo.title}</p>;
+}
+
+function renderPipe(element: React.ReactElement): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let shellReady = false;
+    const { pipe } = renderToPipeableStream(element, {
+      onShellReady() {
+        shellReady = true;
+      },
+      onAllReady() {
+        const chunks: Buffer[] = [];
+        const writable = new Writable({
+          write(chunk, _enc, cb) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            cb();
+          },
+          final(cb) {
+            expect(shellReady).toBe(true);
+            resolve(Buffer.concat(chunks).toString('utf8'));
+            cb();
+          },
+        });
+        pipe(writable);
+      },
+      onError(err) {
+        reject(err);
+      },
+    });
+  });
+}
+
+describe('StreamingDataProvider', () => {
+  beforeEach(() => {
+    fetchTodo.mockClear();
+    jest.useFakeTimers();
+  });
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('composes through @data-client/react/ssr without Next, fetches, or a timer gate', async () => {
+    const queue: DeltaQueue = Object.assign([], {});
+    const snapshotStore: SnapshotStore = {
+      state: seeded,
+      cursor: 0,
+      queue,
+    };
+
+    const html = await renderPipe(
+      <html>
+        <body>
+          <StreamingDataProvider snapshotStore={snapshotStore} devButton={null}>
+            <Suspense fallback="loading">
+              <TodoView />
+            </Suspense>
+          </StreamingDataProvider>
+        </body>
+      </html>,
+    );
+
+    expect(html).toContain('<p>todo 1</p>');
+    expect(fetchTodo).toHaveBeenCalledTimes(0);
+  });
+});
diff --git a/packages/react/src/server/__tests__/escapeJsonForScript.node.tsx b/packages/react/src/server/__tests__/escapeJsonForScript.node.tsx
new file mode 100644
index 000000000000..4f413f58aeeb
--- /dev/null
+++ b/packages/react/src/server/__tests__/escapeJsonForScript.node.tsx
@@ -0,0 +1,59 @@
+import { initialState } from '@data-client/core';
+import { renderToString } from 'react-dom/server';
+
+import { escapeJsonForScript } from '../escapeJsonForScript';
+import ServerData from '../ServerData';
+
+describe('escapeJsonForScript', () => {
+  const hostile = {
+    title: '</script><script>alert(1)</script>',
+    line: 'a\u2028b\u2029c',
+    amp: 'x & y > z',
+    __proto__: { polluted: true },
+  };
+
+  it('keeps the payload inside its script tag', () => {
+    const escaped = escapeJsonForScript(JSON.stringify(hostile));
+    expect(escaped).not.toContain('<');
+    expect(escaped).not.toContain('>');
+    expect(escaped).not.toContain('&');
+    expect(escaped).not.toContain('\u2028');
+    expect(escaped).not.toContain('\u2029');
+  });
+
+  it('remains valid JSON with the same content', () => {
+    const parsed = JSON.parse(escapeJsonForScript(JSON.stringify(hostile)));
+    expect(parsed).toEqual(JSON.parse(JSON.stringify(hostile)));
+    expect(parsed.title).toBe(hostile.title);
+  });
+
+  it('works as the argument of an inline JSON.parse string literal', () => {
+    const literal = escapeJsonForScript(
+      JSON.stringify(JSON.stringify(hostile)),
+    );
+    const parsed = new Function(`return JSON.parse(${literal})`)();
+    expect(parsed).toEqual(JSON.parse(JSON.stringify(hostile)));
+    expect(({} as any).polluted).toBeUndefined();
+    expect(Object.getPrototypeOf(parsed)).toBe(Object.prototype);
+  });
+
+  it('is applied by ServerData', () => {
+    const html = renderToString(
+      <ServerData
+        data={{
+          ...initialState,
+          endpoints: { [hostile.title]: hostile.title },
+        }}
+        nonce="abc"
+      />,
+    );
+    const open = html.indexOf('<script');
+    const tagEnd = html.indexOf('>', open);
+    const close = html.toLowerCase().indexOf('</script', tagEnd);
+    expect(open).toBeGreaterThanOrEqual(0);
+    expect(html.toLowerCase().indexOf('</script', close + 1)).toBe(-1);
+    expect(html).toContain('nonce="abc"');
+    const inner = html.slice(tagEnd + 1, close);
+    expect(JSON.parse(inner).endpoints[hostile.title]).toBe(hostile.title);
+  });
+});
diff --git a/packages/react/src/server/createPersistedStore.tsx b/packages/react/src/server/createPersistedStore.tsx
index 975b96e85ad0..25bac06b2fd4 100644
--- a/packages/react/src/server/createPersistedStore.tsx
+++ b/packages/react/src/server/createPersistedStore.tsx
@@ -1,43 +1,15 @@
 'use client';
-import {
-  Controller,
-  Manager,
-  NetworkManager,
-  State,
-  initialState,
-  createReducer,
-  applyManager,
-  initManager,
-} from '@data-client/core';
+import { Manager, State } from '@data-client/core';
 import { useSyncExternalStore } from 'react';
 
-import { PromiseifyMiddleware } from './redux/index.js';
-import { createStore, applyMiddleware } from './redux/redux.js';
+import createServerStore from './createServerStore.js';
 import SSRDataProvider from './SSRDataProvider.js';
-import { NetworkManager as ReactNetworkManager } from '../managers/index.js';
 
 export default function createPersistedStore(
   managers?: Manager[],
   hasDevManager: boolean = true,
 ) {
-  const controller = new Controller();
-  managers = managers ?? [new ReactNetworkManager()];
-  const networkManager: NetworkManager = managers.find(
-    m => m instanceof NetworkManager,
-  ) as any;
-  if (networkManager === undefined)
-    throw new Error('managers must include a NetworkManager');
-  const reducer = createReducer(controller);
-  const enhancer = applyMiddleware(
-    // redux 5's types are wrong and do not allow any return typing from next, which is incorrect.
-    // `next: (action: unknown) => unknown`: allows any action, but disallows all return types.
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    ...applyManager(managers, controller),
-    PromiseifyMiddleware,
-  );
-  const store = createStore(reducer, initialState as any, enhancer);
-  initManager(managers, controller, store.getState())();
+  const { store, controller, networkManager } = createServerStore(managers);
 
   const selector = (state: any) => state;
 
diff --git a/packages/react/src/server/createServerStore.ts b/packages/react/src/server/createServerStore.ts
new file mode 100644
index 000000000000..515179d0a77b
--- /dev/null
+++ b/packages/react/src/server/createServerStore.ts
@@ -0,0 +1,38 @@
+import {
+  Controller,
+  NetworkManager,
+  initialState,
+  createReducer,
+  applyManager,
+  initManager,
+} from '@data-client/core';
+import type { Manager } from '@data-client/core';
+
+import { PromiseifyMiddleware } from './redux/index.js';
+import { createStore, applyMiddleware } from './redux/redux.js';
+import { NetworkManager as ReactNetworkManager } from '../managers/index.js';
+
+/** Redux-style store for one server render; managers must include a NetworkManager */
+export default function createServerStore(
+  managers?: Manager[],
+  ControllerClass: typeof Controller = Controller,
+) {
+  const controller = new ControllerClass();
+  managers = managers ?? [new ReactNetworkManager()];
+  const networkManager = managers.find(m => m instanceof NetworkManager) as
+    NetworkManager | undefined;
+  if (networkManager === undefined)
+    throw new Error('managers must include a NetworkManager');
+  const reducer = createReducer(controller);
+  const enhancer = applyMiddleware(
+    // redux 5's types are wrong and do not allow any return typing from next, which is incorrect.
+    // `next: (action: unknown) => unknown`: allows any action, but disallows all return types.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    ...applyManager(managers, controller),
+    PromiseifyMiddleware,
+  );
+  const store = createStore(reducer, initialState as any, enhancer);
+  initManager(managers, controller, store.getState())();
+  return { store, controller, networkManager };
+}
diff --git a/packages/react/src/server/escapeJsonForScript.ts b/packages/react/src/server/escapeJsonForScript.ts
new file mode 100644
index 000000000000..33e72937cfe7
--- /dev/null
+++ b/packages/react/src/server/escapeJsonForScript.ts
@@ -0,0 +1,17 @@
+const ESCAPES: Record<string, string> = {
+  '<': '\\u003c',
+  '>': '\\u003e',
+  '&': '\\u0026',
+  '\u2028': '\\u2028',
+  '\u2029': '\\u2029',
+};
+
+/**
+ * Makes JSON text safe to inline inside a `<script>`, inert or executable.
+ *
+ * `<` cannot end the script early, and the U+2028/2029 line terminators stay
+ * valid inside a JavaScript string literal. The result is still valid JSON.
+ */
+export function escapeJsonForScript(json: string): string {
+  return json.replace(/[<>&\u2028\u2029]/g, char => ESCAPES[char]);
+}
diff --git a/packages/react/src/server/index.ts b/packages/react/src/server/index.ts
index 23066f65a1fc..a18dd2a9758b 100644
--- a/packages/react/src/server/index.ts
+++ b/packages/react/src/server/index.ts
@@ -7,3 +7,4 @@ export { default as createPersistedStore } from './createPersistedStore.js';
 export * from './getInitialData.js';
 export { default as createServerDataComponent } from './createServerDataComponent.js';
 export { default as ServerData } from './ServerData.js';
+export * as __INTERNAL__ from './internal.js';
diff --git a/packages/react/src/server/internal.ts b/packages/react/src/server/internal.ts
new file mode 100644
index 000000000000..7a533ceebc86
--- /dev/null
+++ b/packages/react/src/server/internal.ts
@@ -0,0 +1,3 @@
+export { default as StreamingDataProvider } from './StreamingDataProvider.js';
+export type { StreamingDataProviderProps } from './StreamingDataProvider.js';
+export type { SnapshotStore, DeltaQueue } from './stream/types.js';
diff --git a/packages/react/src/server/nextjs/DataProvider/DataProvider.tsx b/packages/react/src/server/nextjs/DataProvider/DataProvider.tsx
index bada1e189735..bcfa729ab1ec 100644
--- a/packages/react/src/server/nextjs/DataProvider/DataProvider.tsx
+++ b/packages/react/src/server/nextjs/DataProvider/DataProvider.tsx
@@ -1,29 +1,37 @@
 'use client';
-import { useMemo, type ComponentProps } from 'react';
+import { useServerInsertedHTML } from 'next/navigation';
+import { useMemo } from 'react';
 
 import createPersistedStore from './createPersistedStore.js';
-import ServerDataComponent from './ServerDataComponent.js';
-import type DataProviderClient from '../../../components/DataProvider.js';
+import type { NextDataProviderProps } from './types.js';
 
+export type { NextDataProviderProps } from './types.js';
+
+/**
+ * DataProvider for the Next.js App Router.
+ *
+ * Emits an inert baseline then a StateDelta per flush via
+ * `useServerInsertedHTML()`. The client adapter owns the snapshot and
+ * folds queued pieces plus live HYDRATE from StreamedStateReceiver's
+ * layout effect. Insertion is the HTML stream, not RSC; a Client
+ * Component may start before that fold. `initialState` is the one-time
+ * seed — later pieces are snapshot folds plus HYDRATE, never a replaced
+ * prop.
+ * @see https://dataclient.io/docs/guides/ssr#streamed-hydration
+ */
 export default function DataProvider({
   children,
+  nonce,
   ...props
-}: ProviderProps): React.ReactElement {
-  const [ServerDataProvider, initPromise] = useMemo(createPersistedStore, []);
-
-  return (
-    <>
-      <ServerDataComponent initPromise={initPromise} />
-      <ServerDataProvider {...props} initPromise={initPromise}>
-        {children}
-      </ServerDataProvider>
-    </>
+}: NextDataProviderProps): React.ReactElement {
+  const [StoreDataProvider, renderStateDelta] = useMemo(
+    () => createPersistedStore(props.managers, props.Controller),
+    // the store lives for the whole request/page; managers cannot change after
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [],
   );
-}
+  useServerInsertedHTML(() => renderStateDelta(nonce));
 
-type ProviderProps = Omit<
-  Partial<ComponentProps<typeof DataProviderClient>>,
-  'initialState'
-> & {
-  children: React.ReactNode;
-};
+  const { managers: _, Controller: __, ...storeProps } = props;
+  return <StoreDataProvider {...storeProps}>{children}</StoreDataProvider>;
+}
diff --git a/packages/react/src/server/nextjs/DataProvider/ServerDataComponent.tsx b/packages/react/src/server/nextjs/DataProvider/ServerDataComponent.tsx
deleted file mode 100644
index 164e6e7ab1ee..000000000000
--- a/packages/react/src/server/nextjs/DataProvider/ServerDataComponent.tsx
+++ /dev/null
@@ -1,17 +0,0 @@
-import { use } from 'react';
-
-import ServerData from '../../ServerData.js';
-
-const id = 'data-client-data';
-
-const ServerDataComponent = ({
-  nonce,
-  initPromise,
-}: {
-  nonce?: string | undefined;
-  initPromise: Promise<any>;
-}) => {
-  const data = use(initPromise);
-  return <ServerData data={data} id={id} nonce={nonce} />;
-};
-export default ServerDataComponent;
diff --git a/packages/react/src/server/nextjs/DataProvider/__tests__/fixtures/next-15.5.2-head-insertion.ts b/packages/react/src/server/nextjs/DataProvider/__tests__/fixtures/next-15.5.2-head-insertion.ts
new file mode 100644
index 000000000000..a0700a4c9741
--- /dev/null
+++ b/packages/react/src/server/nextjs/DataProvider/__tests__/fixtures/next-15.5.2-head-insertion.ts
@@ -0,0 +1,200 @@
+/**
+ * Verbatim copies of the Next.js stream transforms that decide where
+ * `useServerInsertedHTML` output lands, so the streaming tests exercise the
+ * real insertion semantics (into `</head>` on the first chunk, before every
+ * later chunk, once more at stream end; chunks coalesced per setImmediate).
+ *
+ * Source: vercel/next.js v15.5.2 (commit 497ec6aa08a33f9e2d65a5c8461f550c2549d3e6)
+ *   packages/next/src/server/stream-utils/node-web-streams-helper.ts
+ *     createBufferedTransformStream, createHeadInsertionTransformStream, streamToString
+ *   packages/next/src/server/stream-utils/uint8array-helpers.ts (indexOfUint8Array)
+ *   packages/next/src/server/stream-utils/encoded-tags.ts (ENCODED_TAGS.CLOSED.HEAD)
+ *   packages/next/src/lib/detached-promise.ts, packages/next/src/lib/scheduler.ts
+ *
+ * Copyright (c) 2025 Vercel, Inc. Licensed under the MIT License.
+ * Only formatting and import inlining changed.
+ */
+/* eslint-disable */
+
+const encoder = new TextEncoder();
+
+class DetachedPromise<T = any> {
+  public readonly resolve: (value: T | PromiseLike<T>) => void;
+  public readonly reject: (reason: any) => void;
+  public readonly promise: Promise<T>;
+
+  constructor() {
+    let resolve: (value: T | PromiseLike<T>) => void;
+    let reject: (reason: any) => void;
+    this.promise = new Promise<T>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    this.resolve = resolve!;
+    this.reject = reject!;
+  }
+}
+
+const scheduleImmediate = (cb: () => void): void => {
+  setImmediate(cb);
+};
+
+const CLOSED_HEAD = new Uint8Array([60, 47, 104, 101, 97, 100, 62]);
+
+function indexOfUint8Array(a: Uint8Array, b: Uint8Array) {
+  if (b.length === 0) return 0;
+  if (a.length === 0 || b.length > a.length) return -1;
+
+  for (let i = 0; i <= a.length - b.length; i++) {
+    let completeMatch = true;
+    for (let j = 0; j < b.length; j++) {
+      if (a[i + j] !== b[j]) {
+        completeMatch = false;
+        break;
+      }
+    }
+    if (completeMatch) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+export async function streamToString(
+  stream: ReadableStream<Uint8Array>,
+  signal?: AbortSignal,
+): Promise<string> {
+  const decoder = new TextDecoder('utf-8', { fatal: true });
+  let string = '';
+
+  for await (const chunk of stream as any) {
+    if (signal?.aborted) {
+      return string;
+    }
+    string += decoder.decode(chunk, { stream: true });
+  }
+  string += decoder.decode();
+  return string;
+}
+
+export function createBufferedTransformStream(): TransformStream<
+  Uint8Array,
+  Uint8Array
+> {
+  let bufferedChunks: Array<Uint8Array> = [];
+  let bufferByteLength: number = 0;
+  let pending: DetachedPromise<void> | undefined;
+
+  const flush = (controller: TransformStreamDefaultController) => {
+    // If we already have a pending flush, then return early.
+    if (pending) return;
+
+    const detached = new DetachedPromise<void>();
+    pending = detached;
+
+    scheduleImmediate(() => {
+      try {
+        const chunk = new Uint8Array(bufferByteLength);
+        let copiedBytes = 0;
+
+        for (let i = 0; i < bufferedChunks.length; i++) {
+          const bufferedChunk = bufferedChunks[i];
+          chunk.set(bufferedChunk, copiedBytes);
+          copiedBytes += bufferedChunk.byteLength;
+        }
+        // We just wrote all the buffered chunks so we need to reset the bufferedChunks array
+        // and our bufferByteLength to prepare for the next round of buffered chunks
+        bufferedChunks.length = 0;
+        bufferByteLength = 0;
+        controller.enqueue(chunk);
+      } catch {
+        // If an error occurs while enqueuing it can't be due to this
+        // transformers fault. It's likely due to the controller being
+        // errored due to the stream being cancelled.
+      } finally {
+        pending = undefined;
+        detached.resolve();
+      }
+    });
+  };
+
+  return new TransformStream({
+    transform(chunk, controller) {
+      // Combine the previous buffer with the new chunk.
+      bufferedChunks.push(chunk);
+      bufferByteLength += chunk.byteLength;
+
+      // Flush the buffer to the controller.
+      flush(controller);
+    },
+    flush() {
+      if (!pending) return;
+
+      return pending.promise;
+    },
+  });
+}
+
+export function createHeadInsertionTransformStream(
+  insert: () => Promise<string>,
+): TransformStream<Uint8Array, Uint8Array> {
+  let inserted = false;
+
+  // We need to track if this transform saw any bytes because if it didn't
+  // we won't want to insert any server HTML at all
+  let hasBytes = false;
+
+  return new TransformStream({
+    async transform(chunk, controller) {
+      hasBytes = true;
+
+      const insertion = await insert();
+      if (inserted) {
+        if (insertion) {
+          const encodedInsertion = encoder.encode(insertion);
+          controller.enqueue(encodedInsertion);
+        }
+        controller.enqueue(chunk);
+      } else {
+        const index = indexOfUint8Array(chunk, CLOSED_HEAD);
+        // In fully static rendering or non PPR rendering cases:
+        // `/head>` will always be found in the chunk in first chunk rendering.
+        if (index !== -1) {
+          if (insertion) {
+            const encodedInsertion = encoder.encode(insertion);
+            const insertedHeadContent = new Uint8Array(
+              chunk.length + encodedInsertion.length,
+            );
+            insertedHeadContent.set(chunk.slice(0, index));
+            insertedHeadContent.set(encodedInsertion, index);
+            insertedHeadContent.set(
+              chunk.slice(index),
+              index + encodedInsertion.length,
+            );
+            controller.enqueue(insertedHeadContent);
+          } else {
+            controller.enqueue(chunk);
+          }
+          inserted = true;
+        } else {
+          // This will happens in PPR rendering during next start, when the page is partially rendered.
+          // When the page resumes, the head tag will be found in the middle of the chunk.
+          if (insertion) {
+            controller.enqueue(encoder.encode(insertion));
+          }
+          controller.enqueue(chunk);
+          inserted = true;
+        }
+      }
+    },
+    async flush(controller) {
+      // Check before closing if there's anything remaining to insert.
+      if (hasBytes) {
+        const insertion = await insert();
+        if (insertion) {
+          controller.enqueue(encoder.encode(insertion));
+        }
+      }
+    },
+  });
+}
diff --git a/packages/react/src/server/nextjs/DataProvider/__tests__/fixtures/serverInsertedHTMLHarness.tsx b/packages/react/src/server/nextjs/DataProvider/__tests__/fixtures/serverInsertedHTMLHarness.tsx
new file mode 100644
index 000000000000..80be5d70f6f7
--- /dev/null
+++ b/packages/react/src/server/nextjs/DataProvider/__tests__/fixtures/serverInsertedHTMLHarness.tsx
@@ -0,0 +1,88 @@
+/**
+ * Mirrors the parts of Next.js that drive `useServerInsertedHTML`:
+ * `server-inserted-html.shared-runtime.tsx` (the hook and its context),
+ * `app-render/server-inserted-html.tsx` (callback collection) and
+ * `app-render/make-get-server-inserted-html.tsx` (rendering callbacks to a
+ * string per flush). Doubles as the virtual `next/navigation` module.
+ */
+import React, { useContext } from 'react';
+import { renderToReadableStream } from 'react-dom/server';
+
+import {
+  createBufferedTransformStream,
+  createHeadInsertionTransformStream,
+  streamToString,
+} from './next-15.5.2-head-insertion';
+
+type ServerInsertedHTMLHook = (callback: () => React.ReactNode) => void;
+
+export const ServerInsertedHTMLContext =
+  React.createContext<ServerInsertedHTMLHook | null>(null);
+
+export function useServerInsertedHTML(callback: () => React.ReactNode): void {
+  const addInsertedServerHTMLCallback = useContext(ServerInsertedHTMLContext);
+  if (addInsertedServerHTMLCallback) {
+    addInsertedServerHTMLCallback(callback);
+  }
+}
+
+export function createServerInsertedHTML() {
+  const callbacks: (() => React.ReactNode)[] = [];
+  const addInsertedHtml: ServerInsertedHTMLHook = handler => {
+    callbacks.push(handler);
+  };
+  return {
+    ServerInsertedHTMLProvider({ children }: { children: React.ReactNode }) {
+      return (
+        <ServerInsertedHTMLContext.Provider value={addInsertedHtml}>
+          {children}
+        </ServerInsertedHTMLContext.Provider>
+      );
+    },
+    async getServerInsertedHTML(): Promise<string> {
+      const stream = await renderToReadableStream(
+        <>
+          {callbacks.map((callback, index) => (
+            <React.Fragment key={'__next_server_inserted__' + index}>
+              {callback()}
+            </React.Fragment>
+          ))}
+        </>,
+        { progressiveChunkSize: 1024 * 1024 },
+      );
+      return streamToString(stream);
+    },
+  };
+}
+
+export interface RenderPageOptions {
+  /** Static generation waits for the whole tree before flushing anything */
+  staticGeneration?: boolean;
+  onError?: (error: unknown) => void;
+}
+
+/** Streams a document the way Next.js does for an App Router request */
+export async function renderPage(
+  app: React.ReactNode,
+  { staticGeneration = false, onError }: RenderPageOptions = {},
+): Promise<string> {
+  const { ServerInsertedHTMLProvider, getServerInsertedHTML } =
+    createServerInsertedHTML();
+  const stream = await renderToReadableStream(
+    <ServerInsertedHTMLProvider>
+      <html>
+        <head>
+          <meta charSet="utf-8" />
+        </head>
+        <body>{app}</body>
+      </html>
+    </ServerInsertedHTMLProvider>,
+    { onError },
+  );
+  if (staticGeneration) await stream.allReady;
+  return streamToString(
+    stream
+      .pipeThrough(createBufferedTransformStream())
+      .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML)),
+  );
+}
diff --git a/packages/react/src/server/nextjs/DataProvider/__tests__/hydration.web.tsx b/packages/react/src/server/nextjs/DataProvider/__tests__/hydration.web.tsx
new file mode 100644
index 000000000000..d611de50097a
--- /dev/null
+++ b/packages/react/src/server/nextjs/DataProvider/__tests__/hydration.web.tsx
@@ -0,0 +1,406 @@
+jest.mock(
+  'next/navigation',
+  () => ({ useServerInsertedHTML: () => undefined }),
+  { virtual: true },
+);
+
+import {
+  Controller,
+  __INTERNAL__,
+  actions,
+  createReducer,
+  initialState,
+} from '@data-client/core';
+import type { State, StateDelta } from '@data-client/core';
+import { Endpoint, Entity } from '@data-client/endpoint';
+import React, { StrictMode, Suspense, version } from 'react';
+import { renderToString } from 'react-dom/server';
+
+import PlainDataProvider from '../../../../components/DataProvider';
+import useCache from '../../../../hooks/useCache';
+import useController from '../../../../hooks/useController';
+import useSuspense from '../../../../hooks/useSuspense';
+import { NetworkManager } from '../../../../managers';
+import NextDataProvider from '../DataProvider';
+import { BASELINE_ID, getDeltaQueue } from '../deltaQueue';
+import { getSnapshotStore } from '../snapshotStore';
+
+const { diffState } = __INTERNAL__;
+
+class Todo extends Entity {
+  id = '';
+  title = '';
+  pk() {
+    return this.id;
+  }
+}
+const fetchTodo = jest.fn(async ({ id }: { id: string }) => ({
+  id,
+  title: `todo ${id}`,
+}));
+const getTodo = new Endpoint(fetchTodo, { schema: Todo, name: 'getTodo' });
+
+const reducer = createReducer(new Controller());
+const setTodo = (state: State<unknown>, id: string) =>
+  reducer(
+    state,
+    actions.createSetResponse(getTodo, {
+      args: [{ id }],
+      response: { id, title: `todo ${id}` },
+    }),
+  );
+const transport = <T,>(value: T): T => JSON.parse(JSON.stringify(value));
+
+const tick = (ms = 30) => new Promise(resolve => setTimeout(resolve, ms));
+/** React reveals content at most 300ms after it showed a fallback */
+const REVEAL = 500;
+
+type GatePromise = Promise<void> & { done?: boolean; release: () => void };
+function makeGate(open = false): GatePromise {
+  let release!: () => void;
+  const promise: GatePromise = Object.assign(
+    new Promise<void>(resolve => {
+      release = () => {
+        promise.done = true;
+        resolve();
+      };
+    }),
+    { done: open, release: () => undefined },
+  );
+  promise.release = release;
+  return promise;
+}
+/** Suspends until released; resolved during server rendering */
+function Gate({
+  promise,
+  children,
+}: {
+  promise: GatePromise;
+  children: React.ReactNode;
+}) {
+  if (!promise.done) throw promise;
+  return <>{children}</>;
+}
+
+function TodoView({ id }: { id: string }) {
+  const todo = useSuspense(getTodo, { id });
+  return <p data-id={id}>{todo.title}</p>;
+}
+let controller: Controller | undefined;
+/** Observes the live store outside any boundary without affecting the HTML */
+let liveTitle: string | undefined;
+function Probe() {
+  controller = useController();
+  liveTitle = useCache(getTodo, { id: '1' })?.title;
+  return null;
+}
+
+/** What the browser does when a streamed delta script executes */
+function streamDelta(delta: StateDelta) {
+  const queue = getDeltaQueue();
+  queue.push(delta);
+  queue.onDelta?.(delta);
+}
+
+function installBaseline(state: State<unknown>) {
+  const script = document.createElement('script');
+  script.id = BASELINE_ID;
+  script.type = 'application/json';
+  script.textContent = JSON.stringify(state);
+  document.head.appendChild(script);
+}
+
+const LegacyReact = version.startsWith('16') || version.startsWith('17');
+const React19 = Number.parseInt(version, 10) >= 19;
+const describeHydration = LegacyReact ? describe.skip : describe;
+// react-dom/client is 18+; a static import throws on 16/17 before describe.skip
+let createRoot!: typeof import('react-dom/client').createRoot;
+let hydrateRoot!: typeof import('react-dom/client').hydrateRoot;
+if (!LegacyReact) {
+  ({ createRoot, hydrateRoot } = jest.requireActual('react-dom/client'));
+}
+
+describeHydration('Next.js DataProvider hydration', () => {
+  let container: HTMLDivElement;
+  let errors: string[];
+  let consoleError: jest.SpyInstance;
+  let previousActEnv: unknown;
+
+  // server timeline: empty shell -> todo 0 boundary -> todo 1 boundary
+  const s0 = initialState;
+  const s1 = setTodo(s0, '0');
+  const s2 = setTodo(s1, '1');
+  const delta1 = transport(diffState(s0, s1)!);
+  const delta2 = transport(diffState(s1, s2)!);
+
+  beforeAll(async () => {
+    previousActEnv = (globalThis as any).IS_REACT_ACT_ENVIRONMENT;
+    (globalThis as any).IS_REACT_ACT_ENVIRONMENT = false;
+    // let the lazy dev tools button load so renderToString never suspends
+    renderToString(
+      <PlainDataProvider>
+        <div />
+      </PlainDataProvider>,
+    );
+    await tick(0);
+  });
+  afterAll(() => {
+    (globalThis as any).IS_REACT_ACT_ENVIRONMENT = previousActEnv;
+  });
+  beforeEach(() => {
+    fetchTodo.mockClear();
+    controller = undefined;
+    liveTitle = undefined;
+    errors = [];
+    consoleError = jest
+      .spyOn(console, 'error')
+      .mockImplementation((...args) => errors.push(args.join(' ')));
+    container = document.createElement('div');
+    document.body.appendChild(container);
+    delete (globalThis as any).__DATA_CLIENT_DELTAS__;
+    document.getElementById(BASELINE_ID)?.remove();
+  });
+  afterEach(() => {
+    consoleError.mockRestore();
+    container.remove();
+  });
+
+  const Page = ({ gate }: { gate: GatePromise }) => (
+    <>
+      <Probe />
+      <Suspense fallback="loading 0">
+        <TodoView id="0" />
+      </Suspense>
+      <Suspense fallback="loading 1">
+        <Gate promise={gate}>
+          <TodoView id="1" />
+        </Gate>
+      </Suspense>
+    </>
+  );
+
+  /** The server rendered both boundaries, the second one from s2 */
+  function serverHTML() {
+    return renderToString(
+      <PlainDataProvider initialState={s2}>
+        <Page gate={makeGate(true)} />
+      </PlainDataProvider>,
+    );
+  }
+
+  function hydrate(gate: GatePromise, strict = false) {
+    const tree = (
+      <NextDataProvider>
+        <Page gate={gate} />
+      </NextDataProvider>
+    );
+    return hydrateRoot(
+      container,
+      strict ? <StrictMode>{tree}</StrictMode> : tree,
+      {
+        onRecoverableError: e =>
+          errors.push(`recoverable: ${(e as Error).message}`),
+      },
+    );
+  }
+
+  const text = (selector: string) =>
+    container.querySelector(selector)?.textContent;
+
+  async function streamsIntoDehydratedBoundary(strict: boolean) {
+    container.innerHTML = serverHTML();
+    const serverNode = container.querySelector('[data-id="1"]')!;
+    (serverNode as any).__server = true;
+    installBaseline(s0);
+    streamDelta(delta1);
+
+    const gate = makeGate();
+    hydrate(gate, strict);
+    await tick();
+    expect(text('[data-id="0"]')).toBe('todo 0');
+    expect(liveTitle).toBeUndefined();
+
+    // the second boundary's delta script runs while it is still dehydrated
+    streamDelta(delta2);
+    // flushSync: the live store agrees before the parser reaches the boundary
+    expect(liveTitle).toBe('todo 1');
+    expect(getSnapshotStore().state.entities.Todo).toHaveProperty('1');
+
+    gate.release();
+    await tick();
+    const hydrated = container.querySelector('[data-id="1"]')!;
+    expect(hydrated.textContent).toBe('todo 1');
+    // React 18 may client-render a still-dehydrated boundary (docs limitation)
+    if (React19) {
+      expect((hydrated as any).__server).toBe(true);
+      expect(errors).toEqual([]);
+    }
+    expect(fetchTodo).not.toHaveBeenCalled();
+  }
+
+  it('applies deltas that stream in while a boundary is dehydrated', () =>
+    streamsIntoDehydratedBoundary(false));
+
+  it('does the same under StrictMode', () =>
+    streamsIntoDehydratedBoundary(true));
+
+  it('folds deltas queued before hydration into the initial state', async () => {
+    container.innerHTML = serverHTML();
+    installBaseline(s0);
+    streamDelta(delta1);
+    streamDelta(delta2);
+    hydrate(makeGate(true));
+    await tick();
+    expect(text('[data-id="1"]')).toBe('todo 1');
+    expect(liveTitle).toBe('todo 1');
+    expect(errors).toEqual([]);
+    expect(fetchTodo).not.toHaveBeenCalled();
+  });
+
+  it('drops server deltas after the client reset its store', async () => {
+    container.innerHTML = serverHTML();
+    installBaseline(s1);
+    const gate = makeGate();
+    hydrate(gate);
+    await tick();
+    controller!.resetEntireStore();
+    await tick();
+    streamDelta(delta2);
+    // React 18 may client-render and remount from the snapshot (delta already folded).
+    if (React19) {
+      expect(controller!.getState().entities.Todo).not.toHaveProperty('1');
+    }
+    gate.release();
+    await tick(REVEAL);
+    // hydrates against the snapshot the HTML came from, then refetches once
+    expect(text('[data-id="1"]')).toBe('todo 1');
+    if (React19) {
+      expect(errors).toEqual([]);
+    }
+    expect(fetchTodo.mock.calls.map(([args]) => args.id)).toEqual(['0', '1']);
+  });
+
+  it('refetches exactly once when a delta arrives after its boundary hydrated', async () => {
+    container.innerHTML = serverHTML();
+    installBaseline(s1);
+    hydrate(makeGate(true));
+    await tick(100);
+    expect(text('[data-id="1"]')).toBe('todo 1');
+    expect(fetchTodo).toHaveBeenCalledTimes(1);
+    streamDelta(delta2);
+    await tick();
+    expect(fetchTodo).toHaveBeenCalledTimes(1);
+    if (React19) {
+      expect(errors).toEqual([]);
+    }
+  });
+
+  it('renders immediately without a baseline once the document has loaded', async () => {
+    createRoot(container).render(
+      <NextDataProvider>
+        <Suspense fallback="loading">
+          <TodoView id="1" />
+        </Suspense>
+      </NextDataProvider>,
+    );
+    await tick(REVEAL);
+    expect(text('[data-id="1"]')).toBe('todo 1');
+    expect(fetchTodo).toHaveBeenCalledTimes(1);
+    expect(errors).toEqual([]);
+  });
+
+  it('waits for the baseline while the document is still loading', async () => {
+    // HOLD regression guard: missing-baseline still suspends on document
+    // load. Not final no-delay compliance.
+    Object.defineProperty(document, 'readyState', {
+      value: 'loading',
+      configurable: true,
+    });
+    let thrown: unknown;
+    try {
+      getSnapshotStore();
+    } catch (e) {
+      thrown = e;
+    } finally {
+      delete (document as any).readyState;
+    }
+    expect(thrown).toBeInstanceOf(Promise);
+    installBaseline(s1);
+    document.dispatchEvent(new Event('DOMContentLoaded'));
+    await thrown;
+    expect(getSnapshotStore().state.entities.Todo).toHaveProperty('0');
+  });
+
+  it('keeps the receiver when a delta ends the wait before DOMContentLoaded', async () => {
+    Object.defineProperty(document, 'readyState', {
+      value: 'loading',
+      configurable: true,
+    });
+    let thrown: Promise<void> | undefined;
+    try {
+      getSnapshotStore();
+    } catch (e) {
+      thrown = e as Promise<void>;
+    }
+    // the first delta script runs before the document finishes parsing
+    installBaseline(s0);
+    streamDelta(delta1);
+    await thrown;
+    const queue = getDeltaQueue();
+    expect(queue.pending).toBeUndefined();
+    delete (document as any).readyState;
+    expect(getSnapshotStore().state.entities.Todo).toHaveProperty('0');
+
+    const receiver = jest.fn();
+    queue.onDelta = receiver;
+    document.dispatchEvent(new Event('DOMContentLoaded'));
+    streamDelta(delta2);
+    expect(queue.onDelta).toBe(receiver);
+    expect(receiver).toHaveBeenCalledWith(delta2);
+  });
+
+  it('resolves a managers factory once on the client', async () => {
+    const factory = jest.fn(() => [new NetworkManager()]);
+    container.innerHTML = renderToString(
+      <PlainDataProvider initialState={s1} managers={factory()}>
+        <Suspense fallback="loading">
+          <TodoView id="0" />
+        </Suspense>
+      </PlainDataProvider>,
+    );
+    factory.mockClear();
+    installBaseline(s1);
+    // StrictMode invokes useMemo's calculation twice; the factory must not be
+    const root = hydrateRoot(
+      container,
+      <StrictMode>
+        <NextDataProvider managers={factory}>
+          <Suspense fallback="loading">
+            <TodoView id="0" />
+          </Suspense>
+        </NextDataProvider>
+      </StrictMode>,
+    );
+    await tick();
+    expect(factory).toHaveBeenCalledTimes(1);
+    expect(text('[data-id="0"]')).toBe('todo 0');
+    expect(errors).toEqual([]);
+    root.unmount();
+  });
+
+  it('uses a custom Controller class on the client', async () => {
+    class MyController extends Controller {}
+    let seen: Controller | undefined;
+    function Capture() {
+      seen = useController();
+      return null;
+    }
+    createRoot(container).render(
+      <NextDataProvider Controller={MyController as typeof Controller}>
+        <Capture />
+      </NextDataProvider>,
+    );
+    await tick();
+    expect(seen).toBeInstanceOf(MyController);
+  });
+});
diff --git a/packages/react/src/server/nextjs/DataProvider/__tests__/streaming.node.tsx b/packages/react/src/server/nextjs/DataProvider/__tests__/streaming.node.tsx
new file mode 100644
index 000000000000..5c2f5927a9e0
--- /dev/null
+++ b/packages/react/src/server/nextjs/DataProvider/__tests__/streaming.node.tsx
@@ -0,0 +1,415 @@
+jest.mock(
+  'next/navigation',
+  () => require('./fixtures/serverInsertedHTMLHarness'),
+  { virtual: true },
+);
+
+import { __INTERNAL__, NetworkManager } from '@data-client/core';
+import { Controller } from '@data-client/core';
+import type { Manager, State, StateDelta } from '@data-client/core';
+import { Endpoint, Entity } from '@data-client/endpoint';
+import React, { Suspense } from 'react';
+
+import { renderPage } from './fixtures/serverInsertedHTMLHarness';
+import useController from '../../../../hooks/useController';
+import useSuspense from '../../../../hooks/useSuspense';
+import DataProvider from '../DataProvider';
+
+const { applyStateDelta, initialState } = __INTERNAL__;
+
+class Todo extends Entity {
+  id = 0;
+  title = '';
+  pk() {
+    return `${this.id}`;
+  }
+}
+
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+function makeGetTodo(
+  titles: Record<string, string> = {},
+  delays: Record<string, number> = {},
+) {
+  return new Endpoint(
+    async ({ id }: { id: string }) => {
+      await sleep(delays[id] ?? 5);
+      const title = Object.hasOwn(titles, id) ? titles[id] : `todo ${id}`;
+      if (title === 'FAIL') throw new Error(`todo ${id} failed`);
+      return { id, title };
+    },
+    { schema: Todo, name: 'getTodo' },
+  );
+}
+
+/** Suspends its children until `promise` resolves, like an async Server Component */
+function Gate({
+  promise,
+  children,
+}: {
+  promise: Promise<void> & { done?: boolean };
+  children: React.ReactNode;
+}) {
+  if (!promise.done) throw promise;
+  return <>{children}</>;
+}
+const openAfter = (ms: number) => {
+  const promise: Promise<void> & { done?: boolean } = sleep(ms).then(() => {
+    promise.done = true;
+  });
+  return promise;
+};
+
+function TodoView({
+  endpoint,
+  id,
+}: {
+  endpoint: ReturnType<typeof makeGetTodo>;
+  id: string;
+}) {
+  const todo = useSuspense(endpoint, { id });
+  return <p>{todo.title}</p>;
+}
+
+/** Lets tests read the per-request store and dispatch into it */
+class CaptureManager implements Manager {
+  controller!: Controller;
+  middleware: Manager['middleware'] = controller => {
+    this.controller = controller;
+    return next => action => next(action);
+  };
+
+  cleanup() {}
+}
+
+interface Payload {
+  index: number;
+  baseline?: State<unknown>;
+  delta?: StateDelta;
+  attrs: string;
+}
+
+/** Runs the inline scripts the way a browser would while parsing */
+function readPayloads(html: string): Payload[] {
+  const payloads: Payload[] = [];
+  const self: { __DATA_CLIENT_DELTAS__?: StateDelta[] } = {};
+  let cursor = 0;
+  while (cursor < html.length) {
+    const open = html.indexOf('<script', cursor);
+    if (open === -1) break;
+    const afterName = open + '<script'.length;
+    const next = html.charAt(afterName);
+    if (next !== '>' && next !== '' && !/\s/.test(next)) {
+      cursor = afterName;
+      continue;
+    }
+    const tagEnd = html.indexOf('>', afterName);
+    if (tagEnd === -1) break;
+    const attrs = html.slice(afterName, tagEnd);
+    const contentStart = tagEnd + 1;
+    const close = html.toLowerCase().indexOf('</script', contentStart);
+    if (close === -1) break;
+    const content = html.slice(contentStart, close);
+    const closeEnd = html.indexOf('>', close);
+    cursor = closeEnd === -1 ? close : closeEnd + 1;
+
+    if (attrs.includes('id="data-client-data"')) {
+      payloads.push({
+        index: open,
+        baseline: JSON.parse(content),
+        attrs,
+      });
+    } else if (
+      content.startsWith('(function(){var q=self.__DATA_CLIENT_DELTAS__')
+    ) {
+      const before = self.__DATA_CLIENT_DELTAS__?.length ?? 0;
+      new Function('self', content)(self);
+      expect(self.__DATA_CLIENT_DELTAS__).toHaveLength(before + 1);
+      payloads.push({
+        index: open,
+        delta: self.__DATA_CLIENT_DELTAS__![before],
+        attrs,
+      });
+    }
+  }
+  return payloads;
+}
+
+function fold(payloads: Payload[]): State<unknown> {
+  let state = payloads[0]?.baseline ?? initialState;
+  for (const { delta } of payloads.slice(1))
+    state = applyStateDelta(state, delta!);
+  return state;
+}
+
+/** What a JSON transport can carry: no `optimistic`, no `undefined` */
+const serializable = (state: State<unknown>) =>
+  JSON.parse(JSON.stringify({ ...state, optimistic: undefined }));
+
+/** The first payload that carries `key`, or undefined */
+const payloadWith = (payloads: Payload[], key: string) =>
+  payloads.find(
+    p =>
+      (p.baseline && key in p.baseline.endpoints) ||
+      p.delta?.endpoints.some(change => change.key === key),
+  );
+
+describe('Next.js DataProvider streaming', () => {
+  function setup() {
+    const capture = new CaptureManager();
+    const managers = () => [new NetworkManager(), capture];
+    return { capture, managers };
+  }
+
+  it('streams data fetched by a descendant that renders after the shell', async () => {
+    const { capture, managers } = setup();
+    const getTodo = makeGetTodo();
+    const html = await renderPage(
+      <DataProvider managers={managers} nonce="n0nce">
+        <Gate promise={openAfter(40)}>
+          <Suspense fallback="loading">
+            <TodoView endpoint={getTodo} id="1" />
+          </Suspense>
+        </Gate>
+      </DataProvider>,
+    );
+
+    expect(html).toContain('<p>todo 1</p>');
+    const payloads = readPayloads(html);
+    // the shell had nothing yet
+    expect(payloads[0].baseline!.entities).toEqual({});
+    expect(payloads[0].index).toBeLessThan(html.indexOf('</head>'));
+    // the data arrives before the HTML that was rendered from it
+    const key = getTodo.key({ id: '1' });
+    const carrier = payloadWith(payloads, key)!;
+    expect(carrier.delta).toBeDefined();
+    expect(carrier.index).toBeLessThan(html.indexOf('<p>todo 1</p>'));
+    for (const payload of payloads)
+      expect(payload.attrs).toContain('nonce="n0nce"');
+    expect(serializable(fold(payloads))).toEqual(
+      serializable(capture.controller.getState()),
+    );
+  });
+
+  it('emits one delta per flush for staggered descendants', async () => {
+    const { capture, managers } = setup();
+    const getTodo = makeGetTodo();
+    const html = await renderPage(
+      <DataProvider managers={managers}>
+        <Suspense fallback="loading">
+          <TodoView endpoint={getTodo} id="0" />
+        </Suspense>
+        <Gate promise={openAfter(30)}>
+          <Suspense fallback="loading">
+            <TodoView endpoint={getTodo} id="1" />
+          </Suspense>
+        </Gate>
+        <Gate promise={openAfter(70)}>
+          <Suspense fallback="loading">
+            <TodoView endpoint={getTodo} id="2" />
+          </Suspense>
+        </Gate>
+      </DataProvider>,
+    );
+    const payloads = readPayloads(html);
+    for (const id of ['0', '1', '2']) {
+      const text = `<p>todo ${id}</p>`;
+      expect(html).toContain(text);
+      const carrier = payloadWith(payloads, getTodo.key({ id }))!;
+      expect(carrier).toBeDefined();
+      expect(carrier.index).toBeLessThan(html.indexOf(text));
+    }
+    // later deltas only carry what changed
+    const deltas = payloads.filter(p => p.delta);
+    expect(deltas.length).toBeGreaterThanOrEqual(2);
+    for (const { delta } of deltas)
+      expect(delta!.entities.length).toBeLessThanOrEqual(1);
+    expect(serializable(fold(payloads))).toEqual(
+      serializable(capture.controller.getState()),
+    );
+  });
+
+  it('encodes removals from invalidate and a reset mid-stream', async () => {
+    const { capture, managers } = setup();
+    const getTodo = makeGetTodo();
+    const gate = openAfter(40);
+    gate.then(() => {
+      capture.controller.invalidate(getTodo, { id: '0' });
+    });
+    const secondGate = openAfter(80);
+    secondGate.then(() => {
+      capture.controller.resetEntireStore();
+    });
+    const html = await renderPage(
+      <DataProvider managers={managers}>
+        <Suspense fallback="loading">
+          <TodoView endpoint={getTodo} id="0" />
+        </Suspense>
+        <Gate promise={gate}>
+          <Suspense fallback="loading">
+            <TodoView endpoint={getTodo} id="1" />
+          </Suspense>
+        </Gate>
+        <Gate promise={secondGate}>
+          <Suspense fallback="loading">
+            <TodoView endpoint={getTodo} id="2" />
+          </Suspense>
+        </Gate>
+      </DataProvider>,
+    );
+    const payloads = readPayloads(html);
+    const deltas = payloads.map(p => p.delta).filter(Boolean) as StateDelta[];
+    const key0 = getTodo.key({ id: '0' });
+    const removal = deltas
+      .flatMap(d => d.endpoints)
+      .find(c => c.key === key0 && !c.value?.endpoint);
+    expect(removal?.value?.meta?.invalidated).toBe(true);
+    expect(deltas.some(d => d.reset !== undefined)).toBe(true);
+    const final = capture.controller.getState();
+    expect(final.lastReset).toBeGreaterThan(0);
+    expect(serializable(fold(payloads))).toEqual(serializable(final));
+    expect(html).toContain('<p>todo 2</p>');
+  });
+
+  it('keeps streaming when a request fails', async () => {
+    const { capture, managers } = setup();
+    const getTodo = makeGetTodo({ '1': 'FAIL' });
+    const errors: unknown[] = [];
+    const html = await renderPage(
+      <DataProvider managers={managers}>
+        <Suspense fallback="loading">
+          <TodoView endpoint={getTodo} id="0" />
+        </Suspense>
+        <Gate promise={openAfter(30)}>
+          <Suspense fallback="loading">
+            <TodoView endpoint={getTodo} id="1" />
+          </Suspense>
+        </Gate>
+      </DataProvider>,
+      {
+        onError: e => {
+          errors.push(e);
+        },
+      },
+    );
+    expect(html).toContain('<p>todo 0</p>');
+    expect(errors.map(e => (e as Error).message)).toEqual(['todo 1 failed']);
+    const payloads = readPayloads(html);
+    const final = capture.controller.getState();
+    expect(final.meta[getTodo.key({ id: '1' })].error).toBeDefined();
+    expect(serializable(fold(payloads))).toEqual(serializable(final));
+  });
+
+  it('emits only the baseline for a page without requests', async () => {
+    const html = await renderPage(
+      <DataProvider>
+        <p>static</p>
+      </DataProvider>,
+    );
+    const payloads = readPayloads(html);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0].baseline).toEqual(
+      JSON.parse(JSON.stringify(initialState)),
+    );
+    expect(html).not.toContain('__DATA_CLIENT_DELTAS__');
+  });
+
+  it('static generation flushes the complete state once', async () => {
+    const { capture, managers } = setup();
+    const getTodo = makeGetTodo();
+    const html = await renderPage(
+      <DataProvider managers={managers}>
+        <Gate promise={openAfter(30)}>
+          <Suspense fallback="loading">
+            <TodoView endpoint={getTodo} id="1" />
+          </Suspense>
+        </Gate>
+      </DataProvider>,
+      { staticGeneration: true },
+    );
+    const payloads = readPayloads(html);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0].baseline!.endpoints[getTodo.key({ id: '1' })]).toBe('1');
+    expect(serializable(payloads[0].baseline!)).toEqual(
+      serializable(capture.controller.getState()),
+    );
+  });
+
+  it('isolates concurrent requests using a managers factory', async () => {
+    const getTodo = makeGetTodo({ a: 'alpha', b: 'beta' });
+    const page = (id: string) =>
+      renderPage(
+        <DataProvider managers={() => [new NetworkManager()]}>
+          <Gate promise={openAfter(id === 'a' ? 20 : 40)}>
+            <Suspense fallback="loading">
+              <TodoView endpoint={getTodo} id={id} />
+            </Suspense>
+          </Gate>
+        </DataProvider>,
+      );
+    const [a, b] = await Promise.all([page('a'), page('b')]);
+    expect(a).toContain('<p>alpha</p>');
+    expect(a).not.toContain('beta');
+    expect(b).toContain('<p>beta</p>');
+    expect(b).not.toContain('alpha');
+    expect(JSON.stringify(fold(readPayloads(a)).entities)).not.toContain(
+      'beta',
+    );
+    expect(JSON.stringify(fold(readPayloads(b)).entities)).not.toContain(
+      'alpha',
+    );
+  });
+
+  it('escapes payloads so API data cannot break out of the script', async () => {
+    const { capture, managers } = setup();
+    const evil = '</script><script>alert(1)</script>\u2028<b>';
+    const getTodo = makeGetTodo({ '1': evil });
+    const html = await renderPage(
+      <DataProvider managers={managers}>
+        <Suspense fallback="loading">
+          <TodoView endpoint={getTodo} id="__proto__" />
+        </Suspense>
+        <Gate promise={openAfter(30)}>
+          <Suspense fallback="loading">
+            <TodoView endpoint={getTodo} id="1" />
+          </Suspense>
+        </Gate>
+      </DataProvider>,
+    );
+    const payloads = readPayloads(html);
+    const folded = fold(payloads);
+    expect((folded.entities.Todo!['1'] as Todo).title).toBe(evil);
+    // the hostile pk is dropped rather than assigned onto the table prototype
+    expect(Object.getPrototypeOf(folded.entities.Todo)).toBe(Object.prototype);
+    expect(({} as any).title).toBeUndefined();
+    const scripts = html.match(/<script/g)!.length;
+    expect(html.match(/<\/script>/g)!.length).toBe(scripts);
+    expect(capture.controller.getState().entities.Todo).toHaveProperty('1');
+  });
+
+  it('rejects manager instances with a migration hint', async () => {
+    await expect(
+      renderPage(
+        <DataProvider managers={[new NetworkManager()] as any}>
+          <p>hi</p>
+        </DataProvider>,
+        { onError: () => undefined },
+      ),
+    ).rejects.toThrow(/managers=\{\(\) => \[\.\.\.\]\}/);
+  });
+
+  it('exposes the controller to descendants, honoring a custom class', async () => {
+    class MyController extends Controller {}
+    let seen: Controller | undefined;
+    function Probe() {
+      seen = useController();
+      return null;
+    }
+    await renderPage(
+      <DataProvider Controller={MyController as typeof Controller}>
+        <Probe />
+      </DataProvider>,
+    );
+    expect(seen).toBeInstanceOf(MyController);
+  });
+});
diff --git a/packages/react/src/server/nextjs/DataProvider/createPersistedStore.ts b/packages/react/src/server/nextjs/DataProvider/createPersistedStore.ts
index 5fd9812d0ffe..f72b28a2ecc0 100644
--- a/packages/react/src/server/nextjs/DataProvider/createPersistedStore.ts
+++ b/packages/react/src/server/nextjs/DataProvider/createPersistedStore.ts
@@ -1,8 +1,22 @@
+import type { Controller as DataController, Manager } from '@data-client/core';
+
 import createPersistedStoreClient from './createPersistedStoreClient.js';
 import createPersistedStoreServer from './createPersistedStoreServer.js';
 
-const createPersistedStore =
+const createPersistedStoreForEnvironment =
   typeof window === 'undefined' ?
     createPersistedStoreServer
   : createPersistedStoreClient;
-export default createPersistedStore;
+
+export default function createPersistedStore(
+  managers?: () => Manager[],
+  Controller?: typeof DataController,
+) {
+  if (managers !== undefined && typeof managers !== 'function')
+    throw new Error(
+      `DataProvider from @data-client/react/nextjs takes managers as a function so every request gets its own instances.
+Change managers={[...]} to managers={() => [...]}
+See https://dataclient.io/docs/guides/ssr#managers`,
+    );
+  return createPersistedStoreForEnvironment(managers, Controller);
+}
diff --git a/packages/react/src/server/nextjs/DataProvider/createPersistedStoreClient.tsx b/packages/react/src/server/nextjs/DataProvider/createPersistedStoreClient.tsx
index d838398e1834..25bd344776ce 100644
--- a/packages/react/src/server/nextjs/DataProvider/createPersistedStoreClient.tsx
+++ b/packages/react/src/server/nextjs/DataProvider/createPersistedStoreClient.tsx
@@ -1,32 +1,35 @@
-/// <reference types="react/canary" />
-import { type State } from '@data-client/core';
-import { ComponentProps, use } from 'react';
+'use client';
+import type { Controller as DataController, Manager } from '@data-client/core';
 
-import DataProvider from '../../../components/DataProvider.js';
-import { awaitInitialData } from '../../getInitialData.js';
+import { getSnapshotStore } from './snapshotStore.js';
+import type { StoreProviderProps } from './types.js';
+import DataProviderBase from '../../../components/DataProviderBase.js';
+import createStreamingReducer from '../../stream/createStreamingReducer.js';
+import StreamedStateReceiver from '../../stream/StreamedStateReceiver.js';
 
-export default function createPersistedStore() {
-  const initPromise = awaitInitialData();
+export default function createPersistedStore(
+  managers?: () => Manager[],
+  Controller?: typeof DataController,
+) {
+  const snapshotStore = getSnapshotStore();
+  // One-time DataProvider initialState seed. Later pieces are snapshot folds
+  // plus HYDRATE — never a replaced prop.
+  const initialState = snapshotStore.state;
+  const resolvedManagers = (snapshotStore.managers ??= managers?.());
 
-  const StoreDataProvider = ({
-    children,
-    initPromise,
-    ...props
-  }: ProviderProps) => {
-    const initialState = use(initPromise);
-    return (
-      <DataProvider {...props} initialState={initialState}>
-        {children}
-      </DataProvider>
-    );
-  };
-  return [StoreDataProvider, initPromise] as const;
-}
+  const StoreDataProvider = ({ children, ...props }: StoreProviderProps) => (
+    <DataProviderBase
+      {...props}
+      managers={resolvedManagers}
+      Controller={Controller}
+      initialState={initialState}
+      reducerFactory={createStreamingReducer}
+    >
+      <StreamedStateReceiver snapshotStore={snapshotStore} />
+      {children}
+    </DataProviderBase>
+  );
 
-type ProviderProps = Omit<
-  Partial<ComponentProps<typeof DataProvider>>,
-  'initialState'
-> & {
-  children: React.ReactNode;
-  initPromise: Promise<State<any>>;
-};
+  const renderStateDelta = () => null;
+  return [StoreDataProvider, renderStateDelta] as const;
+}
diff --git a/packages/react/src/server/nextjs/DataProvider/createPersistedStoreServer.tsx b/packages/react/src/server/nextjs/DataProvider/createPersistedStoreServer.tsx
index a46a480f43fb..2c326d77f3b9 100644
--- a/packages/react/src/server/nextjs/DataProvider/createPersistedStoreServer.tsx
+++ b/packages/react/src/server/nextjs/DataProvider/createPersistedStoreServer.tsx
@@ -1,97 +1,87 @@
-import {
-  Controller,
+import { DevToolsManager, __INTERNAL__, initialState } from '@data-client/core';
+import type {
+  Controller as DataController,
   Manager,
-  NetworkManager,
   State,
-  createReducer,
-  initialState,
-  applyManager,
-  DevToolsManager,
-  initManager,
+  StateDelta,
 } from '@data-client/core';
-import type { ComponentProps } from 'react';
+import type { ReactElement } from 'react';
 
-import type DataProvider from '../../../components/DataProvider.js';
-import { NetworkManager as ReactNetworkManager } from '../../../managers/index.js';
-import { PromiseifyMiddleware } from '../../redux/index.js';
-import { createStore, applyMiddleware } from '../../redux/redux.js';
+import { DELTA_QUEUE_GLOBAL, BASELINE_ID } from './deltaQueue.js';
+import type { StoreProviderProps } from './types.js';
+import createServerStore from '../../createServerStore.js';
+import { escapeJsonForScript } from '../../escapeJsonForScript.js';
+import ServerData from '../../ServerData.js';
 import SSRDataProvider from '../../SSRDataProvider.js';
 
-export default function createPersistedStore(managers?: Manager[]) {
-  const controller = new Controller();
-  managers = managers ?? [new ReactNetworkManager()];
-  const networkManager: NetworkManager = managers.find(
-    m => m instanceof NetworkManager,
-  ) as any;
-  if (networkManager === undefined)
-    throw new Error('managers must include a NetworkManager');
-  const reducer = createReducer(controller);
-  const enhancer = applyMiddleware(
-    // redux 5's types are wrong and do not allow any return typing from next, which is incorrect.
-    // `next: (action: unknown) => unknown`: allows any action, but disallows all return types.
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    ...applyManager(managers, controller),
-    PromiseifyMiddleware,
-  );
-  const { getState, dispatch, subscribe } = createStore(
-    reducer,
-    initialState as any,
-    enhancer,
-  );
-  initManager(managers, controller, getState())();
+const { diffState, applyStateDelta } = __INTERNAL__;
 
-  const initPromise: Promise<State<any>> = (async () => {
-    let firstRender = true;
+export default function createPersistedStore(
+  managers?: () => Manager[],
+  Controller?: typeof DataController,
+) {
+  const serverManagers = managers?.();
+  const { store } = createServerStore(serverManagers, Controller);
+  // the client runs the same factory, so its dev button decision matches
+  const hasDevManager =
+    serverManagers === undefined ||
+    serverManagers.some(manager => manager instanceof DevToolsManager);
 
-    while (true) {
-      const inFlightFetches = networkManager.allSettled();
-      if (inFlightFetches) {
-        firstRender = false;
-        await inFlightFetches;
-        continue;
-      }
-      if (firstRender) {
-        firstRender = false;
-        // TODO: instead of waiting 10ms - see if we can wait until next part of react is streamed and race with networkManager getting new fetches
-        await new Promise(resolve => setTimeout(resolve, 10));
-        continue;
+  let emittedSnapshot: State<unknown> | undefined;
+  /**
+   * Called by Next.js before every streamed HTML chunk via useServerInsertedHTML.
+   * The first call is the inert baseline; later calls emit a StateDelta. This is
+   * HTML-stream insertion, not an RSC clock.
+   */
+  function renderStateDelta(nonce?: string): ReactElement | null {
+    try {
+      const state = store.getState();
+      if (emittedSnapshot === undefined) {
+        // fold into an owned copy: GC mutates store tables in place, so
+        // aliasing `state` would hide later removals from the diff
+        const delta = diffState(initialState, state);
+        emittedSnapshot =
+          delta ? applyStateDelta(initialState, delta) : initialState;
+        return (
+          <ServerData data={emittedSnapshot} id={BASELINE_ID} nonce={nonce} />
+        );
       }
-      break;
+      const delta = diffState(emittedSnapshot, state);
+      if (delta === null) return null;
+      emittedSnapshot = applyStateDelta(emittedSnapshot, delta);
+      return (
+        <script
+          nonce={nonce}
+          dangerouslySetInnerHTML={{ __html: deltaScript(delta) }}
+        />
+      );
+    } catch (e) {
+      // throwing here would fail the whole response; the client refetches instead
+      console.error('Failed to stream Reactive Data Client state', e);
+      return null;
     }
-    return getState();
-  })();
+  }
 
-  const StoreDataProvider = ({
-    children,
-    devButton,
-    managers,
-  }: ProviderProps) => {
-    // only include if they have devtools integrated
-    // if managers isn't overridden we know it will by default include DevToolsManager, so set this to true
-    const hasDevManager =
-      !managers ||
-      !!managers.find(manager => manager instanceof DevToolsManager);
-    return (
-      <SSRDataProvider
-        getState={getState}
-        subscribe={subscribe}
-        dispatch={dispatch}
-        devButton={devButton}
-        hasDevManager={hasDevManager}
-      >
-        {children}
-      </SSRDataProvider>
-    );
-  };
+  const StoreDataProvider = ({ children, devButton }: StoreProviderProps) => (
+    <SSRDataProvider
+      getState={store.getState}
+      subscribe={store.subscribe}
+      dispatch={store.dispatch}
+      devButton={devButton}
+      hasDevManager={hasDevManager}
+      Controller={Controller}
+    >
+      {children}
+    </SSRDataProvider>
+  );
 
-  return [StoreDataProvider, initPromise] as const;
+  return [StoreDataProvider, renderStateDelta] as const;
 }
 
-type ProviderProps = Omit<
-  Partial<ComponentProps<typeof DataProvider>>,
-  'initialState'
-> & {
-  children: React.ReactNode;
-  initPromise: Promise<State<any>>;
-};
+function deltaScript(delta: StateDelta): string {
+  const queue = `self.${DELTA_QUEUE_GLOBAL}`;
+  // JSON.parse of a string literal: faster than an object literal for large
+  // payloads and immune to `{"__proto__":...}` setting the prototype
+  const literal = escapeJsonForScript(JSON.stringify(JSON.stringify(delta)));
+  return `(function(){var q=${queue}=${queue}||[],d=JSON.parse(${literal});q.push(d);q.onDelta&&q.onDelta(d)})()`;
+}
diff --git a/packages/react/src/server/nextjs/DataProvider/deltaQueue.ts b/packages/react/src/server/nextjs/DataProvider/deltaQueue.ts
new file mode 100644
index 000000000000..e3fd0d93049d
--- /dev/null
+++ b/packages/react/src/server/nextjs/DataProvider/deltaQueue.ts
@@ -0,0 +1,29 @@
+import type { Manager } from '@data-client/core';
+
+import type {
+  DeltaQueue as SharedDeltaQueue,
+  SnapshotStore as SharedSnapshotStore,
+} from '../../stream/types.js';
+
+/** Global array the streamed inline scripts push deltas onto */
+export const DELTA_QUEUE_GLOBAL = '__DATA_CLIENT_DELTAS__';
+/** Element id of the inert JSON baseline emitted with the shell */
+export const BASELINE_ID = 'data-client-data';
+
+export interface SnapshotStore extends SharedSnapshotStore {
+  /** Result of the managers factory; renders React discards must not run it again */
+  managers?: Manager[];
+  queue: DeltaQueue;
+}
+
+export interface DeltaQueue extends SharedDeltaQueue {
+  /** One fold per document, shared by every provider render */
+  snapshot?: SnapshotStore;
+  /** Pending wait for the baseline while the document is still loading */
+  pending?: Promise<void>;
+}
+
+export function getDeltaQueue(): DeltaQueue {
+  const global = globalThis as any;
+  return (global[DELTA_QUEUE_GLOBAL] ??= []);
+}
diff --git a/packages/react/src/server/nextjs/DataProvider/snapshotStore.ts b/packages/react/src/server/nextjs/DataProvider/snapshotStore.ts
new file mode 100644
index 000000000000..9047ad27ab2a
--- /dev/null
+++ b/packages/react/src/server/nextjs/DataProvider/snapshotStore.ts
@@ -0,0 +1,43 @@
+import { __INTERNAL__ } from '@data-client/core';
+import type { State } from '@data-client/core';
+
+import { BASELINE_ID, getDeltaQueue } from './deltaQueue.js';
+import type { SnapshotStore } from './deltaQueue.js';
+
+const { applyStateDelta, initialState } = __INTERNAL__;
+
+/**
+ * Reads the server baseline and folds every delta that has streamed in so far.
+ *
+ * Returns once the G0 baseline is present — no wait for the first delta, the
+ * last delta, or DOMContentLoaded. A document-wide DOMContentLoaded wait is
+ * an acceptable interim, not a required bootstrap gate.
+ *
+ * Today this still suspends only when the baseline element is missing and the
+ * document is still loading. Per-key waiters and fold-on-script-arrival
+ * independent of StreamedStateReceiver are not shipped.
+ */
+export function getSnapshotStore(): SnapshotStore {
+  const queue = getDeltaQueue();
+  if (queue.snapshot) return queue.snapshot;
+  const element = document.getElementById(BASELINE_ID);
+  if (!element && document.readyState === 'loading') {
+    throw (queue.pending ??= new Promise<void>(resolve => {
+      // whichever fires first wins; the loser must not clobber the receiver
+      // that may have been installed on `onDelta` in the meantime
+      const done = () => {
+        document.removeEventListener('DOMContentLoaded', done);
+        if (queue.onDelta === done) queue.onDelta = undefined;
+        queue.pending = undefined;
+        resolve();
+      };
+      document.addEventListener('DOMContentLoaded', done);
+      queue.onDelta = done;
+    }));
+  }
+  let state: State<unknown> =
+    element?.textContent ? JSON.parse(element.textContent) : initialState;
+  for (const delta of queue) state = applyStateDelta(state, delta);
+  queue.snapshot = { state, cursor: queue.length, queue };
+  return queue.snapshot;
+}
diff --git a/packages/react/src/server/nextjs/DataProvider/types.ts b/packages/react/src/server/nextjs/DataProvider/types.ts
new file mode 100644
index 000000000000..d4cb35f50262
--- /dev/null
+++ b/packages/react/src/server/nextjs/DataProvider/types.ts
@@ -0,0 +1,23 @@
+import type { Manager } from '@data-client/core';
+
+import type { ProviderProps } from '../../../components/DataProvider.js';
+
+export interface NextDataProviderProps extends Omit<
+  ProviderProps,
+  'initialState' | 'managers'
+> {
+  /**
+   * Creates the store's Managers. Called once per request on the server and
+   * once in the browser, since instances cannot be shared between requests.
+   * @see https://dataclient.io/docs/guides/ssr#managers
+   */
+  managers?: () => Manager[];
+  /** Content-Security-Policy nonce applied to the inline scripts that stream state */
+  nonce?: string;
+}
+
+/** What reaches the store provider: everything consumed at store creation is stripped */
+export type StoreProviderProps = Omit<
+  NextDataProviderProps,
+  'nonce' | 'managers' | 'Controller'
+>;
diff --git a/packages/react/src/server/nextjs/index.ts b/packages/react/src/server/nextjs/index.ts
index a886d6846ad6..ebeea9f56d1b 100644
--- a/packages/react/src/server/nextjs/index.ts
+++ b/packages/react/src/server/nextjs/index.ts
@@ -1 +1,2 @@
 export { default as DataProvider } from './DataProvider/DataProvider.js';
+export type { NextDataProviderProps } from './DataProvider/types.js';
diff --git a/packages/react/src/server/stream/StreamedStateReceiver.tsx b/packages/react/src/server/stream/StreamedStateReceiver.tsx
new file mode 100644
index 000000000000..1c21033da743
--- /dev/null
+++ b/packages/react/src/server/stream/StreamedStateReceiver.tsx
@@ -0,0 +1,54 @@
+'use client';
+import { __INTERNAL__ } from '@data-client/core';
+import type { StateDelta } from '@data-client/core';
+import { useLayoutEffect } from 'react';
+import { flushSync } from 'react-dom';
+
+import type { StreamingDispatch } from './createStreamingReducer.js';
+import type { SnapshotStore } from './types.js';
+import useController from '../../hooks/useController.js';
+
+const { applyStateDelta, selectBaseline, createHydrate } = __INTERNAL__;
+
+/**
+ * Folds deltas streamed after the shell into the snapshot and the live store.
+ *
+ * Today this runs from a layout effect. RSC may already have started the
+ * island; a miss then fetches. Fold-on-script-arrival (independent of this
+ * effect) and per-key waiters are not shipped. Separate snapshot and live
+ * cursors so a late attach replays missed pieces once.
+ *
+ * flushSync and per-delta live HYDRATE are preserved HOLD behavior, not the
+ * concurrent happy path.
+ */
+export default function StreamedStateReceiver({
+  snapshotStore,
+}: {
+  snapshotStore: SnapshotStore;
+}) {
+  const controller = useController();
+
+  useLayoutEffect(() => {
+    const { queue } = snapshotStore;
+    const dispatchStreamingAction = controller.dispatch as StreamingDispatch;
+    const receive = (delta: StateDelta) => {
+      const baseline = selectBaseline(snapshotStore.state, delta);
+      snapshotStore.state = applyStateDelta(snapshotStore.state, delta);
+      dispatchStreamingAction(createHydrate(delta, baseline));
+    };
+    while (snapshotStore.cursor < queue.length)
+      receive(queue[snapshotStore.cursor++]);
+    queue.onDelta = delta => {
+      snapshotStore.cursor++;
+      // Fold when this effect is attached; RSC may already have started
+      // the island. Per-key waiters are not shipped. flushSync keeps live
+      // store and snapshot in one task.
+      flushSync(() => receive(delta));
+    };
+    return () => {
+      queue.onDelta = undefined;
+    };
+  }, [controller, snapshotStore]);
+
+  return null;
+}
diff --git a/packages/react/src/server/stream/__tests__/StreamedStateReceiver.web.tsx b/packages/react/src/server/stream/__tests__/StreamedStateReceiver.web.tsx
new file mode 100644
index 000000000000..09f640dafc19
--- /dev/null
+++ b/packages/react/src/server/stream/__tests__/StreamedStateReceiver.web.tsx
@@ -0,0 +1,105 @@
+import {
+  Controller,
+  __INTERNAL__,
+  actions,
+  createReducer,
+  initialState,
+} from '@data-client/core';
+import type { State, StateDelta } from '@data-client/core';
+import { Endpoint, Entity } from '@data-client/endpoint';
+import { act, render } from '@testing-library/react';
+import React from 'react';
+
+import DataProviderBase from '../../../components/DataProviderBase';
+import useCache from '../../../hooks/useCache';
+import createStreamingReducer from '../createStreamingReducer';
+import StreamedStateReceiver from '../StreamedStateReceiver';
+import type { DeltaQueue, SnapshotStore } from '../types';
+
+const { diffState } = __INTERNAL__;
+
+class Todo extends Entity {
+  id = '';
+  title = '';
+  pk() {
+    return this.id;
+  }
+}
+const getTodo = new Endpoint(
+  async ({ id }: { id: string }) => ({ id, title: `todo ${id}` }),
+  { schema: Todo, name: 'getTodo' },
+);
+
+const reducer = createReducer(new Controller());
+const setTodo = (state: State<unknown>, id: string) =>
+  reducer(
+    state,
+    actions.createSetResponse(getTodo, {
+      args: [{ id }],
+      response: { id, title: `todo ${id}` },
+    }),
+  );
+const transport = <T,>(value: T): T => JSON.parse(JSON.stringify(value));
+
+function Probe({ id }: { id: string }) {
+  const todo = useCache(getTodo, { id });
+  return <span data-id={id}>{todo?.title ?? 'none'}</span>;
+}
+
+describe('StreamedStateReceiver', () => {
+  const s0 = initialState;
+  const s1 = setTodo(s0, '0');
+  const s2 = setTodo(s1, '1');
+  const delta1 = transport(diffState(s0, s1)!);
+  const delta2 = transport(diffState(s1, s2)!);
+
+  function makeStore(queued: StateDelta[] = []): SnapshotStore {
+    const queue: DeltaQueue = Object.assign([...queued], {});
+    return { state: s0, cursor: 0, queue };
+  }
+
+  it('replays queued deltas on attach', () => {
+    const snapshotStore = makeStore([delta1, delta2]);
+    const { getByText } = render(
+      <DataProviderBase
+        reducerFactory={createStreamingReducer}
+        initialState={s0}
+        devButton={null}
+      >
+        <StreamedStateReceiver snapshotStore={snapshotStore} />
+        <Probe id="1" />
+      </DataProviderBase>,
+    );
+    expect(getByText('todo 1')).toBeDefined();
+    expect(snapshotStore.cursor).toBe(2);
+    expect(snapshotStore.state.entities.Todo).toHaveProperty('1');
+  });
+
+  it('folds live deltas through onDelta and clears on unmount', () => {
+    const snapshotStore = makeStore();
+    const { getByText, unmount } = render(
+      <DataProviderBase
+        reducerFactory={createStreamingReducer}
+        initialState={s0}
+        devButton={null}
+      >
+        <StreamedStateReceiver snapshotStore={snapshotStore} />
+        <Probe id="1" />
+      </DataProviderBase>,
+    );
+    expect(getByText('none')).toBeDefined();
+    act(() => {
+      snapshotStore.queue.push(delta1);
+      snapshotStore.queue.onDelta?.(delta1);
+      snapshotStore.queue.push(delta2);
+      snapshotStore.queue.onDelta?.(delta2);
+    });
+    expect(getByText('todo 1')).toBeDefined();
+    expect(snapshotStore.cursor).toBe(2);
+    const receiver = snapshotStore.queue.onDelta;
+    expect(receiver).toBeDefined();
+    unmount();
+    expect(snapshotStore.queue.onDelta).toBeUndefined();
+    expect(receiver).not.toBe(snapshotStore.queue.onDelta);
+  });
+});
diff --git a/packages/react/src/server/stream/__tests__/createStreamingReducer.node.ts b/packages/react/src/server/stream/__tests__/createStreamingReducer.node.ts
new file mode 100644
index 000000000000..748697b45ee1
--- /dev/null
+++ b/packages/react/src/server/stream/__tests__/createStreamingReducer.node.ts
@@ -0,0 +1,95 @@
+import {
+  Controller,
+  __INTERNAL__,
+  actions,
+  createReducer,
+  initialState,
+} from '@data-client/core';
+import type { ActionTypes, State } from '@data-client/core';
+import { Endpoint, Entity } from '@data-client/endpoint';
+
+import createStreamingReducer from '../createStreamingReducer';
+import type {
+  StreamingDispatch,
+  StreamingReducer,
+} from '../createStreamingReducer';
+
+const { createHydrate, HYDRATE, selectBaseline, diffState } = __INTERNAL__;
+
+class Todo extends Entity {
+  id = '';
+  title = '';
+  pk() {
+    return this.id;
+  }
+}
+const getTodo = new Endpoint(
+  async ({ id }: { id: string }) => ({ id, title: `todo ${id}` }),
+  { schema: Todo, name: 'getTodo' },
+);
+
+const transport = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+
+describe('createStreamingReducer', () => {
+  const controller = new Controller();
+  const master = createReducer(controller);
+  const streaming = createStreamingReducer(controller);
+  const setTodo = (state: State<unknown>, id: string) =>
+    master(
+      state,
+      actions.createSetResponse(getTodo, {
+        args: [{ id }],
+        response: { id, title: `todo ${id}` },
+      }),
+    );
+  const s1 = setTodo(initialState, '0');
+  const s2 = setTodo(s1, '1');
+  const delta = transport(diffState(s1, s2)!);
+  const hydrate = createHydrate(delta, selectBaseline(s1, delta));
+
+  it('applies HYDRATE through hydrateReducer', () => {
+    expect(hydrate.type).toBe(HYDRATE);
+    const next = streaming(s1, hydrate);
+    expect(next.entities.Todo).toHaveProperty('1');
+    expect(next.entities.Todo!['0']).toBe(s1.entities.Todo!['0']);
+  });
+
+  it('forwards committed actions to the master reducer', () => {
+    const next = streaming(
+      initialState,
+      actions.createSetResponse(getTodo, {
+        args: [{ id: '0' }],
+        response: { id: '0', title: 'todo 0' },
+      }),
+    );
+    expect(next.entities.Todo!['0']).toEqual(
+      master(
+        initialState,
+        actions.createSetResponse(getTodo, {
+          args: [{ id: '0' }],
+          response: { id: '0', title: 'todo 0' },
+        }),
+      ).entities.Todo!['0'],
+    );
+  });
+
+  it('rejects HydrateAction on the public Controller and master reducer', () => {
+    function typeTests() {
+      // @ts-expect-error public Controller.dispatch rejects HydrateAction
+      controller.dispatch(hydrate);
+      // @ts-expect-error MasterReducer rejects HydrateAction
+      master(s1, hydrate);
+    }
+    expect(typeof typeTests).toBe('function');
+  });
+
+  it('accepts HydrateAction on StreamingDispatch and StreamingReducer', () => {
+    const dispatchStreaming: StreamingDispatch = async () => {};
+    const streamingReducer: StreamingReducer = streaming;
+    void dispatchStreaming(hydrate);
+    streamingReducer(s1, hydrate);
+    const set: ActionTypes = actions.createReset();
+    void dispatchStreaming(set);
+    streamingReducer(s1, set);
+  });
+});
diff --git a/packages/react/src/server/stream/createStreamingReducer.ts b/packages/react/src/server/stream/createStreamingReducer.ts
new file mode 100644
index 000000000000..b3790697ad16
--- /dev/null
+++ b/packages/react/src/server/stream/createStreamingReducer.ts
@@ -0,0 +1,29 @@
+import { createReducer, __INTERNAL__ } from '@data-client/core';
+import type { ActionTypes, Controller, State } from '@data-client/core';
+
+const { hydrateReducer, HYDRATE, initialState } = __INTERNAL__;
+
+type MasterReducer = ReturnType<typeof createReducer>;
+type HydrateAction = ReturnType<typeof __INTERNAL__.createHydrate>;
+export type StreamingAction = ActionTypes | HydrateAction;
+export type StreamingReducer = (
+  state: State<unknown> | undefined,
+  action: StreamingAction,
+) => State<unknown>;
+export type StreamingDispatch = (action: StreamingAction) => Promise<void>;
+
+/**
+ * Closed master-plus-HYDRATE reducer for streaming adapters.
+ *
+ * Public DataProvider uses core createReducer. Only ./nextjs and the
+ * generic streaming wrapper compose this factory.
+ */
+export default function createStreamingReducer(
+  controller: Controller,
+): StreamingReducer {
+  const master: MasterReducer = createReducer(controller);
+  return (state, action) =>
+    action.type === HYDRATE ?
+      hydrateReducer(state ?? initialState, action)
+    : master(state, action);
+}
diff --git a/packages/react/src/server/stream/types.ts b/packages/react/src/server/stream/types.ts
new file mode 100644
index 000000000000..0dfffc58a87d
--- /dev/null
+++ b/packages/react/src/server/stream/types.ts
@@ -0,0 +1,21 @@
+import type { State, StateDelta } from '@data-client/core';
+
+/**
+ * Queue of streamed store pieces. Adapter transports may extend this
+ * with host-specific fields; the shared receiver only uses `onDelta`.
+ */
+export interface DeltaQueue extends Array<StateDelta> {
+  onDelta?: (delta: StateDelta) => void;
+}
+
+/**
+ * Adapter-owned snapshot of everything the server has sent so far.
+ *
+ * `state` is the snapshot the HTML was rendered from. `cursor` is how far
+ * the live receiver has replayed; a late attach replays the rest once.
+ */
+export interface SnapshotStore {
+  state: State<unknown>;
+  cursor: number;
+  queue: DeltaQueue;
+}
diff --git a/packages/react/tsconfig.json b/packages/react/tsconfig.json
index 742cd7ffda85..15eb3835fe7a 100644
--- a/packages/react/tsconfig.json
+++ b/packages/react/tsconfig.json
@@ -4,7 +4,7 @@
     "outDir": "lib",
     "rootDir": "src"
   },
-  "include": ["src"],
+  "include": ["src", "type-shims"],
   "references": [
     { "path": "../../__tests__" },
     { "path": "../core" },
diff --git a/packages/react/type-shims/next-navigation.d.ts b/packages/react/type-shims/next-navigation.d.ts
new file mode 100644
index 000000000000..bd91ae97261b
--- /dev/null
+++ b/packages/react/type-shims/next-navigation.d.ts
@@ -0,0 +1,8 @@
+// Minimal local declaration so @data-client/react/nextjs can type-check
+// without depending on `next`. Never shipped: consumers resolve the real
+// `next/navigation` types from their own Next.js install.
+declare module 'next/navigation' {
+  import type { ReactNode } from 'react';
+
+  export function useServerInsertedHTML(callback: () => ReactNode): void;
+}
diff --git a/packages/test/package.json b/packages/test/package.json
index 3010470ee6d1..732d9555aaf3 100644
--- a/packages/test/package.json
+++ b/packages/test/package.json
@@ -122,7 +122,7 @@
     "@testing-library/react": "^16.0.0"
   },
   "peerDependencies": {
-    "@data-client/react": "^0.12.15 || ^0.13.0 || ^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0 || ^0.18.0",
+    "@data-client/react": "^0.12.15 || ^0.13.0 || ^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0 || ^0.18.0 || ^0.19.0",
     "@testing-library/react-hooks": "^8.0.0",
     "@testing-library/react-native": "^13.0.0",
     "@types/react": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-0 || ^19.0.0",
diff --git a/tsconfig.test.json b/tsconfig.test.json
index b50a380631ad..ed8cb7e7c9ae 100644
--- a/tsconfig.test.json
+++ b/tsconfig.test.json
@@ -14,5 +14,10 @@
       "__tests__/*": ["./__tests__/*"]
     }
   },
-  "include": ["packages/*/src", "packages/*/typescript-tests", "__tests__"]
+  "include": [
+    "packages/*/src",
+    "packages/*/type-shims",
+    "packages/*/typescript-tests",
+    "__tests__"
+  ]
 }
diff --git a/website/blog/2026-09-11-v0.19-streamed-nextjs-ssr-managers-factory.md b/website/blog/2026-09-11-v0.19-streamed-nextjs-ssr-managers-factory.md
new file mode 100644
index 000000000000..52a3d08cdbf6
--- /dev/null
+++ b/website/blog/2026-09-11-v0.19-streamed-nextjs-ssr-managers-factory.md
@@ -0,0 +1,155 @@
+---
+title: 'v0.19: Streamed state hydration, Managers factory'
+description: SSR store state arrives as a baseline plus per-flush deltas through adapter-owned composition; DataProvider managers move to a function
+authors: [ntucker]
+tags: [releases, nextjs, managers]
+draft: true
+---
+
+import DiffEditor from '@site/src/components/DiffEditor';
+import PkgTabs from '@site/src/components/PkgTabs';
+
+v0.19 hydrates SSR store state incrementally — a baseline in the shell, then a delta per committed
+server revision — and starts the move of `managers` to a function form.
+
+**Platforms:**
+
+- [Incremental streamed hydration](/blog/2026/09/11/v0.19-streamed-nextjs-ssr-managers-factory#streamed-ssr) — SSR store state arrives as a baseline plus per-flush deltas. Next.js App Router is the first adapter ([#4090](https://github.com/reactive/data-client/pull/4090)). RSC may start a Client Component first, and a miss then fetches like any client render.
+- [`managers` as a function](/blog/2026/09/11/v0.19-streamed-nextjs-ssr-managers-factory#managers-factory) - `managers={() => [...]}` on [DataProvider](/docs/api/DataProvider#managers); the long-term form
+
+**New APIs:**
+
+- `StateDelta` / `StateBaseline` types for the streamed wire; Next.js App Router `NextDataProviderProps`
+
+**Other Improvements:**
+
+- Serialized SSR state is escaped, so an API response containing `</script>` can no longer break out of its tag
+- `nonce` prop on the Next.js [DataProvider](/docs/guides/ssr#nonce) for Content-Security-Policy
+
+**[Breaking Changes:](/blog/2026/09/11/v0.19-streamed-nextjs-ssr-managers-factory#migration-guide)**
+
+- [Next.js `DataProvider` `managers` is a function](/blog/2026/09/11/v0.19-streamed-nextjs-ssr-managers-factory#nextjs-managers) - `managers={[...]}` → `managers={() => [...]}`. Affects `@data-client/react/nextjs` only.
+
+{/* truncate */}
+
+## Incremental streamed hydration {#streamed-ssr}
+
+The shell carries an inert baseline. Each later committed server revision emits a `StateDelta`.
+The Next.js adapter folds that piece into its snapshot and publishes it into the live store from
+the receiver layout effect. Public `DataProvider` keeps `StateContext` reads.
+
+```tsx title="app/[userId]/page.tsx"
+export default async function TodoPage({ params }) {
+  const { userId } = await params; // resolves after the shell was sent
+  return <TodoList userId={userId} />; // 'use client' + useSuspense
+}
+```
+
+On Next.js, RSC may run a Client Component before the HTML delta and before that layout
+effect. A miss then fetches like any client render. Per-key waiters that would suppress that
+refetch are not in this release. The figures are in the
+[SSR guide](/docs/guides/ssr#streamed-hydration). Next.js App Router is the first adapter;
+generic `renderToPipeableStream` remains a one-shot document snapshot.
+
+Nothing changes in how you write components. See the [SSR guide](/docs/guides/ssr#nextjs) for the
+`nonce` prop and limitations.
+
+## `managers` as a function {#managers-factory}
+
+[DataProvider](/docs/api/DataProvider#managers) accepts a function that creates the managers. It is
+called once when the provider mounts.
+
+```tsx
+import { DataProvider, getDefaultManagers } from '@data-client/react';
+
+// highlight-next-line
+const managers = () => [...getDefaultManagers(), new MyManager()];
+
+<DataProvider managers={managers}>
+  <App />
+</DataProvider>;
+```
+
+This is the form the library is moving to. The Next.js provider builds a store per request and can
+only take a function; in the browser it also gives each `DataProvider` on a page its own instances
+instead of one hoisted array bound to whichever store mounted last.
+
+:::warning Arrays are transitional
+
+`managers={[...]}` still works on the browser `DataProvider`, but will be removed in a future
+release. Migrate to `managers={() => [...]}` as soon as you can.
+
+:::
+
+## Migration guide
+
+<PkgTabs pkgs="@data-client/react@^0.19.0 @data-client/rest@^0.19.0 @data-client/endpoint@^0.19.0 @data-client/core@^0.19.0 @data-client/vue@^0.19.0 @data-client/test@^0.19.0 @data-client/img@^0.19.0" upgrade />
+
+### @data-client/react 0.19
+
+#### For all users
+
+Optional now, required later: pass `managers` as a function.
+
+<DiffEditor>
+
+```tsx title="Before"
+import { DataProvider, getDefaultManagers } from '@data-client/react';
+
+const managers = [...getDefaultManagers(), new MyManager()];
+
+<DataProvider managers={managers}>
+  <App />
+</DataProvider>;
+```
+
+```tsx title="After"
+import { DataProvider, getDefaultManagers } from '@data-client/react';
+
+const managers = () => [...getDefaultManagers(), new MyManager()];
+
+<DataProvider managers={managers}>
+  <App />
+</DataProvider>;
+```
+
+</DiffEditor>
+
+#### For Next.js App Router users {#nextjs-managers}
+
+Skip this section if you do not pass `managers` to the `@data-client/react/nextjs` provider.
+
+The same change is required here: an array throws with a migration hint. The function runs once per
+request on the server and once in the browser.
+
+<DiffEditor>
+
+```tsx title="Before"
+'use client';
+import { getDefaultManagers } from '@data-client/react';
+import { DataProvider } from '@data-client/react/nextjs';
+
+const managers = [...getDefaultManagers(), new MyManager()];
+
+export default function Provider({ children }) {
+  return <DataProvider managers={managers}>{children}</DataProvider>;
+}
+```
+
+```tsx title="After"
+'use client';
+import { getDefaultManagers } from '@data-client/react';
+import { DataProvider } from '@data-client/react/nextjs';
+
+const managers = () => [...getDefaultManagers(), new MyManager()];
+
+export default function Provider({ children }) {
+  return <DataProvider managers={managers}>{children}</DataProvider>;
+}
+```
+
+</DiffEditor>
+
+### Upgrade support
+
+As usual, if you have any troubles or questions, feel free to join our [![Chat](https://img.shields.io/discord/768254430381735967.svg?style=flat-square&colorB=758ED3)](https://discord.gg/wXGV27xm6t) or [file a bug](https://github.com/reactive/data-client/issues/new/choose)
diff --git a/website/src/components/HomepageFeatures.tsx b/website/src/components/HomepageFeatures.tsx
index d68234be891e..c6256afc0dfa 100644
--- a/website/src/components/HomepageFeatures.tsx
+++ b/website/src/components/HomepageFeatures.tsx
@@ -9,7 +9,7 @@ import ChemicalCompositionSvg from '../../static/img/chemical-composition.svg';
 import FastCarSvg from '../../static/img/fast-car.svg';
 import GrowingBarChartSvg from '../../static/img/growing-bar-chart.svg';
 
-type SvgComponent = React.ComponentType<React.ComponentProps<'svg'>>;
+type SvgComponent = typeof FastCarSvg;
 
 interface BaseFeature {
   description: React.ReactNode;
diff --git a/yarn.lock b/yarn.lock
index 549f78c3ed51..7394ca0027fd 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3245,7 +3245,7 @@ __metadata:
     react-dom: "npm:^19.2.1"
     rollup-plugins: "workspace:*"
   peerDependencies:
-    "@data-client/react": ^0.1.0 || ^0.2.0 || ^0.3.0 || ^0.4.0 || ^0.5.0 || ^0.7.0 || ^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0 || ^0.18.0
+    "@data-client/react": ^0.1.0 || ^0.2.0 || ^0.3.0 || ^0.4.0 || ^0.5.0 || ^0.7.0 || ^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0 || ^0.18.0 || ^0.19.0
     "@types/react": ^16.14.0 || ^17.0.0 || ^18.0.0-0 || ^19.0.0
     react: ^16.14.0 || ^17.0.0 || ^18.0.0-0 || ^19.0.0
   peerDependenciesMeta:
@@ -3305,11 +3305,14 @@ __metadata:
     "@react-navigation/native": ^6.0.0 || ^7.0.0
     "@types/react": ^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-0 || ^19.0.0
     react: ^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-0 || ^19.0.0
+    react-dom: ^18.0.0 || ^19.0.0-0 || ^19.0.0
   peerDependenciesMeta:
     "@react-navigation/native":
       optional: true
     "@types/react":
       optional: true
+    react-dom:
+      optional: true
   languageName: unknown
   linkType: soft
 
@@ -3352,7 +3355,7 @@ __metadata:
     react-test-renderer: "npm:*"
     rollup-plugins: "workspace:*"
   peerDependencies:
-    "@data-client/react": ^0.12.15 || ^0.13.0 || ^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0 || ^0.18.0
+    "@data-client/react": ^0.12.15 || ^0.13.0 || ^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0 || ^0.18.0 || ^0.19.0
     "@testing-library/react-hooks": ^8.0.0
     "@testing-library/react-native": ^13.0.0
     "@types/react": ^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0-0 || ^19.0.0