@wular/pnext 0.0.11 → 0.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wular/pnext",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "A fast little framework for server-first React apps, fully compatible with Next.js",
   "type": "module",
   "bin": {

package/src/cli/adapters/vercel.ts

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync }
 import { builtinModules } from 'node:module'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { pathToFileHref } from '../../config'
+import { DEFAULT_OUT_DIR, pathToFileHref } from '../../config'
 import type { ResolvedConfig } from '../../config'
 import { globalCssSources } from '../../css/build'
 import { getImportAliasExtensions } from '../../extensions'
@@ -109,8 +109,10 @@ function packRules(config: ResolvedConfig): PackRules {
       suffix => !keep.has(suffix),
     ),
     // The app's outDir shares its name with the prune list; it holds the
-    // compiled module cache the function serves from and must survive.
-    keepPaths: new Set([path.resolve(config.outPath)]),
+    // compiled module cache the function serves from and must survive. The
+    // default out root goes with it: a `distDir` app moved its output away, but
+    // the next.config bundle the function imports at boot still lives there.
+    keepPaths: new Set([path.resolve(config.outPath), path.resolve(config.root, DEFAULT_OUT_DIR)]),
   }
 }
 
@@ -348,7 +350,7 @@ async function writeServerFunction(
   // Bun does honor tsconfig paths for bare imports, so map the aliased specifiers to their shims in
   // every shipped tsconfig.
   await log.step('inject compat tsconfig paths', () =>
-    injectCompatPaths(config, functionPath, replicaPathFor),
+    injectCompatPaths(config, functionPath, pnextRoot, replicaPathFor),
   )
 
   const startEntry = toPosixPath(path.join(pnextTargetRel, 'src/cli/start.ts'))
@@ -731,13 +733,31 @@ function isInsideDir(root: string, file: string) {
   return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
 }
 
+/**
+ * Whether a compat alias resolves to framework source (react, next/*) rather than to a real package.
+ * Containment, not a `node_modules` substring: an installed framework lives under node_modules
+ * itself, and a substring test there classifies every next/* shim as a package to ship.
+ * @internal Exported for tests.
+ */
+export function isFrameworkOwnedAliasTarget(frameworkRoot: string, target: string) {
+  if (!path.isAbsolute(target) || !isInsideDir(frameworkRoot, target)) return false
+  // A nested store under the framework root is still a real package.
+  return !path.relative(frameworkRoot, target).split(path.sep).includes('node_modules')
+}
+
+function frameworkOwnedAliases(config: ResolvedConfig, frameworkRoot: string) {
+  return Object.entries(getImportAliasExtensions().aliases(config, 'server')).filter(([, target]) =>
+    isFrameworkOwnedAliasTarget(frameworkRoot, target),
+  )
+}
+
 async function injectCompatPaths(
   config: ResolvedConfig,
   functionPath: string,
+  frameworkRoot: string,
   replicaPathFor: (file: string) => string | undefined,
 ) {
-  const aliasTargets = Object.entries(getImportAliasExtensions().aliases(config, 'server'))
-    .filter(([, target]) => path.isAbsolute(target) && !target.includes('node_modules'))
+  const aliasTargets = frameworkOwnedAliases(config, frameworkRoot)
     .map(([specifier, target]) => [specifier, replicaPathFor(target)] as const)
     .filter((entry): entry is readonly [string, string] => Boolean(entry[1]))
   if (aliasTargets.length === 0) return
@@ -882,9 +902,7 @@ async function traceNodeModulesClosure(
   // them would drag in the full next/react trees. Aliases that point into
   // node_modules (the pinned preact family) still need their packages.
   const frameworkAliasedSpecifiers = new Set(
-    Object.entries(getImportAliasExtensions().aliases(config, 'server'))
-      .filter(([, target]) => path.isAbsolute(target) && !target.includes('node_modules'))
-      .map(([specifier]) => specifier),
+    frameworkOwnedAliases(config, path.resolve(framework.root)).map(([specifier]) => specifier),
   )
   await log.step('trace runtime imports', async () => {
     // Only code Bun imports raw at request time needs real node_modules: route handlers, the proxy,

package/src/cli/serve/pipeline.ts

@@ -88,7 +88,7 @@ export async function createRequestHandler(
   // `start` already resolved (and bootstrapped) the config for its output-mode
   // guard; reusing it skips a second loadConfig — env load, pnext.config +
   // next.config imports, app-path resolution — before the ready banner.
-  const config = options.config ?? (await loadConfig(options.root))
+  const config = options.config ?? (await loadConfig(options.root, { serve: true }))
   // Compat plugin loader: the single gated seam that populates the core
   // extension registries when compat is enabled (no-op for pure-core apps).
   // A prod server answers the very next request, so it takes both tiers here.
@@ -578,8 +578,13 @@ export async function createRequestHandler(
         method === 'GET' &&
         handlerResponse.status === 200
       ) {
-        await writeFile(built.file, new Uint8Array(await handlerResponse.clone().arrayBuffer()))
-        handlerResponse.headers.set('x-nextjs-cache', 'MISS')
+        try {
+          await writeFile(built.file, new Uint8Array(await handlerResponse.clone().arrayBuffer()))
+          handlerResponse.headers.set('x-nextjs-cache', 'MISS')
+        } catch {
+          // Best-effort like the page path below: a read-only serving filesystem
+          // (a serverless host) costs the cache write, never the response.
+        }
       }
       if (
         !built &&
@@ -593,7 +598,9 @@ export async function createRequestHandler(
         handlerResponse.status < 500
       ) {
         const file = lazyStaticHandlerPath(config.outPath, url.pathname)
-        if (file) {
+        // Same best-effort contract as the page path below.
+        try {
+          if (!file) throw new Error('unsafe path')
           await mkdir(path.dirname(file), { recursive: true })
           await writeFile(file, new Uint8Array(await handlerResponse.clone().arrayBuffer()))
           const relative = path
@@ -617,6 +624,8 @@ export async function createRequestHandler(
           }
           await persistManifest()
           handlerResponse.headers.set('x-nextjs-cache', 'MISS')
+        } catch {
+          // Lazy caching is best-effort; the response is still served.
         }
       }
       return applyProxyResponse(handlerResponse, proxyResponse)
@@ -831,8 +840,12 @@ export async function createRequestHandler(
       pageResponse.status === 200 &&
       (pageResponse.headers.get('content-type') ?? '').includes('text/html')
     ) {
-      await writeFile(stalePage, await pageResponse.clone().text())
-      pageResponse.headers.set('x-nextjs-cache', 'MISS')
+      try {
+        await writeFile(stalePage, await pageResponse.clone().text())
+        pageResponse.headers.set('x-nextjs-cache', 'MISS')
+      } catch {
+        // Best-effort write-back; the stale copy stays and the fresh render still serves.
+      }
     }
     // On-demand revalidation (valid x-prerender-revalidate): the fresh render
     // replaces any prebuilt copy and is reported as REVALIDATED (Next's
@@ -844,7 +857,12 @@ export async function createRequestHandler(
         pageResponse.status === 200 &&
         (pageResponse.headers.get('content-type') ?? '').includes('text/html')
       ) {
-        await writeFile(built.file, await pageResponse.clone().text())
+        try {
+          await writeFile(built.file, await pageResponse.clone().text())
+        } catch {
+          // Best-effort: an on-demand revalidation still returns the fresh
+          // render when the prebuilt copy cannot be replaced.
+        }
       }
       pageResponse.headers.set('x-nextjs-cache', 'REVALIDATED')
     }

package/src/cli/start.ts

@@ -113,7 +113,7 @@ function installProcessErrorHandlers(): void {
 // `__NEXT_PRIVATE_STANDALONE_CONFIG` set. pnext mirrors that: load the compat config, read the output
 // mode from the build-compat registry, and reproduce Next's exact messages.
 async function guardUnservableOutputMode(root?: string): Promise<ResolvedConfig> {
-  const config = await loadConfig(root)
+  const config = await loadConfig(root, { serve: true })
   await bootstrapCompat(config)
   const mode = getBuildExtensions().compat.nextOutputMode()
   if (mode === 'export') {

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

@@ -13,7 +13,7 @@
 // export / top-level await / dynamic import() and CJS+ESM authoring styles.
 // ---------------------------------------------------------------------------
 
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
@@ -130,11 +130,17 @@ function findTsconfig(root: string): string | undefined {
  * Bundle the config with esbuild (external node_modules) and import the result.
  * The emitted file is written next to the config so Node resolves the app's
  * node_modules and relative assets from the original location.
+ *
+ * The bundle is also a BUILD artifact: the build leaves it on disk, deployment adapters ship it with
+ * the app's out dir, and a serve imports that file rather than re-running the pass. Request time is
+ * read-only on a serverless host (Vercel's `/var/task`), where the pass cannot write at all - and
+ * where it could, it would still put an esbuild spawn on every cold start. A serve whose build left
+ * no bundle (the config changed since, matching `next start` re-reading next.config) still bundles.
  */
 async function importConfigModule(
   configPath: string,
   root: string,
-  dev: boolean,
+  options: { dev: boolean; serve: boolean },
 ): Promise<NextConfigExport> {
   const cjs = cjsConfigFormat(configPath, root)
   if (process.env.PNEXT_CONFIG_FAST !== '0' && selfContainedConfig(configPath)) {
@@ -147,66 +153,112 @@ async function importConfigModule(
   }
   // Dev keeps its scratch bundle in its own subtree; a concurrent build wipes
   // only the build-owned `config/`.
-  const outDir = path.join(root, '.pnext', ...(dev ? ['dev'] : []), 'config')
-  mkdirSync(outDir, { recursive: true })
+  const outDir = path.join(root, '.pnext', ...(options.dev ? ['dev'] : []), 'config')
   // Content-addressed, not timestamped: a per-boot name leaked one bundle per
   // dev start and put a path that changes every boot into the module graph,
-  // which renamed every artifact that could reach it.
+  // which renamed every artifact that could reach it. It also makes the name a
+  // pure function of the config source, so a serve recomputes what its build wrote.
   const outfile = path.join(
     outDir,
     `next.config.${configSourceKey(configPath)}.${cjs ? 'cjs' : 'mjs'}`,
   )
+  if (options.serve && existsSync(outfile)) return importConfigBundle(outfile, cjs)
   try {
-    await build({
-      entryPoints: [configPath],
-      outfile,
-      bundle: true,
-      platform: 'node',
-      format: cjs ? 'cjs' : 'esm',
-      target: 'esnext',
-      // Keep bare package imports external so Node resolves them from the app's
-      // node_modules at import time (preserves CJS/ESM interop and identity).
-      packages: 'external',
-      // Fixture/app configs may require() or require.resolve() Next internals
-      // (next/dist/*) that don't exist without a real `next` install. Stub them
-      // so the config still loads; features pointing at the stubs degrade
-      // gracefully instead of crashing config loading.
-      plugins: [nextDistStubPlugin(outDir), nextMdxConfigStubPlugin()],
-      banner: cjs
-        ? {
-            js:
-              'var __pnextNodeRequire = module.require.bind(module);\n' +
-              `var require = __pnextNodeRequire("node:module").createRequire(${JSON.stringify(pathToFileURL(configPath).href)});`,
-          }
-        : {
-            js:
-              'import { createRequire as __pnextCreateRequire } from "node:module";\n' +
-              `const require = __pnextCreateRequire(${JSON.stringify(pathToFileURL(configPath).href)});`,
-          },
-      // Relative/absolute imports (incl. .ts/.cts/.mts/.cjs/.mjs and tsconfig
-      // `paths` aliases) are bundled in. esbuild reads `paths`/`extends` and
-      // `baseUrl` from the app tsconfig.
-      tsconfig: findTsconfig(root),
-      // __dirname / __filename in CJS-authored .ts configs (node-api-cjs) and
-      // import.meta.url in ESM configs (node-api-esm) must point at the config's
-      // original location, not the emitted file under .pnext/config.
-      define: {
-        __dirname: JSON.stringify(path.dirname(configPath)),
-        __filename: JSON.stringify(configPath),
-        'import.meta.url': JSON.stringify(pathToFileURL(configPath).href),
-      },
-      logLevel: 'silent',
-      sourcemap: false,
-      metafile: false,
-    })
-    if (cjs) {
-      const require = createRequire(pathToFileURL(outfile))
-      return require(outfile) as NextConfigExport
+    mkdirSync(outDir, { recursive: true })
+    await bundleConfig({ configPath, root, outDir, outfile, cjs })
+  } catch (error) {
+    // The only way here on a serve is a build that shipped no bundle for this config, and the most
+    // likely reason the rebuild then failed is the read-only request-time filesystem it was meant to
+    // avoid. Name the artifact rather than surfacing an esbuild write error from a boot path.
+    if (!options.serve) throw error
+    throw new Error(
+      `pnext: ${path.relative(root, outfile)} is missing and could not be rebuilt here — run ` +
+        '`pnext build` and deploy its output dir, which carries the config bundle. Cause: ' +
+        (error instanceof Error ? error.message : String(error)),
+      { cause: error },
+    )
+  }
+  pruneStaleConfigBundles(outDir, outfile)
+  return importConfigBundle(outfile, cjs)
+}
+
+function bundleConfig({
+  configPath,
+  root,
+  outDir,
+  outfile,
+  cjs,
+}: {
+  configPath: string
+  root: string
+  outDir: string
+  outfile: string
+  cjs: boolean
+}) {
+  return build({
+    entryPoints: [configPath],
+    outfile,
+    bundle: true,
+    platform: 'node',
+    format: cjs ? 'cjs' : 'esm',
+    target: 'esnext',
+    // Keep bare package imports external so Node resolves them from the app's
+    // node_modules at import time (preserves CJS/ESM interop and identity).
+    packages: 'external',
+    // Fixture/app configs may require() or require.resolve() Next internals
+    // (next/dist/*) that don't exist without a real `next` install. Stub them
+    // so the config still loads; features pointing at the stubs degrade
+    // gracefully instead of crashing config loading.
+    plugins: [nextDistStubPlugin(outDir), nextMdxConfigStubPlugin()],
+    banner: cjs
+      ? {
+          js:
+            'var __pnextNodeRequire = module.require.bind(module);\n' +
+            `var require = __pnextNodeRequire("node:module").createRequire(${JSON.stringify(pathToFileURL(configPath).href)});`,
+        }
+      : {
+          js:
+            'import { createRequire as __pnextCreateRequire } from "node:module";\n' +
+            `const require = __pnextCreateRequire(${JSON.stringify(pathToFileURL(configPath).href)});`,
+        },
+    // Relative/absolute imports (incl. .ts/.cts/.mts/.cjs/.mjs and tsconfig
+    // `paths` aliases) are bundled in. esbuild reads `paths`/`extends` and
+    // `baseUrl` from the app tsconfig.
+    tsconfig: findTsconfig(root),
+    // __dirname / __filename in CJS-authored .ts configs (node-api-cjs) and
+    // import.meta.url in ESM configs (node-api-esm) must point at the config's
+    // original location, not the emitted file under .pnext/config.
+    define: {
+      __dirname: JSON.stringify(path.dirname(configPath)),
+      __filename: JSON.stringify(configPath),
+      'import.meta.url': JSON.stringify(pathToFileURL(configPath).href),
+    },
+    logLevel: 'silent',
+    sourcemap: false,
+    metafile: false,
+  })
+}
+
+async function importConfigBundle(outfile: string, cjs: boolean): Promise<NextConfigExport> {
+  if (cjs) return createRequire(pathToFileURL(outfile))(outfile) as NextConfigExport
+  const module = (await import(pathToFileURL(outfile).href)) as { default?: NextConfigExport }
+  return module.default ?? {}
+}
+
+/**
+ * Drop bundles left by an earlier config source. The emitted file used to be deleted right after it
+ * was imported, which is what made a serve re-bundle; keeping only the current key holds the line
+ * that motivated the delete - one bundle per app, not one per edit.
+ */
+function pruneStaleConfigBundles(outDir: string, outfile: string): void {
+  try {
+    for (const entry of readdirSync(outDir)) {
+      if (!/^next\.config\..+\.[cm]js$/.test(entry)) continue
+      if (path.join(outDir, entry) === outfile) continue
+      rmSync(path.join(outDir, entry), { force: true })
     }
-    const module = (await import(pathToFileURL(outfile).href)) as { default?: NextConfigExport }
-    return module.default ?? {}
-  } finally {
-    rmSync(outfile, { force: true })
+  } catch {
+    // Housekeeping only: a missing or unreadable out dir costs nothing here.
   }
 }
 
@@ -589,7 +641,7 @@ function validateDevIndicatorPosition(config: NextConfigObject): void {
  */
 export async function loadNextConfig(
   root: string,
-  options: { dev?: boolean } = {},
+  options: { dev?: boolean; serve?: boolean } = {},
 ): Promise<LoadNextConfigResult> {
   const configPath = findConfigPath(root)
   if (!configPath) {
@@ -599,7 +651,10 @@ export async function loadNextConfig(
   }
   let exported: NextConfigExport
   try {
-    exported = await importConfigModule(configPath, root, Boolean(options.dev))
+    exported = await importConfigModule(configPath, root, {
+      dev: Boolean(options.dev),
+      serve: Boolean(options.serve),
+    })
   } catch (error) {
     // A next.config that pulls in an optional wrapper dependency not installed
     // in this app (e.g. @next/mdx when deps are declared but not installed)

package/src/config.ts

@@ -23,8 +23,15 @@ export type ResolvedConfig = Required<Pick<PNextConfig, 'outDir' | 'basePath'>>
     typesPath: string
   }
 
+/**
+ * The out root before any `outDir`/`distDir` override. Also where a config source keeps the build
+ * artifacts it must emit BEFORE the override it carries is known — the next.config bundle sits here
+ * even for an app whose own output moved elsewhere, so deployment adapters ship it from here.
+ */
+export const DEFAULT_OUT_DIR = '.pnext'
+
 const defaultConfig = {
-  outDir: '.pnext',
+  outDir: DEFAULT_OUT_DIR,
   basePath: '',
 } satisfies Required<Pick<PNextConfig, 'outDir' | 'basePath'>>
 
@@ -48,7 +55,7 @@ export interface ConfigSourceOverrides {
 }
 export type ConfigSource = (
   root: string,
-  options: { dev?: boolean },
+  options: { dev?: boolean; serve?: boolean },
 ) => Promise<ConfigSourceOverrides>
 
 let configSource: ConfigSource | undefined
@@ -60,7 +67,7 @@ export function registerConfigSource(source: ConfigSource): void {
 async function resolveConfigSource(
   config: PNextConfig,
   root: string,
-  options: { dev?: boolean },
+  options: { dev?: boolean; serve?: boolean },
 ): Promise<ConfigSourceOverrides> {
   if (!config.compat?.next) return {}
   if (!configSource) {
@@ -70,9 +77,11 @@ async function resolveConfigSource(
   return configSource(root, options)
 }
 
+// `serve` marks a production start (including a deployment adapter's request handler): config sources
+// 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 } = {},
+  options: { dev?: boolean; serve?: boolean } = {},
 ): Promise<ResolvedConfig> {
   const root = canonicalRoot(path.resolve(rootInput))
   await loadEnv(root, options)