@wular/pnext 0.0.24 → 0.1.0

package/src/dev/server.ts

@@ -3,12 +3,15 @@ import { readFile, readdir, rm, stat, watch } from 'node:fs/promises'
 import path from 'node:path'
 import {
   DEFERRED_DYNAMIC_SIDECAR,
+  buildClientEntries,
   buildClientEntry,
+  clientSourceHash,
   deferredDynamicRefById,
   prebuiltRuntimeDir,
   registerDeferredDynamicRef,
 } from '../client/build'
 import { drainPreplanBuilds } from '../runtime/vendor'
+import { getClientActionBundler } from './client-actions'
 import { devClientCacheKey } from './restart/client-key'
 import { clientChunkStoreDir, contentAddressDir, sweepClientChunkStore } from './client-chunk-store'
 import { restartCacheEnabled } from './restart/enabled'
@@ -98,9 +101,12 @@ import type { RouteManifestEntry, RouteParamValue } from '../types'
 import {
   clearDevRouteBundleKeys,
   devClientModuleHref,
+  devClientReferenceGroups,
+  devClientReferenceModules,
   devModuleGraph,
   devRouteModuleLoaders,
   devServerModuleHref,
+  importDevModule,
   warmDevModulePipeline,
 } from '../runtime/modules'
 import { ssrClientReference } from '../client/reference'
@@ -280,6 +286,7 @@ export async function startDevServer(options: DevServerOptions) {
   installGlobalCssCache(config)
   markBoot('boot:registry')
   let routes = await scanRoutes(config.appPath)
+  setDevClientRoutes(config, routes)
   markBoot('boot:scanRoutes')
   await validateProxyFiles(config)
   let proxyRunner = createProxyRunner(config)
@@ -351,7 +358,10 @@ export async function startDevServer(options: DevServerOptions) {
     }
     // The route table is built from file paths only, so only an added, removed
     // or renamed file can change it — a plain save never does.
-    if (structural) routes = await scanRoutes(config.appPath)
+    if (structural) {
+      routes = await scanRoutes(config.appPath)
+      setDevClientRoutes(config, routes)
+    }
     await validateProxyFiles(config)
     proxyRunner = createProxyRunner(config)
     devImportVersion = `${Date.now()}`
@@ -914,22 +924,43 @@ async function warmDevPageModule(config: ResolvedConfig, route: RouteManifestEnt
 
 /**
  * The client-SSR half of the route: `markClientReferences` imports every SSR-able reference through
- * the CLIENT layer, a different artifact from the browser bundle `buildDevClient` warms, and naming
- * those artifacts walks the reference's whole source graph. Resolving the href here is the same
- * memoized call the render makes, so a request that beats us joins the work instead of repeating it.
+ * the CLIENT layer, a different artifact from the browser bundle `buildDevClient` warms. Import the
+ * content-addressed artifacts here, alongside the route bundle, so a restart evaluates them once
+ * before the render reaches the same module-registry entries.
+ *
+ * The batchable references are one esbuild pass over the whole set rather than one walk per file
+ * (`devClientReferenceModules`); the render joins that same pass. What the pass cannot own - package
+ * references, pages-router sources - keeps the per-file naming below.
  */
 async function warmDevClientReferences(config: ResolvedConfig, route: RouteManifestEntry) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   if (process.env.PNEXT_DEV_WARM_CLIENT_REFS === '0') return
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  const evaluate = process.env.PNEXT_DEV_PRELOAD_REF_IMPORTS !== '0'
   const target = serverBundleTargetForRuntime(route.segmentConfig?.runtime)
-  const files = new Set(
-    route.clientReferences.filter(ssrClientReference).map(reference => reference.file),
-  )
-  await Promise.allSettled(
-    // The version argument is unused by devClientModuleHref (artifacts are named
-    // by content), so there is nothing to keep in sync with the render's call.
-    [...files].map(file => devClientModuleHref(config, file, undefined, target)),
-  )
+  const { batched, perModule } = devClientReferenceGroups(config, route)
+  await Promise.allSettled([
+    batched.length > 0
+      ? devClientReferenceModules(config, route, { evaluate }).catch(error => {
+          console.debug(
+            `PNext dev warm failed for the client references of ${route.route}; falling back to per-module loading.`,
+            error,
+          )
+          throw error
+        })
+      : Promise.resolve(),
+    ...perModule.map(async file => {
+      const href = await devClientModuleHref(config, file, undefined, target)
+      if (evaluate) {
+        try {
+          await importDevModule(href, { warm: true })
+        } catch (error) {
+          console.debug(`PNext dev warm evaluation failed for client reference ${file}.`, error)
+          throw error
+        }
+      }
+    }),
+  ])
 }
 
 const HISTORY_LIMIT = 8
@@ -1203,8 +1234,30 @@ async function loadDeferredDynamicSidecar(outDir: string) {
   }
 }
 
+// The current scan's routes, per app: the client build must span EVERY client route in one
+// esbuild graph (like prod) so shared modules keep one identity — per-route graphs shipped
+// per-route copies of shared libraries, breaking context identity across navigations and
+// remounting the app shell (splash) on every soft nav.
+const devClientRouteSets = new Map<string, RouteManifestEntry[]>()
+function setDevClientRoutes(config: ResolvedConfig, routes: RouteManifestEntry[]) {
+  devClientRouteSets.set(config.outPath, routes)
+}
+function devClientBatchRoutes(config: ResolvedConfig, route: RouteManifestEntry) {
+  const all = devClientRouteSets.get(config.outPath)
+  if (!all?.some(candidate => candidate.id === route.id)) return [route]
+  return all.filter(
+    candidate =>
+      candidate.client || candidate.clientReferences.length > 0 || candidate.needsRouterEntry,
+  )
+}
+
 async function buildDevClient(config: ResolvedConfig, route: RouteManifestEntry) {
-  const cacheKey = await routeClientCacheKey(config, route)
+  const batchRoutes = devClientBatchRoutes(config, route)
+  const cacheKeys = await Promise.all(batchRoutes.map(entry => routeClientCacheKey(config, entry)))
+  const cacheKey =
+    batchRoutes.length === 1
+      ? cacheKeys[0]!
+      : `batch-${clientSourceHash([...cacheKeys].sort().join('\n'))}`
   const outDir = path.join(config.outPath, 'cache', 'client', cacheKey)
   const outFile = path.join(outDir, `${clientEntryName(route)}.js`)
 
@@ -1231,7 +1284,27 @@ async function buildDevClient(config: ResolvedConfig, route: RouteManifestEntry)
   // set) so concurrent callers can't both slip past the dedup check.
   const inner = (async () => {
     await ensureDir(outDir)
-    const file = await buildClientEntry({ config, route, outDir, dev: true })
+    // The action stub plugin builds its filter from the DISCOVERED action modules, so discovery has
+    // to have run before the build is constructed. A route-module compile arms it, but a batch spans
+    // routes no request has reached: unarmed, their `'use server'` imports bundle the real module and
+    // drag its server-only dependencies (node:crypto, http, tls) into the client graph — which fails
+    // the whole batch, not just that route.
+    if (nextCompatEnabled(config)) await getClientActionBundler()?.ensureArmed()
+    const file =
+      batchRoutes.length === 1
+        ? await buildClientEntry({ config, route, outDir, dev: true })
+        : await (async () => {
+            // Action usage is per-request knowledge in dev; force the action runtime like the
+            // single-route dev build always did.
+            await buildClientEntries({
+              config,
+              routes: batchRoutes,
+              outDir,
+              dev: true,
+              hasServerActions: true,
+            })
+            return outFile
+          })()
     // Dedup this generation's chunk bytes against the shared store before serving
     //: identical chunks recur across generations, and this is
     // the one place all of a generation's output exists before requests read it.

package/src/render/island-context.ts

@@ -63,3 +63,6 @@ export const RouteParamsContext = sharedContext<RouteParamsSnapshot | null>(
   'pnext.routeParamsContext',
   null,
 )
+
+/** Marks a client island whose nearest Suspense boundary owns static-generation fallback UI. */
+export const CsrBailoutContext = sharedContext('pnext.csrBailoutContext', false)

package/src/render/ppr.ts

@@ -65,6 +65,10 @@ const PRERENDER_STORAGE = Symbol.for('pnext.prerenderStorage')
 const prerenderStorage = ((globalThis as Record<PropertyKey, unknown>)[PRERENDER_STORAGE] ??=
   new AsyncLocalStorage<PrerenderScope>()) as AsyncLocalStorage<PrerenderScope>
 
+const CSR_BAILOUT_STORAGE = Symbol.for('pnext.csrBailoutStorage')
+const csrBailoutStorage = ((globalThis as Record<PropertyKey, unknown>)[CSR_BAILOUT_STORAGE] ??=
+  new AsyncLocalStorage<boolean>()) as AsyncLocalStorage<boolean>
+
 interface PrerenderDynamicTracker {
   dynamic: boolean
 }
@@ -189,6 +193,16 @@ export function isPrerendering() {
   return prerenderStorage.getStore() !== undefined
 }
 
+/** Run a legacy static render where client URL hooks defer to Suspense. */
+export function runWithCsrBailout<T>(callback: () => T): T {
+  return csrBailoutStorage.run(true, callback)
+}
+
+/** True while a legacy static render must defer URL-dependent client islands. */
+export function isCsrBailoutPrerender(): boolean {
+  return csrBailoutStorage.getStore() === true
+}
+
 /** True inside a runtime-prefetch prerender (see PrerenderScope.runtimePrefetch). */
 export function isRuntimePrefetchPrerender(): boolean {
   return prerenderStorage.getStore()?.runtimePrefetch === true