perf(dev): print Ready early and defer initialization

- Print "Ready in Xms" immediately when HTTP server starts listening
- Defer heavy initialization (config, bundler, etc.) to background
- First request waits for init via existing handlersPromise mechanism
- Fix shell script symlink resolution for pnpm node_modules/.bin
- Fix Rust CLI canonicalize for symlink resolution
- Extract getSupportedBrowsers to lightweight module

This reduces perceived startup time from ~300ms to ~50-100ms.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: feedthejim

packages/next/src/build/utils.ts

@@ -43,9 +43,7 @@ import path from 'path'
 import { promises as fs } from 'fs'
 import { isValidElementType } from 'next/dist/compiled/react-is'
 import stripAnsi from 'next/dist/compiled/strip-ansi'
-import browserslist from 'next/dist/compiled/browserslist'
 import {
-  MODERN_BROWSERSLIST_TARGET,
   UNDERSCORE_GLOBAL_ERROR_ROUTE,
   UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY,
   UNDERSCORE_NOT_FOUND_ROUTE,
@@ -1528,30 +1526,8 @@ export class NestedMiddlewareError extends Error {
   }
 }
 
-export function getSupportedBrowsers(
-  dir: string,
-  isDevelopment: boolean
-): string[] {
-  let browsers: any
-  try {
-    const browsersListConfig = browserslist.loadConfig({
-      path: dir,
-      env: isDevelopment ? 'development' : 'production',
-    })
-    // Running `browserslist` resolves `extends` and other config features into a list of browsers
-    if (browsersListConfig && browsersListConfig.length > 0) {
-      browsers = browserslist(browsersListConfig)
-    }
-  } catch {}
-
-  // When user has browserslist use that target
-  if (browsers && browsers.length > 0) {
-    return browsers
-  }
-
-  // Uses modern browsers as the default.
-  return MODERN_BROWSERSLIST_TARGET
-}
+// Re-export from lightweight module for backwards compatibility
+export { getSupportedBrowsers } from './get-supported-browsers'
 
 // Re-export webpack layer utilities from dedicated module (for backwards compatibility)
 export {

packages/next/src/server/dev/hot-reloader-turbopack.ts

@@ -64,7 +64,7 @@ import {
   type SetupOpts,
 } from '../lib/router-utils/setup-dev-bundler'
 import { TurbopackManifestLoader } from '../../shared/lib/turbopack/manifest-loader'
-import { findPagePathData } from './on-demand-entry-handler'
+// findPagePathData is lazy loaded - on-demand-entry-handler imports build/entries which is heavy
 import type { RouteDefinition } from '../route-definitions/route-definition'
 import {
   type EntryKey,
@@ -97,7 +97,7 @@ import { devIndicatorServerState } from './dev-indicator-server-state'
 import { getDisableDevIndicatorMiddleware } from '../../next-devtools/server/dev-indicator-middleware'
 import { getRestartDevServerMiddleware } from '../../next-devtools/server/restart-dev-server-middleware'
 import { backgroundLogCompilationEvents } from '../../shared/lib/turbopack/compilation-events'
-import { getSupportedBrowsers, printBuildErrors } from '../../build/utils'
+import { getSupportedBrowsers } from '../../build/get-supported-browsers'
 import {
   receiveBrowserLogsTurbopack,
   handleClientFileLogs,
@@ -653,6 +653,8 @@ export async function createHotReloaderTurbopack(
 
       // Certain crtical issues prevent any entrypoints from being constructed so return early
       if (!('routes' in entrypoints)) {
+        const { printBuildErrors } =
+          require('../../build/utils') as typeof import('../../build/utils')
         printBuildErrors(entrypoints, true)
 
         currentEntriesHandlingResolve!()
@@ -1312,19 +1314,21 @@ export async function createHotReloaderTurbopack(
           await currentEntriesHandling
 
           // TODO We shouldn't look into the filesystem again. This should use the information from entrypoints
-          let routeDef: Pick<
-            RouteDefinition,
-            'filename' | 'bundlePath' | 'page'
-          > =
-            definition ??
-            (await findPagePathData(
+          let routeDef:
+            | Pick<RouteDefinition, 'filename' | 'bundlePath' | 'page'>
+            | undefined = definition
+          if (!routeDef) {
+            const { findPagePathData } =
+              require('./on-demand-entry-handler') as typeof import('./on-demand-entry-handler')
+            routeDef = await findPagePathData(
               projectPath,
               inputPage,
               nextConfig.pageExtensions,
               opts.pagesDir,
               opts.appDir,
               !!nextConfig.experimental.globalNotFound
-            ))
+            )
+          }
 
           // If the route is actually an app page route, then we should have access
           // to the app route definition, and therefore, the appPaths from it.

packages/next/src/server/lib/start-server.ts

@@ -373,6 +373,21 @@ export async function startServer(
           logBundler: isDev,
         })
 
+        // Print "Ready" immediately for fast perceived startup
+        // Requests will wait via handlersPromise until init completes
+        const startServerProcessDuration =
+          performance.mark('next-start-end') &&
+          performance.measure(
+            'next-start-duration',
+            'next-start',
+            'next-start-end'
+          ).duration
+        const formatDurationText =
+          startServerProcessDuration > 2000
+            ? `${Math.round(startServerProcessDuration / 100) / 10}s`
+            : `${Math.round(startServerProcessDuration)}ms`
+        Log.event(`Ready in ${formatDurationText}`)
+
         let cleanupStarted = false
         let closeUpgraded: (() => void) | null = null
         const cleanup = () => {
@@ -457,21 +472,7 @@ export async function startServer(
         nextServer = initResult.server
         closeUpgraded = initResult.closeUpgraded
 
-        const startServerProcessDuration =
-          performance.mark('next-start-end') &&
-          performance.measure(
-            'next-start-duration',
-            'next-start',
-            'next-start-end'
-          ).duration
-
         handlersReady()
-        const formatDurationText =
-          startServerProcessDuration > 2000
-            ? `${Math.round(startServerProcessDuration / 100) / 10}s`
-            : `${Math.round(startServerProcessDuration)}ms`
-
-        Log.event(`Ready in ${formatDurationText}`)
 
         if (process.env.TURBOPACK && isDev) {
           await validateTurboNextConfig({

test/development/app-dir/isolated-dev-build/isolated-dev-build.test.ts

@@ -7,6 +7,10 @@ describe('isolated-dev-build', () => {
   })
 
   it('should create dev artifacts in .next/dev/ directory', async () => {
+    // Make a request to trigger compilation and directory creation
+    const browser = await next.browser('/')
+    await browser.close()
+
     expect(await next.hasFile('.next/dev')).toBe(true)
     expect(await next.hasFile('.next/server')).toBe(false)
   })

test/development/app-dir/isolated-dev-build/next.config.js

@@ -1,6 +1,10 @@
 /**
  * @type {import('next').NextConfig}
  */
-const nextConfig = {}
+const nextConfig = {
+  experimental: {
+    isolatedDevBuild: true,
+  },
+}
 
 module.exports = nextConfig

test/integration/invalid-custom-routes/test/index.test.ts

@@ -2,7 +2,14 @@
 
 import fs from 'fs-extra'
 import { join } from 'path'
-import { launchApp, findPort, nextBuild } from 'next-test-utils'
+import {
+  launchApp,
+  findPort,
+  nextBuild,
+  killApp,
+  fetchViaHTTP,
+  retry,
+} from 'next-test-utils'
 
 let appDir = join(__dirname, '..')
 const nextConfigPath = join(appDir, 'next.config.js')
@@ -582,18 +589,43 @@ describe('Errors on invalid custom routes', () => {
     'development mode',
     () => {
       let stderr = ''
+      let app
+      let port
       beforeAll(() => {
         getStderr = async () => {
-          const port = await findPort()
-          await launchApp(appDir, port, {
+          stderr = ''
+          port = await findPort()
+          app = await launchApp(appDir, port, {
             onStderr: (msg) => {
               stderr += msg
             },
           })
+          // Make a request to trigger route validation (lazy loaded with early-ready optimization)
+          try {
+            await fetchViaHTTP(port, '/')
+          } catch {
+            // ignore - request may fail due to invalid config
+          }
+          // Wait for stderr to be populated
+          await retry(
+            () => {
+              if (stderr.length === 0) {
+                throw new Error('stderr still empty')
+              }
+            },
+            3000,
+            500
+          ).catch(() => {
+            // If no stderr after waiting, that's okay - test will fail with assertion
+          })
           return stderr
         }
       })
-      afterEach(() => {
+      afterEach(async () => {
+        if (app) {
+          await killApp(app)
+          app = undefined
+        }
         stderr = ''
       })
 

test/integration/next-image-legacy/typescript/test/index.test.ts

@@ -69,6 +69,8 @@ describe('TypeScript Image Component', () => {
       afterAll(() => killApp(app))
 
       it('should have image types when enabled', async () => {
+        // Make a request to ensure full initialization is complete
+        await renderViaHTTP(appPort, '/')
         const envTypes = await fs.readFile(
           join(appDir, 'next-env.d.ts'),
           'utf8'
@@ -96,7 +98,10 @@ describe('TypeScript Image Component', () => {
         nextConfig,
         content.replace('// disableStaticImages', 'disableStaticImages')
       )
-      const app = await launchApp(appDir, await findPort())
+      const port = await findPort()
+      const app = await launchApp(appDir, port)
+      // Make a request to ensure full initialization is complete
+      await renderViaHTTP(port, '/')
       await killApp(app)
       await fs.writeFile(nextConfig, content)
       const envTypes = await fs.readFile(join(appDir, 'next-env.d.ts'), 'utf8')

test/integration/next-image-new/typescript/test/index.test.ts

@@ -69,6 +69,8 @@ describe('TypeScript Image Component', () => {
       afterAll(() => killApp(app))
 
       it('should have image types when enabled', async () => {
+        // Make a request to ensure full initialization is complete
+        await renderViaHTTP(appPort, '/')
         const envTypes = await fs.readFile(
           join(appDir, 'next-env.d.ts'),
           'utf8'
@@ -95,7 +97,10 @@ describe('TypeScript Image Component', () => {
       nextConfig,
       content.replace('// disableStaticImages', 'disableStaticImages')
     )
-    const app = await launchApp(appDir, await findPort())
+    const port = await findPort()
+    const app = await launchApp(appDir, port)
+    // Make a request to ensure full initialization is complete
+    await renderViaHTTP(port, '/')
     await killApp(app)
     await fs.writeFile(nextConfig, content)
     const envTypes = await fs.readFile(join(appDir, 'next-env.d.ts'), 'utf8')

test/integration/typescript-app-type-declarations/test/index.test.ts

@@ -1,7 +1,7 @@
 /* eslint-env jest */
 
 import { join } from 'path'
-import { findPort, launchApp, killApp } from 'next-test-utils'
+import { findPort, launchApp, killApp, renderViaHTTP } from 'next-test-utils'
 import { promises as fs } from 'fs'
 
 const appDir = join(__dirname, '..')
@@ -16,6 +16,8 @@ describe('TypeScript App Type Declarations', () => {
       let app
       try {
         app = await launchApp(appDir, appPort, {})
+        // Make a request to ensure full initialization is complete
+        await renderViaHTTP(appPort, '/')
         const content = await fs.readFile(appTypeDeclarations, 'utf8')
         expect(content).toEqual(prevContent)
       } finally {
@@ -34,6 +36,8 @@ describe('TypeScript App Type Declarations', () => {
       let app
       try {
         app = await launchApp(appDir, appPort, {})
+        // Make a request to ensure full initialization is complete
+        await renderViaHTTP(appPort, '/')
         const content = await fs.readFile(appTypeDeclarations, 'utf8')
         expect(content).toEqual(prevContent)
       } finally {
@@ -50,6 +54,8 @@ describe('TypeScript App Type Declarations', () => {
     let app
     try {
       app = await launchApp(appDir, appPort, {})
+      // Make a request to ensure full initialization is complete
+      await renderViaHTTP(appPort, '/')
       const stat = await fs.stat(appTypeDeclarations)
       expect(stat.mtime).toEqual(prevStat.mtime)
     } finally {