@wular/pnext 0.1.7 → 0.1.8

package/src/cli/start.ts

@@ -4,8 +4,10 @@
  * dynamically once the port is bound, so neither the listen syscall nor the
  * ready banner waits on parsing it.
  */
+import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'
+import { pathToFileURL } from 'node:url'
 import { loadConfig } from '../config'
 import type { ResolvedConfig } from '../config'
 import { bootstrapCompat } from '../compat-bootstrap'
@@ -17,6 +19,7 @@ import { registerPrebundleResolve } from '../runtime/prebundle'
 import { browserHost, ensurePortFree, openBrowser, printServerReady } from './serve/ui'
 import type { BuildManifest } from '../types'
 import type { PeerAddressSource } from '../routing/forwarded'
+import { buildIndexFile, buildManifestFile, linkStandaloneOrigins } from '../runtime/production'
 
 interface StartOptions {
   root?: string
@@ -35,8 +38,24 @@ export async function createRequestHandler(
   options: { root?: string; config?: ResolvedConfig; manifest?: BuildManifest } = {},
 ): Promise<RequestHandler> {
   registerPrebundleResolve()
+  const config = options.config ?? (await loadConfig(options.root, { serve: true }))
+  // A release this copy cannot serve in place runs on the framework copy it ships.
+  if (shipsElsewhere(config)) {
+    const shipped = await shippedStart(config)
+    return shipped.createRequestHandler({ root: options.root, manifest: options.manifest })
+  }
   const { createRequestHandler: create } = await import('./serve/pipeline')
-  return create(options)
+  return create({ ...options, config })
+}
+
+/** A built release this copy cannot serve in place; a missing build falls through to its error. */
+function shipsElsewhere(config: ResolvedConfig) {
+  return existsSync(buildIndexFile(config.outPath)) && !linkStandaloneOrigins(config.outPath)
+}
+
+function shippedStart(config: ResolvedConfig) {
+  const entry = pathToFileURL(path.join(config.outPath, 'server', 'entry.js')).href
+  return import(entry) as Promise<typeof import('./start')>
 }
 
 export async function maybeBuiltFile(
@@ -51,8 +70,14 @@ export async function start(options: StartOptions = {}) {
   const port = options.port ?? 3000
   // Next's documented default. Bun resolves 'localhost' to ::1 only, refusing IPv4 clients.
   const hostname = options.hostname ?? '0.0.0.0'
+  const config = await loadConfig(options.root, { serve: true })
+  // Delegate before compat bootstraps here, so only the shipped copy patches process globals.
+  if (shipsElsewhere(config)) {
+    await (await shippedStart(config)).start(options)
+    return
+  }
   // Export builds are not served; pnext serves its standalone output directly.
-  const config = await guardUnservableOutputMode(options.root)
+  await guardUnservableOutputMode(config)
   const manifest = await readProductionManifest(config)
   await ensurePortFree(port, hostname)
 
@@ -110,9 +135,7 @@ function installProcessErrorHandlers(): void {
 
 export async function readProductionManifest(config: ResolvedConfig): Promise<BuildManifest> {
   try {
-    return JSON.parse(
-      await readFile(path.join(config.outPath, 'manifest.json'), 'utf8'),
-    ) as BuildManifest
+    return JSON.parse(await readFile(buildManifestFile(config.outPath), 'utf8')) as BuildManifest
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
       throw new Error("No production build found. Run 'pnext build' first.")
@@ -122,8 +145,7 @@ export async function readProductionManifest(config: ResolvedConfig): Promise<Bu
 }
 
 // Export output is unservable; pnext production output remains serveable for standalone apps.
-async function guardUnservableOutputMode(root?: string): Promise<ResolvedConfig> {
-  const config = await loadConfig(root, { serve: true })
+async function guardUnservableOutputMode(config: ResolvedConfig) {
   await bootstrapCompat(config)
   const mode = getBuildExtensions().compat.nextOutputMode()
   if (mode === 'export') {
@@ -142,7 +164,6 @@ async function guardUnservableOutputMode(root?: string): Promise<ResolvedConfig>
         'Use "node .next/standalone/server.js" instead.',
     )
   }
-  return config
 }
 
 // Graceful stop: quit accepting connections, wait for in-flight after() flushes (bounded), then exit

package/src/client/build.ts

@@ -1438,7 +1438,7 @@ async function staticImageModuleSource(config: ResolvedConfig, file: string) {
   const compat = await getAssetExtensions().staticAssetModule({ sourcePath, bytes, emit })
   const source = compat ?? coreStaticAssetModule(sourcePath, bytes, emit)
   for (const relative of emitted) {
-    const target = path.join(config.outPath, 'public', ...relative.split('/'))
+    const target = path.join(config.outPath, 'static', ...relative.split('/'))
     await mkdir(path.dirname(target), { recursive: true })
     if (!existsSync(target)) await copyFile(sourcePath, target)
   }

package/src/client/reference-stub.ts

@@ -11,6 +11,7 @@ import type { ResolvedConfig } from '../config'
 import { resolveImport } from '../resolve/imports'
 import { moduleExportNames, moduleExportStars } from '../resolve/scan-facts'
 import { readText } from '../utils/fs'
+import { hasModuleDirective } from '../utils/directive'
 
 export const clientReferenceRuntimeFile = path.resolve(import.meta.dirname, 'reference.ts')
 
@@ -122,40 +123,7 @@ export async function clientReferenceExportNames(
  * linear and allocation-free.
  */
 export function hasUseClientDirective(source: string) {
-  const isSpace = (index: number) => {
-    const code = source.charCodeAt(index)
-    return code === 32 || (code >= 9 && code <= 13) || (code > 127 && /\s/.test(source[index]!))
-  }
-  let i = 0
-  for (;;) {
-    while (i < source.length && isSpace(i)) i += 1
-    if (source.startsWith('//', i)) {
-      const newline = source.indexOf('\n', i)
-      if (newline === -1) return false
-      i = newline + 1
-      continue
-    }
-    if (source.startsWith('/*', i)) {
-      const end = source.indexOf('*/', i + 2)
-      if (end === -1) return false
-      i = end + 2
-      continue
-    }
-    // Anything that is not a string literal ends the prologue.
-    const quote = source[i]
-    if (quote !== '"' && quote !== "'") return false
-    let end = i + 1
-    while (end < source.length) {
-      const char = source[end]!
-      if (char === quote || char === '\n' || char === '\\') break
-      end += 1
-    }
-    if (source[end] !== quote) return false
-    if (source.slice(i + 1, end) === 'use client') return true
-    i = end + 1
-    while (i < source.length && isSpace(i)) i += 1
-    if (source[i] === ';') i += 1
-  }
+  return hasModuleDirective(source, 'use client')
 }
 
 function isInside(root: string, file: string) {

package/src/compat/actions/extensions.ts

@@ -70,6 +70,7 @@ import { serverActionId, tagServerAction } from './server-tag'
 import { opensWithUseServerDirective } from './detect'
 import { inlineActionModuleKey, isInlineActionId } from './rewrite'
 import { reportActionErrorToUser } from '../lifecycle/error-funnel'
+import { buildManifestFile } from '../../runtime/production'
 
 // ---------------------------------------------------------------------------
 // Build step: action discovery/bundling + server-reference manifest.
@@ -541,7 +542,7 @@ export async function ensureActionsRegistered(runtime: RequestRuntime): Promise<
 // client-action module set (normally armed by the build): render-time form/prop
 // tagging reads it to give module-level actions their stable wire ids.
 async function registerManifestActions(config: ResolvedConfig): Promise<void> {
-  const manifestPath = path.join(config.outPath, 'manifest.json')
+  const manifestPath = buildManifestFile(config.outPath)
   let manifest: BuildManifest
   try {
     manifest = JSON.parse(await readFile(manifestPath, 'utf8')) as BuildManifest
@@ -700,7 +701,7 @@ function requestWouldMiss(config: ResolvedConfig, pathname: string): boolean {
 }
 
 function servableFile(config: ResolvedConfig, pathname: string): boolean {
-  const publicRoot = path.join(config.outPath, 'public')
+  const publicRoot = path.join(config.outPath, 'static')
   const trimmed = pathname.replace(/^\/+|\/+$/g, '')
   const file = trimmed ? path.join(publicRoot, trimmed) : publicRoot
   // Never let a traversal-shaped path claim to be servable (it is not).

package/src/compat/bundler/require-context.ts

@@ -12,6 +12,7 @@
 
 import { existsSync, readdirSync, statSync } from 'node:fs'
 import path from 'node:path'
+import { outCachePath } from '../../out-paths'
 
 /** Extensions whose files also get an extension-less request key (webpack resolves both). */
 const RESOLVABLE_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.json']
@@ -210,7 +211,7 @@ function resolveContextDir(
   const direct = path.resolve(path.dirname(file), specifier)
   if (existsSync(direct)) return direct
   if (paths?.outPath && paths.workspaceRoot) {
-    const cacheRoot = path.join(paths.outPath, 'cache', 'server')
+    const cacheRoot = path.join(outCachePath(paths.outPath), 'server')
     const relative = path.relative(cacheRoot, file)
     if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
       const segments = relative.split(path.sep)

package/src/compat/bundler/webpack-loaders.ts

@@ -25,6 +25,7 @@ import type { Plugin } from 'esbuild'
 import type { ResolvedConfig } from '../../config'
 import { rewriteSpecifierLiterals } from '../../resolve/scan-facts'
 import { turbopackLoaderRules, turbopackResolveAlias, type WebpackLoaderRule } from './config'
+import { outCachePath } from '../../out-paths'
 
 interface LoaderFn {
   (this: LoaderContext, content: string | Buffer): unknown
@@ -293,7 +294,7 @@ function resolveLoaderRequest(root: string, context: string, request: string): P
  */
 function originalResourcePath(resourcePath: string, config: ResolvedConfig | undefined): string {
   if (config) {
-    const cacheRoot = path.join(config.outPath, 'cache', 'server')
+    const cacheRoot = path.join(outCachePath(config.outPath), 'server')
     const rel = path.relative(cacheRoot, resourcePath)
     if (rel && !rel.startsWith('..') && !path.isAbsolute(rel)) {
       const segments = rel.split(path.sep)
@@ -451,7 +452,7 @@ async function emitAssetResourceModule(
     .basename(resourcePath, path.extname(resourcePath))
     .replace(/[^A-Za-z0-9_-]+/g, '-')
   const relative = path.posix.join('_next', 'static', 'media', `${base}.${hash}${ext}`)
-  const target = path.join(config.outPath, 'public', ...relative.split('/'))
+  const target = path.join(config.outPath, 'static', ...relative.split('/'))
   await mkdir(path.dirname(target), { recursive: true })
   if (!existsSync(target)) await writeFile(target, bytes)
   const src = `/${relative}`

package/src/compat/bundler/worker.ts

@@ -128,7 +128,7 @@ async function workerAssetModuleSource(config: ResolvedConfig, file: string): Pr
     source = `const src = ${JSON.stringify(src)};\nexport default { src };\nexport { src };\n`
   }
   for (const relative of emitted) {
-    const target = path.join(config.outPath, 'public', ...relative.split('/'))
+    const target = path.join(config.outPath, 'static', ...relative.split('/'))
     await mkdir(path.dirname(target), { recursive: true })
     if (!existsSync(target)) await copyFile(sourcePath, target)
   }
@@ -208,7 +208,7 @@ async function bundleWorkerEntry(config: ResolvedConfig, entry: string): Promise
   const hash = createHash('sha256').update(output.contents).digest('hex').slice(0, 8)
   const base = path.basename(entry, path.extname(entry)).replace(/[^A-Za-z0-9_-]+/g, '-')
   const relative = path.posix.join('assets', 'workers', `${base}.${hash}.js`)
-  const target = path.join(config.outPath, 'public', ...relative.split('/'))
+  const target = path.join(config.outPath, 'static', ...relative.split('/'))
   await mkdir(path.dirname(target), { recursive: true })
   await writeFile(target, output.contents)
   return `/${relative}`

package/src/compat/css/inline-css.ts

@@ -65,7 +65,7 @@ export function inlineCssStylesheets(
 ): string[] | undefined {
   if (options.dev || suppressed.getStore() === true || !inlineCssEnabled(config)) return undefined
   const assets = options.assetNames.map(asset =>
-    readCss(`${config.outPath}/public/assets/${asset}`),
+    readCss(`${config.outPath}/static/assets/${asset}`),
   )
   if (assets.some(css => css === undefined)) return undefined
   const css = [options.prependCss, ...assets].filter(Boolean).join('\n')

package/src/compat/export/build-complete.ts

@@ -130,7 +130,7 @@ function collectOutputs(config: ResolvedConfig, manifest: BuildManifest): Adapte
   const prerenderedRoutes = new Set<string>()
 
   for (const [relative, metadata] of Object.entries(manifest.staticFiles ?? {})) {
-    const filePath = path.join(config.outPath, 'public', relative)
+    const filePath = path.join(config.outPath, 'static', relative)
     // The manifest also records prerenders that produced no body on disk
     // (an empty response, `_not-found` / `_global-error`). Those are not
     // deployable artifacts: leave them out, and leave the owning route as a

package/src/compat/export/emit.ts

@@ -42,7 +42,7 @@ export async function emitStaticExport({ config, manifest, log }: EmitStaticExpo
   // the running server - client runtime code fetches it unconditionally, and Next's own asset-404 tests
   // probe it as "a known valid asset path". Export mode additionally snapshots a standalone `out/` tree
   // below; the manifest files it needs are the same bytes, so write the server-served copy first.
-  await log.step('build manifest', () => writeBuildManifests(path.join(config.outPath, 'public')))
+  await log.step('build manifest', () => writeBuildManifests(path.join(config.outPath, 'static')))
   const output = getNextConfig().output
   if (output === 'standalone') {
     await emitStandalone({ config, manifest, log })
@@ -74,7 +74,7 @@ async function writeExportTree(config: ResolvedConfig, manifest: BuildManifest):
  * can be pointed at their new location.
  */
 async function copyRuntimeAssets(config: ResolvedConfig, outDir: string): Promise<Set<string>> {
-  const assetsDir = path.join(config.outPath, 'public', 'assets')
+  const assetsDir = path.join(config.outPath, 'static', 'assets')
   const assets = new Set<string>()
   for (const file of await listFiles(assetsDir)) {
     const relative = toPosixPath(path.relative(assetsDir, file))
@@ -91,7 +91,7 @@ async function copyPublicTree(
   outDir: string,
   assets: ReadonlySet<string>,
 ): Promise<void> {
-  const publicDir = path.join(config.outPath, 'public')
+  const publicDir = path.join(config.outPath, 'static')
   for (const file of await listFiles(publicDir)) {
     const relative = toPosixPath(path.relative(publicDir, file))
     if (relative.startsWith('assets/')) continue
@@ -159,7 +159,7 @@ function exportPages(config: ResolvedConfig, manifest: BuildManifest): ExportPag
     if (metadata.kind !== 'page' || !relative.endsWith('.html')) continue
     const route = metadata.routeId ? routeById.get(metadata.routeId) : undefined
     if (route?.kind !== 'page') continue
-    const htmlFile = path.join(config.outPath, 'public', ...relative.split('/'))
+    const htmlFile = path.join(config.outPath, 'static', ...relative.split('/'))
     pages.push({
       route,
       htmlFile,

package/src/compat/export/standalone.ts

@@ -1,18 +1,13 @@
 // `output: 'standalone'` emitter (COMPAT).
 //
-// Next's standalone build drops a self-contained `.next/standalone/` tree whose `server.js` boots the
-// production server on PORT/HOSTNAME. The e2e suites MOVE that folder to a fresh tmp dir, run
-// `node server.js`, wait for the `- Local:` ready banner, and expect route requests to 200. The trace
-// suite additionally reads a `.nft.json` beside each page.
-//
-// pnext has no ahead-of-time Node bundle to drop in, and its production server runs under Bun, so the
-// emitted `server.js` is a thin Node launcher that re-execs the real pnext server via Bun, pointed back
-// at the original build root. The child prints the `- Local:` banner itself, which the launcher inherits
-// straight onto its own stdout, so the harness's readiness regex fires without a proxy hop. The original
-// build tree outlives the moved standalone folder for the duration of the test, so absolute references
-// back into it are safe.
+// Every pnext build writes `<outDir>/standalone/`, the self-contained server; with `output:
+// 'standalone'` the out dir defaults to `.next` (compat/next/config-loader), so it lands where Next's
+// does. Next's contract on top: a `server.js` that boots on PORT/HOSTNAME under `node server.js`, and
+// the `.nft.json` traces its suites read. The e2e suites MOVE the folder to a fresh tmp dir, run
+// `node server.js` and wait for the `- Local:` banner; `server.js` hands over to Bun, which serves the
+// folder's own `server/entry.js`.
 import { existsSync, readFileSync } from 'node:fs'
-import { mkdir, rm, writeFile } from 'node:fs/promises'
+import { mkdir, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import type { ResolvedConfig } from '../../config'
 import type { BuildManifest, RouteManifestEntry } from '../../types'
@@ -37,68 +32,38 @@ export async function emitStandalone({
 }
 
 async function writeStandalone(config: ResolvedConfig, manifest: BuildManifest): Promise<void> {
-  const standaloneDir = path.join(config.root, '.next', 'standalone')
-  await rm(standaloneDir, { recursive: true, force: true })
-  await mkdir(standaloneDir, { recursive: true })
-  await writeServerEntry(config, standaloneDir)
+  const standaloneDir = config.outPath
+  await writeFile(path.join(standaloneDir, 'server.js'), standaloneServerSource())
   await writeTraceFiles(config, standaloneDir)
   await writeMiddlewareManifest(manifest, standaloneDir)
 }
 
 /**
- * The self-contained launcher plus its package.json. The launcher is always CommonJS (a
- * `{ "type": "commonjs" }` sidecar pins the module system even when the app - and the tmp dir the test
- * moves the folder into - is ESM), so it runs unchanged under `node server.js` regardless of the
- * surrounding package type.
+ * Starts `server/entry.js` under Bun on the PORT/HOSTNAME the standalone contract passes through the
+ * environment. The child's `- Local:` banner is inherited onto this process's stdout, so the harness's
+ * readiness regex fires directly. Signals are forwarded so the harness's `killApp` (SIGTERM) tears the
+ * whole tree down and lets pending after() callbacks drain.
  */
-async function writeServerEntry(config: ResolvedConfig, standaloneDir: string): Promise<void> {
-  await writeFile(
-    path.join(standaloneDir, 'package.json'),
-    `${JSON.stringify({ name: 'pnext-standalone', version: '0.0.0', type: 'commonjs', private: true }, null, 2)}\n`,
-  )
-  await writeFile(path.join(standaloneDir, 'server.js'), standaloneServerSource(config))
-}
+function standaloneServerSource(): string {
+  return `// pnext standalone launcher, generated by pnext build (src/compat/export/standalone.ts).
+import { spawn } from 'node:child_process';
 
-/**
- * Boots `pnext start` under Bun against the original build root, on the
- * PORT/HOSTNAME the standalone contract passes through the environment. The
- * child's `- Local:` banner is inherited onto this process's stdout, so the
- * harness's readiness regex fires directly. Signals are forwarded so the
- * harness's `killApp` (SIGTERM) tears the whole tree down and lets pending
- * after() callbacks drain.
- */
-function standaloneServerSource(config: ResolvedConfig): string {
-  const cliPath = path.resolve(import.meta.dirname, '..', '..', 'cli', 'index.ts')
-  return `'use strict';
-// pnext standalone launcher. Generated by pnext build; see
-// src/compat/export/standalone.ts. Spawned as \`node server.js\` from the moved
-// standalone directory; re-execs the real pnext server under Bun.
-const { spawn } = require('node:child_process');
-
-const PNEXT_CLI = ${JSON.stringify(cliPath)};
-const PNEXT_ROOT = ${JSON.stringify(config.root)};
-const port = String(process.env.PORT || '3000');
+const port = Number(process.env.PORT || '3000');
 const hostname = process.env.HOSTNAME || '0.0.0.0';
+const entry = new URL('./server/entry.js', import.meta.url).href;
+const boot = \`const { start } = await import(\${JSON.stringify(entry)}); await start(\${JSON.stringify({ port, hostname })});\`;
 
-const child = spawn(
-  'bun',
-  ['--conditions=react-server', PNEXT_CLI, 'start', '--port', port, '--hostname', hostname],
-  {
-    cwd: PNEXT_ROOT,
-    env: {
-      ...process.env,
-      // Suppresses \`pnext start\`'s "output: standalone" warning (Next gates the
-      // same warning on this private env being set by its standalone server).
-      __NEXT_PRIVATE_STANDALONE_CONFIG: '1',
-      PNEXT_COMPAT: 'next',
-      BROWSER: 'none',
-      NODE_ENV: 'production',
-      PORT: port,
-      HOSTNAME: hostname,
-    },
-    stdio: ['ignore', 'inherit', 'inherit'],
-  }
-);
+const child = spawn('bun', ['--conditions=react-server', '-e', boot], {
+  env: {
+    ...process.env,
+    // Suppresses \`pnext start\`'s "output: standalone" warning (Next gates the
+    // same warning on this private env being set by its standalone server).
+    __NEXT_PRIVATE_STANDALONE_CONFIG: '1',
+    BROWSER: 'none',
+    NODE_ENV: 'production',
+  },
+  stdio: ['ignore', 'inherit', 'inherit'],
+});
 
 child.on('error', (error) => {
   console.error('pnext standalone: failed to start the pnext server:', error);

package/src/compat/image-optimizer/optimize.ts

@@ -378,7 +378,7 @@ async function fetchUpstream(
   }
   const publicFile = await readPublicFile(
     [
-      path.join(coreConfig.outPath, 'public'),
+      path.join(coreConfig.outPath, 'static'),
       coreConfig.publicPath,
       path.join(coreConfig.root, 'public'),
     ],

package/src/compat/lifecycle/instrumentation-client.ts

@@ -23,6 +23,7 @@ import { build } from '../../utils/esbuild'
 import type { ResolvedConfig } from '../../config'
 import { getNextConfig } from '../next/config-loader'
 import { instrumentationLookupRoots } from './instrumentation'
+import { outCachePath } from '../../out-paths'
 
 const CLIENT_BASENAMES = [
   'instrumentation-client.ts',
@@ -90,10 +91,10 @@ export async function buildInstrumentationClient(config: ResolvedConfig): Promis
   const userFile = findInstrumentationClient(config)
   if (!userFile) return
   const modules = [...injectEntries(config), userFile]
-  const workDir = path.join(config.outPath, 'cache', 'instrumentation-client')
+  const workDir = path.join(outCachePath(config.outPath), 'instrumentation-client')
   mkdirSync(workDir, { recursive: true })
   const entryFile = path.join(workDir, 'entry.ts')
-  const outfile = path.join(config.outPath, 'public', INSTRUMENTATION_CLIENT_ASSET)
+  const outfile = path.join(config.outPath, 'static', INSTRUMENTATION_CLIENT_ASSET)
   mkdirSync(path.dirname(outfile), { recursive: true })
   await Bun.write(entryFile, entrySource(modules))
   const tsconfig = path.join(config.root, 'tsconfig.json')
@@ -116,7 +117,7 @@ let bundlePresence: boolean | undefined
 
 /** Whether the built instrumentation-client bundle exists (cached). */
 function hasInstrumentationClientBundle(config: ResolvedConfig): boolean {
-  bundlePresence ??= existsSync(path.join(config.outPath, 'public', INSTRUMENTATION_CLIENT_ASSET))
+  bundlePresence ??= existsSync(path.join(config.outPath, 'static', INSTRUMENTATION_CLIENT_ASSET))
   return bundlePresence
 }
 

package/src/compat/metadata-artifacts.ts

@@ -329,7 +329,7 @@ async function writeStaticMetadataArtifacts(
   metadata: StaticFileMetadata | undefined,
 ): Promise<void> {
   if (!metadata) return
-  const source = path.join(outPath, 'public', relative)
+  const source = path.join(outPath, 'static', relative)
   const outputBase = path.join(root, 'server', 'app', toPosixPath(relative))
   await mkdir(path.dirname(outputBase), { recursive: true })
   const routeMeta = JSON.stringify(toRouteMeta(metadata))

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

@@ -488,6 +488,9 @@ function mapOverrides(config: NextConfigObject): NextConfigCoreOverrides {
     config.output !== 'export'
   ) {
     overrides.outDir = config.distDir
+  } else if (config.output === 'standalone') {
+    // Next's `.next/standalone`: the folder its standalone contract names.
+    overrides.outDir = '.next'
   }
   return overrides
 }

package/src/compat/next/dynamic.tsx

@@ -1,6 +1,5 @@
 /** @jsxImportSource preact */
 import { h, type ComponentType } from 'preact'
-import { lazy, Suspense } from 'preact/compat'
 import {
   dynamic as pnextDynamic,
   dynamicReferenceSymbol,
@@ -19,25 +18,17 @@ export default function dynamic<Props extends object = object>(
   // Injected by the server compile; see rewriteDynamicCallTargets.
   target?: DynamicTarget,
 ) {
-  if (typeof loader === 'string') return pnextDynamic(loader, options, target)
-
   const coreDynamic = pnextDynamic(loader, options, target) as DynamicWithReference<Props>
-  const Lazy = lazy(() => loader().then(module => ({ default: componentFromModule(module) })))
-  const DynamicComponent = ((props: Props) => {
-    const Loading = options.loading
-    // ssr:false renders nothing on the server, so the client mount is a *hydration* whose only child
-    // suspends. preact/compat nulls a hydrating vnode's type when it unmounts, and Suspense reuses the
-    // same props.children vnode on its resolve re-render - the poisoned element then renders as text.
-    // The hooks-based core component loads without suspending, so that boundary is never entered.
-    if (options.ssr === false) {
-      return h(
-        'pnext-dynamic',
-        { style: { display: 'contents' } },
-        !process.browser && typeof window === 'undefined' ? null : h(coreDynamic, props),
-      )
-    }
-    return h(Suspense, { fallback: Loading ? h(Loading, props) : null }, h(Lazy, props))
-  }) as DynamicWithReference<Props>
+  // Core's component server-renders and hydrates like Next, waiting for a chunk still loading.
+  if (typeof loader === 'string' || options.ssr !== false) return coreDynamic
+
+  // ssr:false renders nothing on the server; the client renders `loading`, then the component.
+  const DynamicComponent = ((props: Props) =>
+    h(
+      'pnext-dynamic',
+      { style: { display: 'contents' } },
+      !process.browser && typeof window === 'undefined' ? null : h(coreDynamic, props),
+    )) as DynamicWithReference<Props>
 
   DynamicComponent[dynamicReferenceSymbol] = coreDynamic[dynamicReferenceSymbol]
   return DynamicComponent
@@ -48,7 +39,3 @@ export { dynamic }
 type DynamicWithReference<Props extends object> = ComponentType<Props> & {
   [dynamicReferenceSymbol]?: DynamicReference<Props>
 }
-
-function componentFromModule<Props>(module: DynamicModule<Props>) {
-  return typeof module === 'function' ? module : module.default
-}

package/src/compat/next/font/cache.ts

@@ -15,6 +15,7 @@ import { restartCacheEnabled } from '../../../dev/restart/enabled'
 import { frameworkFingerprint } from '../../../runtime/fingerprint'
 import { writeFileAtomic } from '../../../utils/fs'
 import type { MetadataLink } from '../../../types'
+import { outCachePath } from '../../../out-paths'
 
 export interface PersistableFont {
   css: string
@@ -54,7 +55,7 @@ interface FontIndex {
 const indexes = new Map<string, FontIndex>()
 
 function fontIndex(config: ResolvedConfig): FontIndex {
-  const file = path.join(config.outPath, 'cache', 'fonts', 'index.json')
+  const file = path.join(outCachePath(config.outPath), 'fonts', 'index.json')
   const existing = indexes.get(file)
   if (existing) return existing
   const created: FontIndex = { file, fonts: readIndex(file), dirty: false }

package/src/compat/next/font/runtime.ts

@@ -805,7 +805,7 @@ async function emitFontBytes(
   // Served from `/_next/static/media/` — files under the out dir's public/ map 1:1 to the URL path,
   // which is the only place dev and build both look them up.
   const mediaSegments = ['_next', 'static', 'media']
-  const outDir = path.join(context.config.outPath, 'public', ...mediaSegments)
+  const outDir = path.join(context.config.outPath, 'static', ...mediaSegments)
   const file = path.join(outDir, filename)
   const asset = {
     ext,

package/src/compat/register/image.ts

@@ -122,7 +122,7 @@ async function writeImagesManifestStep(ctx: BuildStepContext): Promise<void> {
 async function mirrorStaticMedia(config: ResolvedConfig): Promise<void> {
   const { cp } = await import('node:fs/promises')
   for (const dir of ['media', 'immutable/media']) {
-    const source = path.join(config.outPath, 'public', '_next', 'static', dir)
+    const source = path.join(config.outPath, 'static', '_next', 'static', dir)
     const target = path.join(config.root, '.next', 'static', dir)
     try {
       await cp(source, target, { recursive: true, force: true })

package/src/compat/typecheck/check.ts

@@ -42,6 +42,7 @@ export function typecheckDisabled(): boolean {
 export interface TypecheckWorkerInput {
   root: string
   outPath: string
+  outRootPath: string
   compat: ResolvedConfig['compat']
   nextConfig: NextConfigObject
 }
@@ -64,6 +65,7 @@ export async function validateTypesOffThread(config: ResolvedConfig): Promise<vo
   const input: TypecheckWorkerInput = {
     root: config.root,
     outPath: config.outPath,
+    outRootPath: config.outRootPath,
     compat: config.compat,
     nextConfig: cloneable({
       typescript: next.typescript,
@@ -210,12 +212,12 @@ function appDiagnostic(file: string | undefined, config: ResolvedConfig): boolea
   if (resolved === generatedProjectPath(config)) return true
   if (!resolved.startsWith(config.root + path.sep)) return false
   if (resolved.includes(`${path.sep}node_modules${path.sep}`)) return false
-  if (resolved.startsWith(path.resolve(config.outPath) + path.sep)) return false
+  if (resolved.startsWith(path.resolve(config.outRootPath) + path.sep)) return false
   return true
 }
 
 function generatedProjectPath(config: ResolvedConfig): string {
-  return path.resolve(config.outPath, 'typecheck', 'tsconfig.json')
+  return path.resolve(config.outRootPath, 'typecheck', 'tsconfig.json')
 }
 
 /**
@@ -292,7 +294,7 @@ async function writeTypecheckProject(
   config: ResolvedConfig,
   native: string | undefined,
 ): Promise<string> {
-  const dir = path.join(config.outPath, 'typecheck')
+  const dir = path.join(config.outRootPath, 'typecheck')
   await mkdir(dir, { recursive: true })
   const reactTypes = resolveTypesDir('react', config.root)
   const hasReactTypes = reactTypes !== undefined
@@ -420,7 +422,7 @@ async function writeTypecheckProject(
 }
 
 function preactTypeShimPath(config: ResolvedConfig): string {
-  return path.join(config.outPath, 'typecheck', 'preact-compat.d.ts')
+  return path.join(config.outRootPath, 'typecheck', 'preact-compat.d.ts')
 }
 
 function preactTypeShim(preact: string, react: string): string {