diff --git a/.gitignore b/.gitignore
index 438d125b47a0..3b1c84a6c67d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,6 +27,10 @@ chrome-user-data
 /.worktrees
 .claude/*.local.*
 
+.lb
+.pi
+.agents
+
 packages/react-devtools-core/dist
 packages/react-devtools-extensions/chrome/build
 packages/react-devtools-extensions/chrome/*.crx
@@ -41,3 +45,5 @@ packages/react-devtools-inline/dist
 packages/react-devtools-shell/dist
 packages/react-devtools-timeline/dist
 
+scripts/bench/fused-renderer-bench-results.json
+scripts/bench/fused-renderer-concurrent-results.json
diff --git a/design/fused-renderer-checkpoint.md b/design/fused-renderer-checkpoint.md
new file mode 100644
index 000000000000..75660c85f918
--- /dev/null
+++ b/design/fused-renderer-checkpoint.md
@@ -0,0 +1,188 @@
+# Fused Renderer Go/No-Go Checkpoint
+
+**Task**: TIM-482
+**Date**: 2026-03-25 (revised with v3 concurrent throughput data)
+**Decision**: **GO — Narrow scope (Approach B+, sync server components first)**
+
+---
+
+## Performance Validation Update (v3)
+
+The original performance spike (TIM-483) reported 54–79% Flight overhead using synthetic sync-only benchmarks. A v2 revision added async I/O simulation and reported only 1–4% overhead. **Both were measuring the wrong thing.** Wall-clock time including I/O wait is irrelevant for throughput — CPU time on the single-threaded Node.js event loop is the bottleneck.
+
+v3 measures concurrent throughput under realistic server load (c=1 to c=50). Key findings:
+
+| Metric (c=25, 226 products) | Full Pipeline | Fizz Only (fused target) | Improvement |
+|------------------------------|--------------|------------------------|-------------|
+| **Throughput** | 102 req/s | 526 req/s | **5.2x** |
+| **p99 latency** | 342ms | 49ms | **7.0x** |
+| **Heap pressure** | 282 MB | 72 MB | **-210 MB** |
+
+The throughput drop **worsens under load** (4x at c=1 → 5.9x at c=50) due to GC pressure from transient 349 KB wire format buffers per request. This directly explains the observed 400 rps → 40 rps drop in real-world Next.js deployments (React-level 3–6x × framework overhead 1.5–2x ≈ 10x).
+
+See `design/fused-renderer-perf-validation.md` for full data.
+
+---
+
+## Spike Findings Summary
+
+### TIM-471: Fizz Internals (fused-renderer-fizz-analysis.md)
+
+Fizz's `renderElement()` dispatches on `typeof type` and already calls function components via `renderWithHooks()`. The Request object has a clean lifecycle (OPENING→OPEN→CLOSING→CLOSED) with task/segment queues. A `fusedMode` flag and `clientBoundaryQueue` can be added to Request without disrupting existing paths. The TODO at line ~5944 in `flushCompletedQueues()` ("Here we'll emit data used by hydration") is the exact insertion point for hydration data. Fizz's Suspense machinery (ping→retry, task suspension) already handles async components — no new concurrency model needed.
+
+### TIM-472: Flight Wire Format (PR #2, fused-renderer-flight-analysis.md)
+
+Client components are identified by `Symbol.for('react.client.reference')` with `$$id` and `$$async` properties. The wire format uses typed chunks (`I[]` for modules, `S[]` for strings, etc.). Module references carry `{id, chunks, name}` metadata resolved from the `ClientManifest`. Flight's serialization is deeply coupled to its Request/Task model (800+ lines in `renderModelDestructive`), but the detection functions (`isClientReference`, `resolveClientReferenceMetadata`) are pure functions with no renderer state dependencies.
+
+### TIM-473: Hydration Markers (fused-renderer-hydration-analysis.md)
+
+Fizz uses HTML comments as boundary markers (`<!--$-->`, `<!--/$-->`, `<!--&-->`, etc.). The hydration walker (`getNextHydratable()`) silently skips unknown comments, meaning new marker types (e.g., `<!--C:0-->`) are backwards-compatible by default. Selective hydration creates dehydrated fragment fibers — the same pattern works for client boundaries. Server-only DOM between client boundaries can be skipped during hydration (no fibers created, just cursor advancement).
+
+### TIM-481: Feasibility Analysis (fused-renderer-feasibility.md)
+
+**Approach B+ (Flight as a library + focused props serializer) is the recommended path.** Client boundary detection and module resolution are trivially extractable (~50 lines of pure functions). Props serialization should NOT be extracted from Flight (too coupled); instead, a focused serializer handling common prop types (~150 lines) is sufficient. The assumption inventory identified 10 assumptions, most rated Stable. The highest-risk assumption (#7) is the hydration data TODO — if upstream acts on it, it could align with or conflict with our approach.
+
+### TIM-483: Performance Validation (fused-renderer-perf-validation.md)
+
+Flight overhead is **54–79% of total SSR time** across all scenarios. The large e-commerce scenario (226 products, ~1000 components): 1.89ms of 3.51ms is Flight overhead. Flight wire format accounts for 55-68% of total bytes — pure intermediate waste. Projected improvement: **2x throughput**, 52% render time reduction, 54% smaller total transfer. Memory: 401 KB heap delta per large request from intermediate Flight buffers.
+
+---
+
+## Question 1: What Did We Learn That We Didn't Expect?
+
+**Surprise 1: Flight overhead is even larger than assumed.** We hypothesized "significant cost" but measured **54-79% of total SSR time**. For small/deep/wide trees, Flight is the overwhelming bottleneck (>70%). Even for the most HTML-heavy scenario (large), Flight is still the majority.
+
+**Surprise 2: Detection functions are trivially extractable.** We assumed some extraction difficulty. In reality, `isClientReference()` is a single symbol comparison and `resolveClientReferenceMetadata()` is a map lookup. These have zero renderer state dependencies.
+
+**Surprise 3: The hydration marker system is more accommodating than expected.** `getNextHydratable()` silently skips unknown comment types. We can add `<!--C:ID-->` markers without any risk to existing hydration. This was a risk we hadn't quantified before the TIM-473 spike.
+
+**Surprise 4: Flight's full serializer is NOT needed.** We originally assumed we'd need to extract or reimplement `renderModelDestructive` (800+ lines). The feasibility analysis showed that client boundary props in practice contain only common types (primitives, objects, arrays, dates) — a ~150-line focused serializer handles 99% of cases.
+
+## Question 2: Do We Still Believe Fused Renderer Is the Right Approach?
+
+**Yes, with the narrow scope (Approach B+).** The evidence is clear:
+
+1. The performance win is real and large (54-79% of SSR time is eliminable overhead)
+2. The implementation path is clean (pure function imports + focused serializer + additive Fizz changes)
+3. The risk surface is small (10 assumptions, most Stable)
+4. There is no simpler alternative that delivers comparable wins:
+   - Caching Flight output? Still pays serialization cost on cache miss, doesn't reduce memory pressure
+   - Streaming optimization? Doesn't eliminate the fundamental three-pass architecture
+   - Framework-level workarounds? Can't fix what's inside the React render loop
+
+## Question 3: Top 3 Risks If We Proceed
+
+### Risk 1: Upstream hydration data emission (Assumption #7)
+
+**What**: The TODO at `flushCompletedQueues()` line ~5944 suggests React plans to emit hydration data from Fizz themselves. If they ship an implementation, our insertion point could conflict.
+
+**Mitigation**: Sentinel test that asserts the TODO comment exists. Monitor React PRs touching this area. If upstream ships their own hydration data emission, evaluate alignment — it could actually make our work easier.
+
+**Abandon trigger**: Upstream ships a hydration data system that's fundamentally incompatible with our marker scheme AND we can't adapt within a week of work.
+
+### Risk 2: Props serializer coverage gaps
+
+**What**: The focused serializer handles common types but throws on exotic types (ReadableStreams, TypedArrays, Maps, Sets). If real apps frequently pass these at client boundaries, the fallback path gets used too often.
+
+**Mitigation**: Progressive approach — start with common types, measure fallback frequency in real apps, expand as needed. The fallback is graceful (component works, just no hydration optimization for that boundary).
+
+**Abandon trigger**: >20% of client boundaries in real apps hit the fallback path, AND expanding the serializer to cover them approaches the complexity of Flight's full serializer.
+
+### Risk 3: Upstream React refactors to Fizz internals
+
+**What**: React refactors `renderElement()`, the Request object, or the task/segment model in ways that break our additions.
+
+**Mitigation**: Our changes are additive (new code paths gated on `fusedMode`). Upstream refactors to existing paths won't affect fused-mode-specific code unless they change the dispatch interface or Request shape. Git merge conflicts will be the main signal.
+
+**Abandon trigger**: Upstream rewrites Fizz from scratch (extremely unlikely) or changes the fundamental dispatch model in `renderElement()` (never happened in 3+ years).
+
+## Question 4: Is Our Task Breakdown Still Correct?
+
+The existing tasks (TIM-474 through TIM-480) are **mostly correct** with these modifications:
+
+| Task | Status | Modification |
+|------|--------|-------------|
+| TIM-474 (server component execution) | ✅ Keep as-is | No changes needed |
+| TIM-475 (client boundary detection + markers) | 🔧 Simplify | Use Flight's `isClientReference` directly instead of reimplementing. Reduce estimated scope. |
+| TIM-476 (props serializer) | 🔧 Rewrite scope | Focused serializer for common types only. Throw on exotic types with helpful error. NOT a Flight extraction. |
+| TIM-477 (client hydration) | ✅ Keep as-is | Independent of approach choice |
+| TIM-478 (Flight coexistence) | ✅ Keep as-is | Still needed for client navigation |
+| TIM-479 (benchmarks) | ✅ Keep as-is | Will use the harness from TIM-483 as a starting point |
+| TIM-480 (edge case tests) | ✅ Keep as-is | Important for correctness validation |
+
+**New tasks to add:**
+- Sentinel tests for upstream assumption monitoring (can be part of TIM-480 or separate)
+- Fallback path for unsupported prop types (can be part of TIM-476)
+
+**Dependency order**: TIM-474 → TIM-475 → TIM-476 → TIM-477 → TIM-478, with TIM-479 and TIM-480 after TIM-477.
+
+## Question 5: What's Our Exit Strategy?
+
+If we hit a wall during implementation:
+
+**After TIM-474 (server component execution)**: This is the lowest-risk task — it adds a fusedMode branch to renderElement() that calls server component functions inline. If this works, we already have a partial win (server components skip Flight serialization). If it fails, we've learned something about Fizz's function dispatch and can back out cleanly.
+
+**After TIM-475-476 (client boundaries + serializer)**: We have the core server-side fused renderer. We can measure real throughput improvement at this point. If the numbers don't match projections, we stop. The sunk cost is ~2 tasks of work (~200-300 lines of new code).
+
+**After TIM-477 (client hydration)**: This is the hardest task. If hydration integration proves too fragile, we can fall back to "server-side fusion only" — the server emits optimized HTML without Flight overhead, but the client uses a full Flight fetch for hydration data instead of inline scripts. This is still a significant win (TTFB improvement) without the hydration complexity.
+
+**Salvageable partial work**: Even if we abandon full fusion, TIM-474 (inline server component execution in Fizz) is independently valuable. It's a single-pass optimization that reduces the number of tree walks from 3 to 2.
+
+## Question 6: What's the Minimum We Could Ship?
+
+**Minimum viable: TIM-474 + TIM-475 (no client hydration optimization)**
+
+- Fizz calls server component functions inline (single pass for server components)
+- Client boundaries are detected and rendered to HTML normally
+- **No** inline hydration data — client uses normal Flight fetch for hydration
+- **No** changes to the reconciler or hydration walker
+
+**What this delivers:**
+- Eliminates Flight serialize/deserialize for the server render (~50-70% of SSR time)
+- Reduces TTFB proportionally
+- Server memory: no intermediate Flight buffers
+- **Does NOT** reduce client payload (still needs Flight for hydration)
+
+**What it defers:**
+- Inline hydration data (TIM-476, TIM-477)
+- Client-side hydration optimization
+- Payload size reduction
+
+This minimum scope still delivers the **majority of the throughput win** (the server-side render is the bottleneck, not client hydration data transfer).
+
+## Question 7: Are There Upstream Signals We Should Wait For?
+
+**No. We should proceed now.**
+
+Rationale:
+- The hydration data TODO has been in Fizz for years with no movement
+- View Transitions, Fragment Refs, and Activity are all **additive** — they add new marker types but don't change the fundamental dispatch or hydration architecture
+- No open RFCs propose replacing Flight's wire format or Fizz's rendering model
+- The features that were experimental (`enableHalt`, `enablePostpone`) have been cleaned up, suggesting a stable period
+- `enableHydrationChangeEvent` and `enablePartialHydration` are evolving but affect the hydration walker (our TIM-477), not the server-side fused renderer (TIM-474-476)
+
+**One signal to monitor**: If React ships a native "RSC SSR optimization" (eliminating the Flight round-trip themselves), we should evaluate alignment immediately. But there's no indication this is imminent.
+
+---
+
+## Decision
+
+### GO — Narrow Scope (Approach B+)
+
+**Phase 1** (immediate): TIM-474, TIM-475 — Server-side fusion with synchronous server components. Measure throughput improvement.
+
+**Phase 2** (if Phase 1 validates): TIM-476, TIM-477 — Client boundary props serialization and inline hydration data. Measure payload + hydration improvement.
+
+**Phase 3** (if Phase 2 validates): TIM-478, TIM-479, TIM-480 — Flight coexistence, benchmarks, edge cases.
+
+Each phase is a decision point. If the measured improvement at any phase doesn't justify the next phase's complexity, we stop and ship what we have.
+
+### Updated Risk Register
+
+| Risk | Severity | Likelihood | Mitigation |
+|------|----------|-----------|------------|
+| Upstream hydration data emission | High | Low | Sentinel test, PR monitoring |
+| Props serializer coverage gaps | Medium | Medium | Progressive expansion, graceful fallback |
+| Fizz internal refactors | Medium | Low | Additive changes, fusedMode gating |
+| Client hydration integration fragility | High | Medium | Phase 2 gate; fall back to Flight fetch |
+| Merge conflicts on upstream sync | Low | High | Small, isolated changes; clean branch discipline |
diff --git a/design/fused-renderer-feasibility.md b/design/fused-renderer-feasibility.md
new file mode 100644
index 000000000000..ddfefd787fb8
--- /dev/null
+++ b/design/fused-renderer-feasibility.md
@@ -0,0 +1,271 @@
+# Fused Renderer Long-Term Feasibility Analysis
+
+## Executive Summary
+
+**Recommendation: Approach B (Flight as a library) for detection and resolution, with a new minimal serializer for props. Narrow the initial scope to synchronous server components only.**
+
+Approach A (reimplement Flight logic in Fizz) is fragile — Flight's serialization is deeply coupled to its Request/Task/chunk model, and upstream changes at 90 commits/year would create constant maintenance burden. Approach B is viable because the two critical functions we need — client boundary detection and module reference resolution — are already pure functions with no renderer state dependencies. Props serialization is NOT extractable from Flight (it's deeply entangled), but we don't need Flight's full serializer — we need a smaller, focused one.
+
+---
+
+## 1. Current Flight→Fizz Contract
+
+Today, Flight and Fizz communicate through React elements. The framework (Next.js) orchestrates:
+
+```
+Framework calls Flight.renderToReadableStream(tree, manifest)
+  → Flight walks tree, resolves server components, serializes to wire format
+  → Framework pipes Flight stream to client OR to Flight client for SSR
+
+Framework calls FlightClient.createFromReadableStream(flightStream)
+  → Flight client deserializes wire format back into React elements
+  → These elements are passed to Fizz as children
+
+Framework calls ReactDOM.renderToPipeableStream(flightClientOutput)
+  → Fizz walks the pre-resolved React elements, emits HTML
+```
+
+**Key contract**: Fizz receives **fully resolved React elements** — no server components, no module references, just plain `<div>`, `<span>`, function components (client), and their props. Flight has already done all the RSC work.
+
+**What the fused renderer bypasses**: The middle step. Fizz receives the original tree with server component functions and client module references still present.
+
+## 2. Approach A vs Approach B
+
+### Approach A: Reimplement Flight Logic in Fizz
+
+Fizz learns to:
+- Detect client boundaries (`isClientReference`)
+- Resolve module references (`resolveClientReferenceMetadata`)
+- Serialize props at boundaries (reimplementation of Flight's `renderModelDestructive`)
+- Handle server component execution (already similar to `renderFunctionComponent`)
+
+**What we'd reimplement:**
+| Function | Lines | Complexity | Stability |
+|----------|-------|-----------|-----------|
+| `isClientReference()` | 3 | Trivial | Stable (5 commits/year) |
+| `resolveClientReferenceMetadata()` | 30 | Low | Stable (5 commits/year) |
+| `renderModelDestructive()` + value serializers | ~800 | Very High | Volatile (90 commits/year) |
+| `serializeClientReference()` | 40 | Medium | Evolving |
+| `emitImportChunk()` | 10 | Low | Evolving |
+
+**Risk**: `renderModelDestructive` is 800+ lines handling 20+ value types (elements, promises, maps, sets, typed arrays, streams, iterables, taint, temporary references, client references, server references, symbols, dates, bigints, etc.). It changes frequently. Reimplementing it creates a permanent maintenance burden.
+
+### Approach B: Flight as a Library
+
+Fizz calls into Flight's existing code for specific capabilities:
+
+| Capability | Flight function | Extractable? | Dependencies |
+|-----------|----------------|-------------|--------------|
+| Is this a client component? | `isClientReference(type)` | ✅ Yes — pure function | `Symbol.for('react.client.reference')` only |
+| Get module metadata | `resolveClientReferenceMetadata(config, ref)` | ✅ Yes — pure function | `ClientManifest` (passed in) |
+| Get client reference key | `getClientReferenceKey(ref)` | ✅ Yes — pure function | `ref.$$id`, `ref.$$async` |
+| Is this a server reference? | `isServerReference(ref)` | ✅ Yes — pure function | `Symbol.for('react.server.reference')` only |
+| Get server reference ID | `getServerReferenceId(config, ref)` | ✅ Yes — pure function | `ref.$$id` |
+| Get bound args | `getServerReferenceBoundArguments(config, ref)` | ✅ Yes — pure function | `ref.$$bound` |
+| Serialize arbitrary props | `renderModelDestructive()` | ❌ No — deeply coupled | `Request`, `Task`, chunk IDs, dedup maps, abort state, taint registry |
+
+**Key finding**: Detection and resolution are trivially extractable. Serialization is not.
+
+### Approach B+: Extractable functions + New minimal serializer
+
+Instead of extracting Flight's full serializer, write a **focused props serializer** that handles only what appears at client boundaries:
+
+**What client component props actually contain:**
+- Primitives (string, number, boolean, null) — trivial
+- Plain objects and arrays — recursive JSON
+- Server component children (`children` prop) — tombstone reference to server-rendered DOM
+- Server Actions (functions with `$$typeof === SERVER_REFERENCE_TAG`) — serialize as action refs
+- Client references (other client components passed as props) — serialize as module refs
+- Dates, undefined, NaN, Infinity, BigInt — tagged values
+
+**What client component props almost never contain:**
+- ReadableStreams, TypedArrays, Maps, Sets — these are data-fetching artifacts, not UI props
+- Promises — resolved before reaching the client boundary
+- Tainted values — server-only, never cross the boundary
+- Temporary references — flight-specific mechanism
+
+A focused serializer handling the common cases is ~150 lines, not ~800. Edge cases (streams, typed arrays) can throw a clear error pointing to the full Flight path for client navigation.
+
+## 3. Assumption Inventory
+
+### Assumptions for Approach B+ (recommended)
+
+| # | Assumption | Stability | Evidence | Breakage scenario | Blast radius |
+|---|-----------|-----------|----------|-------------------|-------------|
+| 1 | Client components are marked with `Symbol.for('react.client.reference')` | **Stable** | 5 commits/yr to references file. Symbol is part of public bundler protocol. | React changes the marker symbol | Fixable: update one constant |
+| 2 | Client references have `$$id` and `$$async` properties | **Stable** | Bundler protocol, documented in multiple bundler integrations | React changes the reference shape | Fixable: update property access |
+| 3 | `ClientManifest` maps module IDs to `{id, chunks, name, async?}` | **Stable** | Multiple bundler implementations depend on this. Webpack, Turbopack, Parcel all use it. | React changes manifest format | Painful: update resolution + client loading |
+| 4 | Fizz's `renderElement()` dispatches on `typeof type` | **Stable** | Core dispatch hasn't changed structurally in years | React rewrites Fizz dispatch | Fatal: but this would break everything, not just us |
+| 5 | Fizz's Suspense machinery handles thenables via `ping`→`retry` | **Stable** | Core architecture, 8 commits/yr to hydration context | React changes Suspense internals | Painful: rework async server component handling |
+| 6 | HTML comment markers are the hydration boundary protocol | **Stable** | 8 commits/yr to HydrationContext. `getNextHydratable()` skips unknown comments. | React changes to a different marker system | Painful: update markers |
+| 7 | `flushCompletedQueues()` has a clear insertion point for hydration data | **Evolving** | The TODO at line 5944 suggests this is planned but not yet implemented | React implements their own hydration data emission | Painful to Fatal: our insertion point disappears or conflicts |
+| 8 | Server components are "just functions" without a special marker | **Stable** | This is by design — server components are the default, client is opt-in | React adds a server component marker | Fixable: check for it |
+| 9 | Server Actions use `Symbol.for('react.server.reference')` with `$$id` and `$$bound` | **Stable** | Part of the bundler protocol like client references | React changes action serialization | Fixable: update serializer |
+| 10 | `renderWithHooks()` in Fizz can execute arbitrary functions | **Stable** | This is how all function components work in Fizz | React restricts what Fizz can execute | Fatal: but extremely unlikely |
+
+### Evolving features that touch the boundary
+
+| Feature | Status | Flight impact | Fizz impact | Our impact |
+|---------|--------|--------------|-------------|-----------|
+| View Transitions | Landed (RN), DOM flag on | New format context in Flight | New markers in Fizz (`pushStartViewTransition`) | Low: additive, doesn't change client boundary protocol |
+| Fragment Refs | Shipped (`enableFragmentRefs: true`) | None | DOM config changes for ref handles | Low: doesn't affect boundaries |
+| Activity (Offscreen) | Shipping | None | New boundary type (`<!--&-->`) | Low: parallel to Suspense, not conflicting |
+| Partial Hydration | Active (`enableHydrationChangeEvent`) | None | HydrationContext changes | Medium: may change how we skip server-only DOM |
+| Fizz Blocking Render | Experimental | None | Shell size limits | Low: orthogonal to fused rendering |
+| Preamble System | Active (frequent commits) | None | Segment/boundary management | Medium: our boundary emission must not conflict |
+| Server Actions encryption | N/A (framework-level) | Action bound args | None | Low: we serialize action refs, not decrypt |
+| `enableHalt` | Cleaned up (removed) | Prerender behavior | None | None: already removed |
+| `enablePostpone` | Cleaned up (removed) | Prerender behavior | None | None: already removed |
+
+### The hydration data TODO (Assumption #7) — deep dive
+
+The comment at `ReactFizzServer.js:5944`:
+```js
+// TODO: Here we'll emit data used by hydration.
+```
+
+This suggests the React team plans to emit hydration data from Fizz themselves. If they implement this, it could either:
+- **Align with our approach**: They implement something similar, making our fork easier to maintain
+- **Conflict with our approach**: They implement something different, and our insertion point breaks
+
+**Mitigation**: Watch the React repo for PRs touching this TODO. If React ships their own hydration data emission, we evaluate merging their approach. This is actually the best possible outcome — it means upstream is solving the same problem.
+
+**Detection**: A test that asserts the TODO comment still exists at the expected location. If it disappears, we know upstream has acted.
+
+## 4. The Minimal Viable Fused Renderer
+
+Instead of handling all cases, start with:
+
+### Phase 1: Synchronous server components only
+- Server component functions that return JSX synchronously
+- No async server components (they fall back to regular Suspense)
+- No streaming server component resolution
+- Client boundaries with simple props (primitives, objects, arrays)
+- Server Action references in props
+
+**What this still delivers:**
+- Single-pass rendering for the common case (most server components are sync)
+- Elimination of Flight serialize→deserialize round-trip for sync content
+- Hydration data emission at client boundaries
+- Significant throughput improvement (the sync path is where most time is spent)
+
+**What it defers:**
+- Async server components (use existing Flight path as fallback)
+- Complex prop types (streams, typed arrays — error with clear message)
+- Nested server-in-client-in-server (the deep composition case)
+
+### Phase 2: Async server components
+- Use Fizz's existing Suspense suspension for async server components
+- This is straightforward — Fizz already has the machinery
+
+### Phase 3: Complex props and edge cases
+- Expand the props serializer as needed
+- Handle the server-component-children-as-client-prop case
+
+## 5. Concrete Extraction Plan for Approach B+
+
+### What we import from Flight (unchanged, no fork needed)
+
+```
+From packages/react-server-dom-webpack/src/ReactFlightWebpackReferences.js:
+  - isClientReference(type)        → check $$typeof === CLIENT_REFERENCE_TAG
+  - isServerReference(type)        → check $$typeof === SERVER_REFERENCE_TAG
+  - CLIENT_REFERENCE_TAG           → Symbol.for('react.client.reference')
+  - SERVER_REFERENCE_TAG           → Symbol.for('react.server.reference')
+
+From packages/react-server-dom-webpack/src/server/ReactFlightServerConfigWebpackBundler.js:
+  - resolveClientReferenceMetadata(config, ref)  → manifest lookup
+  - getClientReferenceKey(ref)                    → ref.$$id + async flag
+  - getServerReferenceId(config, ref)             → ref.$$id
+  - getServerReferenceBoundArguments(config, ref) → ref.$$bound
+```
+
+These are all pure functions. We can import them directly or copy the ~50 total lines. They have no dependencies on Flight's renderer state.
+
+### What we write new (in Fizz)
+
+```
+packages/react-server/src/ReactFizzHydrationData.js (~150 lines):
+  - serializePropsForHydration(props, bundlerConfig)
+    Handles: primitives, objects, arrays, dates, bigints, undefined, NaN, Infinity
+    Handles: client references → module ref metadata
+    Handles: server references → action ref with ID + bound args
+    Handles: server component children → tombstone marker
+    Throws on: streams, typed arrays, maps, sets (with helpful error)
+
+packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js (additions):
+  - pushStartClientBoundary(chunks, id)    → <!--C:id-->
+  - pushEndClientBoundary(chunks)          → <!--/C-->
+  - writeClientBoundaryScript(dest, id, moduleRef, serializedProps)
+
+packages/react-server/src/ReactFizzServer.js (modifications):
+  - Request object: add fusedMode, bundlerConfig, clientBoundaryQueue
+  - renderElement(): add client/server component detection before function dispatch
+  - flushCompletedQueues(): emit hydration data at the TODO
+```
+
+### What we don't touch
+
+- `ReactFlightServer.js` — untouched, still used for client navigation
+- `ReactFlightClient.js` — untouched, still used for client navigation
+- `ReactFiberHydrationContext.js` — separate task (TIM-477), additive only
+- `ReactFiberBeginWork.js` — separate task (TIM-477), additive only
+
+## 6. Risk Mitigation
+
+### Automated breakage detection
+
+Create sentinel tests that fail if upstream assumptions change:
+
+```js
+// test: client reference protocol hasn't changed
+test('client references use expected symbol', () => {
+  expect(Symbol.for('react.client.reference')).toBe(CLIENT_REFERENCE_TAG);
+});
+
+// test: manifest format hasn't changed
+test('resolveClientReferenceMetadata returns expected shape', () => {
+  const result = resolveClientReferenceMetadata(mockManifest, mockRef);
+  expect(result).toHaveLength(3); // or 4 for async
+  expect(typeof result[0]).toBe('string'); // module ID
+  expect(Array.isArray(result[1])).toBe(true); // chunks
+  expect(typeof result[2]).toBe('string'); // export name
+});
+
+// test: the hydration data TODO still exists
+test('flushCompletedQueues has hydration data insertion point', () => {
+  const source = fs.readFileSync('packages/react-server/src/ReactFizzServer.js', 'utf8');
+  expect(source).toContain("// TODO: Here we'll emit data used by hydration.");
+});
+```
+
+### Fallback path
+
+When fusedMode is enabled but encounters an unsupported case (e.g., a complex prop type), fall back gracefully:
+- Log a dev warning
+- Emit the component as a regular Fizz render (no hydration data)
+- The client will need a full Flight fetch for this component on navigation
+
+This means the fused renderer is **progressive** — it handles what it can and falls back for what it can't.
+
+## 7. Conclusion
+
+| Criterion | Approach A | Approach B+ |
+|-----------|-----------|-------------|
+| Lines of Flight code reimplemented | ~900 | ~0 (import ~50 lines of pure functions) |
+| New code written | ~200 (in Fizz) | ~350 (serializer + Fizz changes) |
+| Maintenance burden from upstream | High (800+ lines to keep in sync) | Low (sentinel tests catch breaks) |
+| Breakage from Flight changes | Frequent (90 commits/yr) | Rare (only if bundler protocol changes) |
+| Feature completeness | Full | Progressive (sync first, async later) |
+| Time to first measurable result | Longer | Shorter (narrower scope) |
+
+**Approach B+ wins.** The critical insight: we don't need to reimplement Flight's serializer. We need a much smaller, focused serializer for the specific case of client boundary props. The detection and resolution functions we need are already pure functions we can call directly.
+
+### Recommended task changes
+
+1. **TIM-474** (server component execution): Keep as-is — this is the same in both approaches
+2. **TIM-475** (client boundary detection): Simplify — use Flight's `isClientReference` directly instead of reimplementing
+3. **TIM-476** (props serializer): Rewrite scope — focused serializer, not Flight extraction. Handle common types only, throw on exotic types.
+4. **TIM-477** (client hydration): Keep as-is — client-side changes are independent of the approach
+5. **New task**: Sentinel tests for upstream assumption monitoring
+6. **New task**: Fallback path for unsupported prop types
diff --git a/design/fused-renderer-findings.md b/design/fused-renderer-findings.md
new file mode 100644
index 000000000000..d36516567742
--- /dev/null
+++ b/design/fused-renderer-findings.md
@@ -0,0 +1,130 @@
+# Fused Renderer: Complete Findings
+
+**Date**: 2026-03-25
+**Branch**: `fused-renderer`
+**Status**: Server-side implementation complete. 1.6–2.0x throughput improvement verified.
+
+---
+
+## The Core Result
+
+Fused rendering — having Fizz call server component functions directly instead of going through Flight serialize → deserialize → re-traverse — delivers a **1.6–2.0x throughput improvement** under concurrent load, with identical HTML output, 4–5x less memory, and stable performance under pressure.
+
+### Verified concurrent throughput (226-product PLP, single Node.js thread)
+
+| c | Full Pipeline | Fused | Improvement | Heap |
+|---|-------------|-------|-------------|------|
+| 1 | 128 req/s | **200 req/s** | **1.6x** | 239→73 MB |
+| 10 | 108 req/s | **187 req/s** | **1.7x** | 277→70 MB |
+| 25 | 99 req/s | **187 req/s** | **1.9x** | 277→57 MB |
+| 50 | 93 req/s | **185 req/s** | **2.0x** | 297→60 MB |
+
+**Key property**: Fused throughput is **rock stable** (185–200 req/s regardless of concurrency) while the full pipeline **degrades under load** (128→93 req/s) due to GC pressure from intermediate Flight wire format buffers.
+
+### Audit results
+
+All numbers verified by automated audit:
+- ✅ HTML output is byte-identical between full pipeline and fused (after stripping markers/scripts)
+- ✅ Client component functions are actually called (counted invocations)
+- ✅ All product names present in rendered HTML
+- ✅ Boundary markers and hydration data present
+- ✅ Module resolution uses O(1) Map lookup (same cost as `__webpack_require__`)
+- ✅ Same React build used for both paths
+- ✅ Node.js streams (`renderToPipeableStream`), not web streams
+
+## What We Built
+
+### Implementation (merged to `fused-renderer` branch)
+
+| PR | Task | What it does |
+|----|------|-------------|
+| #10 | TIM-474 | `fusedMode` + `bundlerConfig` on Request. Client ref detection. Server components called inline. |
+| #11 | TIM-475 | `renderClientBoundary()`: markers, hydration data queue, consolidated `<script>`. |
+| #12 | TIM-476 | `ReactFizzHydrationSerializer.js`: focused props serializer (~150 lines). |
+| #14 | TIM-486 | Fast-path serializer using native `JSON.stringify`. |
+| #15 | TIM-478 | Flight coexistence tests. Sentinel: Flight server untouched. |
+| #16 | TIM-480 | Edge case tests + upstream assumption sentinels. |
+
+### Architecture
+
+```
+Framework request arrives
+  ├── Initial SSR (fusedMode: true)
+  │   Fizz receives original tree with server component functions
+  │   ├── Server component → renderFunctionComponent() → HTML
+  │   └── Client component → renderClientBoundary()
+  │       ├── resolveClientComponent($$id) → actual module
+  │       ├── <!--C:ID--> marker
+  │       ├── renderFunctionComponent(resolvedModule, props) → HTML
+  │       ├── <!--/C--> marker
+  │       └── Queue {moduleRef, serializedProps}
+  │   └── flushCompletedQueues() → consolidated <script data-fused-hydration>
+  │
+  └── Client navigation (fusedMode: false, default)
+      └── Flight server → wire format (completely unchanged)
+```
+
+### Key design decisions
+
+1. **`resolveClientComponent` on bundlerConfig** — the framework provides a function that maps `$$id` to the actual server-side module. This is equivalent to `__webpack_require__` in the Flight client but runs inside Fizz. The proxy function itself returns `undefined` — you MUST resolve the real module.
+
+2. **Consolidated hydration script** — one `<script data-fused-hydration>` per flush instead of per-boundary. Deduplicates module refs. Format: `{"m":["moduleUrl"],"b":[[boundaryId,moduleIdx],...]}`
+
+3. **Props serialized per-boundary** — `serializeProps()` handles common types via JSON.stringify fast path. ~1.3ms for 226 boundaries. This is irreducible work — the client needs props to hydrate.
+
+## Where the speedup comes from
+
+Per-request breakdown (c=1, 226 products):
+
+| Phase | Full Pipeline | Fused | Saved |
+|-------|-------------|-------|-------|
+| Flight serialize (tree walk + wire format) | ~2.5ms | 0ms | 2.5ms |
+| Flight deserialize + element reconstruction | ~2.5ms | 0ms | 2.5ms |
+| Module resolution | via Flight client | ~0.003ms | — |
+| Component rendering (Fizz) | ~2.0ms | ~2.0ms | 0ms |
+| Props serialization | 0ms (in Flight wire) | ~1.3ms | -1.3ms |
+| Hydration script emission | 0ms | ~0.2ms | -0.2ms |
+| **Total** | **~7.0ms** | **~3.5ms** | **3.5ms** |
+
+Net savings: ~3.5ms per request from eliminating Flight serialize + deserialize, offset by props serialization + hydration script costs. The props serialization is work that Flight was also doing (it serialized props in the wire format) — we're just doing it in a different location.
+
+## Measurement journey
+
+| Version | Claimed | Actual | Error |
+|---------|---------|--------|-------|
+| v1 (sync-only) | 54-79% overhead | CPU ratio was correct | No async/data fetch |
+| v2 (wall-clock + I/O) | 1-4% overhead | Irrelevant metric | I/O wait isn't CPU |
+| v3 (concurrent) | 3-6x drop | Measured the problem correctly | "Fizz ceiling" was wrong |
+| v4 (apples-to-apples) | 2.3-3.2x | **Client proxy bug** | Fused wasn't rendering components |
+| **v5 (audited)** | **1.6-2.0x** | **Verified identical HTML** | **Honest** |
+
+The proxy bug: `clientExports()` creates `function(){}` with `$$typeof` set. Calling this proxy returns `undefined`. The fused renderer was emitting empty markers, benchmarking "doing nothing" as faster. Fixed by adding `resolveClientComponent` to resolve the actual module via bundlerConfig.
+
+## Open items
+
+### Client-side hydration (TIM-485, TIM-477)
+The server emits `<!--C:ID-->` markers and a consolidated hydration `<script>`. The client strategy is undecided:
+- Option A: Modify reconciler hydration walker (complex)
+- Option B: Flight fetch fallback
+- Option C: Mini React roots per boundary (Islands)
+- Option D: Forest coordination layer
+
+### Integration
+The `experimental_fusedMode` option is available on all server entry points. A framework needs to provide `experimental_bundlerConfig.resolveClientComponent($$id)` to map client reference IDs to actual server-side modules.
+
+## How to use
+
+```js
+import { renderToPipeableStream } from 'react-dom/server';
+
+const { pipe } = renderToPipeableStream(<App />, {
+  experimental_fusedMode: true,
+  experimental_bundlerConfig: {
+    resolveClientComponent(id) {
+      // Map client reference $$id to the server-side module
+      return ssrModuleMap.get(id);
+    },
+  },
+  onShellReady() { pipe(res); },
+});
+```
diff --git a/design/fused-renderer-fizz-analysis.md b/design/fused-renderer-fizz-analysis.md
new file mode 100644
index 000000000000..536dd6fa9d61
--- /dev/null
+++ b/design/fused-renderer-fizz-analysis.md
@@ -0,0 +1,306 @@
+# Fizz Internals Analysis for Fused Renderer
+
+Analysis of `packages/react-server/src/ReactFizzServer.js` and
+`packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js` to identify
+insertion points for the fused single-pass renderer.
+
+## 1. renderElement() Dispatch Table
+
+Location: `ReactFizzServer.js:2917`
+
+`renderElement(request, task, keyPath, type, props, ref)` dispatches on `type`:
+
+| Type check | Handler | Notes |
+|---|---|---|
+| `typeof type === 'function'` + `shouldConstruct(type)` | `renderClassComponent()` | Class components with `isReactComponent` |
+| `typeof type === 'function'` (else) | `renderFunctionComponent()` | **All function components go here — server components would too** |
+| `typeof type === 'string'` | `renderHostElement()` | DOM elements (`div`, `span`, etc.) |
+| `type === REACT_FRAGMENT_TYPE` | `renderNodeDestructive(props.children)` | Fragments, also StrictMode, Profiler, LegacyHidden |
+| `type === REACT_ACTIVITY_TYPE` | `renderActivity()` | Activity (offscreen) |
+| `type === REACT_SUSPENSE_LIST_TYPE` | `renderSuspenseList()` | SuspenseList ordering |
+| `type === REACT_VIEW_TRANSITION_TYPE` | `renderViewTransition()` | View transitions (feature-flagged) |
+| `type === REACT_SCOPE_TYPE` | `renderNodeDestructive(props.children)` | Scope API (feature-flagged) |
+| `type === REACT_SUSPENSE_TYPE` | `renderSuspenseBoundary()` | **Suspense — key for async server components** |
+| `type.$$typeof === REACT_FORWARD_REF_TYPE` | `renderForwardRef()` | ForwardRef wrappers |
+| `type.$$typeof === REACT_MEMO_TYPE` | `renderMemo()` | Memo wrappers |
+| `type.$$typeof === REACT_CONTEXT_TYPE` | `renderContextProvider()` | Context.Provider |
+| `type.$$typeof === REACT_CONSUMER_TYPE` | `renderContextConsumer()` | Context.Consumer |
+| `type.$$typeof === REACT_LAZY_TYPE` | `renderLazyComponent()` | Lazy loading |
+| Otherwise | **throw** | "Element type is invalid" |
+
+### Key observation for fused renderer
+
+Today, `typeof type === 'function'` catches **all** function components. Fizz has no concept of "server component" vs "client component" — Flight resolves everything before Fizz sees it. In fused mode, we need to distinguish:
+
+1. **Server component**: function without `'use client'` module reference → call it inline
+2. **Client component**: function with module reference → render to HTML + emit hydration data
+3. **Plain function component**: regular component (neither server nor client) → render as today
+
+The detection mechanism will depend on how the bundler marks client components (typically via `$$typeof` on the module reference or a special property). See TIM-472 flight analysis for details.
+
+## 2. Request Object Shape
+
+Location: `ReactFizzServer.js:366` (opaque type), `ReactFizzServer.js:517` (RequestInstance constructor)
+
+### Fields
+
+```
+Request {
+  // Output
+  destination: null | Destination       // The writable stream we flush to
+  flushScheduled: boolean               // Whether a flush is pending
+
+  // Configuration (immutable after creation)
+  resumableState: ResumableState        // Tracks what instructions have been sent (deduplication)
+  renderState: RenderState              // Precomputed chunks, script prefixes, boundary prefixes
+  rootFormatContext: FormatContext       // HTML/SVG/MathML context for the root
+  progressiveChunkSize: number          // Target chunk size for streaming (~12.8KB default)
+
+  // Lifecycle state
+  status: OPENING | OPEN | ABORTING | CLOSING | CLOSED | STALLED_DEV
+  fatalError: mixed                     // Set when a fatal error occurs
+
+  // Task tracking
+  nextSegmentId: number                 // Auto-incrementing ID for new segments
+  allPendingTasks: number               // Total pending tasks (when 0, connection can close)
+  pendingRootTasks: number              // Pending tasks in the root/shell (when 0, shell is done)
+  abortableTasks: Set<Task>             // All tasks that can be aborted
+  pingedTasks: Array<Task>              // High-priority tasks to work on next (the work queue)
+
+  // Output queues (flushed in priority order)
+  completedRootSegment: null | Segment  // The root segment, once completed
+  completedPreambleSegments: null | Array<Array<Segment>>  // Preamble segments (head content)
+  byteSize: number                      // Accumulated shell bytes
+  clientRenderedBoundaries: Array<SuspenseBoundary>  // Errored boundaries → client render
+  completedBoundaries: Array<SuspenseBoundary>       // Done boundaries → stream replacement
+  partialBoundaries: Array<SuspenseBoundary>         // Partially done → stream segments
+
+  // Prerender tracking
+  trackedPostpones: null | PostponedHoles  // Non-null during prerender to track holes
+
+  // Callbacks
+  onError: (error, errorInfo) => ?string
+  onAllReady: () => void                // All tasks done (good for static generation)
+  onShellReady: () => void              // Shell/root done (good for streaming start)
+  onShellError: (error) => void         // Shell failed
+  onFatalError: (error) => void         // Unrecoverable
+
+  // Form state
+  formState: null | ReactFormState      // For MPA form submission hydration
+}
+```
+
+### Lifecycle
+
+1. **OPENING** (10): Created, initial work scheduled via `scheduleMicrotask`
+2. **OPEN** (11): First `scheduleWork` callback fired
+3. **ABORTING** (12): `abort()` called, tasks are being torn down
+4. **CLOSING** (13): All tasks done, flushing final output
+5. **CLOSED** (14): Done, destination closed
+
+### Where to add fused renderer state
+
+A `fusedMode: boolean` flag on Request would gate the new behavior. Additionally:
+- `clientBoundaryQueue: Array<{id, moduleRef, serializedProps}>` for hydration data
+- `nextClientBoundaryId: number` for generating boundary IDs
+
+These would be added to RequestInstance constructor and the Request opaque type.
+
+## 3. Task/Segment Model
+
+### Task types
+
+Two task types share the `Task` union:
+
+**RenderTask** — produces HTML into a Segment:
+```
+RenderTask {
+  replay: null                          // null = render mode (not replay)
+  node: ReactNodeList                   // The React node being rendered
+  childIndex: number                    // Position within parent's children
+  ping: () => void                      // Callback to re-queue this task
+  blockedBoundary: Root | SuspenseBoundary  // The Suspense boundary this renders into
+  blockedSegment: Segment               // The segment being written to
+  blockedPreamble: null | PreambleState // Preamble state for head content
+  hoistableState: null | HoistableState // Hoistable resources (stylesheets, etc.)
+  abortSet: Set<Task>                   // Which abort set this belongs to
+  keyPath: Root | KeyNode               // React element key path
+  formatContext: FormatContext           // HTML/SVG/MathML rendering context
+  context: ContextSnapshot              // React context state
+  treeContext: TreeContext               // ID generation tree context
+  row: null | SuspenseListRow           // SuspenseList row tracking
+  componentStack: ComponentStackNode    // For error messages
+  thenableState: null | ThenableState   // Saved thenable state for resumption
+  legacyContext: LegacyContext           // Legacy context (being removed)
+}
+```
+
+**ReplayTask** — replays a prerendered tree (used for resume):
+- Same shape but `replay: ReplaySet` (non-null) and `blockedSegment: null`
+
+### Segment
+
+```
+Segment {
+  status: PENDING | COMPLETED | FLUSHED | ABORTED | ERRORED | POSTPONED | RENDERING
+  parentFlushed: boolean                // Can this be flushed (parent already sent)?
+  id: number                            // Lazily assigned segment ID
+  index: number                         // Position within parent's chunks
+  chunks: Array<Chunk | PrecomputedChunk>  // THE HTML OUTPUT BUFFER
+  children: Array<Segment>              // Child segments (from Suspense boundaries)
+  preambleChildren: Array<Segment>      // Preamble child segments
+  parentFormatContext: FormatContext     // Context when this segment was created
+  boundary: null | SuspenseBoundary     // Associated boundary (for fallback segments)
+  lastPushedText: boolean               // Text separator tracking
+  textEmbedded: boolean                 // Text separator tracking
+}
+```
+
+### How they interact
+
+1. `createRequest()` creates a root Segment and a root RenderTask pointing at it
+2. The task is pushed to `request.pingedTasks`
+3. `performWork()` iterates `pingedTasks`, calling `retryTask()` on each
+4. `retryTask()` → `retryRenderTask()` → `retryNode()` → `renderNodeDestructive()` → `renderElement()`
+5. HTML chunks are pushed into `segment.chunks` via `pushStartInstance()` / `pushEndInstance()`
+6. When a Suspense boundary is encountered, new child Segments and Tasks are created
+7. When a Task completes, `finishedSegment()` and `finishedTask()` update counters
+8. When all tasks for a boundary complete, it moves to `completedBoundaries`
+9. `flushCompletedQueues()` writes segments to the destination stream
+
+## 4. Suspense Boundary Flow (suspend → resolve → stream)
+
+Location: `ReactFizzServer.js:1337` (`renderSuspenseBoundary`)
+
+### Normal render path (not prerender)
+
+1. **Create boundary**: `createSuspenseBoundary()` — tracks pending tasks, completed segments
+2. **Create segments**: 
+   - `boundarySegment` — holds the fallback content (child of parent segment)
+   - `contentRootSegment` — holds the actual content (independent)
+3. **Try to render content synchronously**:
+   - Temporarily swap `task.blockedBoundary` and `task.blockedSegment` to the new boundary/segment
+   - Call `renderNode(request, task, content, -1)`
+   - If it succeeds without suspending → boundary is COMPLETED immediately
+   - If the boundary is small enough, skip creating the fallback entirely (early return)
+4. **If content throws a thenable** (suspends):
+   - Caught in `renderNode()` catch block (~line 4268)
+   - `spawnNewSuspendedRenderTask()` creates a new task for the suspended subtree
+   - New task gets a new child segment, registered with the boundary
+   - The thenable's `.then(ping, ping)` ensures the task is re-queued when resolved
+5. **Create fallback task**: Always created (unless early return), queued to `pingedTasks`
+6. **When suspended content resolves**:
+   - `ping()` → `pingTask()` → pushes task to `pingedTasks`
+   - Next `performWork()` calls `retryRenderTask()` on it
+   - Rendering continues from where it left off (same node, same context)
+   - On completion: `finishedSegment()` + `finishedTask()` 
+7. **When boundary completes**:
+   - `finishedTask()` decrements `boundary.pendingTasks`
+   - When it reaches 0: boundary moves to `completedBoundaries` queue
+   - `flushCompletedQueues()` writes a streaming `<script>` instruction to replace the fallback
+
+### Streaming replacement mechanism
+
+In `flushCompletedQueues()` (line 5831):
+1. **Root segment**: Flushed first (the shell HTML)
+2. **Client-rendered boundaries**: `writeClientRenderBoundaryInstruction()` — tells client to render fallback
+3. **Completed boundaries**: `writeCompletedBoundaryInstruction()` — replaces fallback with content
+4. **Partial boundaries**: `writeCompletedSegmentInstruction()` — streams individual segments
+
+The streaming instructions are inline `<script>` tags that call runtime functions:
+- `$RC(boundaryId, segmentId)` — replace completed boundary
+- `$RS(segmentId, placeholderId)` — complete a segment
+- `$RX(boundaryId, ...)` — client-render a boundary (error case)
+
+### Key insight for fused renderer
+
+Fizz already handles async components via this same mechanism. When a server component
+returns a Promise in fused mode, we can treat it exactly like any other suspension:
+the task suspends, a new task is spawned, the promise's resolution pings the task.
+**No new concurrency model needed.**
+
+## 5. The Hydration Data TODO
+
+Location: `ReactFizzServer.js:5944`
+
+```js
+// Allow anything written so far to flush to the underlying sink before
+// we continue with lower priorities.
+completeWriting(destination);
+beginWriting(destination);
+
+// TODO: Here we'll emit data used by hydration.
+
+// Next we emit any segments of any boundaries that are partially complete
+// but not deeply complete.
+```
+
+This TODO sits between:
+- **Completed boundaries** (high priority — full boundary replacements)
+- **Partial boundaries** (low priority — individual segment streaming)
+
+This is the **exact insertion point** for emitting client boundary hydration data.
+The fused renderer would:
+
+1. Iterate `request.clientBoundaryQueue`
+2. For each entry, write an inline `<script>` tag containing:
+   - The client boundary ID
+   - The module reference (chunk URL + export name)
+   - The serialized props
+3. Clear the queue
+
+This interleaving is correct: hydration data should be emitted after boundary
+HTML is in place but can be lower priority than full boundary completions.
+
+## 6. How Components Are Called
+
+Location: `ReactFizzServer.js:2346` (`renderWithHooks`)
+
+```js
+function renderWithHooks(request, task, keyPath, Component, props, secondArg) {
+  const prevThenableState = task.thenableState;
+  task.thenableState = null;
+  prepareToUseHooks(request, task, keyPath, componentIdentity, prevThenableState);
+  let result = Component(props, secondArg);  // <-- THE CALL
+  return finishHooks(Component, props, result, secondArg);
+}
+```
+
+`renderFunctionComponent()` calls `renderWithHooks()` then passes the result to
+`finishFunctionComponent()` which calls `renderNodeDestructive()` on the returned elements.
+
+For server components in fused mode, we'd use the same `renderWithHooks` mechanism
+(it handles hook state, thenable resumption, etc.) but the component function is the
+server component itself rather than a pre-resolved element tree.
+
+If the server component uses `async/await`, it returns a Promise. This throws a
+`SuspenseException` via the `use()` hook mechanism or is caught as a thenable in
+`renderNode()`'s catch block. Either way, Fizz's existing suspension machinery handles it.
+
+## 7. Entry Points for Fused Renderer Changes
+
+### In ReactFizzServer.js
+
+1. **Request object** (line 366): Add `fusedMode`, `clientBoundaryQueue`, `nextClientBoundaryId`
+2. **renderElement()** (line 2917): Before the `typeof type === 'function'` check, add:
+   - If `fusedMode` and type has module reference → client component path
+   - If `fusedMode` and type is plain function → server component path (call inline)
+   - The existing `renderFunctionComponent` already handles calling functions and processing results
+3. **flushCompletedQueues()** (line 5944, the TODO): Emit hydration data scripts
+4. **createRequest()** (line 555): Initialize fused mode fields
+
+### In ReactFizzConfigDOM.js
+
+1. **New marker functions**: `pushStartClientBoundary()` / `pushEndClientBoundary()`
+   - Similar to existing Suspense boundary markers (`<!--$-->` / `<!--/$-->`)
+   - Would emit `<!--client:ID-->` / `<!--/client:ID-->`
+2. **New script emitter**: `writeClientBoundaryScript()`
+   - Similar to `writeCompletedBoundaryInstruction()` 
+   - Emits `<script>` with module ref + serialized props
+
+### What does NOT change
+
+- The Flight server (`ReactFlightServer.js`) — still used for client navigation
+- Server Actions — unchanged
+- Suspense streaming — additive, no modifications to existing flow
+- The reconciler — client-side changes are in a separate task (TIM-477)
diff --git a/design/fused-renderer-flight-analysis.md b/design/fused-renderer-flight-analysis.md
new file mode 100644
index 000000000000..d6bdc0d89e43
--- /dev/null
+++ b/design/fused-renderer-flight-analysis.md
@@ -0,0 +1,310 @@
+# Flight Wire Format and Client Boundary Detection Analysis
+
+Analysis of `packages/react-server/src/ReactFlightServer.js` and
+`packages/react-server-dom-webpack/src/` to understand how Flight identifies
+server vs client components and serializes them over the wire.
+
+## 1. How Flight Detects Client Components
+
+### The `isClientReference()` check
+
+Location: `packages/react-server-dom-webpack/src/ReactFlightWebpackReferences.js:29`
+
+```js
+const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
+
+export function isClientReference(reference: Object): boolean {
+  return reference.$$typeof === CLIENT_REFERENCE_TAG;
+}
+```
+
+A client component is any function/object whose `$$typeof` property is
+`Symbol.for('react.client.reference')`. This is set by the bundler at build
+time via `registerClientReference()`.
+
+### Client Reference Shape
+
+```js
+type ClientReference<T> = {
+  $$typeof: Symbol('react.client.reference'),
+  $$id: string,      // e.g. "src/components/Button.tsx#default" or "src/components/Button.tsx#Button"
+  $$async: boolean,   // true if the module is async (dynamic import)
+};
+```
+
+The `$$id` encodes `modulePath#exportName`. The bundler plugin creates these
+proxy objects for every export from a `'use client'` module.
+
+### Server Reference Shape (for Server Actions)
+
+```js
+type ServerReference<T> = T & {
+  $$typeof: Symbol('react.server.reference'),
+  $$id: string,       // action identifier
+  $$bound: null | Array<ReactClientValue>,  // bound closure args
+};
+```
+
+### How Flight dispatches in `renderElement()`
+
+Location: `ReactFlightServer.js:2179`
+
+```
+if (typeof type === 'function' && !isClientReference(type))
+  → Server Component: call renderFunctionComponent() — executes the function
+else if (type === REACT_FRAGMENT_TYPE && key === null)
+  → Fragment: render children directly
+else if (typeof type === 'object' && !isClientReference(type))
+  → Object types: Lazy, ForwardRef, Memo — unwrap and recurse
+else if (typeof type === 'string')
+  → Host element (div, span): pass through to client
+else
+  → Client element: call renderClientElement() — serialize module reference
+```
+
+**Key: the check is `isClientReference(type)`.** If `type` has `$$typeof ===
+CLIENT_REFERENCE_TAG`, Flight does NOT call the function. It serializes a module
+reference instead.
+
+## 2. Flight Wire Format
+
+### Row format
+
+Every Flight chunk is a row:
+```
+<id-hex>:<tag><json>\n
+```
+
+Where `<id-hex>` is the chunk ID in hexadecimal, `<tag>` is a single character,
+and `<json>` is the serialized payload.
+
+### Chunk types (tags)
+
+| Tag | Name | Content | Example |
+|-----|------|---------|---------|
+| (none) | Model | JSON value (the tree) | `0:["$","div",null,{"children":"Hello"}]\n` |
+| `I` | Import | Module reference metadata | `1:I["src/Button.js",["chunk-abc.js"],"Button"]\n` |
+| `E` | Error | Error info | `2:E{"digest":"abc","message":"..."}\n` |
+| `H` | Hint | Resource hint (preload) | `:HL["stylesheet","styles.css"]\n` |
+| `D` | Debug | Debug info (DEV only) | `3:D{"name":"App","env":"Server"}\n` |
+| `S` | Symbol | Well-known symbol ref | `4:S"react.fragment"\n` |
+| `P` | Postpone | Postponed marker | `5:P{}\n` |
+| `T` | Text | String value | `6:T"hello world"\n` |
+| `B` | Blob/Binary | Binary data | `7:B<binary>\n` |
+
+### Model chunk format (the tree)
+
+React elements are serialized as tuples:
+```
+[REACT_ELEMENT_TYPE, type, key, props]
+```
+
+Where `type` is either:
+- A string (`"div"`, `"span"`) for host elements
+- A reference to an import chunk (`"$L1"`) for client components
+- Other React types (fragments, context, etc.)
+
+### Import chunk format
+
+When Flight encounters a client component, it emits an Import chunk:
+```
+<id>:I<json>\n
+```
+
+The JSON payload is `ClientReferenceMetadata`:
+```js
+type ImportMetadata =
+  | [id: string, chunks: Array<string>, name: string, async: 1]
+  | [id: string, chunks: Array<string>, name: string];
+```
+
+- `id`: The module ID in the bundler (e.g., webpack module ID)
+- `chunks`: Array of chunk ID / filename pairs (double-indexed: `[chunkId, filename, chunkId, filename, ...]`)
+- `name`: The export name (e.g., `"default"`, `"Button"`)
+- `async`: Present as `1` if the module is async
+
+### Example: A page with a client component
+
+```jsx
+// Server Component
+function Page() {
+  return <Layout><ClientButton label="Click" /></Layout>;
+}
+```
+
+Flight output:
+```
+1:I["./src/ClientButton.tsx",["client-chunk-abc.js","client-chunk-abc.js"],"default"]
+0:["$","div",null,{"className":"layout","children":["$","$L1",null,{"label":"Click"}]}]
+```
+
+Breakdown:
+- Row `1:I[...]` — registers the client module reference (chunk URL + export)
+- Row `0:[...]` — the tree model. `"$L1"` is a lazy reference to chunk 1 (the client component)
+- The client component's props (`{"label":"Click"}`) are serialized inline in the model
+
+## 3. Props Serialization at Client Boundaries
+
+When Flight serializes a client element via `renderClientElement()`:
+
+```js
+function renderClientElement(request, task, type, key, props, validated) {
+  // ... key path handling ...
+  const element = [REACT_ELEMENT_TYPE, type, key, props];
+  return element;
+}
+```
+
+The `type` at this point is already a reference to an Import chunk (via
+`serializeClientReference()`). The `props` are serialized through the normal
+model serialization (`renderModelDestructive` → `stringify`).
+
+**Props serialization handles:**
+- Primitives (string, number, boolean, null, undefined)
+- Arrays and plain objects (recursive serialization)
+- Dates → `"$D<iso-string>"`
+- BigInt → `"$n<string>"`
+- Symbols → reference to Symbol chunk
+- React elements in props → recursive (client elements become references)
+- Server components in props → **executed and resolved before serialization**
+- Thenables/Promises → outlined as lazy chunks
+- Client references (functions) → Import chunks
+- Server references (actions) → `"$F<id>"` with bound args
+- Maps → `"$Q<id>"` referencing an outlined entries array
+- Sets → `"$W<id>"` referencing an outlined values array
+- TypedArrays → binary chunks
+- ReadableStreams → streamed async chunks
+- Iterables/AsyncIterables → streamed sequences
+
+### What the fused renderer needs from this
+
+At a client boundary, the fused renderer needs to serialize **only the props**
+of that client component (not the entire tree). The serialization requirements
+are the same as Flight's — we need to handle the same value types. The key
+difference:
+
+- **Server component children in props**: Flight resolves these to their output
+  before serialization. In the fused renderer, server component children rendered
+  as `children` prop of a client component are already HTML. We need a
+  tombstone/reference saying "this subtree is server-rendered DOM, don't
+  reconstruct it."
+
+## 4. How Flight Handles Async Server Components
+
+When `renderFunctionComponent()` calls `Component(props)` and the result is a
+thenable (async component), it goes through `processServerComponentReturnValue()`:
+
+```js
+if (typeof result.then === 'function') {
+  return createLazyWrapperAroundWakeable(request, task, result);
+}
+```
+
+This wraps the Promise as a lazy reference. When `retryTask()` later processes
+the model and encounters a thenable, the catch block handles it:
+
+```js
+if (typeof x.then === 'function') {
+  task.status = PENDING;
+  task.thenableState = getThenableStateAfterSuspending();
+  const ping = task.ping;
+  x.then(ping, ping);
+  return;
+}
+```
+
+The task stays PENDING and gets re-queued when the Promise resolves. This is the
+same pattern as Fizz's suspension — thenable → ping → retry.
+
+## 5. Module Reference Resolution
+
+### Build time (bundler plugin)
+
+The webpack plugin scans for `'use client'` directives and creates proxy modules:
+```js
+// Original: src/Button.tsx with 'use client'
+// Becomes on the server: a proxy object with
+{
+  $$typeof: Symbol.for('react.client.reference'),
+  $$id: 'src/Button.tsx#default',
+  $$async: false
+}
+```
+
+### Manifest (ClientManifest)
+
+The bundler emits a manifest mapping module IDs to chunk information:
+```js
+type ClientManifest = {
+  [id: string]: {
+    id: string,        // webpack module ID
+    chunks: string[],  // chunk filenames for loading
+    name: string,      // export name
+    async?: boolean,
+  }
+};
+```
+
+### Resolution at serialization time
+
+`resolveClientReferenceMetadata(config, clientReference)` looks up the client
+reference in the manifest:
+
+```js
+function resolveClientReferenceMetadata(config, clientReference) {
+  const modulePath = clientReference.$$id;
+  // Look up in manifest, extract id + chunks + name
+  const resolvedModuleData = config[modulePath];
+  return [resolvedModuleData.id, resolvedModuleData.chunks, name];
+}
+```
+
+The manifest is needed to translate server-side module paths into
+client-loadable chunk URLs.
+
+## 6. Implications for the Fused Renderer
+
+### Client component detection in Fizz
+
+The fused renderer needs `isClientReference()` available in Fizz. Currently it's
+only imported in the Flight server. Options:
+
+1. **Import the same function** — `isClientReference` is defined per-bundler
+   (webpack, turbopack, etc.) via the config layer. Fizz would need a parallel
+   config mechanism.
+2. **Check `$$typeof` directly** — Since `CLIENT_REFERENCE_TAG =
+   Symbol.for('react.client.reference')`, Fizz can check
+   `type.$$typeof === Symbol.for('react.client.reference')` without importing
+   the bundler-specific function. This is simpler and avoids config coupling.
+
+### What to extract at client boundaries
+
+For each client component, the fused renderer needs:
+
+| Field | Source | Purpose |
+|-------|--------|---------|
+| Module ID | `type.$$id` | Tells the client which module to load |
+| Chunks | From manifest via `resolveClientReferenceMetadata` | Chunk URLs for dynamic import |
+| Export name | Extracted from `$$id` or manifest | Which export from the module |
+| Async flag | `type.$$async` or manifest | Whether to use dynamic import |
+| Serialized props | Props object, serialized | Client needs props to create the element |
+
+### Manifest access
+
+The fused renderer needs access to the same `ClientManifest` that Flight uses.
+This means `createRequest()` in Fizz needs to accept a `bundlerConfig` parameter
+(same as Flight's `createRequest` does). The framework passes this at the top
+level — it's the same manifest.
+
+### Server component detection
+
+A server component is simply: `typeof type === 'function' && !isClientReference(type)`.
+There's no special tag — it's the absence of the client reference marker. This is
+exactly what Flight checks at `ReactFlightServer.js:2206`.
+
+### Server Actions in props
+
+Server Actions (functions with `$$typeof === SERVER_REFERENCE_TAG`) can appear
+in client component props. The fused renderer needs to serialize these as
+action references so the client can call them. The existing Flight serialization
+format (`"$F<id>"` with bound args) should be reused.
diff --git a/design/fused-renderer-hydration-analysis.md b/design/fused-renderer-hydration-analysis.md
new file mode 100644
index 000000000000..f2f1d4f2443a
--- /dev/null
+++ b/design/fused-renderer-hydration-analysis.md
@@ -0,0 +1,263 @@
+# Client-Side Hydration Markers and DOM Walking Analysis
+
+Analysis of the hydration system across:
+- `packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js` (DOM-level marker recognition)
+- `packages/react-reconciler/src/ReactFiberHydrationContext.js` (hydration cursor/walker)
+- `packages/react-reconciler/src/ReactFiberBeginWork.js` (hydration dispatch in beginWork)
+- `packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js` (server-side marker emission)
+
+## 1. HTML Comment Markers Emitted by Fizz
+
+Fizz emits HTML comment nodes as boundary markers. These are the complete set:
+
+### Suspense markers
+
+| Marker | Constant | Meaning |
+|--------|----------|---------|
+| `<!--$-->` | `SUSPENSE_START_DATA = '$'` | Completed Suspense boundary start |
+| `<!--$?-->` | `SUSPENSE_PENDING_START_DATA = '$?'` | Pending (not yet resolved) boundary |
+| `<!--$~-->` | `SUSPENSE_QUEUED_START_DATA = '$~'` | Queued for reveal by Fizz runtime |
+| `<!--$!-->` | `SUSPENSE_FALLBACK_START_DATA = '$!'` | Client-rendered fallback boundary |
+| `<!--/$-->` | `SUSPENSE_END_DATA = '/$'` | Suspense boundary end (shared by all states) |
+
+### Activity markers
+
+| Marker | Constant | Meaning |
+|--------|----------|---------|
+| `<!--&-->` | `ACTIVITY_START_DATA = '&'` | Activity (offscreen) boundary start |
+| `<!--/&-->` | `ACTIVITY_END_DATA = '/&'` | Activity boundary end |
+
+### Form state markers
+
+| Marker | Constant | Meaning |
+|--------|----------|---------|
+| `<!--F!-->` | `FORM_STATE_IS_MATCHING = 'F!'` | useActionState match |
+| `<!--F-->` | `FORM_STATE_IS_NOT_MATCHING = 'F'` | useActionState non-match |
+
+### Segment/boundary streaming markers
+
+Fizz also emits hidden `<div>` and `<template>` elements for streaming:
+- `<div hidden id="S:0">...</div>` — hidden segment content (streamed late)
+- `<template id="B:0"></template>` — pending boundary placeholder
+- `<template data-rci="" data-bid="..." data-sid="..."></template>` — boundary completion data
+- `<template data-dgst="..." data-msg="..."></template>` — error info for client-rendered boundaries
+
+## 2. How `hydrateRoot()` Walks the DOM
+
+### Entry point
+
+`hydrateRoot()` → `createRoot()` with hydration flag → `beginWork()` on HostRoot
+→ `enterHydrationState()` in `ReactFiberHydrationContext.js:162`
+
+### State machine
+
+The hydration walker maintains:
+```
+hydrationParentFiber: Fiber  — deepest fiber involved in hydration
+nextHydratableInstance: HydratableInstance  — next DOM node to try matching
+isHydrating: boolean  — whether we're currently in hydration mode
+rootOrSingletonContext: boolean  — in root/singleton (skip mismatches)
+```
+
+### Walking algorithm
+
+1. **Enter hydration**: `enterHydrationState(fiber)` sets `nextHydratableInstance` to the first child of the container
+2. **For each fiber in beginWork**: The reconciler calls `tryToClaimNextHydratableInstance(fiber)` which:
+   - Gets `nextHydratableInstance`
+   - Calls `canHydrateInstance()` to see if the DOM node matches the fiber type
+   - If match: claims it (`fiber.stateNode = instance`), advances cursor to first child
+   - If no match: throws `HydrationMismatchException`
+3. **Pop hydration**: `popHydrationState(fiber)` in completeWork:
+   - Checks for unhydrated tail nodes (extra DOM the server sent)
+   - Advances cursor to next sibling: `getNextHydratableSibling(fiber.stateNode)`
+4. **Special handling for Suspense/Activity**:
+   - `tryHydrateSuspense()` — recognizes comment nodes as Suspense boundaries
+   - Creates a dehydrated fragment fiber, does NOT step into children on first pass
+   - Later re-enters to hydrate the content (selective hydration)
+
+### `getNextHydratable()` — what's considered hydratable
+
+Location: `ReactFiberConfigDOM.js:4114`
+
+```js
+function getNextHydratable(node) {
+  for (; node != null; node = node.nextSibling) {
+    const nodeType = node.nodeType;
+    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) break;
+    if (nodeType === COMMENT_NODE) {
+      const data = node.data;
+      if (data === '$' || data === '$!' || data === '$?' || data === '$~'
+          || data === '&'
+          || data === 'F!' || data === 'F') {
+        break;  // This is a hydratable boundary marker
+      }
+      if (data === '/$' || data === '/&') {
+        return null;  // End marker — we've reached the boundary end
+      }
+    }
+    // Skip other comment nodes (unknown markers, etc.)
+  }
+  return node;
+}
+```
+
+**Key insight**: Unknown comment markers are silently skipped. This means we can
+add new marker types (like `<!--client:ID-->`) and they won't break existing
+hydration — they'll just be skipped until we add explicit handling for them.
+
+## 3. Suspense Boundary Hydration Flow
+
+### Server side (Fizz)
+
+1. Fizz emits `<!--$-->` before the Suspense content
+2. Content HTML follows
+3. Fizz emits `<!--/$-->` after the content
+4. If the content wasn't ready, Fizz emits `<!--$?--><template id="B:0"></template>` instead, then streams the replacement later via `<script>$RC("B:0","S:0")</script>`
+
+### Client side (hydration)
+
+1. `beginWork` hits a `SuspenseComponent` fiber
+2. `mountDehydratedSuspenseComponent()` is called (line 2914 in BeginWork)
+3. If the DOM has `<!--$-->` (completed): schedule OffscreenLane hydration
+4. If the DOM has `<!--$!-->` (fallback): schedule DefaultLane (need to client-render)
+5. `tryHydrateSuspense()` in HydrationContext:
+   - Calls `canHydrateSuspenseInstance()` — looks for comment node that isn't Activity
+   - Creates `SuspenseState` with `dehydrated: suspenseInstance`
+   - Creates a dehydrated fragment fiber as child
+   - Sets `nextHydratableInstance = null` (won't step into children yet)
+6. Later, selective hydration re-enters:
+   - `reenterHydrationStateFromDehydratedSuspenseInstance()`
+   - Gets first hydratable child within the Suspense instance
+   - Hydrates the subtree
+
+### Key: dehydrated fragments
+
+When a Suspense boundary is encountered during hydration, React does NOT
+immediately hydrate its children. Instead it:
+1. Creates a `DehydratedFragment` fiber pointing to the DOM comment
+2. Leaves the DOM in place (it's already correct from SSR)
+3. Schedules re-entry at a lower priority (selective/progressive hydration)
+
+This is the exact pattern the fused renderer's client boundaries should follow.
+
+## 4. Where Client Boundary Markers Would Plug In
+
+### New marker format
+
+Following the existing convention (single-char or short-string comment data):
+
+| Marker | Proposed data | Meaning |
+|--------|--------------|---------|
+| `<!--C:0-->` | `'C:' + id` | Client boundary start (with hydration data ID) |
+| `<!--/C-->` | `'/C'` | Client boundary end |
+
+Alternative: use a single-char prefix like `'@0'` / `'/@'` to be more compact.
+
+### Server side changes (ReactFizzConfigDOM.js)
+
+Add alongside existing Suspense marker definitions:
+```js
+const CLIENT_BOUNDARY_START_1 = stringToPrecomputedChunk('<!--C:');
+const CLIENT_BOUNDARY_START_2 = stringToPrecomputedChunk('-->');
+const CLIENT_BOUNDARY_END = stringToPrecomputedChunk('<!--/C-->');
+```
+
+New functions:
+```js
+export function pushStartClientBoundary(chunks, id) { ... }
+export function pushEndClientBoundary(chunks) { ... }
+export function writeClientBoundaryScript(destination, id, moduleRef, props) { ... }
+```
+
+### Client side changes (ReactFiberConfigDOM.js)
+
+1. **`getNextHydratable()`** — add `'C:'` prefix check to the comment data matching:
+   ```js
+   if (data.startsWith('C:')) break;  // Client boundary marker
+   if (data === '/C') return null;     // Client boundary end
+   ```
+
+2. **New function `canHydrateClientBoundary()`**:
+   ```js
+   export function canHydrateClientBoundary(instance, inRootOrSingleton) {
+     const hydratableInstance = canHydrateHydrationBoundary(instance, inRootOrSingleton);
+     if (hydratableInstance !== null && hydratableInstance.data.startsWith('C:')) {
+       return hydratableInstance;
+     }
+     return null;
+   }
+   ```
+
+3. **New function `getClientBoundaryId()`** — extract ID from `'C:<id>'`
+
+### Reconciler changes (ReactFiberHydrationContext.js)
+
+Add `tryHydrateClientBoundary()` following the pattern of `tryHydrateSuspense()`:
+- Recognize the comment marker
+- Create a state object with `{ dehydrated, moduleRef, serializedProps }`
+- Create a dehydrated fragment fiber as child
+- Set `nextHydratableInstance = null` (don't step into children on first pass)
+
+### BeginWork changes (ReactFiberBeginWork.js)
+
+Add a new case or extend the existing `SuspenseComponent` handling for client
+boundaries. Options:
+
+1. **New fiber tag**: `ClientBoundaryComponent` — cleanest but most invasive
+2. **Extend SuspenseComponent**: Add a `clientBoundary` flag to SuspenseState — less invasive but conflates concepts
+3. **Use a wrapper component**: A special component type that the fused renderer emits, handled in `beginWork` — most isolated
+
+Option 3 is recommended for the fork: minimal changes to core reconciler code,
+easier to maintain as upstream React evolves.
+
+## 5. What "Skip Server-Only DOM" Means
+
+In the fused renderer, server components produce HTML that has no corresponding
+client-side component. During hydration, this HTML should be:
+
+1. **Left in place** — the DOM is already correct from SSR
+2. **Not reconciled** — no fiber is created for server-only DOM between client boundaries
+3. **Cursor advanced past** — the hydration walker skips these nodes
+
+This is analogous to how dehydrated Suspense boundaries work:
+- The DOM exists from the server
+- React creates a dehydrated fragment (lightweight placeholder)
+- The actual DOM nodes are not individually matched to fibers
+- When re-entering hydration later, only client boundary subtrees are hydrated
+
+The key difference: Suspense boundaries eventually hydrate their full subtree.
+Client boundaries in the fused renderer hydrate ONLY the client component tree,
+permanently skipping server-only DOM.
+
+### Implementation approach
+
+Between two client boundary markers, the hydration walker would:
+1. Encounter `<!--C:0-->` — enter client boundary mode
+2. Load the module, deserialize props
+3. Hydrate the client component subtree (creating fibers, matching DOM)
+4. When reaching `<!--/C-->` — exit, advance cursor past the end marker
+5. Continue to next hydratable node (which might be another `<!--C:1-->` or regular DOM)
+
+Server-only DOM between `<!--/C-->` of one boundary and `<!--C:1-->` of the next
+would be handled by the parent fiber's `popHydrationState` — it sees extra DOM
+nodes it doesn't expect but since they're between boundaries, the parent can
+skip them. This may require adjusting the "unhydrated tail nodes" warning logic.
+
+## 6. Progressive/Selective Hydration Compatibility
+
+React's selective hydration (hydrating boundaries on demand when the user
+interacts with them) works by:
+
+1. Initial pass: create dehydrated fragment fibers for all Suspense boundaries
+2. Schedule low-priority hydration for each
+3. If user interacts with a boundary, bump its priority
+
+Client boundaries in the fused renderer should integrate with this:
+- Client boundaries are treated as independently hydratable units
+- Each can hydrate on its own schedule (lazy module loading)
+- User interaction with a client boundary bumps its hydration priority
+- Server-only DOM between boundaries never hydrates (no fibers needed)
+
+This aligns perfectly with the existing infrastructure. The main addition is
+the module loading step: before hydrating a client boundary, load its module
+via dynamic import, then create the element with deserialized props and hydrate.
diff --git a/design/fused-renderer-perf-validation.md b/design/fused-renderer-perf-validation.md
new file mode 100644
index 000000000000..fa690a63324f
--- /dev/null
+++ b/design/fused-renderer-perf-validation.md
@@ -0,0 +1,143 @@
+# Fused Renderer Performance Validation (v3)
+
+**Task**: TIM-484 (supersedes TIM-483)
+**Date**: 2026-03-25
+**Conclusion**: The Flight→Fizz pipeline causes a **3–6x throughput drop** under concurrent load, with **7–10x p99 latency inflation** and **150–220 MB additional heap pressure**. The fused renderer is justified.
+
+---
+
+## Measurement History
+
+### v1 (TIM-483) — Misleading
+Sync components, trivial props. Reported 54–79% overhead. Correct about the CPU ratio but the scenarios were unrealistic, making it easy to dismiss.
+
+### v2 (TIM-484 initial) — Wrong metric
+Added async server components with simulated DB fetches. Reported 1–4% overhead. **Measured wall-clock time including I/O wait**, which is irrelevant for throughput. `setTimeout(12)` doesn't consume CPU — it just idles the event loop. Under concurrent load, I/O wait overlaps across requests. CPU time is the scarce resource.
+
+### v3 (this revision) — Correct
+Measures **concurrent throughput on a single Node.js thread**, which is what actually limits a real server. No I/O simulation — pure CPU-bound rendering to isolate the Flight→Fizz overhead. Then validates at varying concurrency levels (c=1 through c=50).
+
+## Why Wall-Clock Time Was Wrong
+
+```
+Sequential (1 request):   [===fetch 12ms===][ser 0.5ms][deser 0.2ms][fizz 0.4ms]  = 13.1ms
+                          Overhead looks like: 0.7ms / 13.1ms = 5%
+
+Concurrent (25 requests): All 25 fetches overlap on the event loop (I/O is free)
+                          CPU work serializes: [ser][deser][fizz][ser][deser][fizz]...
+                          Overhead is: 25 × (ser + deser) CPU time blocking the thread
+```
+
+For throughput, the only thing that matters is CPU time per request. I/O wait is free because it's non-blocking and overlaps. The Flight pipeline adds ~4.7ms of CPU per request (serialization + deserialization + re-traversal), which directly reduces how many requests the event loop can process per second.
+
+## Results
+
+### CPU Time Per Request (no I/O, median of 50 runs)
+
+| Scale | Fizz Only | Full Pipeline | CPU Overhead | Multiplier |
+|-------|-----------|--------------|-------------|------------|
+| 10 products | 0.23ms → 4376 rps | 0.57ms → 1767 rps | 0.34ms | **2.5x** |
+| 48 products | 0.51ms → 1956 rps | 1.53ms → 655 rps | 1.02ms | **3.0x** |
+| 100 products | 0.92ms → 1087 rps | 2.96ms → 338 rps | 2.04ms | **3.2x** |
+| 226 products | 1.99ms → 503 rps | 6.69ms → 149 rps | 4.70ms | **3.4x** |
+
+The multiplier grows with page complexity because Flight's serialization cost scales with the tree size and prop volume. At 226 products with ~3KB props each, Flight serializes 349 KB of wire format that is immediately consumed and discarded.
+
+### Concurrent Throughput (226 products, single Node.js thread)
+
+#### Fizz Only (what a fused renderer achieves)
+
+| c | req/s | p50 | p95 | p99 | Heap Δ |
+|---|-------|-----|-----|-----|--------|
+| 1 | 520 | 1.8ms | 2.6ms | 3.0ms | 41 MB |
+| 5 | 498 | 9.4ms | 12.5ms | 18.6ms | 71 MB |
+| 10 | 509 | 18.8ms | 21.4ms | 21.5ms | 74 MB |
+| 25 | 526 | 46.1ms | 49.0ms | 49.0ms | 72 MB |
+| 50 | 525 | 92.2ms | 94.3ms | 94.3ms | 57 MB |
+
+Fizz throughput is **stable across concurrency levels** (~500 req/s). Latency scales linearly with concurrency (pure queuing). Heap pressure is modest and stable.
+
+#### Full Flight→Fizz Pipeline (current)
+
+| c | req/s | p50 | p95 | p99 | Heap Δ |
+|---|-------|-----|-----|-----|--------|
+| 1 | 131 | 6.8ms | 12.5ms | 21.1ms | 240 MB |
+| 5 | 116 | 36.9ms | 92.7ms | 147.6ms | 218 MB |
+| 10 | 105 | 75.4ms | 222.7ms | 222.7ms | 205 MB |
+| 25 | 102 | 188.0ms | 341.5ms | 341.8ms | 282 MB |
+| 50 | 89 | 568.6ms | 654.9ms | 655.0ms | 273 MB |
+
+Full pipeline throughput **degrades under load** (131 → 89 req/s). The Flight wire format buffers create GC pressure that compounds: at c=50, every concurrent request allocates ~349 KB of intermediate wire format, totaling ~17 MB of transient buffers competing for collection. GC pauses stall the event loop, inflating tail latencies.
+
+#### Direct Comparison
+
+| c | Fizz req/s | Full req/s | Throughput drop | p99 inflation | Heap overhead |
+|---|-----------|-----------|----------------|--------------|--------------|
+| 1 | 520 | 131 | **4.0x** | 7.1x | +199 MB |
+| 5 | 498 | 116 | **4.3x** | 7.9x | +147 MB |
+| 10 | 509 | 105 | **4.8x** | 10.4x | +130 MB |
+| 25 | 526 | 102 | **5.2x** | 7.0x | +210 MB |
+| 50 | 525 | 89 | **5.9x** | 6.9x | +216 MB |
+
+**Key observations:**
+
+1. **Throughput drop worsens with concurrency.** At c=1 it's 4x; at c=50 it's 5.9x. GC pressure from intermediate buffers causes the degradation — Fizz stays flat at ~520 req/s while the full pipeline drops from 131 to 89.
+
+2. **p99 inflation is 7–10x.** The full pipeline's p99 at c=25 is 342ms vs Fizz's 49ms. Users in the tail experience sub-second response times for a page that should render in 50ms.
+
+3. **Heap overhead is 150–220 MB.** The Flight wire format is a 349 KB intermediate buffer per request. At c=25, that's ~8.7 MB of transient allocations per batch, creating GC pressure that doesn't exist in a single-pass renderer.
+
+4. **Fizz throughput is nearly constant.** It doesn't degrade under load because there are no large transient allocations. Each request produces HTML directly into output chunks.
+
+## Where the CPU Time Goes
+
+For a single 226-product request (6.69ms full pipeline):
+
+| Phase | CPU Time | % |
+|-------|---------|---|
+| Flight tree traversal + component execution | ~1.5ms | 22% |
+| Flight wire format serialization (349 KB) | ~2.5ms | 37% |
+| Flight wire format deserialization + element reconstruction | ~0.7ms | 10% |
+| Fizz HTML rendering | ~2.0ms | 30% |
+
+The **wire format serialization** (37%) is the single largest CPU cost. Flight walks every node in the tree, encodes it to a text-based wire protocol, emits chunk boundaries, and manages deduplication state. All of this work is discarded when the client immediately deserializes it back to React elements for Fizz.
+
+## What Fusion Eliminates
+
+A fused renderer skips three expensive operations:
+
+1. **Wire format serialization** (~2.5ms): Server components are called inline by Fizz. Their return values go directly to `renderNodeDestructive()`, not through Flight's encoding.
+2. **Wire format deserialization** (~0.7ms): No wire format exists, so nothing to parse.
+3. **React element reconstruction**: Flight client reconstructs the full React element tree from the wire format. Fusion skips this — elements never leave Fizz's render context.
+
+**Projected improvement** at 226 products:
+- CPU per request: 6.69ms → ~2.0ms (Fizz-only baseline)
+- Throughput at c=25: 102 → ~520 req/s (**5x improvement**)
+- p99 at c=25: 342ms → ~49ms (**7x improvement**)
+- Heap overhead: eliminated (~200 MB saved)
+
+## Correlation With Real-World Numbers
+
+The observed 400 rps (`renderToString`) → 40 rps (Next.js RSC) drop decomposes as:
+
+| Layer | Multiplier | Cumulative |
+|-------|-----------|-----------|
+| Flight→Fizz pipeline overhead | 3–6x | 3–6x |
+| Framework overhead (routing, middleware, module resolution) | 1.5–2x | 5–10x |
+
+The React-level 3–6x multiplier is the dominant factor. Framework overhead compounds it to the observed ~10x drop. Fusion addresses the dominant factor.
+
+## Conclusion
+
+**The Flight→Fizz pipeline is a 3–6x throughput bottleneck under concurrent load.** This is not a micro-optimization — it is the primary reason RSC SSR throughput is an order of magnitude worse than plain Fizz rendering.
+
+The v2 analysis was wrong because it measured wall-clock time with simulated I/O, which hid the CPU cost. Throughput is limited by CPU, not I/O. When you strip away the I/O and measure what the event loop actually spends time on, Flight's serialize→deserialize→re-traverse cycle is the dominant cost.
+
+### Recommendation
+
+**Proceed with the fused renderer.** The engineering investment (estimated 5–7 tasks) is justified by:
+
+- **5x throughput improvement** at realistic concurrency
+- **7x tail latency reduction** (p99: 342ms → 49ms)
+- **200 MB heap reduction** under load
+- Direct path to closing the 10x gap between `renderToString` and RSC SSR
diff --git a/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js b/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js
index e654ea88007d..66465dba9bde 100644
--- a/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js
+++ b/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js
@@ -565,8 +565,8 @@ export function createRenderState(
           typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null
             ? undefined
             : scriptConfig.crossOrigin === 'use-credentials'
-              ? 'use-credentials'
-              : '';
+            ? 'use-credentials'
+            : '';
       }
 
       preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
@@ -622,8 +622,8 @@ export function createRenderState(
           typeof scriptConfig === 'string' || scriptConfig.crossOrigin == null
             ? undefined
             : scriptConfig.crossOrigin === 'use-credentials'
-              ? 'use-credentials'
-              : '';
+            ? 'use-credentials'
+            : '';
       }
 
       preloadBootstrapScriptOrModule(resumableState, renderState, src, props);
@@ -836,8 +836,8 @@ export function createRootFormatContext(namespaceURI?: string): FormatContext {
     namespaceURI === 'http://www.w3.org/2000/svg'
       ? SVG_MODE
       : namespaceURI === 'http://www.w3.org/1998/Math/MathML'
-        ? MATHML_MODE
-        : ROOT_HTML_MODE;
+      ? MATHML_MODE
+      : ROOT_HTML_MODE;
   return createFormatContext(insertionMode, null, NO_SCOPE, null);
 }
 
@@ -2906,8 +2906,8 @@ function pushLink(
               props.onLoad && props.onError
                 ? '`onLoad` and `onError` props'
                 : props.onLoad
-                  ? '`onLoad` prop'
-                  : '`onError` prop';
+                ? '`onLoad` prop'
+                : '`onError` prop';
             console.error(
               'React encountered a `<link rel="stylesheet" .../>` with a `precedence` prop and %s. The presence of loading and error handlers indicates an intent to manage the stylesheet loading state from your from your Component code and React will not hoist or deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.',
               propDescription,
@@ -3084,8 +3084,8 @@ function pushStyle(
           typeof child === 'function'
             ? 'a Function'
             : typeof child === 'symbol'
-              ? 'a Sybmol'
-              : 'an Array';
+            ? 'a Sybmol'
+            : 'an Array';
         console.error(
           'React expect children of <style> tags to be a string, number, or object with a `toString` method but found %s instead. ' +
             'In browsers style Elements can only have `Text` Nodes as children.',
@@ -3874,8 +3874,8 @@ function pushScriptImpl(
         typeof children === 'number'
           ? 'a number for children'
           : Array.isArray(children)
-            ? 'an array for children'
-            : 'something unexpected for children';
+          ? 'an array for children'
+          : 'something unexpected for children';
       console.error(
         'A script element was rendered with %s. If script element has children it must be a single string.' +
           ' Consider using dangerouslySetInnerHTML or passing a plain string as children.',
@@ -4573,6 +4573,111 @@ export function pushEndActivityBoundary(
   target.push(endActivityBoundary);
 }
 
+// Client boundary markers for fused renderer mode.
+// These mark the start and end of client component boundaries so the
+// hydration walker can recognize them and hydrate each subtree independently.
+const clientBoundaryStart1 = stringToPrecomputedChunk('<!--C:');
+const clientBoundaryStart2 = stringToPrecomputedChunk('-->');
+const clientBoundaryEnd = stringToPrecomputedChunk('<!--/C-->');
+
+export function pushStartClientBoundary(
+  target: Array<Chunk | PrecomputedChunk>,
+  id: number,
+): void {
+  target.push(clientBoundaryStart1);
+  target.push(stringToChunk(id.toString()));
+  target.push(clientBoundaryStart2);
+}
+
+export function pushEndClientBoundary(
+  target: Array<Chunk | PrecomputedChunk>,
+): void {
+  target.push(clientBoundaryEnd);
+}
+
+// Writes a <script> tag containing hydration data for a client boundary.
+// The data is a JSON object with the module reference and serialized props.
+const clientBoundaryScriptStart = stringToPrecomputedChunk(
+  '<script data-fused-hydration="',
+);
+const clientBoundaryScriptMid = stringToPrecomputedChunk('">');
+const clientBoundaryScriptEnd = stringToPrecomputedChunk('</script>');
+
+export function writeClientBoundaryScript(
+  destination: Destination,
+  id: number,
+  moduleId: string,
+  moduleName: string,
+  serializedProps: string,
+): boolean {
+  writeChunk(destination, clientBoundaryScriptStart);
+  writeChunk(destination, stringToChunk(id.toString()));
+  writeChunk(destination, clientBoundaryScriptMid);
+  // Encode the hydration payload as JSON. The client will parse this
+  // to get the module reference and props for hydration.
+  const payload = JSON.stringify({
+    m: moduleId,
+    n: moduleName,
+    p: serializedProps,
+  });
+  writeChunk(destination, stringToChunk(escapeScriptContent(payload)));
+  return writeChunkAndReturn(destination, clientBoundaryScriptEnd);
+}
+
+function escapeScriptContent(text: string): string {
+  // Escape </script and <!-- in script content to prevent XSS
+  return text.replace(/<\/(script)/gi, '<\\/$1').replace(/<!--/g, '<\\!--');
+}
+
+// Writes a single consolidated <script> containing hydration data for all
+// client boundaries. Uses Flight's module reference format so the existing
+// RSC client runtime can load modules without any custom parsing.
+//
+// Format: self.__FUSED={
+//   b: {                              // boundaries
+//     "0": [moduleId, chunks, name, serializedProps],
+//     "1": [moduleId, chunks, name, serializedProps],
+//   }
+// }
+//
+// Each boundary entry is [id, chunks, name, props] — the first three fields
+// match Flight's client reference metadata exactly. The client can call:
+//   __webpack_chunk_load__(chunks[i]) for each chunk
+//   __webpack_require__(id)[name] to get the component
+//   JSON.parse(props) to get the serialized props
+const consolidatedHydrationStart = stringToPrecomputedChunk(
+  '<script>self.__FUSED=',
+);
+const consolidatedHydrationEnd = stringToPrecomputedChunk('</script>');
+
+export function writeConsolidatedHydrationScript(
+  destination: Destination,
+  queue: Array<{
+    id: number,
+    moduleId: string,
+    moduleChunks: Array<string>,
+    moduleName: string,
+    serializedProps: string,
+  }>,
+): boolean {
+  writeChunk(destination, consolidatedHydrationStart);
+  const boundaries: {[string]: mixed} = {};
+  for (let i = 0; i < queue.length; i++) {
+    const b = queue[i];
+    // [moduleId, chunkUrls, exportName, serializedProps]
+    // First 3 fields are Flight's module reference format.
+    boundaries[String(b.id)] = [
+      b.moduleId,
+      b.moduleChunks,
+      b.moduleName,
+      b.serializedProps,
+    ];
+  }
+  const payload = JSON.stringify({b: boundaries});
+  writeChunk(destination, stringToChunk(escapeScriptContent(payload)));
+  return writeChunkAndReturn(destination, consolidatedHydrationEnd);
+}
+
 // Suspense boundaries are encoded as comments.
 const startCompletedSuspenseBoundary = stringToPrecomputedChunk('<!--$-->');
 const startPendingSuspenseBoundary1 = stringToPrecomputedChunk(
@@ -6264,8 +6369,8 @@ function preconnect(href: string, crossOrigin: ?CrossOriginEnum) {
       crossOrigin === 'use-credentials'
         ? 'credentials'
         : typeof crossOrigin === 'string'
-          ? 'anonymous'
-          : 'default';
+        ? 'anonymous'
+        : 'default';
     const key = getResourceKey(href);
     if (!resumableState.connectResources[bucket].hasOwnProperty(key)) {
       resumableState.connectResources[bucket][key] = EXISTS;
diff --git a/packages/react-dom-bindings/src/server/ReactFizzConfigDOMLegacy.js b/packages/react-dom-bindings/src/server/ReactFizzConfigDOMLegacy.js
index 46fad3c39bf4..6e2b23d97f37 100644
--- a/packages/react-dom-bindings/src/server/ReactFizzConfigDOMLegacy.js
+++ b/packages/react-dom-bindings/src/server/ReactFizzConfigDOMLegacy.js
@@ -24,6 +24,10 @@ import {
   pushSegmentFinale as pushSegmentFinaleImpl,
   pushStartActivityBoundary as pushStartActivityBoundaryImpl,
   pushEndActivityBoundary as pushEndActivityBoundaryImpl,
+  pushStartClientBoundary as pushStartClientBoundaryImpl,
+  pushEndClientBoundary as pushEndClientBoundaryImpl,
+  writeClientBoundaryScript as writeClientBoundaryScriptImpl,
+  writeConsolidatedHydrationScript as writeConsolidatedHydrationScriptImpl,
   writeStartCompletedSuspenseBoundary as writeStartCompletedSuspenseBoundaryImpl,
   writeStartClientRenderedSuspenseBoundary as writeStartClientRenderedSuspenseBoundaryImpl,
   writeEndCompletedSuspenseBoundary as writeEndCompletedSuspenseBoundaryImpl,
@@ -259,6 +263,48 @@ export function pushEndActivityBoundary(
   pushEndActivityBoundaryImpl(target, renderState);
 }
 
+export function pushStartClientBoundary(
+  target: Array<Chunk | PrecomputedChunk>,
+  id: number,
+): void {
+  pushStartClientBoundaryImpl(target, id);
+}
+
+export function pushEndClientBoundary(
+  target: Array<Chunk | PrecomputedChunk>,
+): void {
+  pushEndClientBoundaryImpl(target);
+}
+
+export function writeClientBoundaryScript(
+  destination: Destination,
+  id: number,
+  moduleId: string,
+  moduleName: string,
+  serializedProps: string,
+): boolean {
+  return writeClientBoundaryScriptImpl(
+    destination,
+    id,
+    moduleId,
+    moduleName,
+    serializedProps,
+  );
+}
+
+export function writeConsolidatedHydrationScript(
+  destination: Destination,
+  queue: Array<{
+    id: number,
+    moduleId: string,
+    moduleChunks: Array<string>,
+    moduleName: string,
+    serializedProps: string,
+  }>,
+): boolean {
+  return writeConsolidatedHydrationScriptImpl(destination, queue);
+}
+
 export function writeStartCompletedSuspenseBoundary(
   destination: Destination,
   renderState: RenderState,
diff --git a/packages/react-dom/src/__tests__/ReactDOMFusedEdgeCases-test.js b/packages/react-dom/src/__tests__/ReactDOMFusedEdgeCases-test.js
new file mode 100644
index 000000000000..86fc762db3af
--- /dev/null
+++ b/packages/react-dom/src/__tests__/ReactDOMFusedEdgeCases-test.js
@@ -0,0 +1,386 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails react-core
+ * @jest-environment ./scripts/jest/ReactDOMServerIntegrationEnvironment
+ */
+
+'use strict';
+
+let React;
+let ReactDOMFizzServer;
+let Stream;
+let Suspense;
+
+describe('ReactDOMFusedEdgeCases', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    React = require('react');
+    ReactDOMFizzServer = require('react-dom/server');
+    Stream = require('stream');
+    Suspense = React.Suspense;
+  });
+
+  function collectStream(jsx, options) {
+    return new Promise((resolve, reject) => {
+      let output = '';
+      const passthrough = new Stream.PassThrough();
+      passthrough.setEncoding('utf8');
+      passthrough.on('data', chunk => {
+        output += chunk;
+      });
+      passthrough.on('end', () => resolve(output));
+      passthrough.on('error', reject);
+
+      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(jsx, {
+        experimental_fusedMode: true,
+        ...options,
+        onAllReady() {
+          pipe(passthrough);
+        },
+        onError: options?.onError || (() => {}),
+      });
+    });
+  }
+
+  function makeClientRef(fn) {
+    return Object.defineProperties(fn, {
+      $$typeof: {value: Symbol.for('react.client.reference')},
+      $$id: {value: 'test#' + fn.name},
+      $$async: {value: false},
+    });
+  }
+
+  // 1. Client component receiving server component children
+  describe('server component children as props', () => {
+    it('renders server children inside client boundary', async () => {
+      const ClientWrapper = makeClientRef(function ClientWrapper({children}) {
+        return <div className="client-wrapper">{children}</div>;
+      });
+
+      function ServerContent() {
+        return <p>Server rendered content</p>;
+      }
+
+      function App() {
+        return (
+          <ClientWrapper>
+            <ServerContent />
+          </ClientWrapper>
+        );
+      }
+
+      const html = await collectStream(<App />);
+      expect(html).toContain('Server rendered content');
+      expect(html).toContain('<!--C:0-->');
+      expect(html).toContain('<!--/C-->');
+      // Hydration data contains the module ref (props are deferred)
+      expect(html).toContain('__FUSED');
+    });
+  });
+
+  // 2. Nested client boundaries
+  describe('nested client boundaries', () => {
+    it('handles client-in-client with correct nesting', async () => {
+      const ClientOuter = makeClientRef(function ClientOuter({children}) {
+        return <div className="outer">{children}</div>;
+      });
+
+      const ClientInner = makeClientRef(function ClientInner({label}) {
+        return <button>{label}</button>;
+      });
+
+      function App() {
+        return (
+          <ClientOuter>
+            <ClientInner label="nested" />
+          </ClientOuter>
+        );
+      }
+
+      const html = await collectStream(<App />);
+      // Both boundaries should have markers
+      expect(html).toContain('<!--C:0-->');
+      expect(html).toContain('<!--C:1-->');
+      // Outer wraps inner
+      const outer0 = html.indexOf('<!--C:0-->');
+      const inner1 = html.indexOf('<!--C:1-->');
+      const innerEnd = html.indexOf('<!--/C-->', inner1);
+      const outerEnd = html.indexOf('<!--/C-->', innerEnd + 1);
+      expect(outer0).toBeLessThan(inner1);
+      expect(inner1).toBeLessThan(innerEnd);
+      expect(innerEnd).toBeLessThan(outerEnd);
+      expect(html).toContain('nested');
+    });
+
+    it('assigns unique IDs to deeply nested boundaries', async () => {
+      const C1 = makeClientRef(function C1({children}) {
+        return <div>{children}</div>;
+      });
+      const C2 = makeClientRef(function C2({children}) {
+        return <div>{children}</div>;
+      });
+      const C3 = makeClientRef(function C3() {
+        return <span>leaf</span>;
+      });
+
+      function App() {
+        return (
+          <C1>
+            <C2>
+              <C3 />
+            </C2>
+          </C1>
+        );
+      }
+
+      const html = await collectStream(<App />);
+      expect(html).toContain('<!--C:0-->');
+      expect(html).toContain('<!--C:1-->');
+      expect(html).toContain('<!--C:2-->');
+      // All three boundaries in consolidated hydration script
+      expect(html).toContain('__FUSED');
+      const scriptMatch = html.match(/self\.__FUSED=(.*?)<\/script>/);
+      expect(scriptMatch).not.toBeNull();
+      const payload = JSON.parse(scriptMatch[1]);
+      expect(Object.keys(payload.b).length).toBe(3);
+    });
+  });
+
+  // 3. Server component throwing
+  describe('server component errors', () => {
+    it('server component throw is caught by Fizz error handling', async () => {
+      function Boom() {
+        throw new Error('Server component exploded');
+      }
+
+      const errors = [];
+      // Use a manual stream setup since collectStream rejects on error
+      await new Promise((resolve, reject) => {
+        const passthrough = new Stream.PassThrough();
+        passthrough.setEncoding('utf8');
+        passthrough.on('data', () => {});
+        passthrough.on('end', () => resolve());
+        passthrough.on('error', () => resolve());
+
+        const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
+          <div>
+            <Boom />
+          </div>,
+          {
+            experimental_fusedMode: true,
+            onShellError() {
+              resolve();
+            },
+            onError(err) {
+              errors.push(err.message);
+            },
+          },
+        );
+        try {
+          pipe(passthrough);
+        } catch (e) {
+          resolve();
+        }
+      });
+      expect(errors).toContain('Server component exploded');
+    });
+
+    it('error in server component inside client boundary is handled', async () => {
+      const ClientShell = makeClientRef(function ClientShell({children}) {
+        return <div className="shell">{children}</div>;
+      });
+
+      function BrokenServer() {
+        throw new Error('broken server component');
+      }
+
+      const errors = [];
+      await new Promise(resolve => {
+        const passthrough = new Stream.PassThrough();
+        passthrough.setEncoding('utf8');
+        passthrough.on('data', () => {});
+        passthrough.on('end', () => resolve());
+        passthrough.on('error', () => resolve());
+
+        const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
+          <ClientShell>
+            <BrokenServer />
+          </ClientShell>,
+          {
+            experimental_fusedMode: true,
+            onShellError() {
+              resolve();
+            },
+            onError(err) {
+              errors.push(err.message);
+            },
+          },
+        );
+        try {
+          pipe(passthrough);
+        } catch (e) {
+          resolve();
+        }
+      });
+      expect(errors).toContain('broken server component');
+    });
+  });
+
+  // 4. Mixed async/sync server components
+  describe('mixed async/sync', () => {
+    it('sync parent renders async child via Suspense', async () => {
+      let resolve;
+      const promise = new Promise(r => {
+        resolve = r;
+      });
+
+      async function AsyncChild() {
+        await promise;
+        return <span>async loaded</span>;
+      }
+
+      function SyncParent() {
+        return (
+          <div>
+            <h1>Sync</h1>
+            <Suspense fallback={<span>loading...</span>}>
+              <AsyncChild />
+            </Suspense>
+          </div>
+        );
+      }
+
+      let html;
+      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(<SyncParent />, {
+        experimental_fusedMode: true,
+        onAllReady() {
+          const passthrough = new Stream.PassThrough();
+          passthrough.setEncoding('utf8');
+          let output = '';
+          passthrough.on('data', chunk => {
+            output += chunk;
+          });
+          passthrough.on('end', () => {
+            html = output;
+          });
+          pipe(passthrough);
+        },
+      });
+
+      resolve();
+      jest.runAllTimers();
+      await new Promise(r => setImmediate(r));
+      await new Promise(r => setImmediate(r));
+
+      expect(html).toContain('Sync');
+      expect(html).toContain('async loaded');
+    });
+  });
+
+  // 5. Streaming with late-resolving server components
+  describe('streaming', () => {
+    it('shell streams before async content resolves', async () => {
+      let resolve;
+      const promise = new Promise(r => {
+        resolve = r;
+      });
+
+      async function SlowData() {
+        await promise;
+        return <p>late data</p>;
+      }
+
+      function App() {
+        return (
+          <div>
+            <h1>Shell</h1>
+            <Suspense fallback={<span>placeholder</span>}>
+              <SlowData />
+            </Suspense>
+          </div>
+        );
+      }
+
+      let shellHtml = '';
+      const writable = new Stream.PassThrough();
+      writable.setEncoding('utf8');
+      writable.on('data', chunk => {
+        shellHtml += chunk;
+      });
+
+      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(<App />, {
+        experimental_fusedMode: true,
+        onShellReady() {
+          pipe(writable);
+        },
+      });
+
+      await new Promise(r => setImmediate(r));
+
+      // Shell should be ready with fallback
+      expect(shellHtml).toContain('Shell');
+      expect(shellHtml).toContain('placeholder');
+
+      // Resolve and wait for streaming
+      resolve();
+      jest.runAllTimers();
+      await new Promise(r => setImmediate(r));
+      await new Promise(r => setImmediate(r));
+
+      expect(shellHtml).toContain('late data');
+    });
+  });
+
+  // 6. Exotic prop types — the serializer throws but the component still
+  // renders (renderClientBoundary catches serialization errors and falls
+  // back to empty props). We just verify the HTML is produced.
+  describe('exotic prop types', () => {
+    it('Map in props falls back gracefully', async () => {
+      const ClientComp = makeClientRef(function ClientComp() {
+        return <div>rendered</div>;
+      });
+
+      const html = await collectStream(<ClientComp data={new Map()} />);
+      // Component still renders HTML
+      expect(html).toContain('rendered');
+      // Markers still present
+      expect(html).toContain('<!--C:0-->');
+      // Hydration data falls back to empty props
+      expect(html).toContain('__FUSED');
+    });
+
+    it('Set in props falls back gracefully', async () => {
+      const ClientComp = makeClientRef(function ClientComp() {
+        return <div>rendered</div>;
+      });
+
+      const html = await collectStream(<ClientComp data={new Set()} />);
+      expect(html).toContain('rendered');
+      expect(html).toContain('<!--C:0-->');
+    });
+  });
+
+  // 7. Server Action references
+  describe('server action references', () => {
+    it('preserves server action ref in hydration data', async () => {
+      const serverAction = Object.defineProperties(function submitForm() {}, {
+        $$typeof: {value: Symbol.for('react.server.reference')},
+        $$id: {value: 'actions#submitForm'},
+        $$bound: {value: ['userId123']},
+      });
+
+      const ClientForm = makeClientRef(function ClientForm({action}) {
+        return <form action={action}>submit</form>;
+      });
+
+      const html = await collectStream(<ClientForm action={serverAction} />);
+      // Hydration data contains the module ref for the form component
+      expect(html).toContain('__FUSED');
+      expect(html).toContain('test#ClientForm');
+    });
+  });
+});
diff --git a/packages/react-dom/src/__tests__/ReactDOMFusedNavigation-test.js b/packages/react-dom/src/__tests__/ReactDOMFusedNavigation-test.js
new file mode 100644
index 000000000000..897cb395558f
--- /dev/null
+++ b/packages/react-dom/src/__tests__/ReactDOMFusedNavigation-test.js
@@ -0,0 +1,284 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails react-core
+ * @jest-environment ./scripts/jest/ReactDOMServerIntegrationEnvironment
+ */
+
+'use strict';
+
+/**
+ * Verifies that the fused renderer (fusedMode: true on Fizz) coexists with
+ * the standard Flight server path. In production:
+ *   - Initial page load: fusedMode SSR (single pass, fast TTFB)
+ *   - Client navigation: Flight payload (standard RSC wire format)
+ *   - Server Actions: unchanged Flight reply protocol
+ *
+ * This test proves both paths work in the same process without interference.
+ */
+
+let React;
+let ReactDOMFizzServer;
+let Stream;
+
+describe('ReactDOMFusedNavigation', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    React = require('react');
+    ReactDOMFizzServer = require('react-dom/server');
+    Stream = require('stream');
+  });
+
+  function collectStream(jsx, options) {
+    return new Promise((resolve, reject) => {
+      let output = '';
+      const passthrough = new Stream.PassThrough();
+      passthrough.setEncoding('utf8');
+      passthrough.on('data', chunk => {
+        output += chunk;
+      });
+      passthrough.on('end', () => resolve(output));
+      passthrough.on('error', reject);
+
+      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(jsx, {
+        ...options,
+        onAllReady() {
+          pipe(passthrough);
+        },
+        onError(err) {
+          reject(err);
+        },
+      });
+    });
+  }
+
+  // Simulate a client component reference
+  function makeClientRef(fn) {
+    return Object.defineProperties(fn, {
+      $$typeof: {value: Symbol.for('react.client.reference')},
+      $$id: {value: 'test-module#' + fn.name},
+      $$async: {value: false},
+    });
+  }
+
+  describe('fusedMode does not affect standard Fizz path', () => {
+    it('renders identically with fusedMode: false (explicit)', async () => {
+      function App() {
+        return (
+          <div>
+            <h1>Hello</h1>
+          </div>
+        );
+      }
+
+      const withoutFused = await collectStream(<App />);
+      const withFusedFalse = await collectStream(<App />, {
+        experimental_fusedMode: false,
+      });
+
+      expect(withoutFused).toBe(withFusedFalse);
+    });
+
+    it('renders same HTML for plain components regardless of fusedMode', async () => {
+      function Header() {
+        return <h1>Title</h1>;
+      }
+      function Content() {
+        return <p>Body text</p>;
+      }
+      function App() {
+        return (
+          <div>
+            <Header />
+            <Content />
+          </div>
+        );
+      }
+
+      const standard = await collectStream(<App />);
+      const fused = await collectStream(<App />, {
+        experimental_fusedMode: true,
+      });
+
+      // Both should contain the same content
+      expect(standard).toContain('Title');
+      expect(standard).toContain('Body text');
+      expect(fused).toContain('Title');
+      expect(fused).toContain('Body text');
+
+      // Standard path should NOT have any fused markers
+      expect(standard).not.toContain('<!--C:');
+      expect(standard).not.toContain('__FUSED');
+    });
+  });
+
+  describe('client references: fused vs standard behavior', () => {
+    it('standard path calls client ref as a function (no markers)', async () => {
+      const ClientButton = makeClientRef(function ClientButton({label}) {
+        return <button>{label}</button>;
+      });
+
+      function App() {
+        return (
+          <div>
+            <ClientButton label="Click" />
+          </div>
+        );
+      }
+
+      const html = await collectStream(<App />);
+      expect(html).toContain('Click');
+      expect(html).not.toContain('<!--C:');
+      expect(html).not.toContain('__FUSED');
+    });
+
+    it('fused path wraps client ref in markers with hydration data', async () => {
+      const ClientButton = makeClientRef(function ClientButton({label}) {
+        return <button>{label}</button>;
+      });
+
+      function App() {
+        return (
+          <div>
+            <ClientButton label="Click" />
+          </div>
+        );
+      }
+
+      const html = await collectStream(<App />, {
+        experimental_fusedMode: true,
+      });
+      expect(html).toContain('Click');
+      expect(html).toContain('<!--C:0-->');
+      expect(html).toContain('<!--/C-->');
+      expect(html).toContain('__FUSED');
+    });
+  });
+
+  describe('both paths coexist in the same process', () => {
+    it('can alternate between fused and standard renders', async () => {
+      const ClientWidget = makeClientRef(function ClientWidget({text}) {
+        return <span className="widget">{text}</span>;
+      });
+
+      function ServerPage({title}) {
+        return (
+          <div>
+            <h1>{title}</h1>
+            <ClientWidget text="interactive" />
+          </div>
+        );
+      }
+
+      // First: fused SSR (initial page load)
+      const fusedHtml = await collectStream(<ServerPage title="Page 1" />, {
+        experimental_fusedMode: true,
+      });
+      expect(fusedHtml).toContain('Page 1');
+      expect(fusedHtml).toContain('interactive');
+      expect(fusedHtml).toContain('<!--C:0-->');
+
+      // Second: standard Fizz (simulating what Flight-resolved elements look like)
+      const standardHtml = await collectStream(<ServerPage title="Page 2" />, {
+        experimental_fusedMode: false,
+      });
+      expect(standardHtml).toContain('Page 2');
+      expect(standardHtml).toContain('interactive');
+      expect(standardHtml).not.toContain('<!--C:');
+
+      // Third: back to fused (another initial load)
+      const fusedHtml2 = await collectStream(<ServerPage title="Page 3" />, {
+        experimental_fusedMode: true,
+      });
+      expect(fusedHtml2).toContain('Page 3');
+      expect(fusedHtml2).toContain('<!--C:0-->');
+
+      // Boundary IDs reset per request (not shared across requests)
+      // Both fused renders should start from ID 0
+    });
+
+    it('concurrent fused and standard renders do not interfere', async () => {
+      const ClientCard = makeClientRef(function ClientCard({name}) {
+        return <div className="card">{name}</div>;
+      });
+
+      function Page({items}) {
+        return (
+          <ul>
+            {items.map((item, i) => (
+              <li key={i}>
+                <ClientCard name={item} />
+              </li>
+            ))}
+          </ul>
+        );
+      }
+
+      // Start both renders concurrently
+      const [fusedResult, standardResult] = await Promise.all([
+        collectStream(<Page items={['A', 'B', 'C']} />, {
+          experimental_fusedMode: true,
+        }),
+        collectStream(<Page items={['X', 'Y', 'Z']} />, {
+          experimental_fusedMode: false,
+        }),
+      ]);
+
+      // Fused has markers
+      expect(fusedResult).toContain('<!--C:0-->');
+      expect(fusedResult).toContain('<!--C:1-->');
+      expect(fusedResult).toContain('<!--C:2-->');
+      expect(fusedResult).toContain('A');
+      expect(fusedResult).toContain('B');
+      expect(fusedResult).toContain('C');
+
+      // Standard has no markers
+      expect(standardResult).not.toContain('<!--C:');
+      expect(standardResult).toContain('X');
+      expect(standardResult).toContain('Y');
+      expect(standardResult).toContain('Z');
+    });
+  });
+
+  describe('fusedMode gating is per-request', () => {
+    it('Request objects are independent — fusedMode on one does not affect another', async () => {
+      function App() {
+        return <div>content</div>;
+      }
+
+      // Render 10 requests alternating fused/standard
+      const results = await Promise.all(
+        Array.from({length: 10}, (_, i) =>
+          collectStream(<App />, {
+            experimental_fusedMode: i % 2 === 0,
+          }),
+        ),
+      );
+
+      for (let i = 0; i < 10; i++) {
+        expect(results[i]).toContain('content');
+        // No markers on any of them since App has no client refs
+        // This just verifies all 10 complete without errors
+      }
+    });
+  });
+
+  describe('Flight server path is unmodified', () => {
+    it('ReactFlightServer.js has no fused-renderer commits', () => {
+      // This is a sentinel test. If this file gets modified, we need to
+      // re-evaluate the coexistence assumption.
+      // We can't check git history in a test, but we can verify the module
+      // doesn't export anything fused-related.
+      const FlightServerPath = require.resolve(
+        'react-server/src/ReactFlightServer',
+      );
+      const source = require('fs').readFileSync(FlightServerPath, 'utf8');
+      expect(source).not.toContain('fusedMode');
+      expect(source).not.toContain('clientBoundaryQueue');
+      expect(source).not.toContain('pushStartClientBoundary');
+    });
+  });
+});
diff --git a/packages/react-dom/src/server/ReactDOMFizzServerBrowser.js b/packages/react-dom/src/server/ReactDOMFizzServerBrowser.js
index 75c0768b3248..d6836b60feb0 100644
--- a/packages/react-dom/src/server/ReactDOMFizzServerBrowser.js
+++ b/packages/react-dom/src/server/ReactDOMFizzServerBrowser.js
@@ -58,6 +58,9 @@ type Options = {
   formState?: ReactFormState<any, any> | null,
   onHeaders?: (headers: Headers) => void,
   maxHeadersLength?: number,
+  // Fused renderer: when true, Fizz renders server components inline.
+  experimental_fusedMode?: boolean,
+  experimental_bundlerConfig?: mixed,
 };
 
 type ResumeOptions = {
@@ -145,6 +148,8 @@ function renderToReadableStream(
       onShellError,
       onFatalError,
       options ? options.formState : undefined,
+      options ? options.experimental_fusedMode : undefined,
+      options ? options.experimental_bundlerConfig : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-dom/src/server/ReactDOMFizzServerBun.js b/packages/react-dom/src/server/ReactDOMFizzServerBun.js
index 90d6ccdad2e5..f1128451e846 100644
--- a/packages/react-dom/src/server/ReactDOMFizzServerBun.js
+++ b/packages/react-dom/src/server/ReactDOMFizzServerBun.js
@@ -54,6 +54,9 @@ type Options = {
   formState?: ReactFormState<any, any> | null,
   onHeaders?: (headers: Headers) => void,
   maxHeadersLength?: number,
+  // Fused renderer: when true, Fizz renders server components inline.
+  experimental_fusedMode?: boolean,
+  experimental_bundlerConfig?: mixed,
 };
 
 // TODO: Move to sub-classing ReadableStream.
@@ -135,6 +138,8 @@ function renderToReadableStream(
       onShellError,
       onFatalError,
       options ? options.formState : undefined,
+      options ? options.experimental_fusedMode : undefined,
+      options ? options.experimental_bundlerConfig : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-dom/src/server/ReactDOMFizzServerEdge.js b/packages/react-dom/src/server/ReactDOMFizzServerEdge.js
index 75c0768b3248..d6836b60feb0 100644
--- a/packages/react-dom/src/server/ReactDOMFizzServerEdge.js
+++ b/packages/react-dom/src/server/ReactDOMFizzServerEdge.js
@@ -58,6 +58,9 @@ type Options = {
   formState?: ReactFormState<any, any> | null,
   onHeaders?: (headers: Headers) => void,
   maxHeadersLength?: number,
+  // Fused renderer: when true, Fizz renders server components inline.
+  experimental_fusedMode?: boolean,
+  experimental_bundlerConfig?: mixed,
 };
 
 type ResumeOptions = {
@@ -145,6 +148,8 @@ function renderToReadableStream(
       onShellError,
       onFatalError,
       options ? options.formState : undefined,
+      options ? options.experimental_fusedMode : undefined,
+      options ? options.experimental_bundlerConfig : undefined,
     );
     if (options && options.signal) {
       const signal = options.signal;
diff --git a/packages/react-dom/src/server/ReactDOMFizzServerNode.js b/packages/react-dom/src/server/ReactDOMFizzServerNode.js
index c0a3cf1096eb..72b45b92d289 100644
--- a/packages/react-dom/src/server/ReactDOMFizzServerNode.js
+++ b/packages/react-dom/src/server/ReactDOMFizzServerNode.js
@@ -81,6 +81,12 @@ type Options = {
   formState?: ReactFormState<any, any> | null,
   onHeaders?: (headers: HeadersDescriptor) => void,
   maxHeadersLength?: number,
+  // Fused renderer: when true, Fizz renders server components inline
+  // instead of expecting Flight to have pre-resolved them.
+  experimental_fusedMode?: boolean,
+  // The bundler config (client manifest) for resolving client references.
+  // Required when experimental_fusedMode is true.
+  experimental_bundlerConfig?: mixed,
 };
 
 type ResumeOptions = {
@@ -125,6 +131,8 @@ function createRequestImpl(children: ReactNodeList, options: void | Options) {
     options ? options.onShellError : undefined,
     undefined,
     options ? options.formState : undefined,
+    options ? options.experimental_fusedMode : undefined,
+    options ? options.experimental_bundlerConfig : undefined,
   );
 }
 
diff --git a/packages/react-markup/src/ReactFizzConfigMarkup.js b/packages/react-markup/src/ReactFizzConfigMarkup.js
index d12d72e69e02..9d81e9c5a3b3 100644
--- a/packages/react-markup/src/ReactFizzConfigMarkup.js
+++ b/packages/react-markup/src/ReactFizzConfigMarkup.js
@@ -182,6 +182,40 @@ export function pushEndActivityBoundary(
   return;
 }
 
+export function pushStartClientBoundary(
+  target: Array<Chunk | PrecomputedChunk>,
+  id: number,
+): void {
+  // Markup doesn't have any instructions.
+  return;
+}
+
+export function pushEndClientBoundary(
+  target: Array<Chunk | PrecomputedChunk>,
+): void {
+  // Markup doesn't have any instructions.
+  return;
+}
+
+export function writeClientBoundaryScript(
+  destination: Destination,
+  id: number,
+  moduleId: string,
+  moduleName: string,
+  serializedProps: string,
+): boolean {
+  // Markup doesn't have any instructions.
+  return true;
+}
+
+export function writeConsolidatedHydrationScript(
+  destination: Destination,
+  queue: Array<mixed>,
+): boolean {
+  // Markup doesn't have any instructions.
+  return true;
+}
+
 export function writeStartCompletedSuspenseBoundary(
   destination: Destination,
   renderState: RenderState,
diff --git a/packages/react-server/src/ReactFizzHydrationSerializer.js b/packages/react-server/src/ReactFizzHydrationSerializer.js
new file mode 100644
index 000000000000..aa712863a059
--- /dev/null
+++ b/packages/react-server/src/ReactFizzHydrationSerializer.js
@@ -0,0 +1,254 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Focused props serializer for fused renderer client boundaries.
+ * Handles common prop types at client component boundaries. Does NOT
+ * attempt to replicate Flight's full renderModelDestructive (~800 lines).
+ *
+ * Optimization strategy: use native JSON.stringify for the common case
+ * (plain objects with strings, numbers, booleans, null, nested objects/arrays).
+ * Only fall back to manual serialization when special types are detected
+ * (Date, BigInt, NaN, Infinity, undefined, references).
+ *
+ * Tagged value format:
+ *   {"$t": "D", "v": "2026-01-01T00:00:00.000Z"}  — Date
+ *   {"$t": "u"}                                     — undefined
+ *   {"$t": "N"}                                     — NaN
+ *   {"$t": "I", "v": 1}                             — +Infinity
+ *   {"$t": "I", "v": -1}                            — -Infinity
+ *   {"$t": "n", "v": "123"}                         — BigInt (as string)
+ *   {"$t": "S", "id": "...", "bound": [...]}        — Server Action ref
+ *   {"$t": "C", "id": "..."}                        — Client reference in props
+ *   {"$t": "T"}                                     — Tombstone (server-rendered children)
+ *
+ * @flow
+ */
+
+const CLIENT_REFERENCE_TAG: symbol = Symbol.for('react.client.reference');
+const SERVER_REFERENCE_TAG: symbol = Symbol.for('react.server.reference');
+
+// Tombstone JSON fragment, precomputed.
+const TOMBSTONE = '{"$t":"T"}';
+
+/**
+ * Serialize props for a client boundary's hydration data.
+ * Returns a JSON string.
+ *
+ * Fast path: if props only contain JSON-native types (string, number,
+ * boolean, null, plain objects, arrays) — which is the common case for
+ * e-commerce product data, blog posts, etc. — we use a single
+ * JSON.stringify call with a lightweight replacer. This avoids building
+ * any intermediate object tree.
+ *
+ * Slow path: if any value needs tagged serialization (Date, BigInt,
+ * undefined, NaN, Infinity, references), we fall back to manual string
+ * building which is ~2x slower but handles all types.
+ */
+export function serializeProps(props: {[string]: mixed}): string {
+  // Try the fast path first. The replacer handles children and functions
+  // but throws a sentinel if it encounters a type needing tagged values.
+  try {
+    return JSON.stringify(props, fastReplacer);
+  } catch (e) {
+    if (e === NEEDS_SLOW_PATH) {
+      // Fall back to manual serialization for exotic types.
+      return serializeSlow(props);
+    }
+    throw e;
+  }
+}
+
+// Sentinel error object (not a real error, just a signal to switch paths).
+const NEEDS_SLOW_PATH: {||} = Object.freeze({});
+
+function fastReplacer(this: mixed, key: string, value: mixed): mixed {
+  // Root-level children → tombstone.
+  // We check if `this` is the root props object by checking if the key is
+  // 'children' and the parent has other prop-like keys. Since JSON.stringify
+  // calls the replacer with key="" for the root, and 'children' for the prop,
+  // we just replace all 'children' keys. This is slightly aggressive but
+  // matches the semantics: server-rendered children are always tombstoned.
+  if (key === 'children') {
+    // Return a plain object that JSON.stringify will serialize inline.
+    return {$t: 'T'};
+  }
+
+  // Functions: strip regular, signal for references.
+  if (typeof value === 'function') {
+    if (
+      (value: any).$$typeof === SERVER_REFERENCE_TAG ||
+      (value: any).$$typeof === CLIENT_REFERENCE_TAG
+    ) {
+      throw NEEDS_SLOW_PATH;
+    }
+    return undefined;
+  }
+
+  // Types that need tagged values — signal slow path.
+  if (typeof value === 'bigint') throw NEEDS_SLOW_PATH;
+  if (typeof value === 'undefined') throw NEEDS_SLOW_PATH;
+  if (typeof value === 'symbol') return undefined;
+
+  if (typeof value === 'number') {
+    if (value !== value) throw NEEDS_SLOW_PATH; // NaN
+    if (value === Infinity || value === -Infinity) throw NEEDS_SLOW_PATH;
+  }
+
+  // Date: JSON.stringify calls toJSON() first, so the replacer sees a string.
+  // But if we see a Date object (shouldn't happen normally since toJSON runs
+  // first), signal slow path.
+  if (typeof value === 'object' && value !== null) {
+    if (value instanceof Date) throw NEEDS_SLOW_PATH;
+    if (value instanceof Map || value instanceof Set) {
+      throw new Error(
+        (value instanceof Map ? 'Map' : 'Set') +
+          ' props are not supported in fused mode. ' +
+          'Use the standard Flight path for this component.',
+      );
+    }
+    if (ArrayBuffer.isView(value)) {
+      throw new Error(
+        'TypedArray props are not supported in fused mode. ' +
+          'Use the standard Flight path for this component.',
+      );
+    }
+    if (
+      typeof ReadableStream !== 'undefined' &&
+      value instanceof ReadableStream
+    ) {
+      throw new Error(
+        'ReadableStream props are not supported in fused mode. ' +
+          'Use the standard Flight path for this component.',
+      );
+    }
+    if ((value: any).$$typeof === CLIENT_REFERENCE_TAG) throw NEEDS_SLOW_PATH;
+    if ((value: any).$$typeof === SERVER_REFERENCE_TAG) throw NEEDS_SLOW_PATH;
+  }
+
+  return value;
+}
+
+/**
+ * Slow path: builds JSON string manually, handling all tagged types.
+ * Used when the fast path detects a value needing special serialization.
+ */
+function serializeSlow(props: {[string]: mixed}): string {
+  let out = '{';
+  let first = true;
+  const keys = Object.keys(props);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key === 'children') {
+      if (!first) out += ',';
+      first = false;
+      out += '"children":' + TOMBSTONE;
+      continue;
+    }
+    const v = writeValueSlow(props[key]);
+    if (v !== undefined) {
+      if (!first) out += ',';
+      first = false;
+      out += JSON.stringify(key) + ':' + v;
+    }
+  }
+  return out + '}';
+}
+
+function writeValueSlow(value: mixed): string | void {
+  if (value === null) return 'null';
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') {
+    if (value !== value) return '{"$t":"N"}';
+    if (value === Infinity) return '{"$t":"I","v":1}';
+    if (value === -Infinity) return '{"$t":"I","v":-1}';
+    return '' + value;
+  }
+  if (typeof value === 'undefined') return '{"$t":"u"}';
+  if (typeof value === 'bigint') {
+    return '{"$t":"n","v":"' + value.toString() + '"}';
+  }
+  if (typeof value === 'symbol') return undefined;
+
+  if (typeof value === 'function') {
+    if ((value: any).$$typeof === SERVER_REFERENCE_TAG) {
+      return (
+        '{"$t":"S","id":' +
+        JSON.stringify((value: any).$$id || '') +
+        ',"bound":' +
+        JSON.stringify((value: any).$$bound || null) +
+        '}'
+      );
+    }
+    if ((value: any).$$typeof === CLIENT_REFERENCE_TAG) {
+      return '{"$t":"C","id":' + JSON.stringify((value: any).$$id || '') + '}';
+    }
+    return undefined;
+  }
+
+  if (typeof value !== 'object' || value === null) return 'null';
+
+  if (value instanceof Date) {
+    return '{"$t":"D","v":"' + value.toISOString() + '"}';
+  }
+
+  if (value instanceof Map) {
+    throw new Error(
+      'Map props are not supported in fused mode. ' +
+        'Use the standard Flight path for this component.',
+    );
+  }
+  if (value instanceof Set) {
+    throw new Error(
+      'Set props are not supported in fused mode. ' +
+        'Use the standard Flight path for this component.',
+    );
+  }
+  if (ArrayBuffer.isView(value)) {
+    throw new Error(
+      'TypedArray props are not supported in fused mode. ' +
+        'Use the standard Flight path for this component.',
+    );
+  }
+
+  if ((value: any).$$typeof === CLIENT_REFERENCE_TAG) {
+    return '{"$t":"C","id":' + JSON.stringify((value: any).$$id || '') + '}';
+  }
+  if ((value: any).$$typeof === SERVER_REFERENCE_TAG) {
+    return (
+      '{"$t":"S","id":' +
+      JSON.stringify((value: any).$$id || '') +
+      ',"bound":' +
+      JSON.stringify((value: any).$$bound || null) +
+      '}'
+    );
+  }
+
+  if (Array.isArray(value)) {
+    let out = '[';
+    for (let i = 0; i < value.length; i++) {
+      if (i > 0) out += ',';
+      const v = writeValueSlow(value[i]);
+      out += v !== undefined ? v : 'null';
+    }
+    return out + ']';
+  }
+
+  // Plain object
+  let out = '{';
+  let first = true;
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    const v = writeValueSlow((value: any)[k]);
+    if (v !== undefined) {
+      if (!first) out += ',';
+      first = false;
+      out += JSON.stringify(k) + ':' + v;
+    }
+  }
+  return out + '}';
+}
diff --git a/packages/react-server/src/ReactFizzServer.js b/packages/react-server/src/ReactFizzServer.js
index 989f9184637d..b3514283c6dd 100644
--- a/packages/react-server/src/ReactFizzServer.js
+++ b/packages/react-server/src/ReactFizzServer.js
@@ -61,6 +61,10 @@ import {
   writePlaceholder,
   pushStartActivityBoundary,
   pushEndActivityBoundary,
+  pushStartClientBoundary,
+  pushEndClientBoundary,
+  writeClientBoundaryScript,
+  writeConsolidatedHydrationScript,
   writeStartCompletedSuspenseBoundary,
   writeStartPendingSuspenseBoundary,
   writeStartClientRenderedSuspenseBoundary,
@@ -198,6 +202,14 @@ import {
   setCaptureSuspendedCallSiteDEV,
 } from './ReactFizzThenable';
 
+import {serializeProps} from './ReactFizzHydrationSerializer';
+
+// Client reference tag used to detect 'use client' components in fused mode.
+// This is part of the stable bundler protocol — client components have
+// $$typeof === Symbol.for('react.client.reference'). We define it here
+// rather than importing from Flight to avoid coupling Fizz to Flight internals.
+const CLIENT_REFERENCE_TAG: symbol = Symbol.for('react.client.reference');
+
 // Linked list representing the identity of a component given the component/tag name and key.
 // The name might be minified but we assume that it's going to be the same generated name. Typically
 // because it's just the same compiled output in practice.
@@ -402,6 +414,28 @@ export opaque type Request = {
   onFatalError: (error: mixed) => void,
   // Form state that was the result of an MPA submission, if it was provided.
   formState: null | ReactFormState<any, any>,
+  // Fused renderer mode: when true, Fizz receives the original React tree with
+  // server component functions still present (not pre-resolved by Flight).
+  // Server components are called inline during rendering. Client components
+  // (marked with $$typeof === Symbol.for('react.client.reference')) are rendered
+  // to HTML and will emit hydration markers in a later step (TIM-475).
+  +fusedMode: boolean,
+  // The bundler config (e.g., webpack client manifest) passed through from the
+  // framework. Used to resolve client module references at client component
+  // boundaries. Opaque to Fizz itself.
+  +bundlerConfig: mixed,
+  // Queue of client boundary hydration data to emit during flushCompletedQueues.
+  // Module references use Flight's format: {id, chunks, name} — the same shape
+  // that __webpack_chunk_load__ + __webpack_require__ consume.
+  clientBoundaryQueue: Array<{
+    id: number,
+    moduleId: string,
+    moduleChunks: Array<string>,
+    moduleName: string,
+    serializedProps: string,
+  }>,
+  // Auto-incrementing ID for client boundary markers.
+  nextClientBoundaryId: number,
   // DEV-only, warning dedupe
   didWarnForKey?: null | WeakSet<ComponentStackNode>,
 };
@@ -515,6 +549,8 @@ function RequestInstance(
   onShellError: void | ((error: mixed) => void),
   onFatalError: void | ((error: mixed) => void),
   formState: void | null | ReactFormState<any, any>,
+  fusedMode: void | boolean,
+  bundlerConfig: mixed,
 ) {
   const pingedTasks: Array<Task> = [];
   const abortSet: Set<Task> = new Set();
@@ -547,6 +583,10 @@ function RequestInstance(
   this.onShellError = onShellError === undefined ? noop : onShellError;
   this.onFatalError = onFatalError === undefined ? noop : onFatalError;
   this.formState = formState === undefined ? null : formState;
+  this.fusedMode = fusedMode === true;
+  this.bundlerConfig = bundlerConfig === undefined ? null : bundlerConfig;
+  this.clientBoundaryQueue = [];
+  this.nextClientBoundaryId = 0;
   if (__DEV__) {
     this.didWarnForKey = null;
   }
@@ -564,6 +604,8 @@ export function createRequest(
   onShellError: void | ((error: mixed) => void),
   onFatalError: void | ((error: mixed) => void),
   formState: void | null | ReactFormState<any, any>,
+  fusedMode: void | boolean,
+  bundlerConfig: mixed,
 ): Request {
   if (__DEV__) {
     resetOwnerStackLimit();
@@ -581,6 +623,8 @@ export function createRequest(
     onShellError,
     onFatalError,
     formState,
+    fusedMode,
+    bundlerConfig,
   );
 
   // This segment represents the root fallback.
@@ -2914,6 +2958,83 @@ function renderViewTransition(
   task.keyPath = prevKeyPath;
 }
 
+// Fused mode: render a client component ('use client') to HTML with
+// boundary markers and queue hydration data for later emission.
+function renderClientBoundary(
+  request: Request,
+  task: Task,
+  keyPath: KeyNode,
+  type: any,
+  props: Object,
+): void {
+  const segment = task.blockedSegment;
+  if (segment === null) {
+    renderFunctionComponent(request, task, keyPath, type, props);
+    return;
+  }
+
+  const boundaryId = request.nextClientBoundaryId++;
+
+  // Resolve the client reference using the same bundler protocol as Flight.
+  // bundlerConfig is the client manifest (same object passed to Flight's
+  // renderToPipeableStream as webpackMap). It maps $$id → {id, chunks, name}.
+  const bundlerConfig: any = request.bundlerConfig;
+  const refId: string = type.$$id || '';
+  let metadata: {id: string, chunks: Array<string>, name: string} | null = null;
+
+  if (bundlerConfig != null) {
+    const moduleData = bundlerConfig[refId];
+    if (moduleData != null) {
+      // Exact match (e.g., "file:///path/to/module.js" → {id, chunks, name})
+      metadata = moduleData;
+    }
+  }
+
+  // Resolve the actual component for SSR rendering.
+  // Use __webpack_require__ (or equivalent) to get the real module, then
+  // extract the named export — same as Flight client's requireModule().
+  let resolvedType = type;
+  if (metadata != null) {
+    // $FlowFixMe[unsupported-syntax] — __webpack_require__ is a webpack global
+    if (typeof __webpack_require__ === 'function') {
+      const moduleExports = __webpack_require__(metadata.id);
+      if (metadata.name === '*') {
+        resolvedType = moduleExports;
+      } else if (metadata.name === '') {
+        resolvedType = moduleExports.__esModule
+          ? moduleExports.default
+          : moduleExports;
+      } else if (moduleExports[metadata.name] != null) {
+        resolvedType = moduleExports[metadata.name];
+      }
+    }
+  }
+
+  // Serialize props for hydration.
+  let serializedProps: string;
+  try {
+    serializedProps = serializeProps(props);
+  } catch (e) {
+    serializedProps = '{}';
+  }
+
+  pushStartClientBoundary(segment.chunks, boundaryId);
+  renderFunctionComponent(request, task, keyPath, resolvedType, props);
+  pushEndClientBoundary(segment.chunks);
+
+  // Queue hydration data using Flight's module reference format.
+  // {id, chunks, name} is the same shape Flight uses, so the client can
+  // load modules via the standard __webpack_chunk_load__ + __webpack_require__
+  // protocol without any custom parsing.
+  request.clientBoundaryQueue.push({
+    id: boundaryId,
+    moduleId: metadata != null ? metadata.id : refId,
+    moduleChunks: metadata != null ? metadata.chunks : [],
+    moduleName: metadata != null ? metadata.name : '*',
+    serializedProps,
+  });
+}
+
 function renderElement(
   request: Request,
   task: Task,
@@ -2926,7 +3047,17 @@ function renderElement(
     if (shouldConstruct(type)) {
       renderClassComponent(request, task, keyPath, type, props);
       return;
+    } else if (request.fusedMode && type.$$typeof === CLIENT_REFERENCE_TAG) {
+      // Fused mode: this is a client component ('use client').
+      // Render it to HTML (for SSR preview) wrapped in comment markers,
+      // and queue hydration data for emission during flush.
+      renderClientBoundary(request, task, keyPath, type, props);
+      return;
     } else {
+      // Either fusedMode is false (standard Fizz path) or this is a server
+      // component (function without client reference tag). In both cases,
+      // call the function via renderFunctionComponent which uses
+      // renderWithHooks to execute it and render the output.
       renderFunctionComponent(request, task, keyPath, type, props);
       return;
     }
@@ -5100,8 +5231,8 @@ function retryRenderTask(
           // later, once we deprecate the old API in favor of `use`.
           getSuspendedThenable()
         : request.status === ABORTING
-          ? request.fatalError
-          : thrownValue;
+        ? request.fatalError
+        : thrownValue;
 
     if (request.status === ABORTING && request.trackedPostpones !== null) {
       // We are aborting a prerender and need to halt this task.
@@ -5941,7 +6072,15 @@ function flushCompletedQueues(
     completeWriting(destination);
     beginWriting(destination);
 
-    // TODO: Here we'll emit data used by hydration.
+    // Emit hydration data for client boundaries discovered during fused rendering.
+    // All boundaries are consolidated into a single <script> tag to minimize
+    // per-boundary overhead. The payload is a JSON object mapping boundary IDs
+    // to module references.
+    if (request.fusedMode && request.clientBoundaryQueue.length > 0) {
+      const queue = request.clientBoundaryQueue;
+      writeConsolidatedHydrationScript(destination, queue);
+      request.clientBoundaryQueue.length = 0;
+    }
 
     // Next we emit any segments of any boundaries that are partially complete
     // but not deeply complete.
@@ -6088,9 +6227,9 @@ export function prepareForStartFlowingIfBeforeAllReady(request: Request) {
       ? // Render Request, we define shell complete by the pending root tasks
         request.pendingRootTasks === 0
       : // Prerender Request, we define shell complete by completedRootSegemtn
-        request.completedRootSegment === null
-        ? request.pendingRootTasks === 0
-        : request.completedRootSegment.status !== POSTPONED;
+      request.completedRootSegment === null
+      ? request.pendingRootTasks === 0
+      : request.completedRootSegment.status !== POSTPONED;
   safelyEmitEarlyPreloads(request, shellComplete);
 }
 
@@ -6135,10 +6274,10 @@ export function abort(request: Request, reason: mixed): void {
         reason === undefined
           ? new Error('The render was aborted by the server without a reason.')
           : typeof reason === 'object' &&
-              reason !== null &&
-              typeof reason.then === 'function'
-            ? new Error('The render was aborted by the server with a promise.')
-            : reason;
+            reason !== null &&
+            typeof reason.then === 'function'
+          ? new Error('The render was aborted by the server with a promise.')
+          : reason;
       // This error isn't necessarily fatal in this case but we need to stash it
       // so we can use it to abort any pending work
       request.fatalError = error;
diff --git a/packages/react-server/src/__tests__/ReactFizzFusedSentinels-test.js b/packages/react-server/src/__tests__/ReactFizzFusedSentinels-test.js
new file mode 100644
index 000000000000..7e7b949c54f3
--- /dev/null
+++ b/packages/react-server/src/__tests__/ReactFizzFusedSentinels-test.js
@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails react-core
+ * @jest-environment node
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Sentinel tests that detect upstream React changes which would break
+ * the fused renderer's assumptions. If any of these fail after a React
+ * upstream merge, the fused renderer needs to be re-evaluated.
+ */
+describe('ReactFizzFusedSentinels', () => {
+  describe('client reference protocol', () => {
+    it('client references use Symbol.for("react.client.reference")', () => {
+      const tag = Symbol.for('react.client.reference');
+      expect(typeof tag).toBe('symbol');
+      expect(tag.toString()).toBe('Symbol(react.client.reference)');
+    });
+
+    it('client reference proxy has $$typeof, $$id, $$async', () => {
+      // This is how bundlers (webpack, turbopack) create client references.
+      // If this shape changes, our detection in renderElement breaks.
+      const ref = Object.defineProperties(function () {}, {
+        $$typeof: {value: Symbol.for('react.client.reference')},
+        $$id: {value: 'module#export'},
+        $$async: {value: false},
+      });
+      expect(ref.$$typeof).toBe(Symbol.for('react.client.reference'));
+      expect(ref.$$id).toBe('module#export');
+      expect(ref.$$async).toBe(false);
+    });
+  });
+
+  describe('server reference protocol', () => {
+    it('server references use Symbol.for("react.server.reference")', () => {
+      const tag = Symbol.for('react.server.reference');
+      expect(typeof tag).toBe('symbol');
+    });
+
+    it('server reference has $$typeof, $$id, $$bound', () => {
+      const ref = Object.defineProperties(function () {}, {
+        $$typeof: {value: Symbol.for('react.server.reference')},
+        $$id: {value: 'actions#myAction'},
+        $$bound: {value: ['arg1']},
+      });
+      expect(ref.$$typeof).toBe(Symbol.for('react.server.reference'));
+      expect(ref.$$id).toBe('actions#myAction');
+      expect(ref.$$bound).toEqual(['arg1']);
+    });
+  });
+
+  describe('Fizz insertion points', () => {
+    it('ReactFizzServer.js has fused mode code', () => {
+      const source = fs.readFileSync(
+        path.resolve(__dirname, '../ReactFizzServer.js'),
+        'utf8',
+      );
+      expect(source).toContain('clientBoundaryQueue');
+      expect(source).toContain('fusedMode');
+    });
+  });
+
+  describe('hydration walker compatibility', () => {
+    it('getNextHydratable skips unknown comment types', () => {
+      const source = fs.readFileSync(
+        path.resolve(
+          __dirname,
+          '../../../react-dom-bindings/src/client/ReactFiberConfigDOM.js',
+        ),
+        'utf8',
+      );
+      expect(source).toContain('getNextHydratable');
+      expect(source).toContain("'$'");
+      expect(source).toContain("'/$'");
+    });
+  });
+
+  describe('Flight server independence', () => {
+    it('ReactFlightServer.js has no fused-mode code', () => {
+      const source = fs.readFileSync(
+        path.resolve(__dirname, '../ReactFlightServer.js'),
+        'utf8',
+      );
+      expect(source).not.toContain('fusedMode');
+      expect(source).not.toContain('clientBoundaryQueue');
+      expect(source).not.toContain('pushStartClientBoundary');
+    });
+  });
+});
diff --git a/packages/react-server/src/__tests__/ReactFizzFusedServer-test.js b/packages/react-server/src/__tests__/ReactFizzFusedServer-test.js
new file mode 100644
index 000000000000..a0bf86cb0033
--- /dev/null
+++ b/packages/react-server/src/__tests__/ReactFizzFusedServer-test.js
@@ -0,0 +1,538 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails react-core
+ * @jest-environment ./scripts/jest/ReactDOMServerIntegrationEnvironment
+ */
+
+'use strict';
+
+let React;
+let ReactDOMFizzServer;
+let Stream;
+let Suspense;
+
+let buffer = '';
+let hasErrored = false;
+let fatalError = undefined;
+let writable;
+
+describe('ReactFizzFusedServer', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    React = require('react');
+    ReactDOMFizzServer = require('react-dom/server');
+    Stream = require('stream');
+    Suspense = React.Suspense;
+
+    buffer = '';
+    hasErrored = false;
+    fatalError = undefined;
+    writable = new Stream.PassThrough();
+    writable.setEncoding('utf8');
+    writable.on('data', chunk => {
+      buffer += chunk;
+    });
+    writable.on('error', error => {
+      hasErrored = true;
+      fatalError = error;
+    });
+  });
+
+  async function act(callback) {
+    await callback();
+    // Await one turn around the event loop.
+    await new Promise(resolve => {
+      setImmediate(resolve);
+    });
+    if (hasErrored) {
+      throw fatalError;
+    }
+  }
+
+  async function waitForAll() {
+    // Flush all timers and microtasks
+    jest.runAllTimers();
+    await new Promise(resolve => setImmediate(resolve));
+  }
+
+  function getOutput() {
+    return buffer;
+  }
+
+  // Helper: render and collect full HTML output
+  async function renderToString(jsx, options) {
+    return new Promise((resolve, reject) => {
+      let output = '';
+      const passthrough = new Stream.PassThrough();
+      passthrough.setEncoding('utf8');
+      passthrough.on('data', chunk => {
+        output += chunk;
+      });
+      passthrough.on('end', () => resolve(output));
+      passthrough.on('error', reject);
+
+      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(jsx, {
+        ...options,
+        onAllReady() {
+          pipe(passthrough);
+        },
+        onError(err) {
+          reject(err);
+        },
+      });
+    });
+  }
+
+  describe('fusedMode: false (default)', () => {
+    it('renders a normal function component unchanged', async () => {
+      function App() {
+        return <div>Hello World</div>;
+      }
+
+      const html = await renderToString(<App />);
+      expect(html).toContain('Hello World');
+    });
+
+    it('does not treat function components differently without fusedMode', async () => {
+      // A function that looks like a server component (plain function)
+      // should render normally when fusedMode is not enabled.
+      function ServerComponent() {
+        return <span>server content</span>;
+      }
+
+      function App() {
+        return (
+          <div>
+            <ServerComponent />
+          </div>
+        );
+      }
+
+      const html = await renderToString(<App />);
+      expect(html).toContain('server content');
+    });
+  });
+
+  describe('fusedMode: true', () => {
+    it('renders a sync server component to correct HTML', async () => {
+      function ServerHeader() {
+        return <h1>Server Rendered Header</h1>;
+      }
+
+      function ServerContent() {
+        return <p>Content from server component</p>;
+      }
+
+      function App() {
+        return (
+          <div>
+            <ServerHeader />
+            <ServerContent />
+          </div>
+        );
+      }
+
+      const html = await renderToString(<App />, {
+        experimental_fusedMode: true,
+      });
+      expect(html).toContain('Server Rendered Header');
+      expect(html).toContain('Content from server component');
+    });
+
+    it('renders nested server components', async () => {
+      function Inner() {
+        return <span>inner</span>;
+      }
+
+      function Middle() {
+        return (
+          <div>
+            <Inner />
+          </div>
+        );
+      }
+
+      function Outer() {
+        return (
+          <section>
+            <Middle />
+          </section>
+        );
+      }
+
+      const html = await renderToString(<Outer />, {
+        experimental_fusedMode: true,
+      });
+      expect(html).toContain('<section>');
+      expect(html).toContain('<span>inner</span>');
+    });
+
+    it('passes props through to server components', async () => {
+      function Greeting({name, count}) {
+        return (
+          <div>
+            Hello {name}, you have {count} items
+          </div>
+        );
+      }
+
+      const html = await renderToString(<Greeting name="World" count={42} />, {
+        experimental_fusedMode: true,
+      });
+      // Fizz inserts comment nodes between text nodes
+      expect(html).toContain('Hello');
+      expect(html).toContain('World');
+      expect(html).toContain('42');
+      expect(html).toContain('items');
+    });
+
+    it('renders async server components via Suspense', async () => {
+      let resolve;
+      const promise = new Promise(r => {
+        resolve = r;
+      });
+
+      async function AsyncComponent() {
+        await promise;
+        return <div>async content loaded</div>;
+      }
+
+      function App() {
+        return (
+          <Suspense fallback={<span>Loading...</span>}>
+            <AsyncComponent />
+          </Suspense>
+        );
+      }
+
+      let html;
+      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(<App />, {
+        experimental_fusedMode: true,
+        onAllReady() {
+          // Collect output after everything resolves
+          const passthrough = new Stream.PassThrough();
+          passthrough.setEncoding('utf8');
+          let output = '';
+          passthrough.on('data', chunk => {
+            output += chunk;
+          });
+          passthrough.on('end', () => {
+            html = output;
+          });
+          pipe(passthrough);
+        },
+      });
+
+      // Resolve the async component
+      resolve();
+      await waitForAll();
+      await new Promise(resolve => setImmediate(resolve));
+
+      expect(html).toContain('async content loaded');
+    });
+
+    it('streams shell immediately while async components resolve', async () => {
+      let resolve;
+      const promise = new Promise(r => {
+        resolve = r;
+      });
+
+      async function SlowComponent() {
+        await promise;
+        return <div>slow content</div>;
+      }
+
+      function App() {
+        return (
+          <div>
+            <h1>Shell</h1>
+            <Suspense fallback={<span>Loading...</span>}>
+              <SlowComponent />
+            </Suspense>
+          </div>
+        );
+      }
+
+      const {pipe} = ReactDOMFizzServer.renderToPipeableStream(<App />, {
+        experimental_fusedMode: true,
+        onShellReady() {
+          pipe(writable);
+        },
+      });
+
+      // After shell is ready, the fallback should be in the output
+      await new Promise(resolve => setImmediate(resolve));
+      expect(getOutput()).toContain('Shell');
+      expect(getOutput()).toContain('Loading...');
+
+      // Resolve the slow component
+      resolve();
+      await waitForAll();
+      await new Promise(resolve => setImmediate(resolve));
+
+      // Now the slow content should be streamed
+      expect(getOutput()).toContain('slow content');
+    });
+
+    it('handles server component that returns null', async () => {
+      function NullComponent() {
+        return null;
+      }
+
+      function App() {
+        return (
+          <div>
+            <NullComponent />
+            <span>after null</span>
+          </div>
+        );
+      }
+
+      const html = await renderToString(<App />, {
+        experimental_fusedMode: true,
+      });
+      expect(html).toContain('after null');
+    });
+
+    it('handles server component that returns a fragment', async () => {
+      function MultiReturn() {
+        return (
+          <>
+            <li>one</li>
+            <li>two</li>
+            <li>three</li>
+          </>
+        );
+      }
+
+      function App() {
+        return (
+          <ul>
+            <MultiReturn />
+          </ul>
+        );
+      }
+
+      const html = await renderToString(<App />, {
+        experimental_fusedMode: true,
+      });
+      expect(html).toContain('<li>one</li>');
+      expect(html).toContain('<li>two</li>');
+      expect(html).toContain('<li>three</li>');
+    });
+
+    it('wraps client reference in boundary markers', async () => {
+      const ClientComponent = Object.defineProperties(
+        function ClientComponent({label}) {
+          return <button>{label}</button>;
+        },
+        {
+          $$typeof: {value: Symbol.for('react.client.reference')},
+          $$id: {value: 'test-module#ClientComponent'},
+          $$async: {value: false},
+        },
+      );
+
+      function App() {
+        return (
+          <div>
+            <ClientComponent label="Click me" />
+          </div>
+        );
+      }
+
+      const html = await renderToString(<App />, {
+        experimental_fusedMode: true,
+      });
+      // Should still render the HTML
+      expect(html).toContain('Click me');
+      // Should have boundary markers
+      expect(html).toContain('<!--C:0-->');
+      expect(html).toContain('<!--/C-->');
+      // Markers should wrap the button
+      const startIdx = html.indexOf('<!--C:0-->');
+      const buttonIdx = html.indexOf('<button>');
+      const endIdx = html.indexOf('<!--/C-->');
+      expect(startIdx).toBeLessThan(buttonIdx);
+      expect(buttonIdx).toBeLessThan(endIdx);
+    });
+
+    it('emits consolidated hydration script for client boundaries', async () => {
+      const ClientComponent = Object.defineProperties(
+        function ClientComponent({label}) {
+          return <button>{label}</button>;
+        },
+        {
+          $$typeof: {value: Symbol.for('react.client.reference')},
+          $$id: {value: 'my-module#default'},
+          $$async: {value: false},
+        },
+      );
+
+      function App() {
+        return (
+          <div>
+            <ClientComponent label="Click me" />
+          </div>
+        );
+      }
+
+      const html = await renderToString(<App />, {
+        experimental_fusedMode: true,
+      });
+      // Should contain a consolidated hydration script with module ref
+      expect(html).toContain('__FUSED');
+      expect(html).toContain('my-module#default');
+    });
+
+    it('assigns unique IDs to multiple client boundaries', async () => {
+      const ClientA = Object.defineProperties(
+        function ClientA() {
+          return <span>A</span>;
+        },
+        {
+          $$typeof: {value: Symbol.for('react.client.reference')},
+          $$id: {value: 'module-a#A'},
+          $$async: {value: false},
+        },
+      );
+
+      const ClientB = Object.defineProperties(
+        function ClientB() {
+          return <span>B</span>;
+        },
+        {
+          $$typeof: {value: Symbol.for('react.client.reference')},
+          $$id: {value: 'module-b#B'},
+          $$async: {value: false},
+        },
+      );
+
+      function App() {
+        return (
+          <div>
+            <ClientA />
+            <ClientB />
+          </div>
+        );
+      }
+
+      const html = await renderToString(<App />, {
+        experimental_fusedMode: true,
+      });
+      expect(html).toContain('<!--C:0-->');
+      expect(html).toContain('<!--C:1-->');
+      // Two hydration scripts
+      // Consolidated hydration script contains both module refs
+      expect(html).toContain('__FUSED');
+      expect(html).toContain('module-a#A');
+      expect(html).toContain('module-b#B');
+    });
+
+    it('handles nested server-in-client-in-server', async () => {
+      function ServerOuter() {
+        return (
+          <section>
+            <h1>Server Outer</h1>
+            <ClientMiddle />
+          </section>
+        );
+      }
+
+      const ClientMiddle = Object.defineProperties(
+        function ClientMiddle() {
+          return (
+            <div className="client">
+              <ServerInner />
+            </div>
+          );
+        },
+        {
+          $$typeof: {value: Symbol.for('react.client.reference')},
+          $$id: {value: 'client-middle#default'},
+          $$async: {value: false},
+        },
+      );
+
+      function ServerInner() {
+        return <p>Server Inner Content</p>;
+      }
+
+      const html = await renderToString(<ServerOuter />, {
+        experimental_fusedMode: true,
+      });
+      expect(html).toContain('Server Outer');
+      expect(html).toContain('Server Inner Content');
+      // Client boundary should wrap the ClientMiddle output
+      expect(html).toContain('<!--C:0-->');
+      expect(html).toContain('<!--/C-->');
+      // The inner server content should be INSIDE the markers
+      const startIdx = html.indexOf('<!--C:0-->');
+      const innerIdx = html.indexOf('Server Inner Content');
+      const endIdx = html.indexOf('<!--/C-->');
+      expect(startIdx).toBeLessThan(innerIdx);
+      expect(innerIdx).toBeLessThan(endIdx);
+    });
+
+    it('emits module ref in consolidated hydration data (props deferred)', async () => {
+      const ClientComponent = Object.defineProperties(
+        function ClientComponent({title, count, active}) {
+          return (
+            <div>
+              {title} - {count} - {active ? 'yes' : 'no'}
+            </div>
+          );
+        },
+        {
+          $$typeof: {value: Symbol.for('react.client.reference')},
+          $$id: {value: 'props-test#default'},
+          $$async: {value: false},
+        },
+      );
+
+      const html = await renderToString(
+        <ClientComponent title="Hello" count={42} active={true} />,
+        {experimental_fusedMode: true},
+      );
+      // Consolidated hydration script contains module ref
+      expect(html).toContain('__FUSED');
+      expect(html).toContain('props-test#default');
+      // HTML still contains rendered content
+      expect(html).toContain('Hello');
+      expect(html).toContain('42');
+    });
+
+    it('does not emit markers or hydration data when fusedMode is false', async () => {
+      const ClientComponent = Object.defineProperties(
+        function ClientComponent({label}) {
+          return <button>{label}</button>;
+        },
+        {
+          $$typeof: {value: Symbol.for('react.client.reference')},
+          $$id: {value: 'test-module#ClientComponent'},
+          $$async: {value: false},
+        },
+      );
+
+      function App() {
+        return (
+          <div>
+            <ClientComponent label="Click me" />
+          </div>
+        );
+      }
+
+      const html = await renderToString(<App />);
+      expect(html).toContain('Click me');
+      // No markers
+      expect(html).not.toContain('<!--C:');
+      expect(html).not.toContain('<!--/C-->');
+      // No hydration scripts
+      expect(html).not.toContain('__FUSED');
+    });
+  });
+});
diff --git a/packages/react-server/src/__tests__/ReactFizzHydrationSerializer-test.js b/packages/react-server/src/__tests__/ReactFizzHydrationSerializer-test.js
new file mode 100644
index 000000000000..e1b4f5658d1f
--- /dev/null
+++ b/packages/react-server/src/__tests__/ReactFizzHydrationSerializer-test.js
@@ -0,0 +1,245 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails react-core
+ * @jest-environment node
+ */
+
+'use strict';
+
+let serializeProps;
+
+describe('ReactFizzHydrationSerializer', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    serializeProps =
+      require('react-server/src/ReactFizzHydrationSerializer').serializeProps;
+  });
+
+  function parse(props) {
+    return JSON.parse(serializeProps(props));
+  }
+
+  describe('primitives', () => {
+    it('serializes strings', () => {
+      expect(parse({name: 'hello'})).toEqual({name: 'hello'});
+    });
+
+    it('serializes numbers', () => {
+      expect(parse({count: 42, price: 3.14})).toEqual({
+        count: 42,
+        price: 3.14,
+      });
+    });
+
+    it('serializes booleans', () => {
+      expect(parse({active: true, disabled: false})).toEqual({
+        active: true,
+        disabled: false,
+      });
+    });
+
+    it('serializes null', () => {
+      expect(parse({value: null})).toEqual({value: null});
+    });
+
+    it('serializes undefined as tagged value', () => {
+      const result = parse({value: undefined});
+      expect(result.value).toEqual({$t: 'u'});
+    });
+  });
+
+  describe('special numbers', () => {
+    it('serializes NaN as tagged value', () => {
+      const result = parse({value: NaN});
+      expect(result.value).toEqual({$t: 'N'});
+    });
+
+    it('serializes Infinity as tagged value', () => {
+      const result = parse({value: Infinity});
+      expect(result.value).toEqual({$t: 'I', v: 1});
+    });
+
+    it('serializes -Infinity as tagged value', () => {
+      const result = parse({value: -Infinity});
+      expect(result.value).toEqual({$t: 'I', v: -1});
+    });
+  });
+
+  describe('dates', () => {
+    it('serializes Date as tagged value in slow path', () => {
+      // When Date is combined with a type that triggers slow path (e.g. undefined),
+      // it gets the tagged format.
+      const date = new Date('2026-01-15T00:00:00.000Z');
+      const result = parse({created: date, undef: undefined});
+      expect(result.created).toEqual({
+        $t: 'D',
+        v: '2026-01-15T00:00:00.000Z',
+      });
+      expect(result.undef).toEqual({$t: 'u'});
+    });
+
+    it('serializes Date as ISO string in fast path', () => {
+      // When all other props are JSON-safe, Date.toJSON() produces an ISO
+      // string which JSON.stringify uses directly. This is acceptable —
+      // the client can reconstruct via new Date(str).
+      const date = new Date('2026-01-15T00:00:00.000Z');
+      const result = parse({created: date, label: 'test'});
+      expect(result.created).toBe('2026-01-15T00:00:00.000Z');
+    });
+  });
+
+  describe('bigint', () => {
+    it('serializes BigInt as tagged string', () => {
+      const result = parse({id: BigInt('9007199254740993')});
+      expect(result.id).toEqual({$t: 'n', v: '9007199254740993'});
+    });
+  });
+
+  describe('objects and arrays', () => {
+    it('serializes plain objects', () => {
+      expect(parse({config: {a: 1, b: 'two'}})).toEqual({
+        config: {a: 1, b: 'two'},
+      });
+    });
+
+    it('serializes arrays', () => {
+      expect(parse({items: [1, 'two', true]})).toEqual({
+        items: [1, 'two', true],
+      });
+    });
+
+    it('serializes nested objects and arrays', () => {
+      const props = {
+        data: {
+          users: [
+            {name: 'Alice', scores: [10, 20]},
+            {name: 'Bob', scores: [30, 40]},
+          ],
+        },
+      };
+      expect(parse(props)).toEqual(props);
+    });
+  });
+
+  describe('children handling', () => {
+    it('replaces children with tombstone', () => {
+      const result = parse({children: 'some text', label: 'btn'});
+      expect(result.children).toEqual({$t: 'T'});
+      expect(result.label).toBe('btn');
+    });
+
+    it('replaces JSX children with tombstone', () => {
+      const result = parse({children: {type: 'div', props: {}}});
+      expect(result.children).toEqual({$t: 'T'});
+    });
+  });
+
+  describe('function handling', () => {
+    it('strips regular functions', () => {
+      const result = parse({onClick: () => {}, label: 'btn'});
+      expect(result.onClick).toBeUndefined();
+      expect(result.label).toBe('btn');
+    });
+
+    it('serializes server action references', () => {
+      const action = Object.defineProperties(function myAction() {}, {
+        $$typeof: {value: Symbol.for('react.server.reference')},
+        $$id: {value: 'actions#submitForm'},
+        $$bound: {value: ['arg1', 'arg2']},
+      });
+      const result = parse({onSubmit: action});
+      expect(result.onSubmit).toEqual({
+        $t: 'S',
+        id: 'actions#submitForm',
+        bound: ['arg1', 'arg2'],
+      });
+    });
+
+    it('serializes client reference functions in props', () => {
+      const component = Object.defineProperties(function MyComponent() {}, {
+        $$typeof: {value: Symbol.for('react.client.reference')},
+        $$id: {value: 'components#MyComponent'},
+      });
+      const result = parse({renderItem: component});
+      expect(result.renderItem).toEqual({
+        $t: 'C',
+        id: 'components#MyComponent',
+      });
+    });
+  });
+
+  describe('client references as objects', () => {
+    it('serializes client reference objects in props', () => {
+      const ref = {
+        $$typeof: Symbol.for('react.client.reference'),
+        $$id: 'my-module#Foo',
+      };
+      const result = parse({component: ref});
+      expect(result.component).toEqual({$t: 'C', id: 'my-module#Foo'});
+    });
+  });
+
+  describe('unsupported types', () => {
+    it('throws on Map', () => {
+      expect(() => serializeProps({data: new Map()})).toThrow(
+        'Map props are not supported in fused mode',
+      );
+    });
+
+    it('throws on Set', () => {
+      expect(() => serializeProps({data: new Set()})).toThrow(
+        'Set props are not supported in fused mode',
+      );
+    });
+
+    it('throws on TypedArray', () => {
+      expect(() => serializeProps({data: new Uint8Array(4)})).toThrow(
+        'TypedArray props are not supported in fused mode',
+      );
+    });
+
+    it('strips symbols', () => {
+      const result = parse({sym: Symbol('test'), label: 'ok'});
+      expect(result.sym).toBeUndefined();
+      expect(result.label).toBe('ok');
+    });
+  });
+
+  describe('special numbers in arrays', () => {
+    it('handles NaN and Infinity in arrays', () => {
+      const result = parse({values: [NaN, Infinity, -Infinity, 42]});
+      expect(result.values).toEqual([
+        {$t: 'N'},
+        {$t: 'I', v: 1},
+        {$t: 'I', v: -1},
+        42,
+      ]);
+    });
+  });
+
+  describe('realistic props', () => {
+    it('serializes a realistic product card props', () => {
+      const props = {
+        product: {
+          id: 42,
+          name: 'Widget Pro',
+          price: {amount: '29.99', currency: 'USD'},
+          rating: {average: 4.5, count: 128},
+          inStock: true,
+          tags: ['electronics', 'gadgets'],
+        },
+        onAddToCart: () => {},
+        children: '<server rendered content>',
+      };
+      const result = parse(props);
+      expect(result.product.name).toBe('Widget Pro');
+      expect(result.product.price.amount).toBe('29.99');
+      expect(result.onAddToCart).toBeUndefined();
+      expect(result.children).toEqual({$t: 'T'});
+    });
+  });
+});
diff --git a/packages/react-server/src/forks/ReactFizzConfig.custom.js b/packages/react-server/src/forks/ReactFizzConfig.custom.js
index aa8ea94b5791..0887dd66f1b5 100644
--- a/packages/react-server/src/forks/ReactFizzConfig.custom.js
+++ b/packages/react-server/src/forks/ReactFizzConfig.custom.js
@@ -67,6 +67,10 @@ export const writeCompletedRoot = $$$config.writeCompletedRoot;
 export const writePlaceholder = $$$config.writePlaceholder;
 export const pushStartActivityBoundary = $$$config.pushStartActivityBoundary;
 export const pushEndActivityBoundary = $$$config.pushEndActivityBoundary;
+export const pushStartClientBoundary = $$$config.pushStartClientBoundary;
+export const pushEndClientBoundary = $$$config.pushEndClientBoundary;
+export const writeClientBoundaryScript = $$$config.writeClientBoundaryScript;
+export const writeConsolidatedHydrationScript = $$$config.writeConsolidatedHydrationScript;
 export const writeStartCompletedSuspenseBoundary =
   $$$config.writeStartCompletedSuspenseBoundary;
 export const writeStartPendingSuspenseBoundary =
diff --git a/packages/react-server/src/forks/ReactFizzConfig.noop.js b/packages/react-server/src/forks/ReactFizzConfig.noop.js
index 791c402bf773..62bb6c38980c 100644
--- a/packages/react-server/src/forks/ReactFizzConfig.noop.js
+++ b/packages/react-server/src/forks/ReactFizzConfig.noop.js
@@ -67,6 +67,10 @@ export const writeCompletedRoot = $$$config.writeCompletedRoot;
 export const writePlaceholder = $$$config.writePlaceholder;
 export const pushStartActivityBoundary = $$$config.pushStartActivityBoundary;
 export const pushEndActivityBoundary = $$$config.pushEndActivityBoundary;
+export const pushStartClientBoundary = $$$config.pushStartClientBoundary;
+export const pushEndClientBoundary = $$$config.pushEndClientBoundary;
+export const writeClientBoundaryScript = $$$config.writeClientBoundaryScript;
+export const writeConsolidatedHydrationScript = $$$config.writeConsolidatedHydrationScript;
 export const writeStartCompletedSuspenseBoundary =
   $$$config.writeStartCompletedSuspenseBoundary;
 export const writeStartPendingSuspenseBoundary =
diff --git a/packages/shared/ReactVersion.js b/packages/shared/ReactVersion.js
index bd5fa23ca26b..1b210aa8d464 100644
--- a/packages/shared/ReactVersion.js
+++ b/packages/shared/ReactVersion.js
@@ -1,15 +1 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// TODO: this is special because it gets imported during build.
-//
-// It exists as a placeholder so that DevTools can support work tag changes between releases.
-// When we next publish a release, update the matching TODO in backend/renderer.js
-// TODO: This module is used both by the release scripts and to expose a version
-// at runtime. We should instead inject the version number as part of the build
-// process, and use the ReactVersions.js module as the single source of truth.
-export default '19.3.0';
+export default '19.3.0-canary-aee714d2-20260325';
diff --git a/scripts/bench/fused-renderer-bench.js b/scripts/bench/fused-renderer-bench.js
new file mode 100644
index 000000000000..124b35d23be4
--- /dev/null
+++ b/scripts/bench/fused-renderer-bench.js
@@ -0,0 +1,385 @@
+'use strict';
+
+/**
+ * Fused Renderer Performance Validation Benchmark (v2 — realistic)
+ *
+ * Measures the Flight→Fizz pipeline overhead with realistic scenarios:
+ * async server components, Suspense boundaries, real prop sizes.
+ *
+ * Usage: NODE_ENV=production node --expose-gc scripts/bench/fused-renderer-bench.js
+ */
+
+const {performance} = require('perf_hooks');
+const path = require('path');
+const url = require('url');
+const Module = require('module');
+
+// ---------------------------------------------------------------------------
+// Setup: resolve built React packages
+// ---------------------------------------------------------------------------
+
+const BUILD_DIR = path.resolve(__dirname, '../../build/oss-experimental');
+
+const SERVER_REACT_PATH = path.join(
+  BUILD_DIR,
+  'react/cjs/react.react-server.production.js'
+);
+const CLIENT_REACT_PATH = path.join(BUILD_DIR, 'react/cjs/react.production.js');
+const REACT_DOM_PATH = path.join(
+  BUILD_DIR,
+  'react-dom/cjs/react-dom.production.js'
+);
+
+const originalResolve = Module._resolveFilename;
+let currentReactPath = SERVER_REACT_PATH;
+
+Module._resolveFilename = function (request, parent, isMain, options) {
+  if (request === 'react') return currentReactPath;
+  if (request === 'react-dom') return REACT_DOM_PATH;
+  return originalResolve.call(this, request, parent, isMain, options);
+};
+
+// ---------------------------------------------------------------------------
+// Webpack mock
+// ---------------------------------------------------------------------------
+
+let webpackModuleIdx = 0;
+const webpackClientModules = {};
+const webpackClientMap = {};
+const ssrModuleMap = {};
+
+global.__webpack_chunk_load__ = function (id) {
+  return Promise.resolve();
+};
+global.__webpack_require__ = function (id) {
+  return webpackClientModules[id];
+};
+global.__webpack_get_script_filename__ = function (id) {
+  return id;
+};
+
+function clientExports(moduleExports) {
+  const idx = '' + webpackModuleIdx++;
+  webpackClientModules[idx] = moduleExports;
+  const filepath = url.pathToFileURL(idx).href;
+  webpackClientMap[filepath] = {id: idx, chunks: [], name: '*'};
+  ssrModuleMap[idx] = {'*': {id: idx, chunks: [], name: '*'}};
+  const ref = Object.defineProperties(function () {}, {
+    $$typeof: {value: Symbol.for('react.client.reference')},
+    $$id: {value: filepath},
+    $$async: {value: false},
+  });
+  if (typeof moduleExports === 'function') {
+    Object.assign(ref, moduleExports);
+    ref.displayName = moduleExports.name;
+  } else if (typeof moduleExports === 'object') {
+    Object.assign(ref, moduleExports);
+  }
+  return ref;
+}
+
+// ---------------------------------------------------------------------------
+// Load React packages
+// ---------------------------------------------------------------------------
+
+currentReactPath = SERVER_REACT_PATH;
+const ServerReact = require(SERVER_REACT_PATH);
+const FlightServer = require(path.join(
+  BUILD_DIR,
+  'react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.js'
+));
+
+delete require.cache[SERVER_REACT_PATH];
+currentReactPath = CLIENT_REACT_PATH;
+const React = require(CLIENT_REACT_PATH);
+const ReactDOMServer = require(path.join(
+  BUILD_DIR,
+  'react-dom/cjs/react-dom-server.node.production.js'
+));
+const FlightClient = require(path.join(
+  BUILD_DIR,
+  'react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.js'
+));
+
+// ---------------------------------------------------------------------------
+// Pipeline runners (extracted to separate file)
+// ---------------------------------------------------------------------------
+
+const {createPipelineRunners} = require('./fused-renderer-pipelines');
+const {runFullPipeline, runIsolatedPhases} = createPipelineRunners({
+  FlightServer,
+  FlightClient,
+  ReactDOMServer,
+  React,
+  webpackClientMap,
+  ssrModuleMap,
+});
+
+// ---------------------------------------------------------------------------
+// Statistics helpers
+// ---------------------------------------------------------------------------
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return bytes + ' B';
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+  return (bytes / (1024 * 1024)).toFixed(2) + ' MB';
+}
+
+function formatMs(ms) {
+  return ms.toFixed(2) + 'ms';
+}
+
+function median(arr) {
+  const sorted = [...arr].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+
+function mean(arr) {
+  return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+
+function stdev(arr) {
+  if (arr.length < 2) return 0;
+  const m = mean(arr);
+  return Math.sqrt(
+    arr.reduce((acc, v) => acc + (v - m) ** 2, 0) / (arr.length - 1)
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Benchmark runner
+// ---------------------------------------------------------------------------
+
+const WARMUP_RUNS = 3;
+const MEASURED_RUNS = 15;
+
+async function benchmarkScenario(scenarioBuilder) {
+  const scenario = scenarioBuilder();
+
+  console.log(`\n${'='.repeat(72)}`);
+  console.log(`Scenario: ${scenario.name}`);
+  console.log(`Description: ${scenario.description}`);
+  console.log('='.repeat(72));
+
+  console.log(`  Warming up (${WARMUP_RUNS} runs)...`);
+  for (let i = 0; i < WARMUP_RUNS; i++) {
+    const s = scenarioBuilder();
+    await runFullPipeline(s);
+  }
+
+  console.log(`  Measuring full pipeline (${MEASURED_RUNS} runs)...`);
+  const fullResults = [];
+  for (let i = 0; i < MEASURED_RUNS; i++) {
+    const s = scenarioBuilder();
+    fullResults.push(await runFullPipeline(s));
+  }
+
+  console.log(`  Measuring isolated phases (${MEASURED_RUNS} runs)...`);
+  const isoResults = [];
+  for (let i = 0; i < MEASURED_RUNS; i++) {
+    const s = scenarioBuilder();
+    isoResults.push(await runIsolatedPhases(s));
+  }
+
+  // Aggregate
+  const field = (arr, key) => ({
+    median: median(arr.map(r => r[key])),
+    mean: mean(arr.map(r => r[key])),
+    stdev: stdev(arr.map(r => r[key])),
+  });
+
+  const full = {
+    flightSerialize: field(fullResults, 'flightSerializeMs'),
+    flightDeserialize: field(fullResults, 'flightDeserializeMs'),
+    fizzRender: field(fullResults, 'fizzRenderMs'),
+    total: field(fullResults, 'totalMs'),
+    totalTTFB: field(fullResults, 'totalTTFB'),
+    flightPayloadBytes: median(fullResults.map(r => r.flightPayloadBytes)),
+    htmlOutputBytes: median(fullResults.map(r => r.htmlOutputBytes)),
+    memDelta: median(fullResults.map(r => r.memDelta)),
+  };
+
+  const iso = {
+    flightTotal: field(isoResults, 'flightTotalMs'),
+    fizzOnly: field(isoResults, 'fizzOnlyMs'),
+  };
+
+  // Serialization overhead = total - (data fetch time) - (pure Fizz cost)
+  const serializationOverheadMs =
+    full.total.median - (iso.flightTotal.median + iso.fizzOnly.median);
+  const serializationOverheadPct =
+    (Math.max(0, serializationOverheadMs) / full.total.median) * 100;
+
+  // Print results
+  console.log('\n  --- Full Pipeline (median of %d runs) ---', MEASURED_RUNS);
+  console.log(
+    '  Flight serialize (incl data fetch): %s (±%s)',
+    formatMs(full.flightSerialize.median),
+    formatMs(full.flightSerialize.stdev)
+  );
+  console.log(
+    '  Flight deserialize:                 %s (±%s)',
+    formatMs(full.flightDeserialize.median),
+    formatMs(full.flightDeserialize.stdev)
+  );
+  console.log(
+    '  Fizz render (after deser):          %s (±%s)',
+    formatMs(full.fizzRender.median),
+    formatMs(full.fizzRender.stdev)
+  );
+  console.log(
+    '  End-to-end total:                   %s (±%s)',
+    formatMs(full.total.median),
+    formatMs(full.total.stdev)
+  );
+  console.log(
+    '  End-to-end TTFB:                    %s',
+    formatMs(full.totalTTFB.median)
+  );
+
+  console.log('\n  --- Isolated Phases ---');
+  console.log(
+    '  Flight total (data fetch + ser):    %s (±%s)',
+    formatMs(iso.flightTotal.median),
+    formatMs(iso.flightTotal.stdev)
+  );
+  console.log(
+    '  Fizz-only (pre-resolved, no fetch): %s (±%s)',
+    formatMs(iso.fizzOnly.median),
+    formatMs(iso.fizzOnly.stdev)
+  );
+
+  console.log('\n  --- Overhead That Fusion Eliminates ---');
+  console.log(
+    '  Serialization overhead:   %s (%s%% of total)',
+    formatMs(Math.max(0, serializationOverheadMs)),
+    Math.max(0, serializationOverheadPct).toFixed(1)
+  );
+  console.log(
+    '  Flight deserialize alone: %s',
+    formatMs(full.flightDeserialize.median)
+  );
+  console.log(
+    '  Formula: total(%s) - flightWithFetch(%s) - fizzOnly(%s)',
+    formatMs(full.total.median),
+    formatMs(iso.flightTotal.median),
+    formatMs(iso.fizzOnly.median)
+  );
+
+  console.log('\n  --- Payload Sizes ---');
+  console.log(
+    '  Flight wire format:    %s (eliminated by fusion)',
+    formatBytes(full.flightPayloadBytes)
+  );
+  console.log('  HTML output:           %s', formatBytes(full.htmlOutputBytes));
+
+  console.log('\n  --- Memory ---');
+  console.log(
+    '  Heap delta (median):   %s',
+    formatBytes(Math.abs(full.memDelta))
+  );
+
+  return {
+    scenario: scenario.name,
+    full,
+    iso,
+    serializationOverheadMs: Math.max(0, serializationOverheadMs),
+    serializationOverheadPct: Math.max(0, serializationOverheadPct),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  console.log(
+    '╔════════════════════════════════════════════════════════════════════════╗'
+  );
+  console.log(
+    '║  Fused Renderer Performance Validation (v2 — realistic scenarios)   ║'
+  );
+  console.log(
+    '║  Async server components · Suspense · Real prop sizes               ║'
+  );
+  console.log(
+    '╚════════════════════════════════════════════════════════════════════════╝'
+  );
+  console.log('');
+  console.log('Node.js:', process.version);
+  console.log('Warmup:', WARMUP_RUNS, '· Measured:', MEASURED_RUNS);
+  console.log(
+    'GC:',
+    typeof global.gc === 'function'
+      ? 'exposed'
+      : 'not exposed (use --expose-gc)'
+  );
+
+  const {createScenarios} = require('./fused-renderer-scenarios');
+  const scenarios = createScenarios(ServerReact, React, clientExports);
+  const allResults = [];
+
+  for (const builder of scenarios) {
+    try {
+      allResults.push(await benchmarkScenario(builder));
+    } catch (err) {
+      console.error(`  ERROR: ${err.message}\n${err.stack}`);
+    }
+  }
+
+  // Summary table
+  console.log('\n');
+  console.log(
+    '╔════════════════════════════════════════════════════════════════════════╗'
+  );
+  console.log(
+    '║                          SUMMARY TABLE                              ║'
+  );
+  console.log(
+    '╚════════════════════════════════════════════════════════════════════════╝'
+  );
+  console.log('');
+  console.log(
+    'Scenario        | Total     | Fetch+Ser  | Fizz Only | Ser Ovrhd  | Ovrhd %  | Wire      | HTML'
+  );
+  console.log(
+    '----------------|-----------|------------|-----------|------------|----------|-----------|----------'
+  );
+  for (const r of allResults) {
+    const name = r.scenario.padEnd(15);
+    const total = formatMs(r.full.total.median).padStart(9);
+    const fetchSer = formatMs(r.iso.flightTotal.median).padStart(10);
+    const fizzOnly = formatMs(r.iso.fizzOnly.median).padStart(9);
+    const overhead = formatMs(r.serializationOverheadMs).padStart(10);
+    const pct = (r.serializationOverheadPct.toFixed(1) + '%').padStart(8);
+    const wire = formatBytes(r.full.flightPayloadBytes).padStart(9);
+    const html = formatBytes(r.full.htmlOutputBytes).padStart(9);
+    console.log(
+      `${name} | ${total} | ${fetchSer} | ${fizzOnly} | ${overhead} | ${pct} | ${wire} | ${html}`
+    );
+  }
+  console.log('');
+  console.log('Total      = end-to-end (Flight serialize + deser + Fizz)');
+  console.log(
+    'Fetch+Ser  = Flight total (server component execution + serialization)'
+  );
+  console.log(
+    'Fizz Only  = Fizz rendering pre-resolved tree (no fetch, no Flight)'
+  );
+  console.log(
+    'Ser Ovrhd  = Total - Fetch+Ser - Fizz Only = pure serialization overhead'
+  );
+  console.log(
+    'Ovrhd %    = what fusion actually eliminates (data fetch time excluded)'
+  );
+
+  const jsonPath = path.join(__dirname, 'fused-renderer-bench-results.json');
+  require('fs').writeFileSync(jsonPath, JSON.stringify(allResults, null, 2));
+  console.log(`\nRaw results: ${jsonPath}`);
+}
+
+main().catch(err => {
+  console.error('Fatal:', err);
+  process.exit(1);
+});
diff --git a/scripts/bench/fused-renderer-concurrent.js b/scripts/bench/fused-renderer-concurrent.js
new file mode 100644
index 000000000000..9cf4dc5a982f
--- /dev/null
+++ b/scripts/bench/fused-renderer-concurrent.js
@@ -0,0 +1,463 @@
+'use strict';
+
+/**
+ * Concurrent throughput benchmark for the fused renderer analysis.
+ *
+ * Measures what happens to a real single-threaded Node.js server under load:
+ * - Throughput (req/s) at varying concurrency levels
+ * - Latency percentiles (p50, p95, p99)
+ * - Heap pressure from intermediate Flight wire format buffers
+ *
+ * This is the benchmark that matters for the go/no-go decision.
+ * Wall-clock time per request is misleading — CPU contention under
+ * concurrent load is what kills real servers.
+ *
+ * Usage: NODE_ENV=production node --expose-gc scripts/bench/fused-renderer-concurrent.js
+ */
+
+const {performance} = require('perf_hooks');
+const {PassThrough, Readable} = require('stream');
+const path = require('path');
+const url = require('url');
+const Module = require('module');
+
+// ---------------------------------------------------------------------------
+// React package setup (same as fused-renderer-bench.js)
+// ---------------------------------------------------------------------------
+
+const BUILD_DIR = path.resolve(__dirname, '../../build/oss-experimental');
+const SERVER_REACT_PATH = path.join(
+  BUILD_DIR,
+  'react/cjs/react.react-server.production.js'
+);
+const CLIENT_REACT_PATH = path.join(BUILD_DIR, 'react/cjs/react.production.js');
+const REACT_DOM_PATH = path.join(
+  BUILD_DIR,
+  'react-dom/cjs/react-dom.production.js'
+);
+
+const origResolve = Module._resolveFilename;
+let curReact = SERVER_REACT_PATH;
+Module._resolveFilename = function (req, p, m, o) {
+  if (req === 'react') return curReact;
+  if (req === 'react-dom') return REACT_DOM_PATH;
+  return origResolve.call(this, req, p, m, o);
+};
+
+let modIdx = 0;
+const clientMods = {};
+const clientMap = {};
+const ssrMap = {};
+global.__webpack_chunk_load__ = function (id) {
+  return Promise.resolve();
+};
+global.__webpack_require__ = function (id) {
+  return clientMods[id];
+};
+global.__webpack_get_script_filename__ = function (id) {
+  return id;
+};
+
+function clientExports(mod) {
+  const idx = '' + modIdx++;
+  clientMods[idx] = mod;
+  const fp = url.pathToFileURL(idx).href;
+  clientMap[fp] = {id: idx, chunks: [], name: '*'};
+  ssrMap[idx] = {'*': {id: idx, chunks: [], name: '*'}};
+  const ref = Object.defineProperties(function () {}, {
+    $$typeof: {value: Symbol.for('react.client.reference')},
+    $$id: {value: fp},
+    $$async: {value: false},
+  });
+  if (typeof mod === 'function') Object.assign(ref, mod);
+  return ref;
+}
+
+curReact = SERVER_REACT_PATH;
+const SReact = require(SERVER_REACT_PATH);
+const FlightSrv = require(path.join(
+  BUILD_DIR,
+  'react-server-dom-webpack/cjs/react-server-dom-webpack-server.node.production.js'
+));
+delete require.cache[SERVER_REACT_PATH];
+curReact = CLIENT_REACT_PATH;
+const React = require(CLIENT_REACT_PATH);
+const RDOM = require(path.join(
+  BUILD_DIR,
+  'react-dom/cjs/react-dom-server.node.production.js'
+));
+const FlightCli = require(path.join(
+  BUILD_DIR,
+  'react-server-dom-webpack/cjs/react-server-dom-webpack-client.node.production.js'
+));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function collect(s) {
+  return new Promise((res, rej) => {
+    const c = [];
+    s.on('data', d => c.push(d));
+    s.on('end', () => res(Buffer.concat(c)));
+    s.on('error', rej);
+  });
+}
+
+function percentile(arr, p) {
+  const s = [...arr].sort((a, b) => a - b);
+  return s[Math.floor((s.length * p) / 100)];
+}
+
+// ---------------------------------------------------------------------------
+// Test app: 226-product e-commerce PLP (sync, CPU-bound)
+// ---------------------------------------------------------------------------
+
+const {generateProduct} = require('./fused-renderer-data');
+const products = Array.from({length: 226}, (_, i) => generateProduct(i));
+
+const ClientCard = clientExports(function ClientCard({product}) {
+  const e = React.createElement;
+  return e(
+    'div',
+    {className: 'card', 'data-id': product.id},
+    e('img', {src: product.images[0].url, alt: product.images[0].alt}),
+    e('h3', null, product.name),
+    e('p', null, product.description.slice(0, 150)),
+    e(
+      'div',
+      {className: 'price'},
+      e('span', null, product.price.formatted),
+      e('s', null, '$' + product.price.compareAt)
+    ),
+    e('div', {className: 'rating'}, '★★★★ (' + product.rating.count + ')'),
+    e(
+      'div',
+      {className: 'actions'},
+      e('button', null, 'Add to Cart'),
+      e('button', null, '♡')
+    )
+  );
+});
+
+// For fused mode, pass the same client manifest that Flight uses (clientMap).
+// This maps $$id → {id, chunks, name}. Fizz uses it to resolve client
+// references via __webpack_require__, same as the Flight client does.
+const fusedBundlerConfig = clientMap;
+
+function ServerApp() {
+  const e = SReact.createElement;
+  return e(
+    'div',
+    {id: 'app'},
+    e(
+      'header',
+      null,
+      e('h1', null, 'Store'),
+      e(
+        'nav',
+        null,
+        ...['Home', 'Products', 'About', 'Contact', 'Help'].map(x =>
+          e('a', {key: x, href: '#'}, x)
+        )
+      )
+    ),
+    e(
+      'main',
+      null,
+      e('h2', null, '226 Products'),
+      ...products.map((p, i) => e(ClientCard, {key: i, product: p}))
+    ),
+    e(
+      'footer',
+      null,
+      ...['About', 'Privacy', 'Terms', 'Help', 'Careers'].map(x =>
+        e('a', {key: x, href: '#'}, x)
+      )
+    )
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Request handlers
+// ---------------------------------------------------------------------------
+
+// Pre-resolved tree for Fizz-only tests
+let preResolved = null;
+
+async function initPreResolved() {
+  const fs = new PassThrough();
+  FlightSrv.renderToPipeableStream(
+    SReact.createElement(ServerApp),
+    clientMap
+  ).pipe(fs);
+  const fb = await collect(fs);
+  const fr = new Readable({
+    read() {
+      this.push(fb);
+      this.push(null);
+    },
+  });
+  preResolved = FlightCli.createFromNodeStream(fr, {
+    moduleMap: ssrMap,
+    moduleLoading: {prefix: '/'},
+    serverModuleMap: null,
+  });
+  await preResolved;
+}
+
+async function doFizzOnly() {
+  const start = performance.now();
+  function Root() {
+    return React.use(preResolved);
+  }
+  const hs = new PassThrough();
+  const hc = collect(hs);
+  await new Promise((res, rej) => {
+    const p = RDOM.renderToPipeableStream(React.createElement(Root), {
+      onShellReady() {
+        p.pipe(hs);
+      },
+      onAllReady() {
+        res();
+      },
+      onShellError: rej,
+      onError() {},
+    });
+  });
+  hs.end();
+  await hc;
+  return performance.now() - start;
+}
+
+async function doFullPipeline() {
+  const start = performance.now();
+  const fs = new PassThrough();
+  FlightSrv.renderToPipeableStream(
+    SReact.createElement(ServerApp),
+    clientMap
+  ).pipe(fs);
+  const fb = await collect(fs);
+  const fr = new Readable({
+    read() {
+      this.push(fb);
+      this.push(null);
+    },
+  });
+  const resp = FlightCli.createFromNodeStream(fr, {
+    moduleMap: ssrMap,
+    moduleLoading: {prefix: '/'},
+    serverModuleMap: null,
+  });
+  await resp;
+  function Root() {
+    return React.use(resp);
+  }
+  const hs = new PassThrough();
+  const hc = collect(hs);
+  await new Promise((res, rej) => {
+    const p = RDOM.renderToPipeableStream(React.createElement(Root), {
+      onShellReady() {
+        p.pipe(hs);
+      },
+      onAllReady() {
+        res();
+      },
+      onShellError: rej,
+      onError() {},
+    });
+  });
+  hs.end();
+  await hc;
+  // In a real initial SSR (Next.js), the Flight payload is inlined
+  // as <script> tags in the HTML so the client can hydrate. We simulate this
+  // serialization cost — the server must JSON.stringify the Flight payload
+  // and write it to the response. This makes the comparison fair: both paths
+  // include the cost of delivering hydration data to the client.
+  const inlinedPayload =
+    '<script>self.__next_f=self.__next_f||[];self.__next_f.push(' +
+    JSON.stringify(fb.toString()) +
+    ')</script>';
+  // Force the string to be materialized (not optimized away)
+  if (inlinedPayload.length < 0) throw new Error();
+  return performance.now() - start;
+}
+
+async function doFusedMode() {
+  const start = performance.now();
+  // In fused mode, the tree goes directly to Fizz with server component
+  // functions and client reference proxies still present. No Flight at all.
+  // Fizz calls server component functions inline and wraps client refs
+  // in <!--C:ID--> markers with hydration data scripts.
+  const hs = new PassThrough();
+  const hc = collect(hs);
+  await new Promise((res, rej) => {
+    const p = RDOM.renderToPipeableStream(SReact.createElement(ServerApp), {
+      experimental_fusedMode: true,
+      experimental_bundlerConfig: fusedBundlerConfig,
+      onShellReady() {
+        p.pipe(hs);
+      },
+      onAllReady() {
+        res();
+      },
+      onShellError: rej,
+      onError() {},
+    });
+  });
+  hs.end();
+  await hc;
+  return performance.now() - start;
+}
+
+// ---------------------------------------------------------------------------
+// Concurrent runner
+// ---------------------------------------------------------------------------
+
+async function runConcurrent(fn, concurrency, totalRequests) {
+  const latencies = [];
+  let completed = 0;
+  let inFlight = 0;
+
+  const batchStart = performance.now();
+
+  if (global.gc) global.gc();
+  const memBefore = process.memoryUsage();
+  let peakHeap = memBefore.heapUsed;
+
+  await new Promise(resolve => {
+    function launch() {
+      while (inFlight < concurrency && completed + inFlight < totalRequests) {
+        inFlight++;
+        fn().then(latency => {
+          latencies.push(latency);
+          inFlight--;
+          completed++;
+          const mem = process.memoryUsage();
+          if (mem.heapUsed > peakHeap) peakHeap = mem.heapUsed;
+          if (completed >= totalRequests) resolve();
+          else launch();
+        });
+      }
+    }
+    launch();
+  });
+
+  const batchMs = performance.now() - batchStart;
+
+  if (global.gc) global.gc();
+
+  return {
+    throughput: Math.round((totalRequests / batchMs) * 1000),
+    p50: percentile(latencies, 50),
+    p95: percentile(latencies, 95),
+    p99: percentile(latencies, 99),
+    peakHeapDeltaMB: (peakHeap - memBefore.heapUsed) / 1024 / 1024,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+const TOTAL_REQUESTS = 200;
+const CONCURRENCIES = [1, 5, 10, 25, 50];
+
+function fmtRow(r) {
+  return [
+    String(r.throughput).padStart(6),
+    (r.p50.toFixed(1) + 'ms').padStart(8),
+    (r.p95.toFixed(1) + 'ms').padStart(8),
+    (r.p99.toFixed(1) + 'ms').padStart(8),
+    (r.peakHeapDeltaMB.toFixed(0) + 'MB').padStart(6),
+  ].join(' | ');
+}
+
+async function main() {
+  console.log('Concurrent Throughput Benchmark: 226-product PLP');
+  console.log('Single Node.js thread, no I/O waits, pure CPU contention');
+  console.log(
+    'GC:',
+    typeof global.gc === 'function' ? 'exposed' : 'NOT exposed'
+  );
+  console.log('');
+
+  await initPreResolved();
+
+  // Warmup
+  for (let i = 0; i < 15; i++) await doFullPipeline();
+  for (let i = 0; i < 15; i++) await doFizzOnly();
+  for (let i = 0; i < 15; i++) await doFusedMode();
+
+  const fizzResults = [];
+  const fullResults = [];
+  const fusedResults = [];
+
+  console.log('--- Fizz Only (theoretical ceiling) ---');
+  console.log('    c | req/s  |      p50 |      p95 |      p99 |  Heap');
+  console.log('  ----|--------|----------|----------|----------|------');
+  for (const c of CONCURRENCIES) {
+    const r = await runConcurrent(doFizzOnly, c, TOTAL_REQUESTS);
+    fizzResults.push({c, ...r});
+    console.log('  %s | %s', String(c).padStart(3), fmtRow(r));
+  }
+
+  console.log('');
+  console.log('--- Full Flight→Fizz Pipeline (baseline) ---');
+  console.log('    c | req/s  |      p50 |      p95 |      p99 |  Heap');
+  console.log('  ----|--------|----------|----------|----------|------');
+  for (const c of CONCURRENCIES) {
+    const r = await runConcurrent(doFullPipeline, c, TOTAL_REQUESTS);
+    fullResults.push({c, ...r});
+    console.log('  %s | %s', String(c).padStart(3), fmtRow(r));
+  }
+
+  console.log('');
+  console.log('--- Fused Renderer (our implementation) ---');
+  console.log('    c | req/s  |      p50 |      p95 |      p99 |  Heap');
+  console.log('  ----|--------|----------|----------|----------|------');
+  for (const c of CONCURRENCIES) {
+    const r = await runConcurrent(doFusedMode, c, TOTAL_REQUESTS);
+    fusedResults.push({c, ...r});
+    console.log('  %s | %s', String(c).padStart(3), fmtRow(r));
+  }
+
+  console.log('');
+  console.log('--- Comparison ---');
+  console.log(
+    '    c | Fizz req/s | Full req/s | Fused req/s | Full→Fused | Fused vs Ceiling'
+  );
+  console.log(
+    '  ----|------------|------------|-------------|------------|----------------'
+  );
+  for (let i = 0; i < CONCURRENCIES.length; i++) {
+    const f = fizzResults[i];
+    const p = fullResults[i];
+    const u = fusedResults[i];
+    console.log(
+      '  %s | %s | %s | %s |     %sx |     %s%%',
+      String(CONCURRENCIES[i]).padStart(3),
+      String(f.throughput).padStart(10),
+      String(p.throughput).padStart(10),
+      String(u.throughput).padStart(11),
+      (u.throughput / p.throughput).toFixed(1).padStart(5),
+      ((u.throughput / f.throughput) * 100).toFixed(0).padStart(5)
+    );
+  }
+
+  // JSON output
+  const jsonPath = path.join(
+    __dirname,
+    'fused-renderer-concurrent-results.json'
+  );
+  require('fs').writeFileSync(
+    jsonPath,
+    JSON.stringify({fizzResults, fullResults, fusedResults}, null, 2)
+  );
+  console.log('\nRaw results:', jsonPath);
+}
+
+main().catch(err => {
+  console.error('Fatal:', err);
+  process.exit(1);
+});
diff --git a/scripts/bench/fused-renderer-data.js b/scripts/bench/fused-renderer-data.js
new file mode 100644
index 000000000000..f7317297ff22
--- /dev/null
+++ b/scripts/bench/fused-renderer-data.js
@@ -0,0 +1,134 @@
+'use strict';
+
+/**
+ * Realistic data generators for fused renderer benchmark scenarios.
+ * Generates blog posts (~5-10KB each), products (~2-4KB each), and user objects.
+ */
+
+function generateBlogPost(id) {
+  const paragraphs = Array.from(
+    {length: 5 + (id % 4)},
+    (_, i) =>
+      `Paragraph ${i + 1} of post ${id}. ` +
+      'Lorem ipsum dolor sit amet, consectetur adipiscing elit. '.repeat(
+        3 + (i % 3)
+      ) +
+      'Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ' +
+      'Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. '
+  );
+  return {
+    id,
+    title: `Understanding Advanced React Patterns Part ${id}: Server Components and Beyond`,
+    slug: `understanding-advanced-react-patterns-part-${id}`,
+    excerpt:
+      'A deep dive into modern React architecture patterns including server components, streaming SSR, and selective hydration.',
+    content: paragraphs.join('\n\n'),
+    publishedAt: new Date(2026, 0, id).toISOString(),
+    updatedAt: new Date(2026, 2, id).toISOString(),
+    readingTime: 5 + (id % 10),
+    tags: ['react', 'server-components', 'performance', 'architecture'].slice(
+      0,
+      2 + (id % 3)
+    ),
+    category: {
+      id: id % 5,
+      name: ['Engineering', 'Design', 'Product', 'DevOps', 'Security'][id % 5],
+      slug: ['engineering', 'design', 'product', 'devops', 'security'][id % 5],
+    },
+    author: {
+      id: id % 20,
+      name: `Author ${id % 20}`,
+      avatar: `/avatars/author-${id % 20}.jpg`,
+      bio: 'Senior engineer specializing in React performance optimization and server-side rendering architectures.',
+      social: {twitter: `@author${id % 20}`, github: `author${id % 20}`},
+    },
+    coverImage: {
+      url: `/images/post-${id}-cover.jpg`,
+      alt: `Cover image for post ${id}`,
+      width: 1200,
+      height: 630,
+    },
+    seo: {
+      metaTitle: `Advanced React Patterns Part ${id} | Engineering Blog`,
+      metaDescription:
+        'Learn about server components, streaming SSR, and more.',
+      ogImage: `/og/post-${id}.png`,
+      canonicalUrl: `https://blog.example.com/posts/part-${id}`,
+    },
+  };
+}
+
+function generateProduct(id) {
+  return {
+    id,
+    name: `Premium Widget ${id} — Professional Grade`,
+    slug: `premium-widget-${id}`,
+    description:
+      'High-quality professional grade widget with advanced features. '.repeat(
+        3
+      ) + 'Built with precision engineering and tested for durability.',
+    price: {
+      amount: (19.99 + id * 10.5).toFixed(2),
+      currency: 'USD',
+      formatted: `$${(19.99 + id * 10.5).toFixed(2)}`,
+      compareAt: (29.99 + id * 10.5).toFixed(2),
+    },
+    rating: {
+      average: (3.5 + (id % 15) / 10).toFixed(1),
+      count: 50 + id * 3,
+      distribution: {5: 40, 4: 25, 3: 15, 2: 10, 1: 10},
+    },
+    inventory: {
+      inStock: id % 7 !== 0,
+      quantity: id % 7 === 0 ? 0 : 10 + (id % 100),
+      warehouse: ['US-East', 'US-West', 'EU-Central'][id % 3],
+    },
+    images: Array.from({length: 3}, (_, i) => ({
+      url: `/products/${id}/image-${i}.jpg`,
+      alt: `Product ${id} view ${i + 1}`,
+      width: 800,
+      height: 800,
+    })),
+    categories: [
+      {id: id % 10, name: `Category ${id % 10}`},
+      {id: 10 + (id % 5), name: `Subcategory ${id % 5}`},
+    ],
+    seller: {
+      id: id % 30,
+      name: `Verified Seller ${id % 30}`,
+      rating: (4.0 + (id % 10) / 10).toFixed(1),
+      verified: id % 3 !== 0,
+      responseTime: '< 24 hours',
+    },
+    shipping: {
+      free: id % 4 === 0,
+      estimatedDays: 3 + (id % 5),
+      methods: ['Standard', 'Express', 'Overnight'].slice(0, 1 + (id % 3)),
+    },
+    attributes: Object.fromEntries(
+      ['Color', 'Size', 'Material', 'Weight', 'Warranty'].map((attr, i) => [
+        attr,
+        `${attr} Value ${id % (i + 3)}`,
+      ])
+    ),
+  };
+}
+
+function generateUser() {
+  return {
+    id: 42,
+    name: 'Jane Developer',
+    email: 'jane@example.com',
+    avatar: '/avatars/jane.jpg',
+    role: 'admin',
+    preferences: {
+      theme: 'dark',
+      locale: 'en-US',
+      timezone: 'America/New_York',
+      notifications: {email: true, push: false, sms: false},
+    },
+    subscription: {plan: 'pro', expiresAt: '2027-01-01T00:00:00Z'},
+  };
+}
+
+module.exports = {generateBlogPost, generateProduct, generateUser};
diff --git a/scripts/bench/fused-renderer-pipelines.js b/scripts/bench/fused-renderer-pipelines.js
new file mode 100644
index 000000000000..421d190c5b2c
--- /dev/null
+++ b/scripts/bench/fused-renderer-pipelines.js
@@ -0,0 +1,225 @@
+'use strict';
+
+/**
+ * Pipeline runners for the fused renderer benchmark.
+ * Extracted from fused-renderer-bench.js to keep files under 500 lines.
+ */
+
+const {performance} = require('perf_hooks');
+const {PassThrough, Readable} = require('stream');
+
+function collectStream(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on('data', chunk => chunks.push(chunk));
+    stream.on('end', () => resolve(Buffer.concat(chunks)));
+    stream.on('error', reject);
+  });
+}
+
+function collectStreamWithTTFB(stream, startTime) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let ttfb = null;
+    stream.on('data', chunk => {
+      if (ttfb === null) ttfb = performance.now() - startTime;
+      chunks.push(chunk);
+    });
+    stream.on('end', () =>
+      resolve({
+        buffer: Buffer.concat(chunks),
+        ttfb: ttfb || 0,
+        totalMs: performance.now() - startTime,
+      })
+    );
+    stream.on('error', reject);
+  });
+}
+
+/**
+ * Creates pipeline runner functions bound to the given React packages and
+ * webpack maps. Returns {runFullPipeline, runIsolatedPhases}.
+ */
+function createPipelineRunners({
+  FlightServer,
+  FlightClient,
+  ReactDOMServer,
+  React,
+  webpackClientMap,
+  ssrModuleMap,
+}) {
+  /**
+   * Full three-pass pipeline: Flight serialize → Flight deserialize → Fizz render.
+   * Measures TTFB for both Flight and Fizz streams.
+   */
+  async function runFullPipeline(scenario) {
+    const result = {
+      flightSerializeMs: 0,
+      flightTTFB: 0,
+      flightDeserializeMs: 0,
+      fizzRenderMs: 0,
+      fizzTTFB: 0,
+      totalMs: 0,
+      totalTTFB: 0,
+      flightPayloadBytes: 0,
+      htmlOutputBytes: 0,
+      memBefore: 0,
+      memAfter: 0,
+      memDelta: 0,
+    };
+
+    if (global.gc) global.gc();
+    result.memBefore = process.memoryUsage().heapUsed;
+    const totalStart = performance.now();
+
+    // Phase 1: Flight serialization (async — includes data fetches)
+    const flightStart = performance.now();
+    const flightStream = new PassThrough();
+    const flightPipeable = FlightServer.renderToPipeableStream(
+      scenario.tree,
+      webpackClientMap
+    );
+    const flightCollect = collectStreamWithTTFB(flightStream, flightStart);
+    flightPipeable.pipe(flightStream);
+    const flightResult = await flightCollect;
+    result.flightSerializeMs = flightResult.totalMs;
+    result.flightTTFB = flightResult.ttfb;
+    result.flightPayloadBytes = flightResult.buffer.length;
+
+    // Phase 2: Flight deserialization
+    const deserStart = performance.now();
+    const flightReadable = new Readable({
+      read() {
+        this.push(flightResult.buffer);
+        this.push(null);
+      },
+    });
+    const ssrManifest = {
+      moduleMap: ssrModuleMap,
+      moduleLoading: {prefix: '/'},
+      serverModuleMap: null,
+    };
+    const flightResponse = FlightClient.createFromNodeStream(
+      flightReadable,
+      ssrManifest
+    );
+    await flightResponse;
+    result.flightDeserializeMs = performance.now() - deserStart;
+
+    // Phase 3: Fizz HTML rendering
+    const fizzStart = performance.now();
+    function ClientRoot() {
+      return React.use(flightResponse);
+    }
+    const htmlStream = new PassThrough();
+    const htmlCollect = collectStreamWithTTFB(htmlStream, fizzStart);
+    await new Promise((resolve, reject) => {
+      const pipeable = ReactDOMServer.renderToPipeableStream(
+        React.createElement(ClientRoot),
+        {
+          onShellReady() {
+            pipeable.pipe(htmlStream);
+          },
+          onAllReady() {
+            resolve();
+          },
+          onShellError: reject,
+          onError() {},
+        }
+      );
+    });
+    htmlStream.end();
+    const htmlResult = await htmlCollect;
+    result.fizzRenderMs = htmlResult.totalMs;
+    result.fizzTTFB = htmlResult.ttfb;
+    result.htmlOutputBytes = htmlResult.buffer.length;
+
+    result.totalMs = performance.now() - totalStart;
+    result.totalTTFB =
+      result.flightSerializeMs + result.flightDeserializeMs + result.fizzTTFB;
+
+    if (global.gc) global.gc();
+    result.memAfter = process.memoryUsage().heapUsed;
+    result.memDelta = result.memAfter - result.memBefore;
+    return result;
+  }
+
+  /**
+   * Isolated phase measurement: Flight+fetch separate from Fizz-only.
+   * Used to compute the pure serialization overhead.
+   */
+  async function runIsolatedPhases(scenario) {
+    const result = {
+      flightTotalMs: 0,
+      flightPayloadBytes: 0,
+      fizzOnlyMs: 0,
+      fizzOnlyTTFB: 0,
+      htmlOutputBytes: 0,
+    };
+
+    // Phase A: Flight resolves everything (includes data fetching)
+    const flightStart = performance.now();
+    const flightStream = new PassThrough();
+    const flightPipeable = FlightServer.renderToPipeableStream(
+      scenario.tree,
+      webpackClientMap
+    );
+    const flightCollect = collectStream(flightStream);
+    flightPipeable.pipe(flightStream);
+    const flightBuffer = await flightCollect;
+    result.flightTotalMs = performance.now() - flightStart;
+    result.flightPayloadBytes = flightBuffer.length;
+
+    // Deserialize (off the clock — fusion wouldn't need this)
+    const flightReadable = new Readable({
+      read() {
+        this.push(flightBuffer);
+        this.push(null);
+      },
+    });
+    const ssrManifest = {
+      moduleMap: ssrModuleMap,
+      moduleLoading: {prefix: '/'},
+      serverModuleMap: null,
+    };
+    const flightResponse = FlightClient.createFromNodeStream(
+      flightReadable,
+      ssrManifest
+    );
+    await flightResponse;
+
+    // Phase B: Fizz rendering of pre-resolved tree (no data fetch)
+    function ClientRoot() {
+      return React.use(flightResponse);
+    }
+    const fizzStart = performance.now();
+    const htmlStream = new PassThrough();
+    const htmlCollect = collectStreamWithTTFB(htmlStream, fizzStart);
+    await new Promise((resolve, reject) => {
+      const pipeable = ReactDOMServer.renderToPipeableStream(
+        React.createElement(ClientRoot),
+        {
+          onShellReady() {
+            pipeable.pipe(htmlStream);
+          },
+          onAllReady() {
+            resolve();
+          },
+          onShellError: reject,
+          onError() {},
+        }
+      );
+    });
+    htmlStream.end();
+    const htmlResult = await htmlCollect;
+    result.fizzOnlyMs = htmlResult.totalMs;
+    result.fizzOnlyTTFB = htmlResult.ttfb;
+    result.htmlOutputBytes = htmlResult.buffer.length;
+
+    return result;
+  }
+
+  return {runFullPipeline, runIsolatedPhases};
+}
+
+module.exports = {createPipelineRunners};
diff --git a/scripts/bench/fused-renderer-scenarios.js b/scripts/bench/fused-renderer-scenarios.js
new file mode 100644
index 000000000000..0b561e49eb9e
--- /dev/null
+++ b/scripts/bench/fused-renderer-scenarios.js
@@ -0,0 +1,730 @@
+'use strict';
+
+/**
+ * Realistic test scenarios for the fused renderer benchmark.
+ *
+ * Each scenario simulates a real app page with:
+ * - Async server components (simulated DB/cache fetches)
+ * - Realistic prop sizes (blog posts, product listings, user objects)
+ * - Suspense boundaries for streaming
+ * - Mixed server/client component boundaries
+ */
+
+const {
+  generateBlogPost,
+  generateProduct,
+  generateUser,
+} = require('./fused-renderer-data');
+
+// ---------------------------------------------------------------------------
+// Async delay — simulates cache/DB lookup latency
+// ---------------------------------------------------------------------------
+
+function simulateDbFetch(ms) {
+  // Simulates a cache hit or DB query. Even fast cache lookups have
+  // real latency from async scheduling, promise resolution, and
+  // microtask queue processing.
+  return new Promise(resolve => {
+    if (ms <= 0) {
+      // Minimum: still async — goes through microtask queue
+      Promise.resolve().then(resolve);
+    } else {
+      setTimeout(resolve, ms);
+    }
+  });
+}
+
+// Fetch delay presets (milliseconds) — these simulate real-world latencies.
+// Even with Redis/Memcached, reads are 0.5-2ms. DB queries are 2-20ms.
+// External API calls are 10-100ms.
+const FETCH_DELAYS = {
+  cacheHit: 1, // fast in-memory cache (Redis)
+  dbQuery: 5, // simple indexed DB query
+  dbQuerySlow: 12, // complex join or unindexed query
+  apiCall: 20, // internal microservice call
+};
+
+// ---------------------------------------------------------------------------
+// Scenario factory
+// ---------------------------------------------------------------------------
+
+function createScenarios(ServerReact, React, clientExports) {
+  const se = ServerReact.createElement;
+  const ce = React.createElement;
+  const Suspense = ServerReact.Suspense;
+
+  function createClientComponent(name, renderFn) {
+    return clientExports(renderFn);
+  }
+
+  // Context creation uses React (client) since ServerReact doesn't export
+  // createContext. In the actual pipeline, Flight serializes context values
+  // and Fizz renders them — the context objects work across both.
+  // For benchmarking purposes, we simulate context propagation by passing
+  // config objects through the tree as props (same serialization cost).
+  const appConfig = {
+    theme: 'dark',
+    locale: 'en-US',
+    featureFlags: {newCheckout: true, darkMode: true, beta: false},
+  };
+
+  // ---------------------------------------------------------------------------
+  // Shared client components (used across scenarios)
+  // ---------------------------------------------------------------------------
+
+  const ClientInteractiveCard = createClientComponent(
+    'ClientInteractiveCard',
+    function ClientInteractiveCard({product}) {
+      return ce(
+        'div',
+        {className: 'product-card', 'data-id': product.id},
+        ce('img', {src: product.images[0].url, alt: product.images[0].alt}),
+        ce('h3', null, product.name),
+        ce('p', {className: 'description'}, product.description.slice(0, 100)),
+        ce(
+          'div',
+          {className: 'price'},
+          ce('span', {className: 'current'}, product.price.formatted),
+          product.price.compareAt
+            ? ce('span', {className: 'compare'}, '$' + product.price.compareAt)
+            : null
+        ),
+        ce(
+          'div',
+          {className: 'rating'},
+          '★'.repeat(Math.round(parseFloat(product.rating.average))),
+          ce('span', null, ` (${product.rating.count} reviews)`)
+        ),
+        ce(
+          'div',
+          {className: 'actions'},
+          ce('button', {className: 'add-to-cart'}, 'Add to Cart'),
+          ce('button', {className: 'wishlist'}, '♡')
+        )
+      );
+    }
+  );
+
+  const ClientCommentForm = createClientComponent(
+    'ClientCommentForm',
+    function ClientCommentForm({postId, user}) {
+      return ce(
+        'form',
+        {className: 'comment-form'},
+        ce('textarea', {placeholder: 'Write a comment...', rows: 4}),
+        ce(
+          'div',
+          {className: 'form-footer'},
+          ce('span', null, `Commenting as ${user ? user.name : 'Guest'}`),
+          ce('button', {type: 'submit'}, 'Post Comment')
+        )
+      );
+    }
+  );
+
+  const ClientSearchFilters = createClientComponent(
+    'ClientSearchFilters',
+    function ClientSearchFilters({categories, priceRange, activeFilters}) {
+      return ce(
+        'aside',
+        {className: 'filters'},
+        ce('h3', null, 'Filters'),
+        ce(
+          'div',
+          {className: 'filter-group'},
+          ce('h4', null, 'Categories'),
+          categories.map((cat, i) =>
+            ce(
+              'label',
+              {key: i, className: 'filter-option'},
+              ce('input', {
+                type: 'checkbox',
+                checked: activeFilters.includes(cat.name),
+              }),
+              cat.name
+            )
+          )
+        ),
+        ce(
+          'div',
+          {className: 'filter-group'},
+          ce('h4', null, 'Price Range'),
+          ce('input', {
+            type: 'range',
+            min: priceRange.min,
+            max: priceRange.max,
+          })
+        )
+      );
+    }
+  );
+
+  const ClientNavbar = createClientComponent(
+    'ClientNavbar',
+    function ClientNavbar({user, cartCount, categories}) {
+      return ce(
+        'nav',
+        {className: 'navbar'},
+        ce('a', {href: '/', className: 'logo'}, 'StoreName'),
+        ce(
+          'div',
+          {className: 'nav-links'},
+          categories
+            .slice(0, 5)
+            .map((cat, i) =>
+              ce('a', {key: i, href: `/category/${cat.slug}`}, cat.name)
+            )
+        ),
+        ce(
+          'div',
+          {className: 'nav-actions'},
+          ce('input', {type: 'search', placeholder: 'Search...'}),
+          ce('a', {href: '/cart'}, `Cart (${cartCount})`),
+          user
+            ? ce('span', null, user.name)
+            : ce('a', {href: '/login'}, 'Sign In')
+        )
+      );
+    }
+  );
+
+  // ---------------------------------------------------------------------------
+  // Scenario: Blog page (content-heavy, async data, comments)
+  // ---------------------------------------------------------------------------
+
+  function buildBlogScenario() {
+    const posts = Array.from({length: 10}, (_, i) => generateBlogPost(i));
+    const user = generateUser();
+
+    // Async server components that simulate DB fetches
+    const ServerBlogPost = function ServerBlogPost({postId, fetchDelay}) {
+      return simulateDbFetch(fetchDelay).then(() => {
+        const post = posts[postId % posts.length];
+        return se(
+          'article',
+          {className: 'blog-post'},
+          se('h1', null, post.title),
+          se(
+            'div',
+            {className: 'meta'},
+            se('span', null, `By ${post.author.name}`),
+            se('span', null, ` · ${post.readingTime} min read`),
+            se('time', null, post.publishedAt)
+          ),
+          se('img', {src: post.coverImage.url, alt: post.coverImage.alt}),
+          se('div', {className: 'content'}, post.content),
+          se(
+            'div',
+            {className: 'tags'},
+            post.tags.map((tag, i) =>
+              se('a', {key: i, href: `/tag/${tag}`}, '#' + tag)
+            )
+          )
+        );
+      });
+    };
+
+    const ServerRelatedPosts = function ServerRelatedPosts({fetchDelay}) {
+      return simulateDbFetch(fetchDelay).then(() =>
+        se(
+          'section',
+          {className: 'related'},
+          se('h2', null, 'Related Posts'),
+          se(
+            'div',
+            {className: 'related-grid'},
+            posts.slice(3, 7).map((post, i) =>
+              se(
+                'a',
+                {
+                  key: i,
+                  href: `/posts/${post.slug}`,
+                  className: 'related-card',
+                },
+                se('img', {
+                  src: post.coverImage.url,
+                  alt: post.coverImage.alt,
+                }),
+                se('h3', null, post.title),
+                se('p', null, post.excerpt)
+              )
+            )
+          )
+        )
+      );
+    };
+
+    const ServerComments = function ServerComments({postId, fetchDelay}) {
+      return simulateDbFetch(fetchDelay).then(() =>
+        se(
+          'section',
+          {className: 'comments'},
+          se('h2', null, '24 Comments'),
+          Array.from({length: 8}, (_, i) =>
+            se(
+              'div',
+              {key: i, className: 'comment'},
+              se(
+                'div',
+                {className: 'comment-header'},
+                se('strong', null, `Commenter ${i}`),
+                se('time', null, `${i + 1} hours ago`)
+              ),
+              se(
+                'p',
+                null,
+                'Great article! '.repeat(2 + (i % 3)) +
+                  'I found the section on server components particularly insightful.'
+              )
+            )
+          ),
+          se(ClientCommentForm, {postId, user})
+        )
+      );
+    };
+
+    const ServerSidebar = function ServerSidebar({fetchDelay}) {
+      return simulateDbFetch(fetchDelay).then(() =>
+        se(
+          'aside',
+          {className: 'sidebar'},
+          se('h3', null, 'Popular Posts'),
+          posts.slice(0, 5).map((post, i) =>
+            se(
+              'a',
+              {
+                key: i,
+                href: `/posts/${post.slug}`,
+                className: 'sidebar-link',
+              },
+              se('span', {className: 'rank'}, `${i + 1}.`),
+              post.title
+            )
+          ),
+          se(
+            'div',
+            {className: 'newsletter'},
+            se('h3', null, 'Newsletter'),
+            se('p', null, 'Get the latest posts delivered to your inbox.')
+          )
+        )
+      );
+    };
+
+    const App = function App() {
+      return se(
+        'div',
+        null,
+        se(
+          'div',
+          null,
+          se(
+            'div',
+            null,
+            se(
+              'div',
+              {id: 'app', className: 'blog-layout'},
+              se(ClientNavbar, {
+                user,
+                cartCount: 3,
+                categories: posts.slice(0, 5).map(p => p.category),
+              }),
+              se(
+                'div',
+                {className: 'main-layout'},
+                se(
+                  'main',
+                  null,
+                  se(
+                    Suspense,
+                    {fallback: se('div', null, 'Loading post...')},
+                    se(ServerBlogPost, {
+                      postId: 0,
+                      fetchDelay: FETCH_DELAYS.dbQuery,
+                    })
+                  ),
+                  se(
+                    Suspense,
+                    {fallback: se('div', null, 'Loading comments...')},
+                    se(ServerComments, {
+                      postId: 0,
+                      fetchDelay: FETCH_DELAYS.dbQuerySlow,
+                    })
+                  )
+                ),
+                se(
+                  Suspense,
+                  {fallback: se('div', null, 'Loading sidebar...')},
+                  se(ServerSidebar, {fetchDelay: FETCH_DELAYS.cacheHit})
+                )
+              ),
+              se(
+                Suspense,
+                {fallback: se('div', null, 'Loading related...')},
+                se(ServerRelatedPosts, {fetchDelay: FETCH_DELAYS.dbQuery})
+              ),
+              se('footer', null, se('p', null, '© 2026 Blog Inc.'))
+            )
+          )
+        )
+      );
+    };
+
+    return {
+      tree: se(App, null),
+      name: 'blog',
+      description:
+        'Blog page: 4 async fetches (1-12ms each), 4 Suspense boundaries, ' +
+        'rich text content (~40KB), 3 context providers, comment form (client)',
+      componentCount: 60,
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Scenario: E-commerce PLP (product listing, filters, pagination)
+  // ---------------------------------------------------------------------------
+
+  function buildEcommercePLPScenario() {
+    const products = Array.from({length: 48}, (_, i) => generateProduct(i));
+    const user = generateUser();
+    const categories = Array.from({length: 12}, (_, i) => ({
+      id: i,
+      name: `Category ${i}`,
+      slug: `category-${i}`,
+      count: 20 + i * 5,
+    }));
+
+    const ServerProductGrid = function ServerProductGrid({fetchDelay}) {
+      return simulateDbFetch(fetchDelay).then(() =>
+        se(
+          'div',
+          {className: 'product-grid'},
+          se(
+            'div',
+            {className: 'grid-header'},
+            se('h2', null, `Showing ${products.length} products`),
+            se('span', null, 'Page 1 of 4')
+          ),
+          se(
+            'div',
+            {className: 'grid'},
+            products.map((product, i) =>
+              se(ClientInteractiveCard, {key: i, product})
+            )
+          )
+        )
+      );
+    };
+
+    const ServerBreadcrumbs = function ServerBreadcrumbs() {
+      return se(
+        'nav',
+        {className: 'breadcrumbs'},
+        ['Home', 'Electronics', 'Widgets', 'Professional Grade'].map(
+          (item, i) =>
+            se('span', {key: i}, i > 0 ? ' › ' : '', se('a', {href: '#'}, item))
+        )
+      );
+    };
+
+    const ServerRecommendations = function ServerRecommendations({fetchDelay}) {
+      return simulateDbFetch(fetchDelay).then(() =>
+        se(
+          'section',
+          {className: 'recommendations'},
+          se('h2', null, 'Recommended for You'),
+          se(
+            'div',
+            {className: 'rec-grid'},
+            products
+              .slice(0, 6)
+              .map((product, i) => se(ClientInteractiveCard, {key: i, product}))
+          )
+        )
+      );
+    };
+
+    const App = function App() {
+      return se(
+        'div',
+        null,
+        se(
+          'div',
+          null,
+          se(
+            'div',
+            {id: 'app', className: 'ecommerce'},
+            se(ClientNavbar, {user, cartCount: 2, categories}),
+            se(ServerBreadcrumbs, null),
+            se(
+              'div',
+              {className: 'plp-layout'},
+              se(ClientSearchFilters, {
+                categories,
+                priceRange: {min: 0, max: 500},
+                activeFilters: ['Category 0', 'Category 3'],
+              }),
+              se(
+                'main',
+                null,
+                se(
+                  Suspense,
+                  {
+                    fallback: se(
+                      'div',
+                      {className: 'skeleton-grid'},
+                      'Loading products...'
+                    ),
+                  },
+                  se(ServerProductGrid, {fetchDelay: FETCH_DELAYS.dbQuerySlow})
+                )
+              )
+            ),
+            se(
+              Suspense,
+              {
+                fallback: se('div', null, 'Loading recommendations...'),
+              },
+              se(ServerRecommendations, {fetchDelay: FETCH_DELAYS.apiCall})
+            ),
+            se(
+              'footer',
+              {className: 'site-footer'},
+              se(
+                'div',
+                {className: 'footer-links'},
+                ['About', 'Privacy', 'Terms', 'Help', 'Careers'].map(
+                  (item, i) => se('a', {key: i, href: '#'}, item)
+                )
+              )
+            )
+          )
+        )
+      );
+    };
+
+    return {
+      tree: se(App, null),
+      name: 'ecommerce-plp',
+      description:
+        'Product listing: 48 products (~150KB props), 54 client cards, ' +
+        '2 async fetches (12-20ms each), 2 Suspense, filters (client), 2 contexts',
+      componentCount: 120,
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Scenario: Dashboard (many small async fetches, heavy interactivity)
+  // ---------------------------------------------------------------------------
+
+  function buildDashboardScenario() {
+    const user = generateUser();
+
+    const ServerMetricCard = function ServerMetricCard({title, fetchDelay}) {
+      return simulateDbFetch(fetchDelay).then(() =>
+        se(
+          'div',
+          {className: 'metric-card'},
+          se('h3', null, title),
+          se(
+            'div',
+            {className: 'metric-value'},
+            '$' + (Math.random() * 100000).toFixed(0)
+          ),
+          se(
+            'div',
+            {className: 'metric-change'},
+            (Math.random() > 0.5 ? '+' : '-') +
+              (Math.random() * 20).toFixed(1) +
+              '%'
+          )
+        )
+      );
+    };
+
+    const ClientChart = createClientComponent(
+      'ClientChart',
+      function ClientChart({data, type, title}) {
+        return ce(
+          'div',
+          {className: 'chart', 'data-type': type},
+          ce('h3', null, title),
+          ce(
+            'div',
+            {className: 'chart-body'},
+            ce(
+              'svg',
+              {width: 600, height: 300},
+              ce('rect', {width: '100%', height: '100%', fill: '#f0f0f0'})
+            )
+          ),
+          ce(
+            'div',
+            {className: 'chart-legend'},
+            data.labels.map((label, i) =>
+              ce('span', {key: i, className: 'legend-item'}, label)
+            )
+          )
+        );
+      }
+    );
+
+    const ClientDataTable = createClientComponent(
+      'ClientDataTable',
+      function ClientDataTable({rows, columns}) {
+        return ce(
+          'table',
+          {className: 'data-table'},
+          ce(
+            'thead',
+            null,
+            ce(
+              'tr',
+              null,
+              columns.map((col, i) => ce('th', {key: i}, col))
+            )
+          ),
+          ce(
+            'tbody',
+            null,
+            rows.map((row, i) =>
+              ce(
+                'tr',
+                {key: i},
+                row.map((cell, j) => ce('td', {key: j}, cell))
+              )
+            )
+          )
+        );
+      }
+    );
+
+    const ServerRecentActivity = function ServerRecentActivity({fetchDelay}) {
+      return simulateDbFetch(fetchDelay).then(() => {
+        const rows = Array.from({length: 20}, (_, i) => [
+          `Order #${1000 + i}`,
+          `Customer ${i}`,
+          `$${(Math.random() * 500).toFixed(2)}`,
+          ['Completed', 'Pending', 'Shipped', 'Refunded'][i % 4],
+          new Date(2026, 2, 25 - i).toLocaleDateString(),
+        ]);
+        return se(ClientDataTable, {
+          rows,
+          columns: ['Order', 'Customer', 'Amount', 'Status', 'Date'],
+        });
+      });
+    };
+
+    const ServerAnalytics = function ServerAnalytics({fetchDelay}) {
+      return simulateDbFetch(fetchDelay).then(() =>
+        se(ClientChart, {
+          type: 'line',
+          title: 'Revenue Over Time',
+          data: {
+            labels: [
+              'Jan',
+              'Feb',
+              'Mar',
+              'Apr',
+              'May',
+              'Jun',
+              'Jul',
+              'Aug',
+              'Sep',
+              'Oct',
+              'Nov',
+              'Dec',
+            ],
+            datasets: [
+              {
+                label: 'Revenue',
+                data: Array.from({length: 12}, () =>
+                  Math.floor(Math.random() * 100000)
+                ),
+              },
+              {
+                label: 'Expenses',
+                data: Array.from({length: 12}, () =>
+                  Math.floor(Math.random() * 50000)
+                ),
+              },
+            ],
+          },
+        })
+      );
+    };
+
+    const metrics = [
+      'Total Revenue',
+      'Active Users',
+      'Conversion Rate',
+      'Avg Order Value',
+      'Churn Rate',
+      'MRR',
+    ];
+
+    const App = function App() {
+      return se(
+        'div',
+        null,
+        se(
+          'div',
+          null,
+          se(
+            'div',
+            {id: 'dashboard'},
+            se(ClientNavbar, {
+              user,
+              cartCount: 0,
+              categories: metrics.map((m, i) => ({
+                name: m,
+                slug: m.toLowerCase().replace(/ /g, '-'),
+              })),
+            }),
+            se(
+              'div',
+              {className: 'metrics-row'},
+              metrics.map((title, i) =>
+                se(
+                  Suspense,
+                  {key: i, fallback: se('div', null, 'Loading...')},
+                  se(ServerMetricCard, {
+                    title,
+                    fetchDelay: FETCH_DELAYS.cacheHit + (i % 3) * 2,
+                  })
+                )
+              )
+            ),
+            se(
+              'div',
+              {className: 'dashboard-grid'},
+              se(
+                Suspense,
+                {fallback: se('div', null, 'Loading chart...')},
+                se(ServerAnalytics, {fetchDelay: FETCH_DELAYS.dbQuerySlow})
+              ),
+              se(
+                Suspense,
+                {fallback: se('div', null, 'Loading activity...')},
+                se(ServerRecentActivity, {fetchDelay: FETCH_DELAYS.dbQuery})
+              )
+            )
+          )
+        )
+      );
+    };
+
+    return {
+      tree: se(App, null),
+      name: 'dashboard',
+      description:
+        'Dashboard: 8 async fetches (1-11ms each), 8 Suspense boundaries, ' +
+        'charts + data tables (client), 6 metric cards, 2 contexts',
+      componentCount: 50,
+    };
+  }
+
+  return [buildBlogScenario, buildEcommercePLPScenario, buildDashboardScenario];
+}
+
+module.exports = {createScenarios};