• A textarea input feeds text to a server action (renderAction) which returns Promise<ReactNode>

• The promise is wrapped in useDeferredValue, then consumed via use() inside <Suspense>

• In dev mode (next dev): the deferred output box tracks the input and catches up after typing stops

• In prod mode (next build && next start): the deferred output frequently gets stuck and never catches up to the final input value

• Dev (working): 06447062-f403-49f3-8bd8-476a65b448d2

• Prod (broken): c0b7c6fb-8f2a-461c-9fca-0ba2e9be3083

• No console errors in either recording

• The server action POST requests all return 200 OK with valid data

• The app code is identical between dev and prod — only the build mode differs

• It only manifests in production builds

1. Bug Description — What happens

2. Root Cause Analysis — What exactly causes the deferred value to get stuck in prod but not dev

3. Suggested Fix — What code change would fix this

4. Key Evidence Trail — Table of tools used and findings at each step

1. root.suspendedLanes = 0 — The lane hasn't been marked as suspended yet because markRootSuspended runs after the render completes, but the ping fires during the render

2. executionContext & 2 is truthy — The ping fires inside the render context

3. workInProgressRootExitStatus = 4 (RootSuspended) — Set by renderDidSuspendDelayIfPossible in throwException, before attachPingListener is called

javascript
root.pingedLanes |= root.suspendedLanes & pingedLanes;
//                   ^^^^^^^^^^^^^^^^^ = 0, so pingedLanes stays 0

javascript
workInProgressRoot === root                           // TRUE
  && (workInProgressRootRenderLanes & pingedLanes)    // TRUE
  && (4 === workInProgressRootExitStatus              // TRUE (RootSuspended)
      ? 0 === (executionContext & 2)                  // FALSE! In render context.
        && prepareFreshStack(root, 0)                 // NOT CALLED
      : (workInProgressRootPingedLanes |= pingedLanes) // NOT REACHED (wrong ternary branch)
     )

javascript
// L542-549
if (this.status === "resolved_model") initializeModelChunk(this);
if (this.status === "fulfilled") {
  if (typeof resolve === "function") resolve(this.value); // SYNCHRONOUS!
}

javascript
// In pingSuspendedRoot, after L13076:
if (workInProgressRoot === root) {
  if ((workInProgressRootRenderLanes & pingedLanes) === pingedLanes) {
    if (4 === workInProgressRootExitStatus || ...) {
      if (0 === (executionContext & 2)) {
        prepareFreshStack(root, 0);
      } else {
        // NEW: Even if we can't restart now, mark lanes as pinged
        // so the scheduler picks them up after render completes
        workInProgressRootPingedLanes |= pingedLanes;
      }
    } else {
      workInProgressRootPingedLanes |= pingedLanes;
    }
  }
}

javascript
// In attachPingListener, wrap the ping:
wakeable.then(
  () => queueMicrotask(() => pingSuspendedRoot(root, pingedLanes)),
  () => queueMicrotask(() => pingSuspendedRoot(root, pingedLanes))
);

javascript
// Before markRootSuspended in the exitStatus=4 path:
root.pingedLanes |= workInProgressRootPingedLanes;

• A textarea input feeds text to a server action (renderAction) which returns Promise<ReactNode>

• The promise is wrapped in useDeferredValue, then consumed via use() inside <Suspense>

• In dev mode (next dev): the deferred output box tracks the input and catches up after typing stops

• In prod mode (next build && next start): the deferred output frequently gets stuck and never catches up to the final input value

• Dev (working): 06447062-f403-49f3-8bd8-476a65b448d2

• Prod (broken): c0b7c6fb-8f2a-461c-9fca-0ba2e9be3083

• No console errors in either recording

• The server action POST requests all return 200 OK with valid data

• The app code is identical between dev and prod — only the build mode differs

• It only manifests in production builds

1. Bug Description — What happens

2. Root Cause Analysis — What exactly causes the deferred value to get stuck in prod but not dev

3. Suggested Fix — What code change would fix this

4. Key Evidence Trail — Table of tools used and findings at each step

javascript
root.pingedLanes |= root.suspendedLanes & pingedLanes
//                    ^^^^^^^^^^^^^^^^
//                    = 0 (not yet set!)
// Result: pingedLanes stays 0. Ping is wasted.

• pendingLanes: has bit 19 ✓

• suspendedLanes: has bit 19 ✓

• pingedLanes: 0 ✗

javascript
// react-reconciler: ReactFiberThenable.js
function isThenableResolved(thenable) {
  var status = thenable.status;
  return status === "fulfilled" || status === "rejected"
    || status === "resolved_model" || status === "resolved_module";
}

javascript
// react-reconciler: ReactFiberWorkLoop.js
function markRootSuspended(root, suspendedLanes, ...) {
  root.suspendedLanes |= suspendedLanes;
  root.pingedLanes &= ~suspendedLanes;
  // NEW: Check if any of these lanes were pinged while render was in progress
  // If so, immediately re-ping them
  if (root._pendingPingsDuringRender & suspendedLanes) {
    root.pingedLanes |= root._pendingPingsDuringRender & suspendedLanes;
    root._pendingPingsDuringRender = 0;
  }
}

• Severity: High — causes permanent UI staleness with no recovery

• Scope: Any Next.js app using useDeferredValue + use() + RSC server actions with rapid updates

• Workarounds: None clean. Adding artificial delays would mask but not fix. Avoiding useDeferredValue with server actions works but defeats the purpose.

• React version affected: 19.3.0-canary-f93b9fd4-20251217 (and likely all React 19 builds with RSC support)

• A textarea input feeds text to a server action (renderAction) which returns Promise<ReactNode>

• The promise is wrapped in useDeferredValue, then consumed via use() inside <Suspense>

• In dev mode (next dev): the deferred output box tracks the input and catches up after typing stops

• In prod mode (next build && next start): the deferred output frequently gets stuck and never catches up to the final input value

• Dev (working): 06447062-f403-49f3-8bd8-476a65b448d2

• Prod (broken): c0b7c6fb-8f2a-461c-9fca-0ba2e9be3083

• No console errors in either recording

• The server action POST requests all return 200 OK with valid data

• The app code is identical between dev and prod — only the build mode differs

• It only manifests in production builds

• Lanes: React uses a bitmask-based priority system called "lanes." Each update is assigned a lane (e.g., SyncLane, TransitionLane, DeferredLane). useDeferredValue schedules work on deferred lanes, which are lower priority than user-initiated updates.

• Suspension and pinging: When a component throws a Promise (Suspense), React marks the update's lanes as "suspended." When the promise resolves, a "ping" fires that marks those lanes as "pinged," telling the scheduler to retry. The lifecycle is: pending → rendering → suspended → pinged → retry rendering → committed.

• workInProgress state: During rendering, React tracks the current render's state in module-scoped variables prefixed with workInProgress — things like what root is being rendered, what lanes, what the exit status is, which lanes have been pinged during this render. These are mutable and change throughout the render cycle.

• markRootSuspended: When a render suspends, this function marks the lanes as suspended on the root. It uses workInProgressRootPingedLanes to exclude lanes that were pinged during the current render (so they don't get stuck as suspended). It also adds lanes to warmLanes which affects future scheduling.

• Concurrent rendering and yielding: In prod, React uses time-slicing — renders can yield back to the browser mid-work and resume later. This means microtasks (like promise .then() callbacks) can fire between render chunks. In dev mode, renders tend to run longer without yielding due to extra dev checks, so microtasks fire after the render completes.

• The key timing question: When a suspended promise resolves, the .then() ping callback might fire during an active render (prod, due to yielding) or after the render completes (dev, due to slower execution). If the ping handling code doesn't correctly handle the "ping arrives mid-render" case, the lane can get stuck.

1. Bug Description — What happens

2. Root Cause Analysis — What exactly causes the deferred value to get stuck in prod but not dev

3. Suggested Fix — What code change would fix this

4. Key Evidence Trail — Table of tools used and findings at each step

• Schedules a new server action POST for "hello world from prod"

• Begins a concurrent render on lane 524288 (DeferredLane)

javascript
function pingSuspendedRoot(root, wakeable, pingedLanes) {
  // Line 13076: Try to mark root.pingedLanes
  root.pingedLanes |= root.suspendedLanes & pingedLanes;
  //                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  //  BUG: root.suspendedLanes is STILL 0 here!
  //  The lane hasn't been marked suspended yet (render is still in progress).
  //  So this is: 0 |= (0 & 524288) = 0. NO EFFECT.

  root.warmLanes &= ~pingedLanes;  // warmLanes also 0 at this point

  // Line 13078: Are we currently rendering this root+lanes?
  workInProgressRoot === root &&           // TRUE (same root)
  (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&  // TRUE (same lane)

  // Line 13080: Ternary — exitStatus check
  (4 === workInProgressRootExitStatus ||   // TRUE (RootSuspendedWithDelay = 4)
   (...))
    // FIRST BRANCH taken:
    ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
    //       ^^^^^^^^^^^^^^^^^^^^^^
    //  BUG: executionContext IS 2 (RenderContext)! We're mid-render!
    //  So 0 === (2 & 2) is FALSE. prepareFreshStack is NOT called.
    //  This entire branch is a no-op.

    // ELSE BRANCH (never reached because ternary was truthy):
    : (workInProgressRootPingedLanes |= pingedLanes)
    //  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    //  This would have saved us! But it's unreachable.

  ensureRootIsScheduled(root);  // Called, but getNextLanes returns 0
}

javascript
function markRootSuspended(root, suspendedLanes, spawnedLane, didAttemptEntireTree) {
  suspendedLanes &= ~workInProgressRootPingedLanes;  // 524288 &= ~0 = 524288 (no exclusion)
  root.suspendedLanes |= suspendedLanes;              // Lane 524288 marked SUSPENDED
  root.pingedLanes &= ~suspendedLanes;                // Clears any pings (already 0)
  didAttemptEntireTree && (root.warmLanes |= suspendedLanes);  // Lane marked WARM
}

• root.pendingLanes = 524288 ✓ (work pending)

• root.suspendedLanes = 524288 ✗ (excluded from scheduling)

• root.pingedLanes = 0 ✗ (no ping recorded to rescue it)

• root.warmLanes = 524288 ✗ (excluded from cold-retry path)

1. pendingLanes & ~suspendedLanes = 0 (suspended)

2. pingedLanes & nonIdlePendingLanes = 0 (not pinged)

3. nonIdlePendingLanes & ~warmLanes = 0 (warm)

• Extra validation checks, warning infrastructure, DevTools hooks

• StrictMode double-rendering

javascript
// In pingSuspendedRoot, replace the ternary at lines 13080-13086:

// BEFORE (buggy):
(4 === workInProgressRootExitStatus || (...))
  ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
  : (workInProgressRootPingedLanes |= pingedLanes)

// AFTER (fixed):
if (4 === workInProgressRootExitStatus || (...)) {
  if (0 === (executionContext & 2)) {
    prepareFreshStack(root, 0);
  } else {
    // Ping arrived mid-render. Can't restart now, but record the ping
    // so markRootSuspended won't mark this lane as suspended.
    workInProgressRootPingedLanes |= pingedLanes;
  }
} else {
  workInProgressRootPingedLanes |= pingedLanes;
}

javascript
// At the top of pingSuspendedRoot, unconditionally record the ping on the root
// for lanes that are pending (not just suspended):
root.pingedLanes |= root.suspendedLanes & pingedLanes;
root.pingedLanes |= root.pendingLanes & pingedLanes;  // NEW: catch pre-suspension pings

1. root.pingedLanes can't be set (lane not yet suspended on root)

2. prepareFreshStack can't be called (currently in render context)

3. workInProgressRootPingedLanes isn't set (unreachable else-branch of ternary)

• A textarea input feeds text to a server action (renderAction) which returns Promise<ReactNode>

• The promise is wrapped in useDeferredValue, then consumed via use() inside <Suspense>

• In dev mode (next dev): the deferred output box tracks the input and catches up after typing stops

• In prod mode (next build && next start): the deferred output frequently gets stuck and never catches up to the final input value

• Dev (working): 06447062-f403-49f3-8bd8-476a65b448d2

• Prod (broken): c0b7c6fb-8f2a-461c-9fca-0ba2e9be3083

• No console errors in either recording

• The server action POST requests all return 200 OK with valid data

• The app code is identical between dev and prod — only the build mode differs

• It only manifests in production builds

• Lanes: React uses a bitmask-based priority system called "lanes." Each update is assigned a lane (e.g., SyncLane, TransitionLane, DeferredLane). useDeferredValue schedules work on deferred lanes, which are lower priority than user-initiated updates.

• Suspension and pinging: When a component throws a Promise (Suspense), React marks the update's lanes as "suspended." When the promise resolves, a "ping" fires that marks those lanes as "pinged," telling the scheduler to retry. The lifecycle is: pending → rendering → suspended → pinged → retry rendering → committed.

• workInProgress state: During rendering, React tracks the current render's state in module-scoped variables prefixed with workInProgress — things like what root is being rendered, what lanes, what the exit status is, which lanes have been pinged during this render. These are mutable and change throughout the render cycle.

• markRootSuspended: When a render suspends, this function marks the lanes as suspended on the root. It uses workInProgressRootPingedLanes to exclude lanes that were pinged during the current render (so they don't get stuck as suspended). It also adds lanes to warmLanes which affects future scheduling.

• Concurrent rendering and yielding: In prod, React uses time-slicing — renders can yield back to the browser mid-work and resume later. This means microtasks (like promise .then() callbacks) can fire between render chunks. In dev mode, renders tend to run longer without yielding due to extra dev checks, so microtasks fire after the render completes.

• The key timing question: When a suspended promise resolves, the .then() ping callback might fire during an active render (prod, due to yielding) or after the render completes (dev, due to slower execution). If the ping handling code doesn't correctly handle the "ping arrives mid-render" case, the lane can get stuck.

• RecordingOverview — Start here for each recording. Gets you error counts, render commit stats, network summary, environment info. Run on BOTH recordings first.

• ReactRenders — Your primary comparison tool. Use mode: commits to see the full commit sequence. Use mode: commit with commitIndex to drill into individual commits. Focus on the last few commits in each recording — where does prod diverge from dev?

• NetworkRequest — Verify all server action POSTs returned successfully. Use to rule out data-level issues early. Check timing of responses relative to render commits.

• SearchSources — Find functions in the recorded bundles by name. React 19 ships unminified production bundles, so function names are preserved. Search for scheduling and reconciler functions to find their locations.

• ReadSource — Read source code with execution hit counts per line. This is a built-in static profiler — you can see which branches executed and how many times. Use this to understand code flow without needing to instrument anything.

• Logpoint — Your most powerful investigation tool. Evaluates any JavaScript expression at a specific source line, every time that line executes. Returns the expression value at each hit with timestamps. This is equivalent to adding console.log statements retroactively — unlimited, no rebuild, no reproduction needed.
• Use beginPoint/endPoint to filter hits to a specific time window (critical for high-frequency functions)
• Build complex string expressions to capture multiple values in one logpoint: `lanes=${lanes} status=${status} pinged=${root.pingedLanes}`
• Place logpoints at key decision points in scheduling functions to trace mutable state over time

• DescribePoint / Evaluate — Inspect full program state at a specific execution point. Use after Logpoint identifies an interesting moment — drill in to see all variables, the call stack, and dependency chains.

• Screenshot — Confirm visual state at timestamps. Use at the end of each recording to verify the bug visually.

1. Bug Description — What happens

2. Root Cause Analysis — What exactly causes the deferred value to get stuck in prod but not dev

3. Suggested Fix — What code change would fix this

4. Key Evidence Trail — Table of tools used and findings at each step

1. User types the final character ('d'). React starts rendering the deferred lane (lane 524288 = 0x80000).

2. During rendering, the component suspends (throws a Promise) because the server action response hasn't arrived yet. React sets workInProgressRootExitStatus = 4 (RootSuspended) but continues in the render context (executionContext = 2).

3. The server action response arrives at ~5155ms. The promise resolves, firing the .then() ping callback at 5169ms — while the render is still active.

4. pingSuspendedRoot fires mid-render with this state:
• workInProgressRoot === root → TRUE (active render)
• workInProgressRootExitStatus === 4 (suspended)
• executionContext & 2 !== 0 (mid-render)
• root.suspendedLanes === 0 (lane hasn't been marked suspended on root yet — that happens later in markRootSuspended)

5. Three things fail simultaneously:
• root.pingedLanes not set: Line 13076 does root.pingedLanes |= root.suspendedLanes & pingedLanes, but root.suspendedLanes is still 0 (not yet marked), so this is a no-op.
• prepareFreshStack blocked: The ternary at lines 13080-13086 takes the ? branch (because exitStatus === 4), but prepareFreshStack is guarded by 0 === (executionContext & 2) which is false (mid-render). Result: the expression evaluates to false and nothing happens.
• workInProgressRootPingedLanes not set: The : branch (workInProgressRootPingedLanes |= pingedLanes) is only reached when exitStatus is NOT 4 or 3+fallback. Since exitStatus IS 4, we're on the ? branch, and this line never executes.

6. 5191ms — markRootSuspended runs after the render completes:
• suspendedLanes = 524288
• workInProgressRootPingedLanes = 0 (the ping was lost!)
• Line 12147: suspendedLanes &= ~0 → 524288 (no exclusion)
• Line 12149: root.suspendedLanes |= 524288 → lane marked suspended
• Line 12150: root.pingedLanes &= ~524288 → any ping bit cleared
• Line 12151: root.warmLanes |= 524288 → lane added to warm lanes
• Result: Lane 524288 is permanently suspended and warm, with no ping to trigger a retry.

javascript
// Current code (simplified):
if (workInProgressRoot === root &&
    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes) {

  if (exitStatus === RootSuspended || (exitStatus === RootSuspendedWithDelay && ...)) {
    // TRUE branch: try to restart
    if ((executionContext & RenderContext) === 0) {
      prepareFreshStack(root, 0);  // Can't do this mid-render!
    }
    // If mid-render, NOTHING happens — ping is silently dropped
  } else {
    // FALSE branch: record the ping for later
    workInProgressRootPingedLanes |= pingedLanes;  // Never reached when exitStatus===4
  }
}

javascript
// In pingSuspendedRoot, the ternary handling for exitStatus === 4:
if (exitStatus === RootSuspended || (exitStatus === RootSuspendedWithDelay && ...)) {
  if ((executionContext & RenderContext) === 0) {
    prepareFreshStack(root, 0);
  } else {
    // FIX: Record the ping even when we can't restart mid-render.
    // markRootSuspended will check workInProgressRootPingedLanes
    // and exclude this lane from being marked suspended.
    workInProgressRootPingedLanes |= pingedLanes;
  }
} else {
  workInProgressRootPingedLanes |= pingedLanes;
}

javascript
# Recording Overview

## Recording Info & Environment

- **URL:** http://localhost:3000/
- **Duration:** 10.3s
- **React:** v19.3.0-canary-f93b9fd4-20251217 (production)
- **Libraries:** NextJS, React

## Console Errors & Warnings

App healthy — no console errors or warnings detected.

## Screenshot

**Final recording state** — screenshot available at timestamp 9955ms.
Use the **Screenshot** tool with `timestamp: 9955` to view it.

## Network Summary

- **Total requests:** 37
- **Failed:** 1
- **Slow:** 0

### API Patterns
- `POST /` — 21 requests
- `GET /` — 1 request

## React Render Summary

- **Total commits:** 38
- **Total render time:** 107ms

### Costliest Commits
- Commit #24: 54ms, 4 fibers — SuspenseResumed
- Commit #13: 4ms, 4 fibers — SuspenseResumed
- Commit #22: 4ms, 4 fibers — SuspenseResumed
- Commit #19: 4ms, 4 fibers — SuspenseResumed
- Commit #9: 4ms, 4 fibers — SuspenseResumed

## Suggested Next Steps

1. **NetworkRequest** — Investigate failed network requests
   _1 failed request_
2. **ReactRenders** — Analyze React render performance
   _38 commits, 107ms total render time_
3. **Screenshot** — View screenshot of the application state
   _Final recording state at 9955ms_

javascript
# Commits

|  # |  Time | Duration | Fibers | Mutating | Wasted | Waste% | Trigger         |
| -: | ----: | -------: | -----: | -------: | -----: | -----: | --------------- |
| 28 | 4.52s |    3.3ms |      4 |        1 |      3 |  75.0% | SuspenseResumed |
| 29 | 4.56s |     15µs |      2 |        1 |      1 |  50.0% | SetState        |
| 30 | 4.66s |    1.6ms |      3 |        1 |      2 |  66.7% | SetState        |
| 31 | 4.67s |    3.3ms |      4 |        1 |      3 |  75.0% | SuspenseResumed |
| 32 | 4.76s |      4µs |      2 |        1 |      1 |  50.0% | SetState        |
| 33 | 4.77s |    3.3ms |      4 |        1 |      3 |  75.0% | SuspenseResumed |
| 34 | 4.83s |      4µs |      2 |        1 |      1 |  50.0% | SetState        |
| 35 | 5.07s |    3.3ms |      4 |        1 |      3 |  75.0% | SetState        |
| 36 | 5.08s |    3.3ms |      4 |        1 |      3 |  75.0% | SuspenseResumed |
| 37 | 5.15s |      4µs |      2 |        1 |      1 |  50.0% | SetState        |

Showing 29–38 of 38

## Next Steps

- Use mode=commit&commitIndex=N to inspect a specific commit
- Use mode=summary to see the recording overview

javascript
# Commit #37

**Timestamp:** 5.15s
**Render duration:** 4µs
**Fibers rendered:** 2 (1 mutating, 1 wasted — 50.0%)

## Triggers

- **SetState**
  - Source: TestPreviewClient (client.tsx:38:25)
  - Point: 11682667932122379955827658622763010

## Components

| Component         | Instances | Renders | Wasted | Duration | DOM Muts |
| ----------------- | --------: | ------: | -----: | -------: | -------: |
| Resolved          |         1 |       1 |      1 |      4µs |        0 |
| TestPreviewClient |         1 |       1 |      0 |      0µs |        1 |

## DOM Mutations (1 total)

- TestPreviewClient: 1

## Next Steps

- Use mode=component&componentName=X to investigate a specific component
- Use mode=commits to browse other commits
- Use mode=summary to see the recording overview

javascript
 hits | L | code 
------|------|------
   0 | 12116 |       for (var i = 0; i < tag.length; i++) { 
   0 | 12117 |         var check = tag[i], 
   0 | 12118 |           getSnapshot = check.getSnapshot; 
   0 | 12119 |         check = check.value; 
     | 12120 |         try { 
   0 | 12121 |           if (!objectIs(getSnapshot(), check)) return !1; 
     | 12122 |         } catch (error) { 
   0 | 12123 |           return !1; 
     | 12124 |         } 
     | 12125 |       } 
     | 12126 |     tag = node.child; 
  87 | 12127 |     if (node.subtreeFlags & 16384 && null !== tag) 
   0 | 12128 |       (tag.return = node), (node = tag); 
     | 12129 |     else { 
  87 | 12130 |       if (node === finishedWork) break; 
   0 | 12131 |       for (; null === node.sibling; ) { 
   0 | 12132 |         if (null === node.return || node.return === finishedWork) return !0; 
   0 | 12133 |         node = node.return; 
     | 12134 |       } 
   0 | 12135 |       node.sibling.return = node.return; 
   0 | 12136 |       node = node.sibling; 
     | 12137 |     } 
     | 12138 |   } 
  87 | 12139 |   return !0; 
  87 | 12140 | } 
     | *12141 | function markRootSuspended( 
     | 12142 |   root, 
     | 12143 |   suspendedLanes, 
     | 12144 |   spawnedLane, 
     | 12145 |   didAttemptEntireTree 
     | 12146 | ) { 
  67 | 12147 |   suspendedLanes &= ~workInProgressRootPingedLanes; 
  67 | 12148 |   suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes; 
  67 | 12149 |   root.suspendedLanes |= suspendedLanes; 
  67 | 12150 |   root.pingedLanes &= ~suspendedLanes; 
  67 | 12151 |   didAttemptEntireTree && (root.warmLanes |= suspendedLanes); 
  67 | 12152 |   didAttemptEntireTree = root.expirationTimes; 
 134 | 12153 |   for (var lanes = suspendedLanes; /*<HIT>*/0 < lanes; ) { 
  67 | 12154 |     var index$6 = 31 - clz32(lanes), 
  67 | 12155 |       lane = 1 << index$6; 
  67 | 12156 |     didAttemptEntireTree[index$6] = -1; 
  67 | 12157 |     lanes &= ~lane; 
     | 12158 |   } 
  67 | 12159 |   0 !== spawnedLane && 
   0 | 12160 |     markSpawnedDeferredLane(root, spawnedLane, suspendedLanes); 
     | 12161 | } 
     | 12162 | function flushSyncWork$1() { 
  21 | 12163 |   return 0 === (executionContext & 6) 
  21 | 12164 |     ? (flushSyncWorkAcrossRoots_impl(0, !1), !1) 
     | 12165 |     : !0; 
     | 12166 | }

javascript
Found 46 total hits at turbopack:///[project]/node_modules/.pnpm/next@16.1.6_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/next/dist/compiled/react-dom/cjs/react-dom-client.production.js:13076 (showing first 20)

Hit 1 at point Point:239 @ 2676.17ms:
  Expression: ["ping", pingedLanes, "suspended", root.suspendedLanes, "renderLanes", workInProgressRootRenderLanes, "exit", workInProgressRootExitStatus, "isRoot", workInProgressRoot === root, "execCtx", executionContext]
  Result: [
  "ping",
  524288,
  "suspended",
  524800,
  "renderLanes",
  0,
  "exit",
  4,
  "isRoot",
  false,
  "execCtx",
  0
]

Hit 2 at point Point:240 @ 2676.21ms:
  Expression: ["ping", pingedLanes, "suspended", root.suspendedLanes, "renderLanes", workInProgressRootRenderLanes, "exit", workInProgressRootExitStatus, "isRoot", workInProgressRoot === root, "execCtx", executionContext]
  Result: [
  "ping",
  512,
  "suspended",
  524800,
  "renderLanes",
  0,
  "exit",
  4,
  "isRoot",
  false,
  "execCtx",
  0
]

Hit 3 at point Point:241 @ 2841.09ms:
  Expression: ["ping", pingedLanes, "suspended", root.suspendedLanes, "renderLanes", workInProgressRootRenderLanes, "exit", workInProgressRootExitStatus, "isRoot", workInProgressRoot === root, "execCtx", executionContext]
  Result: [
  "ping",
  1048576,
  "suspended",
  1049600,
  "renderLanes",
  0,
  "exit",
  4,
  "isRoot",
  false,
  "execCtx",
  0
]

// snip