@wular/pnext 0.0.24 → 0.1.0

package/src/compat/client/segment-cache-policy.ts

@@ -89,24 +89,6 @@ function record(input: SegmentCacheRecord): void {
     complete: input.complete,
     runtime: input.runtime,
   })
-  // App Shells: the per-URL prerender carried the route's shared shell. File it
-  // at the route's fallback vary path (empty vary = every param value) as a
-  // SHELL — it paints, but a navigation still fetches the per-URL remainder.
-  if (decoded.shell) {
-    recordSegment({
-      segmentPath: input.segmentPath,
-      pathname: input.pathname,
-      search: '',
-      html: decoded.shell.html,
-      staleTimeMs: input.staleTimeMs,
-      complete: false,
-      static: true,
-      runtime: false,
-      vary: [],
-      route: decoded.shell.route,
-      params: decoded.params,
-    })
-  }
   recordSegment({
     segmentPath: input.segmentPath,
     pathname: input.pathname,
@@ -116,6 +98,7 @@ function record(input: SegmentCacheRecord): void {
     complete: input.complete,
     static: input.static,
     runtime: input.runtime,
+    ...(input.postponedShell ? { postponedShell: true } : {}),
     vary: decoded.vary,
     // w9-segment-split: pass the layout/page vary sets through so the cache can
     // file the two frames alongside the whole-document entry.
@@ -124,6 +107,7 @@ function record(input: SegmentCacheRecord): void {
     // The route's static siblings, so a learned dynamic pattern never keys onto
     // a literal sibling's URL.
     ...(decoded.staticSiblings ? { staticSiblings: decoded.staticSiblings } : {}),
+    ...(decoded.shell ? { shell: decoded.shell } : {}),
     route: decoded.route,
     params: decoded.params,
   })
@@ -140,6 +124,7 @@ function take(input: {
       html: hit.html,
       networkFree: hit.networkFree,
       prefetchSatisfied: hit.prefetchSatisfied,
+      postponedShell: hit.postponedShell,
     }
   }
   // w9-segment-split: the whole-document entry missed because ONE of the two
@@ -154,6 +139,7 @@ function take(input: {
         html: composed.html,
         networkFree: composed.networkFree,
         prefetchSatisfied: composed.prefetchSatisfied,
+        postponedShell: composed.postponedShell,
       }
     : null
 }

package/src/compat/client/segment-cache.ts

@@ -96,6 +96,10 @@ export interface SegmentRecordInput extends SegmentPayloadMeta {
   static: boolean
   /** True when the payload came from a runtime (request-sampled) prefetch. */
   runtime: boolean
+  /** True when the server marked the payload its POSTPONED (PPR) shell for this URL. */
+  postponedShell?: boolean
+  /** True when this is an extracted route-wide App Shell, valid for sibling params too. */
+  sharedAppShell?: boolean
   /** True when the route's catch-all is optional (`[[...slug]]`). */
   catchAllOptional?: boolean
 }
@@ -110,6 +114,8 @@ interface SegmentEntry {
   complete: boolean
   static: boolean
   runtime: boolean
+  postponedShell: boolean
+  sharedAppShell: boolean
 }
 
 export interface SegmentHit {
@@ -123,6 +129,11 @@ export interface SegmentHit {
    */
   prefetchSatisfied: boolean
   runtime: boolean
+  /**
+   * The entry is an authorised static shell stage: either this URL's own
+   * postponed PPR shell, or an extracted route-wide App Shell.
+   */
+  postponedShell: boolean
 }
 
 interface LearnedRoute {
@@ -158,6 +169,26 @@ function now(): number {
 // ---------------------------------------------------------------------------
 
 export function recordSegment(input: SegmentRecordInput): void {
+  // A fully-static prerender may carry the route's params-hanging App Shell
+  // alongside its concrete per-URL body. File that extracted shell through the
+  // same cache seam as every other response so all producers (the router policy
+  // and the standalone segment-prefetch scheduler) prime the fallback vary
+  // path consistently.
+  if (input.shell) {
+    recordAppShell({
+      segmentPath: input.segmentPath,
+      pathname: input.pathname,
+      search: '',
+      html: input.shell.html,
+      staleTimeMs: input.staleTimeMs,
+      complete: false,
+      static: true,
+      runtime: false,
+      vary: [],
+      route: input.shell.route,
+      params: input.params,
+    })
+  }
   recordOneSegment(input)
   // w9-segment-split: a body response the server split also files its two
   // frames, each under its OWN vary set. Additive — the whole-document entry
@@ -202,6 +233,27 @@ export function recordSegment(input: SegmentRecordInput): void {
   }
 }
 
+/**
+ * Extract and file a route-wide App Shell from a prerender response.
+ *
+ * Next publishes a byte boundary and decodes the Flight prefix again. PNext's
+ * segment payload carries HTML, whose equivalent boundary is the first
+ * streamed continuation: removing those resolved chunks leaves the original
+ * params-hanging Suspense shell.
+ */
+export function recordAppShell(input: SegmentRecordInput): void {
+  recordSegment({
+    ...input,
+    html: stripStreamedContinuation(input.html),
+    complete: false,
+    static: true,
+    runtime: false,
+    postponedShell: true,
+    sharedAppShell: true,
+    vary: [],
+  })
+}
+
 /**
  * A payload is REWRITE-PRODUCED when the route the server resolved does not describe the URL it was
  * served at - either structurally, or in its concrete param values.
@@ -282,6 +334,22 @@ function recordOneSegment(rawInput: SegmentRecordInput): void {
     // map without limit (memory-pressure leak-slope test).
     trimLearnedRoutes(byRoute)
   }
+  const sharedAppShell = input.sharedAppShell === true || isRouteWideAppShell(input)
+  const existing = entries.get(key)
+  // A fully-static response can extract and cache this route shell with its
+  // own static window, then a concurrent runtime-shell response for the same
+  // fallback key can arrive with the full response's zero window. Next tracks
+  // shell-stage freshness independently; do not let that duplicate erase the
+  // already-fresh extracted shell.
+  if (
+    sharedAppShell &&
+    input.staleTimeMs <= 0 &&
+    existing?.sharedAppShell &&
+    now() - existing.time < existing.staleTimeMs
+  ) {
+    touch(key)
+    return
+  }
   entries.set(key, {
     key,
     html: input.html,
@@ -291,11 +359,39 @@ function recordOneSegment(rawInput: SegmentRecordInput): void {
     complete: input.complete,
     static: input.static,
     runtime: input.runtime,
+    postponedShell: input.postponedShell === true,
+    sharedAppShell,
   })
   touch(key)
   trim()
 }
 
+/**
+ * A runtime App Shell response renders the route with its params hanging. Its
+ * empty fallback vary path and absent concrete route params distinguish it
+ * from an ordinary postponed response for one URL.
+ */
+function isRouteWideAppShell(input: SegmentRecordInput): boolean {
+  if (!input.postponedShell || !input.static || !input.route || input.vary?.length !== 0)
+    return false
+  const concrete = matchRoutePattern(input.route, input.pathname, true)
+  if (concrete !== null && Object.keys(concrete).some(name => input.params[name] === undefined)) {
+    return true
+  }
+  // PNext restamps concrete params onto the shell payload for client state,
+  // even though the render itself hung them. The navigation-state child keeps
+  // the params-hanging route pattern, unlike an ordinary exact-URL PPR shell.
+  const match = /<script id="__PNEXT_NAV_STATE__" type="application\/json">(.*?)<\/script>/s.exec(
+    input.html,
+  )
+  if (!match?.[1]) return false
+  try {
+    return (JSON.parse(match[1]) as { children?: unknown }).children === input.route
+  } catch {
+    return false
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Lookup.
 // ---------------------------------------------------------------------------
@@ -371,6 +467,11 @@ export function takeSegment(options: {
       // match. The navigation that follows still fetches the dynamic remainder.
       prefetchSatisfied: !shared || (optimisticRoutingEnabled() && (entry.static || entry.runtime)),
       runtime: entry.runtime,
+      // An ordinary postponed response only describes the URL it rendered, so
+      // sharing clears its paint licence. An extracted App Shell was rendered
+      // with route params deliberately hanging and is the server's shell stage
+      // for every sibling param, so it retains that licence.
+      postponedShell: entry.postponedShell && (!shared || entry.sharedAppShell),
     }
   }
   return null
@@ -472,6 +573,9 @@ export function takeComposedSegment(options: {
     networkFree: layout.networkFree && page.networkFree,
     prefetchSatisfied: layout.prefetchSatisfied && page.prefetchSatisfied,
     runtime: layout.runtime || page.runtime,
+    // Composed from two frames: it is the destination's own static stage only when both
+    // halves are.
+    postponedShell: layout.postponedShell && page.postponedShell,
   }
 }
 

package/src/compat/client/segment-prefetch.ts

@@ -1,5 +1,6 @@
 import {
   decodeSegmentPayload,
+  recordAppShell,
   recordSegment,
   segmentPrefetchCovered,
   takeSegment,
@@ -209,6 +210,7 @@ function recordBodySegment(url: URL, response: Response, body: string, staleTime
     static: response.headers.get('x-nextjs-prerender') === '1',
     runtime,
     vary: decoded.vary,
+    ...(decoded.shell ? { shell: decoded.shell } : {}),
     route: decoded.route,
     params: decoded.params,
   })
@@ -332,23 +334,21 @@ async function fetchAppShell(pathname: string): Promise<void> {
   if (!response.ok) return
   const decoded = decodeSegmentPayload(await response.text(), INDEX_SEGMENT_PATH)
   if (!decoded) return
-  recordSegment({
+  recordAppShell({
     segmentPath: INDEX_SEGMENT_PATH,
     pathname,
     search: '',
-    html: decoded.html,
+    html: decoded.shell?.html ?? decoded.html,
     // Recorded with the response's own window (NaN → the old 300s fallback):
     // the 30s floor is a re-prefetch dedupe rule, not a payload lifetime.
     staleTimeMs: (seconds => (Number.isFinite(seconds) ? seconds : 300) * 1000)(
       headerStaleTimeSeconds(response),
     ),
-    // A shell, by construction: the params-dependent subtree is still a hole,
-    // so a navigation paints it and then fetches the per-URL remainder.
     complete: false,
     static: response.headers.get('x-nextjs-prerender') === '1',
     runtime: false,
-    vary: decoded.vary,
-    route: decoded.route,
+    vary: [],
+    route: decoded.shell?.route ?? decoded.route,
     params: decoded.params,
   })
 }

package/src/compat/next/config-loader.ts

@@ -558,8 +558,8 @@ const DEPRECATED_CONFIG_OPTIONS: readonly { key: string; reason: (file: string)
 // re-run every call - it throws.
 const warnedConfigPaths = new Set<string>()
 
-function validateConfig(config: NextConfigObject, configPath: string): void {
-  if (!warnedConfigPaths.has(configPath)) {
+function validateConfig(config: NextConfigObject, configPath: string, emitWarnings: boolean): void {
+  if (emitWarnings && !warnedConfigPaths.has(configPath)) {
     warnedConfigPaths.add(configPath)
     const configFileName = path.basename(configPath)
     warnUnknownConfigKeys(config)
@@ -647,7 +647,7 @@ function validateDevIndicatorPosition(config: NextConfigObject): void {
  */
 export async function loadNextConfig(
   root: string,
-  options: { dev?: boolean; serve?: boolean } = {},
+  options: { dev?: boolean; serve?: boolean; warnings?: boolean } = {},
 ): Promise<LoadNextConfigResult> {
   const configPath = findConfigPath(root)
   if (!configPath) {
@@ -681,7 +681,9 @@ export async function loadNextConfig(
     await resolveConfigExport(exported, Boolean(options.dev)),
     root,
   )
-  validateConfig(config, configPath)
+  // Internal build workers need the resolved config but must not surface a
+  // second copy of CLI warnings already emitted by the owning build process.
+  validateConfig(config, configPath, options.warnings !== false)
   setNextConfig(config)
   applyEnv(config)
   applyRuntimeConfig(config)

package/src/compat/next/navigation.ts

@@ -16,7 +16,7 @@ import {
   ReadonlyURLSearchParams,
   redirect as pnextRedirect,
 } from '../../api/navigation'
-import { isPostpone } from '../../render/postpone'
+import { isPostpone, PostponeError } from '../../render/postpone'
 import { currentParams, currentRequest } from '../../request/context'
 import { useContext } from 'preact/hooks'
 import {
@@ -24,7 +24,11 @@ import {
   currentParamsSnapshot,
   hasLayoutSegmentScope,
 } from '../../render/slots'
-import { LayoutSegmentContext, RouteParamsContext } from '../../render/island-context'
+import {
+  CsrBailoutContext,
+  LayoutSegmentContext,
+  RouteParamsContext,
+} from '../../render/island-context'
 import { canonicalUrlHref } from './canonical-url'
 import { isUnrecognizedActionError } from '../actions/unrecognized-error'
 import { stripBasePath } from '../client/base-path'
@@ -96,9 +100,19 @@ export function usePathname() {
 }
 
 export function useSearchParams(): ReadonlyURLSearchParams {
+  if (useContext(CsrBailoutContext) && isStaticCsrBailout()) {
+    throw new PostponeError('useSearchParams')
+  }
   return new ReadonlyURLSearchParams(currentUrl().search)
 }
 
+function isStaticCsrBailout(): boolean {
+  const storage = (globalThis as Record<PropertyKey, unknown>)[
+    Symbol.for('pnext.csrBailoutStorage')
+  ] as { getStore?: () => boolean | undefined } | undefined
+  return storage?.getStore?.() === true
+}
+
 export function useParams<Route extends RoutePath = RoutePath>() {
   return resolveParams() as RouteParams<Route>
 }

package/src/compat/pages/router.ts

@@ -1,10 +1,20 @@
 import { createHash } from 'node:crypto'
 import { existsSync, statSync } from 'node:fs'
-import { copyFile, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises'
+import {
+  copyFile,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  symlink,
+  writeFile,
+} from 'node:fs/promises'
 import path from 'node:path'
 import { tmpdir } from 'node:os'
+import { fileURLToPath } from 'node:url'
 import { hasUseClientDirective } from '../../client/reference-stub'
-import { listFiles, toPosixPath } from '../../utils/fs'
+import { listFiles, listFilesSync, toPosixPath } from '../../utils/fs'
 import { getNextConfig } from '../next/config-loader'
 
 const basePageExtensions = ['tsx', 'ts', 'jsx', 'js', 'mjs']
@@ -51,17 +61,103 @@ export async function materializePagesApp(root: string): Promise<string | undefi
   const pagesPath = path.join(root, 'pages')
   if (!existsSync(pagesPath)) return undefined
 
+  const nativeApp = path.join(root, 'app')
+  const pages = await discoverPages(pagesPath)
+  const apiRoutes = await discoverPagesApi(pagesPath)
+  if (pages.length === 0 && apiRoutes.length === 0) return undefined
+
+  // Content-addressed, never rebuilt in place. Every pnext process that resolves this app's config
+  // materializes — a build and the warm child it spawns do so concurrently — so wiping and repopulating
+  // one shared directory let one process scan a half-materialized tree ("page.js doesn't have a root
+  // layout" on a build that passes on the next run). Naming the directory after what goes in it makes
+  // the second writer a no-op, and staging + rename means a reader sees the whole tree or nothing.
   const generatedRoot = path.join(
     tmpdir(),
     'pnext-pages-compat',
-    createHash('sha256').update(root).digest('hex').slice(0, 16),
+    materializationKey(root, nativeApp, pages, apiRoutes),
   )
+  const appPath = path.join(generatedRoot, 'app')
+  if (existsSync(appPath)) return appPath
+
+  const staging = `${generatedRoot}.${process.pid.toString(36)}.staging`
+  await buildMaterializedApp(staging, root, pagesPath, nativeApp, pages, apiRoutes)
+  try {
+    await rename(staging, generatedRoot)
+  } catch {
+    // Another process materialized the same key first; its tree is byte-identical to ours.
+    await rm(staging, { recursive: true, force: true })
+    if (!existsSync(appPath)) throw new Error(`pnext: could not materialize ${root}/pages`)
+  }
+  void sweepStaleMaterializations(path.dirname(generatedRoot))
+  return appPath
+}
+
+/**
+ * Everything the materialized tree is derived from: the pages facts (already parsed out of the
+ * sources), the native app tree's shape, and this module — whose `wrapperSource` writes the files.
+ */
+function materializationKey(
+  root: string,
+  nativeApp: string,
+  pages: PagesRoute[],
+  apiRoutes: PagesApiRoute[],
+): string {
+  const stamp = (file: string) => {
+    const info = statSync(file, { throwIfNoEntry: false })
+    return info ? `${info.size}:${info.mtimeMs}` : ''
+  }
+  const nativeFiles = existsSync(nativeApp)
+    ? listFilesSync(nativeApp)
+        .map(file => `${toPosixPath(path.relative(nativeApp, file))}\0${stamp(file)}`)
+        .sort()
+    : []
+  // Sorted: discovery follows readdir order, and two processes that disagreed on it would key the
+  // same tree twice.
+  const byRelative = <T extends { relative: string }>(routes: T[]) =>
+    [...routes].sort((a, b) => a.relative.localeCompare(b.relative))
+  return createHash('sha256')
+    .update(
+      JSON.stringify([
+        root,
+        materializeExtensions(),
+        byRelative(pages),
+        byRelative(apiRoutes),
+        nativeFiles,
+        stamp(fileURLToPath(import.meta.url)),
+      ]),
+    )
+    .digest('hex')
+    .slice(0, 16)
+}
+
+// Abandoned stagings and superseded trees, swept on an age that no live process can still be using:
+// a dev server holds its materialized tree open for as long as it runs.
+const STALE_MATERIALIZATION_MS = 7 * 24 * 60 * 60_000
+
+async function sweepStaleMaterializations(base: string) {
+  try {
+    const cutoff = Date.now() - STALE_MATERIALIZATION_MS
+    for (const entry of await readdir(base)) {
+      const dir = path.join(base, entry)
+      const info = statSync(dir, { throwIfNoEntry: false })
+      if (info && info.mtimeMs < cutoff) await rm(dir, { recursive: true, force: true })
+    }
+  } catch {
+    // Best-effort: a stale tree only costs a few KB of temp space.
+  }
+}
+
+async function buildMaterializedApp(
+  generatedRoot: string,
+  root: string,
+  pagesPath: string,
+  nativeApp: string,
+  pages: PagesRoute[],
+  apiRoutes: PagesApiRoute[],
+): Promise<void> {
   const appPath = path.join(generatedRoot, 'app')
   const sourcePages = path.join(generatedRoot, 'source-pages')
   const sourceApp = path.join(generatedRoot, 'source-app')
-  const pages = await discoverPages(pagesPath)
-  const apiRoutes = await discoverPagesApi(pagesPath)
-  if (pages.length === 0 && apiRoutes.length === 0) return undefined
 
   await rm(generatedRoot, { recursive: true, force: true })
   await mkdir(appPath, { recursive: true })
@@ -77,7 +173,6 @@ export async function materializePagesApp(root: string): Promise<string | undefi
   const publicDir = path.join(root, 'public')
   if (existsSync(publicDir)) await symlink(publicDir, path.join(generatedRoot, 'public'), 'dir')
 
-  const nativeApp = path.join(root, 'app')
   if (existsSync(nativeApp)) {
     await symlink(nativeApp, sourceApp, 'dir')
     await materializeNativeApp(sourceApp, appPath)
@@ -135,8 +230,6 @@ export async function materializePagesApp(root: string): Promise<string | undefi
       ),
     )
   }
-
-  return appPath
 }
 
 async function materializeNativeApp(sourceApp: string, appPath: string): Promise<void> {

package/src/compat/protocol.ts

@@ -71,12 +71,21 @@ const APP_ROUTE_KINDS = new Set<ResponseFinalizerContext['routeKind']>([
 
 const protocolFinalizer: ResponseFinalizer = ctx => {
   if (!APP_ROUTE_KINDS.has(ctx.routeKind)) return
-  mergeVary(ctx.headers, ROUTER_VARY)
+  if (!isPlainRedirect(ctx)) mergeVary(ctx.headers, ROUTER_VARY)
   normalizeRscRedirectStatus(ctx)
   applyRewrittenHeaders(ctx)
   applyEdgeRuntimeHeader(ctx)
 }
 
+function isPlainRedirect(ctx: ResponseFinalizerContext): boolean {
+  if (ctx.status < 300 || ctx.status >= 400 || !ctx.headers.has('location')) return false
+  return (
+    ctx.request.headers.get('rsc') !== '1' &&
+    !ctx.request.headers.has('next-router-prefetch') &&
+    !ctx.request.headers.has('next-router-segment-prefetch')
+  )
+}
+
 // Next's edge SSR/route wrappers stamp `x-edge-runtime: 1` on every response
 // from a route whose segment config selects the edge runtime (edge-ssr-app.ts).
 // The matched route's runtime rides on the work-unit response hints.

package/src/compat/register/actions.ts

@@ -33,6 +33,7 @@ import {
   actionStubSourceFor,
   clientActionModulesRoot,
   isClientActionModule,
+  loadClientActionSource,
 } from '../actions/client-plugin'
 import { validateServerActionsConfigSync } from '../actions/config'
 import { hoistNonCapturingInlineActions } from '../actions/hoist'
@@ -102,5 +103,6 @@ export function registerActionExtensions(_config: ResolvedConfig): void {
     },
     isClientActionModule,
     stubSource: file => actionStubSourceFor(file, clientActionModulesRoot() ?? undefined),
+    loadClientSource: (file, root) => loadClientActionSource(file, root),
   })
 }

package/src/compat/register/bundler.ts

@@ -67,6 +67,7 @@ import {
 import { createModularizeImportsTransform } from '../bundler/modularize-imports'
 import {
   createOptimizePackageImportsTransform,
+  optimizePackageImportsSniffTokens,
   optimizedPackageSet,
 } from '../bundler/optimize-package-imports'
 import { createRelayTransform } from '../bundler/relay-transform'
@@ -207,6 +208,7 @@ export function registerBundlerExtensions(config: ResolvedConfig): void {
   // route named. Same chain position as modularizeImports, so the emitted leaf specifiers still flow
   // through alias/path resolution.
   const optimizedPackages = optimizedPackageSet(optimizePackageImports())
+  const optimizeSniff = optimizePackageImportsSniffTokens(optimizedPackages)
   const optimizeTransform = createOptimizePackageImportsTransform(optimizedPackages, config.root)
   registerServerSourcePreTransforms(optimizeTransform)
   registerClientSourceTransforms(optimizeTransform)
@@ -363,7 +365,7 @@ export function registerBundlerExtensions(config: ResolvedConfig): void {
   // a vendor pass runs over the same workspace sources.
   const firstPartyRewrite = createFirstPartySourceRewrite(config, {
     transform: optimizeTransform,
-    sniff: specifierSniffTokens(optimizedPackages),
+    sniff: optimizeSniff,
   })
   const priorClient = getBundlerExtensions().clientEsbuildPlugins
   const priorServer = getBundlerExtensions().serverEsbuildPlugins
@@ -411,11 +413,7 @@ export function registerBundlerExtensions(config: ResolvedConfig): void {
       ...optional(clientExternalPackageResolvePlugin(cfg, externals)),
       // First-party source outside every source root gets no
       // registerClientSourceTransforms pass — the OPI rewrite must live here too.
-      firstPartyClientOptimizeImportsLoadPlugin(
-        cfg,
-        optimizeTransform,
-        specifierSniffTokens(optimizedPackages),
-      ),
+      firstPartyClientOptimizeImportsLoadPlugin(cfg, optimizeTransform, optimizeSniff),
       clientDynamicCommonJsImportsPlugin(cfg.root),
       ...priorClient(cfg),
     ],

package/src/compat/register/routing.ts

@@ -297,10 +297,9 @@ function usesNextRequestImport(source: string): boolean {
   // __prerender_bypass cookie opts into a fresh dynamic render at request time.
   const draftModeOnlyImport =
     /\bimport\s+\{\s*draftMode\s*(?:as\s+[\w$]+\s*)?,?\s*\}\s*from\s*['"]next\/headers(?:\.js)?['"]/g
-  return (
-    nextHeadersImportPattern().test(withoutComments.replace(draftModeOnlyImport, '')) ||
-    importsNextNavigationRequestHook(withoutComments)
-  )
+  const headers = nextHeadersImportPattern().test(withoutComments.replace(draftModeOnlyImport, ''))
+  const client = /^\s*['"]use client['"]\s*;?/.test(withoutComments)
+  return headers || (!client && importsNextNavigationRequestHook(withoutComments))
 }
 
 function nextHeadersImportPattern() {

package/src/compat/tsconfig-defaults.ts

@@ -171,13 +171,14 @@ function typeDefinitionGlobPatterns(distDir: string): string[] {
  */
 export async function writeTsconfigDefaults(config: ResolvedConfig): Promise<void> {
   const tsConfigPath = path.join(config.root, 'tsconfig.json')
+  const tempDirectory = path.dirname(config.root)
   let isFirstTimeSetup = false
   if (!existsSync(tsConfigPath)) {
     if (!hasTypescriptSources(config.root)) return
     isFirstTimeSetup = true
     // Atomic: the client build's tsconfig-paths reader runs in a parallel phase
     // and must never see a truncated file.
-    await writeFileAtomic(tsConfigPath, '{}\n')
+    await writeFileAtomic(tsConfigPath, '{}\n', tempDirectory)
   }
 
   let userTsConfig: TsconfigShape
@@ -271,7 +272,7 @@ export async function writeTsconfigDefaults(config: ResolvedConfig): Promise<voi
 
   if (suggestedActions.length === 0 && requiredActions.length === 0) return
 
-  await writeFileAtomic(tsConfigPath, `${JSON.stringify(userTsConfig, null, 2)}\n`)
+  await writeFileAtomic(tsConfigPath, `${JSON.stringify(userTsConfig, null, 2)}\n`, tempDirectory)
 
   if (isFirstTimeSetup) {
     console.log(

package/src/config.ts

@@ -61,7 +61,7 @@ export interface ConfigSourceOverrides {
 }
 export type ConfigSource = (
   root: string,
-  options: { dev?: boolean; serve?: boolean },
+  options: { dev?: boolean; serve?: boolean; warnings?: boolean },
 ) => Promise<ConfigSourceOverrides>
 
 let configSource: ConfigSource | undefined
@@ -73,7 +73,7 @@ export function registerConfigSource(source: ConfigSource): void {
 async function resolveConfigSource(
   config: PNextConfig,
   root: string,
-  options: { dev?: boolean; serve?: boolean },
+  options: { dev?: boolean; serve?: boolean; warnings?: boolean },
 ): Promise<ConfigSourceOverrides> {
   if (!config.compat?.next) return {}
   if (!configSource) {
@@ -87,7 +87,7 @@ async function resolveConfigSource(
 // then consume what the build emitted instead of regenerating it, since request time can be read-only.
 export async function loadConfig(
   rootInput = process.cwd(),
-  options: { dev?: boolean; serve?: boolean } = {},
+  options: { dev?: boolean; serve?: boolean; warnings?: boolean } = {},
 ): Promise<ResolvedConfig> {
   const root = canonicalRoot(path.resolve(rootInput))
   await loadEnv(root, options)