How does this even make sense?

unstubbable · unstubbable · commit 53c8facf20eb · 2025-11-08T23:22:40.000+01:00
diff --git a/packages/next/src/server/app-render/app-render.tsx b/packages/next/src/server/app-render/app-render.tsx
@@ -3243,17 +3243,19 @@ async function renderWithRestartOnCacheMissInDev(
   // where sync IO does not cause aborts, so it's okay if it happens before render.
   const initialRscPayload = await getPayload(requestStore)
 
-  console.log('\n\n##########################################################')
-  console.log(
+  process.stdout.write(
+    '\n\n##########################################################\n'
+  )
+  process.stdout.write(
     `[app-render] :: rendering ${requestStore.url.pathname} (${ctx.workStore.route})\n`
   )
   const maybeInitialServerStream = await workUnitAsyncStorage.run(
     requestStore,
     () =>
       pipelineInSequentialTasks(
         () => {
-          console.log(
-            '=================== [initial] Static ==================='
+          process.stdout.write(
+            '=================== [initial] Static ===================\n'
           )
           // Static stage
           initialStageController.advanceStage(RenderStage.Static)
@@ -3292,8 +3294,8 @@ async function renderWithRestartOnCacheMissInDev(
 
           if (initialStageController.currentStage === RenderStage.Abandoned) {
             // If we abandoned the render in the static stage, we won't proceed further.
-            console.log(
-              '[app-render] initial render was abandoned due to sync IO in the static stage'
+            process.stdout.write(
+              '[app-render] initial render was abandoned due to sync IO in the static stage\n'
             )
             return null
           }
@@ -3306,15 +3308,15 @@ async function renderWithRestartOnCacheMissInDev(
             // Regardless of whether we are going to abandon this
             // render we need the unblock runtime b/c it's essential
             // filling caches.
-            console.log(
-              '[app-render] abandoning initial render due to a cache miss in the static stage'
+            process.stdout.write(
+              '[app-render] abandoning initial render due to a cache miss in the static stage\n'
             )
             initialStageController.abandonRender()
             return null
           }
 
-          console.log(
-            '=================== [initial] Runtime ==================='
+          process.stdout.write(
+            '=================== [initial] Runtime ===================\n'
           )
 
           initialStageController.advanceStage(RenderStage.Runtime)
@@ -3330,8 +3332,8 @@ async function renderWithRestartOnCacheMissInDev(
               stream !== null &&
               initialStageController.currentStage === RenderStage.Abandoned
             ) {
-              console.log(
-                '[app-render] initial render was abandoned due to sync IO in the runtime stage'
+              process.stdout.write(
+                '[app-render] initial render was abandoned due to sync IO in the runtime stage\n'
               )
             }
             // If we abandoned the render in the static or runtime stage, we won't proceed further.
@@ -3343,15 +3345,15 @@ async function renderWithRestartOnCacheMissInDev(
           // We won't advance the stage, and thus leave dynamic APIs hanging,
           // because they won't be cached anyway, so it'd be wasted work.
           if (cacheSignal.hasPendingReads()) {
-            console.log(
-              '[app-render] abandoning initial render due to a cache miss in the runtime stage'
+            process.stdout.write(
+              '[app-render] abandoning initial render due to a cache miss in the runtime stage\n'
             )
             initialStageController.abandonRender()
             return null
           }
 
-          console.log(
-            '=================== [initial] Dynamic ==================='
+          process.stdout.write(
+            '=================== [initial] Dynamic ===================\n'
           )
           // Regardless of whether we are going to abandon this
           // render we need the unblock runtime b/c it's essential
@@ -3395,7 +3397,7 @@ async function renderWithRestartOnCacheMissInDev(
   await cacheSignal.cacheReady()
   initialReactController.abort()
 
-  console.log('*********** restarting render ***********')
+  process.stdout.write('*********** restarting render ***********\n')
 
   //===============================================
   // Final render (restarted)
@@ -3444,7 +3446,9 @@ async function renderWithRestartOnCacheMissInDev(
   const finalServerStream = await workUnitAsyncStorage.run(requestStore, () =>
     pipelineInSequentialTasks(
       () => {
-        console.log('=================== [final] Static ===================')
+        process.stdout.write(
+          '=================== [final] Static ===================\n'
+        )
         // Static stage
         finalStageController.advanceStage(RenderStage.Static)
 
@@ -3472,22 +3476,26 @@ async function renderWithRestartOnCacheMissInDev(
       },
       (stream) => {
         if (finalStageController.currentStage !== RenderStage.Static) {
-          console.log(
-            `[app-render] stage was advanced to ${RenderStage[finalStageController.currentStage]} before reaching the runtime stage`
+          process.stdout.write(
+            `[app-render] stage was advanced to ${RenderStage[finalStageController.currentStage]} before reaching the runtime stage\n`
           )
         }
-        console.log('=================== [final] Runtime ===================')
+        process.stdout.write(
+          '=================== [final] Runtime ===================\n'
+        )
         // Runtime stage
         finalStageController.advanceStage(RenderStage.Runtime)
         return stream
       },
       (stream) => {
         if (finalStageController.currentStage !== RenderStage.Runtime) {
-          console.log(
-            `[app-render] stage was advanced to ${RenderStage[finalStageController.currentStage]} before reaching the dynamic stage`
+          process.stdout.write(
+            `[app-render] stage was advanced to ${RenderStage[finalStageController.currentStage]} before reaching the dynamic stage\n`
           )
         }
-        console.log('=================== [final] Dynamic ===================')
+        process.stdout.write(
+          '=================== [final] Dynamic ===================\n'
+        )
         // Dynamic stage
         finalStageController.advanceStage(RenderStage.Dynamic)
         return stream
@@ -3542,7 +3550,10 @@ async function accumulateStreamChunks(
         cancel()
         break
       }
-      switch (stageController.currentStage) {
+      process.stdout.write(
+        `CHUNK ${stageController.chunkStage}\n${new TextDecoder().decode(value)}\n`
+      )
+      switch (stageController.chunkStage) {
         case RenderStage.Before:
           throw new InvariantError(
             'Unexpected stream chunk while in Before stage'
@@ -3561,7 +3572,7 @@ async function accumulateStreamChunks(
           // so there's no need to accumulate them
           break
         default:
-          stageController.currentStage satisfies never
+          stageController.chunkStage satisfies never
           break
       }
     }
@@ -3700,32 +3711,32 @@ async function spawnStaticShellValidationInDev(
     const logChunks = (chunks: Array<Uint8Array>) => {
       const textDecoder = new TextDecoder()
       for (const chunk of chunks) {
-        console.log(textDecoder.decode(chunk))
+        process.stdout.write(textDecoder.decode(chunk) + '\n')
       }
     }
-    console.log(`Static chunks (${staticServerChunks.length})`)
-    console.log('------------------------')
+    process.stdout.write(`Static chunks (${staticServerChunks.length})\n`)
+    process.stdout.write('------------------------\n')
     logChunks(staticServerChunks)
-    console.log('------------------------')
+    process.stdout.write('------------------------\n')
 
     const runtimeOnlyChunks = runtimeServerChunks.slice(
       staticServerChunks.length
     )
-    console.log('\n')
-    console.log(`Runtime chunks (${runtimeOnlyChunks.length})`)
-    console.log('------------------------')
+    process.stdout.write('\n\n')
+    process.stdout.write(`Runtime chunks (${runtimeOnlyChunks.length})\n`)
+    process.stdout.write('------------------------\n')
     logChunks(runtimeOnlyChunks)
-    console.log('------------------------')
+    process.stdout.write('------------------------\n')
 
     const dynamicOnlyChunks = dynamicServerChunks.slice(
       runtimeServerChunks.length
     )
-    console.log('\n')
-    console.log(`Dynamic chunks (${dynamicOnlyChunks.length})`)
-    console.log('------------------------')
+    process.stdout.write('\n\n')
+    process.stdout.write(`Dynamic chunks (${dynamicOnlyChunks.length})\n`)
+    process.stdout.write('------------------------\n')
     logChunks(dynamicOnlyChunks)
-    console.log('------------------------')
-    console.log('\n\n')
+    process.stdout.write('------------------------\n')
+    process.stdout.write('\n\n\n')
   }
 
   const { allowEmptyStaticShell = false } = renderOpts
diff --git a/packages/next/src/server/app-render/staged-rendering.ts b/packages/next/src/server/app-render/staged-rendering.ts
@@ -14,6 +14,11 @@ export type NonStaticRenderStage = RenderStage.Runtime | RenderStage.Dynamic
 export class StagedRenderingController {
   currentStage: RenderStage = RenderStage.Before
 
+  // chunkStage lags behind currentStage, updated on process.nextTick after
+  // stage transitions. This allows React to emit additional chunks after stage
+  // listeners fire, at which point the current stage might already be ahead.
+  chunkStage: RenderStage = RenderStage.Before
+
   staticInterruptReason: Error | null = null
   runtimeInterruptReason: Error | null = null
   staticStageEndTime: number = Infinity
@@ -168,11 +173,13 @@ export class StagedRenderingController {
     switch (currentStage) {
       case RenderStage.Static: {
         this.currentStage = RenderStage.Abandoned
+        this.chunkStage = RenderStage.Abandoned
         this.resolveRuntimeStage()
         return
       }
       case RenderStage.Runtime: {
         this.currentStage = RenderStage.Abandoned
+        this.chunkStage = RenderStage.Abandoned
         return
       }
       case RenderStage.Dynamic:
@@ -197,6 +204,14 @@ export class StagedRenderingController {
     let currentStage = this.currentStage
     this.currentStage = stage
 
+    if (stage === RenderStage.Static) {
+      this.chunkStage = stage
+    } else {
+      process.nextTick(() => {
+        this.chunkStage = stage
+      })
+    }
+
     if (currentStage < RenderStage.Runtime && stage >= RenderStage.Runtime) {
       this.staticStageEndTime = performance.now() + performance.timeOrigin
       this.resolveRuntimeStage()
