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

crates/next-cli/src/main.rs

@@ -17,8 +17,11 @@ fn main() {
     let args: Vec<String> = env::args().collect();
 
     // Get the directory where this binary lives (packages/next/bin/)
+    // Use canonicalize to resolve symlinks (e.g., node_modules/.bin/next -> packages/next/bin/next)
     let bin_dir = env::current_exe()
         .expect("failed to get executable path")
+        .canonicalize()
+        .expect("failed to canonicalize executable path")
         .parent()
         .expect("failed to get parent directory")
         .to_path_buf();
@@ -42,6 +45,18 @@ fn main() {
             cmd.env("NODE_OPTIONS", &node_options);
         }
 
+        // Dev-specific environment variables
+        if args.get(1).map(|s| s.as_str()) == Some("dev") {
+            // Set development env vars (previously done by cross-env in pnpm scripts)
+            // This allows the Rust binary to handle the full restart loop
+            if env::var("NEXT_PRIVATE_LOCAL_DEV").is_err() {
+                cmd.env("NEXT_PRIVATE_LOCAL_DEV", "1");
+            }
+            if env::var("NEXT_TELEMETRY_DISABLED").is_err() {
+                cmd.env("NEXT_TELEMETRY_DISABLED", "1");
+            }
+        }
+
         // macOS workaround: limit file watchers to avoid slow close
         // https://github.com/nodejs/node/issues/29949
         #[cfg(target_os = "macos")]

packages/next/bin/next

@@ -1,5 +1,13 @@
 #!/bin/sh
-DIR="$(dirname "$0")"
+# Resolve symlinks to get the real directory (handles node_modules/.bin symlinks)
+SCRIPT="$0"
+while [ -L "$SCRIPT" ]; do
+  DIR="$(dirname "$SCRIPT")"
+  SCRIPT="$(readlink "$SCRIPT")"
+  # Handle relative symlinks
+  [ "${SCRIPT#/}" = "$SCRIPT" ] && SCRIPT="$DIR/$SCRIPT"
+done
+DIR="$(dirname "$SCRIPT")"
 
 # Development: local binary
 [ -x "$DIR/next-native" ] && exec "$DIR/next-native" "$@"

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({