@wular/pnext 0.1.7 → 0.1.9

package/src/runtime/loader.ts

@@ -6,6 +6,7 @@
  * imports them; this module never imports from `./vendor-build`.
  */
 
+import { hasModuleDirective } from '../utils/directive'
 import { createHash } from 'node:crypto'
 import { createRequire } from 'node:module'
 import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs'
@@ -33,6 +34,7 @@ import {
   pnextAliases,
   type CompatAliasTarget,
   type ResolvedConfig,
+  outCachePath,
 } from '../config'
 import {
   rewriteDynamicCallTargets,
@@ -175,7 +177,7 @@ export function registerServerRuntime(config: ResolvedConfig, sourceFiles: strin
     ...rootPaths(config.root),
     ...rootPaths(config.appPath),
     // A release build evaluates its compiled artifacts as the release will: natively.
-    ...(isReleaseCompile() ? [] : rootPaths(path.join(config.outPath, 'cache', 'server'))),
+    ...(isReleaseCompile() ? [] : rootPaths(path.join(outCachePath(config.outPath), 'server'))),
     // The pnext src root, so the framework's own source transforms too.
     ...rootPaths(path.join(import.meta.dirname, '..')),
     ...sourceRoots.flatMap(rootPaths),
@@ -380,7 +382,7 @@ export function nodeModuleSourceLoadsAsIs(source: string) {
 /** The relative specifiers of a file that loads as-is, or undefined when it needs the bundle. */
 function nodeModuleRelativeImports(source: string) {
   if (serverDefineOptions().define || source.includes('use cache')) return undefined
-  if (/^\s*(?:(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/)\s*)*['"]use (?:client|server)['"]/.test(source)) {
+  if (hasModuleDirective(source, 'use client') || hasModuleDirective(source, 'use server')) {
     return undefined
   }
   try {
@@ -1140,7 +1142,7 @@ async function staticImageModuleSource(config: ResolvedConfig | undefined, file:
   const source = compat ?? coreStaticAssetModule(sourcePath, bytes, emit)
   if (config) {
     for (const asset of emitted) {
-      const target = path.join(config.outPath, 'public', ...asset.relative.split('/'))
+      const target = path.join(config.outPath, 'static', ...asset.relative.split('/'))
       await mkdir(path.dirname(target), { recursive: true })
       if (!existsSync(target)) await Bun.write(target, asset.bytes)
     }

package/src/runtime/module-cache.ts

@@ -17,6 +17,7 @@ import { fileURLToPath } from 'node:url'
 import type { ResolvedConfig } from '../config'
 import { writeFileAtomic } from '../utils/fs'
 import { traceEnabled } from '../utils/trace-flags'
+import { outCachePath } from '../out-paths'
 
 /**
  * Kill switch for the request-head trims: the naming walk's synchronous source
@@ -205,7 +206,7 @@ export function devModuleCache(
 }
 
 export function cacheRoot(outPath: string) {
-  return path.join(outPath, 'cache', 'server')
+  return path.join(outCachePath(outPath), 'server')
 }
 
 function createDevModuleCache(

package/src/runtime/modules.ts

@@ -61,7 +61,9 @@ import {
   resolvePackageSpecifier,
 } from '../resolve/imports'
 import {
+  absolutePathLiterals,
   importSpecifiers,
+  lineComments,
   moduleSpecifierEdges,
   rewriteSpecifierLiterals,
   stripJsonImportAttributes,
@@ -1498,16 +1500,38 @@ function relocateSource(
   const specifiers = spliceSource(contents, edits)
   if (!isReleaseCompile()) return specifiers
   // Path literals (client-reference targets, module URLs) resolve beside the artifact at runtime.
-  return specifiers.replace(
-    /(?<!\\)"((?:file:\/\/)?\/[^"\\\n]+)"(\s*:)?/g,
-    (literal, value: string, key: string | undefined) => {
-      const url = value.startsWith('file:')
-      const target = locate(url ? fileURLToPath(value) : value)
-      if (!target) return literal
-      const href = `new URL(${JSON.stringify(relativeTo(target))}, import.meta.url)`
-      const expression = url ? `${href}.href` : `decodeURIComponent(${href}.pathname)`
-      return key ? `[${expression}]${key}` : expression
-    },
+  const expression = (value: string) => {
+    const url = value.startsWith('file:')
+    const target = locate(url ? fileURLToPath(value) : value)
+    if (!target) return undefined
+    const href = `new URL(${JSON.stringify(relativeTo(target))}, import.meta.url)`
+    return url ? `${href}.href` : `decodeURIComponent(${href}.pathname)`
+  }
+  const literals = absolutePathLiterals(file, specifiers)
+  if (!literals) {
+    // A recovered parse: the textual form, double-quoted literals only.
+    return specifiers.replace(
+      /(?<!\\)"((?:file:\/\/)?\/[^"\\\n]+)"(\s*:)?/g,
+      (literal, value: string, key: string | undefined) => {
+        const replacement = expression(value)
+        if (!replacement) return literal
+        return key ? `[${replacement}]${key}` : replacement
+      },
+    )
+  }
+  return spliceSource(
+    specifiers,
+    literals.flatMap(literal => {
+      const replacement = expression(literal.value)
+      if (!replacement) return []
+      return [
+        {
+          start: literal.start,
+          end: literal.end,
+          value: literal.key ? `[${replacement}]` : replacement,
+        },
+      ]
+    }),
   )
 }
 
@@ -1591,7 +1615,7 @@ export function releaseArtifactSource(file: string, contents: string) {
   if (!cacheRoot || !anchors) return contents
   return relocateSource(
     file,
-    releaseInputComments(contents),
+    releaseInputComments(file, contents),
     absolute => (isInside(cacheRoot, absolute) ? absolute : portableTarget(anchors, absolute)),
     absolute => !isInside(cacheRoot, absolute) && isInstalled(absolute),
   )
@@ -1601,11 +1625,21 @@ export function releaseArtifactSource(file: string, contents: string) {
  * esbuild's per-input `// <path>` comments, cut to the file name (or its `node_modules/` path, which
  * names a vendored font caller): their paths walk the build machine.
  */
-function releaseInputComments(contents: string) {
-  return contents.replace(/^\/\/ (?:[\w-]+:)?\.{0,2}\/[^\s]*$/gm, comment => {
+function releaseInputComments(file: string, contents: string) {
+  const shorten = (comment: string) => {
     const installed = comment.indexOf('node_modules/')
     return `// ${installed === -1 ? path.basename(comment) : comment.slice(installed)}`
-  })
+  }
+  const inputPath = /^ (?:[\w-]+:)?\.{0,2}\/\S*$/
+  const comments = lineComments(file, contents)
+  // A recovered parse: the textual form, whole lines only.
+  if (!comments) return contents.replace(/^\/\/ (?:[\w-]+:)?\.{0,2}\/[^\s]*$/gm, shorten)
+  return spliceSource(
+    contents,
+    comments
+      .filter(comment => inputPath.test(comment.value))
+      .map(comment => ({ ...comment, value: shorten(`//${comment.value}`) })),
+  )
 }
 
 /** `target` as a path a moved release still reaches: through the app's own tree, never the machine's. */
@@ -1634,7 +1668,7 @@ async function writeCompiledFile(file: string, contents: string) {
     const cacheRoot = path.dirname(profileRoot)
     contents = relocateSource(
       file,
-      anchors ? releaseInputComments(contents) : contents,
+      anchors ? releaseInputComments(file, contents) : contents,
       absolute =>
         isInside(cacheRoot, absolute) ? absolute : anchors && portableTarget(anchors, absolute),
       absolute => !isInside(cacheRoot, absolute) && isInstalled(absolute),
@@ -3585,7 +3619,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/runtime/prebundle.ts

@@ -55,6 +55,21 @@ export function prebundledFile(file: string): string {
   return entries.has(entry) ? path.join(distRoot, `${entry}.js`) : file
 }
 
+/** A resolve-only `Bun.plugin`, typed here: these modules sit in app type graphs without bun-types. */
+interface ResolvePlugin {
+  name: string
+  setup(build: {
+    onResolve(
+      options: { filter: RegExp },
+      resolve: (args: { path: string; importer: string }) => { path: string } | undefined,
+    ): void
+  }): void
+}
+
+export function registerResolvePlugin(plugin: ResolvePlugin) {
+  ;(globalThis as unknown as { Bun: { plugin(plugin: ResolvePlugin): void } }).Bun.plugin(plugin)
+}
+
 let registered = false
 
 /** Route imports of framework source, by path, to the prebundle. */
@@ -62,11 +77,16 @@ export function registerPrebundleResolve(): void {
   if (!prebundle || registered) return
   registered = true
   const escaped = srcRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  Bun.plugin({
+  registerResolvePlugin({
     name: 'pnext-prebundle',
     setup(build) {
-      build.onResolve({ filter: new RegExp(`^(?:file://)?${escaped}.*\\.tsx?$`) }, args => {
-        const file = args.path.startsWith('file:') ? fileURLToPath(args.path) : args.path
+      build.onResolve({ filter: new RegExp(`^${escaped}.*\\.tsx?$`) }, args => {
+        const target = prebundledFile(args.path)
+        return target === args.path ? undefined : { path: target }
+      })
+      // A URL encodes the root (`%20` for a space), so it is decoded before the root is compared.
+      build.onResolve({ filter: /^file:.*\.tsx?$/ }, args => {
+        const file = fileURLToPath(args.path)
         const target = prebundledFile(file)
         return target === file ? undefined : { path: target }
       })

package/src/runtime/production.ts

@@ -3,16 +3,17 @@
  * build froze. A served request never reads, stats or hashes app source or config, and never
  * compiles; everything it imports is named here. Dev and the build itself keep their own loaders.
  */
-import { type Dirent, existsSync, readFileSync, readdirSync } from 'node:fs'
-import { mkdir, rename, rm, writeFile } from 'node:fs/promises'
+import { type Dirent, existsSync, readFileSync, readdirSync, realpathSync } from 'node:fs'
+import { rename, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import type { ResolvedConfig } from '../config'
 import type { ReleasedFont } from '../render/hooks'
 import type { StaticMetadataFile } from '../routing/metadata-files'
+import { prebundledFile, registerResolvePlugin } from './prebundle'
+import { splitResourceQuery } from '../utils/resource-query'
 
 export const BUILD_INDEX_VERSION = 1
-const LOCATOR_FILE = 'release-locator.json'
 
 /** `server` is the RSC/server layer, `client` the SSR copy of client components. */
 export type ReleaseLayer = 'server' | 'client'
@@ -91,6 +92,96 @@ export function buildIndexFile(outPath: string) {
   return path.join(outPath, 'server', 'build-index.json')
 }
 
+export function buildManifestFile(outPath: string) {
+  return path.join(outPath, 'server', 'manifest.json')
+}
+
+/** The framework copy a standalone dir ships: its compiled modules name framework files there. */
+export function releaseFrameworkRoot(outPath: string) {
+  try {
+    const { name } = JSON.parse(readFileSync(path.join(frameworkRoot, 'package.json'), 'utf8')) as {
+      name: string
+    }
+    return realpathSync(path.join(outPath, 'node_modules', name))
+  } catch {
+    return frameworkRoot
+  }
+}
+
+/**
+ * Where a release's app sources are, as its compiled modules name them: the app root the build recorded
+ * relative to its output. In place that is the real root; a copied standalone keeps the same relation.
+ */
+export function releaseSourceRoot(outPath: string, serializedOutPath: string) {
+  return path.resolve(outPath, path.relative(serializedOutPath, '.'))
+}
+
+/** Build-machine facts about a standalone dir, kept in the build cache beside it. */
+export function standaloneOriginsFile(outPath: string) {
+  return path.join(path.dirname(outPath), 'cache', 'standalone.json')
+}
+
+let shippedRelease: string | null | undefined
+
+/** The standalone dir this framework copy ships in (`<dir>/node_modules/…/<name>`), if it is one. */
+export function servingReleaseDir(): string | undefined {
+  if (shippedRelease === undefined) {
+    shippedRelease = null
+    // Isolated installs nest the copy deeper: `node_modules/.bun/<pkg>/node_modules/<name>`.
+    for (
+      let dir = path.dirname(frameworkRoot);
+      dir !== path.dirname(dir);
+      dir = path.dirname(dir)
+    ) {
+      if (path.basename(dir) === 'node_modules' && existsSync(buildIndexFile(path.dirname(dir)))) {
+        shippedRelease = path.dirname(dir)
+        break
+      }
+    }
+  }
+  return shippedRelease ?? undefined
+}
+
+const linkedReleases = new Map<string, boolean>()
+
+/**
+ * Serve `release` from this framework copy without loading the standalone one beside it: its imports
+ * of its `node_modules` copies resolve back to the files they were cloned from, so the process keeps
+ * one instance of the framework and of every package. False when this copy cannot serve it in
+ * place: the build cache naming the origins is gone, or the release moved since.
+ */
+export function linkStandaloneOrigins(release: string): boolean {
+  if (servingReleaseDir() === release) return true
+  const known = linkedReleases.get(release)
+  if (known !== undefined) return known
+  let origins: Record<string, string> | undefined
+  try {
+    const parsed = JSON.parse(readFileSync(standaloneOriginsFile(release), 'utf8')) as {
+      release: string
+      origins: Record<string, string>
+    }
+    if (parsed.release === release) origins = parsed.origins
+  } catch {
+    origins = undefined
+  }
+  linkedReleases.set(release, origins !== undefined)
+  if (!origins) return false
+  const files = origins
+  const modules = `${path.join(release, 'node_modules')}${path.sep}`
+  registerResolvePlugin({
+    name: 'pnext-standalone-origins',
+    setup(build) {
+      build.onResolve({ filter: /node_modules\// }, args => {
+        const file = path.resolve(path.dirname(args.importer), splitResourceQuery(args.path).path)
+        if (!file.startsWith(modules)) return undefined
+        const origin = files[path.relative(release, file).split(path.sep).join('/')]
+        return origin && existsSync(origin) ? { path: prebundledFile(origin) } : undefined
+      })
+    },
+  })
+  return true
+}
+
 export function releaseModuleKey(layer: ReleaseLayer, target: string, file: string) {
   return `${layer}:${target}:${file}`
 }
@@ -145,11 +236,12 @@ export function attachRelease(config: ResolvedConfig, index = readBuildIndex(con
   const existing = releases.get(config)
   if (existing) return existing
   const fromRoot = (file: string) => path.resolve(config.root, file)
+  const framework = releaseFrameworkRoot(config.outPath)
   const modules = new Map<string, string>()
   for (const [key, artifact] of Object.entries(index.modules)) {
     const second = key.indexOf(':', key.indexOf(':') + 1)
     modules.set(
-      `${key.slice(0, second + 1)}${releaseSourceFile(key.slice(second + 1), config.root, config.workspaceRoot)}`,
+      `${key.slice(0, second + 1)}${releaseSourceFile(key.slice(second + 1), config.root, config.workspaceRoot, framework)}`,
       pathToFileURL(path.resolve(config.outPath, artifact)).href,
     )
   }
@@ -272,11 +364,16 @@ export function releaseSourceKey(file: string, root: string, workspaceRoot: stri
   return `r:${toPosix(inRoot)}`
 }
 
-export function releaseSourceFile(key: string, root: string, workspaceRoot: string) {
+export function releaseSourceFile(
+  key: string,
+  root: string,
+  workspaceRoot: string,
+  framework = frameworkRoot,
+) {
   const value = key.slice(2)
   if (key.startsWith('r:')) return path.join(root, value)
   if (key.startsWith('w:')) return path.resolve(workspaceRoot, value)
-  if (key.startsWith('f:')) return path.resolve(frameworkRoot, value)
+  if (key.startsWith('f:')) return path.resolve(framework, value)
   return path.join(root, value)
 }
 
@@ -303,23 +400,6 @@ export function readBuildIndex(outPath: string): BuildIndex {
   return index
 }
 
-/**
- * Where a built root keeps its release: the dir its locator names when the latest build wrote outside
- * the default out dir (a build into the default empties it, locator included), else the default.
- * Undefined when the root holds no build.
- */
-export function locateRelease(root: string, defaultOutDir: string): string | undefined {
-  const outPath = path.join(root, defaultOutDir)
-  try {
-    const { outDir } = JSON.parse(readFileSync(path.join(outPath, LOCATOR_FILE), 'utf8')) as {
-      outDir: string
-    }
-    return path.resolve(root, outDir)
-  } catch {
-    return existsSync(buildIndexFile(outPath)) ? outPath : undefined
-  }
-}
-
 /** The resolved config as the build saw it, with paths made relative to the root. */
 export function serializeReleaseConfig(config: ResolvedConfig): Record<string, unknown> {
   const relative = (file: string) => path.relative(config.root, file) || '.'
@@ -367,25 +447,10 @@ export function releaseConfig(
   }
 }
 
-/** Publish the build index last, atomically, plus a locator when the out dir is not the default. */
-export async function writeBuildIndex(
-  config: ResolvedConfig,
-  index: BuildIndex,
-  defaultOutDir: string,
-) {
+/** Publish the build index last, atomically. */
+export async function writeBuildIndex(config: ResolvedConfig, index: BuildIndex) {
   const file = buildIndexFile(config.outPath)
   const temporary = `${file}.${process.pid}.tmp`
   await writeFile(temporary, JSON.stringify(index))
   await rename(temporary, file)
-  const defaultOut = path.join(config.root, defaultOutDir)
-  if (path.resolve(config.outPath) === path.resolve(defaultOut)) return
-  await mkdir(defaultOut, { recursive: true })
-  const locator = path.join(defaultOut, LOCATOR_FILE)
-  await writeFile(
-    `${locator}.${process.pid}.tmp`,
-    JSON.stringify({ outDir: path.relative(config.root, config.outPath) }),
-  )
-  await rename(`${locator}.${process.pid}.tmp`, locator)
-  // A default-out release left by an earlier build is now stale: the locator already outranks it.
-  await rm(buildIndexFile(defaultOut), { force: true })
 }

package/src/runtime/release-graph.ts

@@ -9,7 +9,8 @@ import { readFile, readdir, rm } from 'node:fs/promises'
 import path from 'node:path'
 import type { ResolvedConfig } from '../config'
 import { getExternalPackagePolicy } from '../resolve/imports'
-import { importSpecifiers } from '../resolve/scan-facts'
+import { importMetaRefs, importSpecifiers } from '../resolve/scan-facts'
+import { splitResourceQuery } from '../utils/resource-query'
 import { toPosixPath, writeFileAtomic } from '../utils/fs'
 import { hashBundleSpecifier } from './loader'
 import { cacheRoot, devSourceIdentity } from './module-cache'
@@ -242,9 +243,7 @@ export async function pruneReleaseVendor(config: ResolvedConfig, sources: Map<st
   const cache = cacheRoot(config.outPath)
   const vendor = path.join(cache, 'vendor')
   const graphs = path.join(cache, 'deps')
-  const compiled = (await readdir(cache, { recursive: true, withFileTypes: true }))
-    .filter(entry => !entry.isDirectory() && /\.[cm]?js$/.test(entry.name))
-    .map(entry => path.join(entry.parentPath, entry.name))
+  const compiled = await compiledFiles(cache)
   const reached = new Set<string>()
   let frontier = compiled.filter(file => !isInside(vendor, file) && !isInside(graphs, file))
   while (frontier.length > 0) {
@@ -260,7 +259,7 @@ export async function pruneReleaseVendor(config: ResolvedConfig, sources: Map<st
           (/\.[cm]?js$/.test(file)
             ? await readFile(file, 'utf8').catch(() => undefined)
             : undefined)
-        for (const specifier of code ? relativeReferences(code) : []) {
+        for (const specifier of code ? relativeReferences(file, code) : []) {
           const target = path.resolve(path.dirname(file), splitSuffix(specifier).specifier)
           if (isInside(vendor, target)) next.push(target)
         }
@@ -275,14 +274,25 @@ export async function pruneReleaseVendor(config: ResolvedConfig, sources: Map<st
   )
 }
 
+// The compat cache mirrors app-root entries (node_modules included) as symlinks; never follow them.
+async function compiledFiles(dir: string): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+  const nested = await Promise.all(
+    entries.map(async entry => {
+      const file = path.join(dir, entry.name)
+      if (entry.isDirectory()) return compiledFiles(file)
+      return entry.isFile() && /\.[cm]?js$/.test(entry.name) ? [file] : []
+    }),
+  )
+  return nested.flat()
+}
+
 /** Relative module references in emitted code: imports, requires and `new URL(…, import.meta.url)`. */
-function relativeReferences(code: string) {
+function relativeReferences(file: string, code: string) {
   return [
     ...outputSpecifiers(code).map(found => found.value),
     ...emittedRefs(code).map(ref => ref.specifier),
-    ...[...code.matchAll(/new URL\(("[^"]+"),\s*import\.meta\.url\)/g)].map(
-      match => JSON.parse(match[1]!) as string,
-    ),
+    ...importMetaRefs(file, code).urls.map(url => url.specifier),
   ].filter(specifier => specifier.startsWith('.'))
 }
 
@@ -296,10 +306,8 @@ function entryName(config: ResolvedConfig, entry: string) {
 }
 
 function splitSuffix(value: string) {
-  const index = value.search(/[?#]/)
-  return index < 0
-    ? { specifier: value, suffix: '' }
-    : { specifier: value.slice(0, index), suffix: value.slice(index) }
+  const { path: specifier, query: suffix } = splitResourceQuery(value)
+  return { specifier, suffix }
 }
 
 function packageName(specifier: string) {

package/src/runtime/vendor-build.ts

@@ -34,7 +34,12 @@ import {
   serverDefineOptions,
   type ServerEsbuildPluginOptions,
 } from '../extensions'
-import { pathToFileHref, type CompatAliasTarget, type ResolvedConfig } from '../config'
+import {
+  pathToFileHref,
+  type CompatAliasTarget,
+  type ResolvedConfig,
+  outCachePath,
+} from '../config'
 import {
   cacheRoot,
   devArtifactUsable,
@@ -65,9 +70,10 @@ import {
 } from '../client/reference-stub'
 import { noteCompiledClientReference } from '../client/reference'
 import { reactCompatEnabled } from '../render/hooks'
-import { writeFileAtomic } from '../utils/fs'
+import { toPosixPath, writeFileAtomic } from '../utils/fs'
 import { releaseArtifactSource } from './modules'
 import { formatDuration } from '../utils/verbose'
+import { hasModuleState, importMetaRefs, scanFacts } from '../resolve/scan-facts'
 import {
   addCommonJsNamedExports,
   canonicalVendorCode,
@@ -263,6 +269,21 @@ function appendReleaseLog(config: ResolvedConfig, record: object) {
  * itself (`import.meta.url`) or imports computed paths loads in place, as in 0.1.6: Next's webpack
  * contexts bundle computed imports instead. Returns the files written and the entries left in place.
  */
+/**
+ * esbuild names CommonJS modules by path from `absWorkingDir`; a `node_modules` linked from outside
+ * the app makes those names climb to the build machine's absolute path. The quoted prefix to rewrite.
+ */
+function machineModuleKeyPrefix(root: string) {
+  let real: string
+  try {
+    real = realpathSync(path.join(root, 'node_modules'))
+  } catch {
+    return undefined
+  }
+  const relative = toPosixPath(path.relative(root, real))
+  return relative.startsWith('../') ? `"${relative}/` : undefined
+}
+
 export async function linkReleaseDependencies(
   config: ResolvedConfig,
   layer: ReleaseDependencyLayer,
@@ -338,10 +359,12 @@ export async function linkReleaseDependencies(
   await rm(staging, { recursive: true, force: true })
   try {
     await mkdir(path.join(staging, 'chunks'), { recursive: true })
+    const keys = machineModuleKeyPrefix(config.root)
     for (const output of outputs) {
+      const text = keys ? output.text.replaceAll(keys, '"node_modules/') : output.text
       const code = entryFiles.has(output.path)
-        ? addCommonJsNamedExports(output.text, sharedCommonJsBody(output.path, output.text, texts))
-        : output.text
+        ? addCommonJsNamedExports(text, sharedCommonJsBody(output.path, text, texts))
+        : text
       await writeFile(
         path.join(staging, path.relative(outdir, output.path)),
         releaseArtifactSource(
@@ -364,16 +387,13 @@ export async function linkReleaseDependencies(
 
 // `import.meta` paths and an `import()` of a computed path resolve where the file lies; an import marked
 // `webpackIgnore`/`@vite-ignore` is meant to stay a runtime import, as Next's bundle keeps it.
-const IMPORT_META_PATH = /\bimport\.meta\.(?:url|dirname|filename|resolve)\b/
-const COMPUTED_IMPORT =
-  /(?<![.\w$])import\s*\(((?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n)*)(?!['"`)\s/])/g
-
-function readsBesideItself(source: string) {
-  if (IMPORT_META_PATH.test(source)) return true
-  for (const match of source.matchAll(COMPUTED_IMPORT)) {
-    if (!/webpackIgnore:\s*true|@vite-ignore/.test(match[1]!)) return true
-  }
-  return false
+/** Reads its own location or imports a computed path (unless it opts out with a magic comment). */
+function readsBesideItself(file: string, source: string) {
+  const refs = importMetaRefs(file, source)
+  if (refs.readsLocation) return true
+  return refs.computedImports.some(
+    call => !/webpackIgnore:\s*true|@vite-ignore/.test(source.slice(call.start, call.end)),
+  )
 }
 
 /** Package dirs whose files read beside themselves or import computed paths. */
@@ -392,7 +412,7 @@ async function inPlacePackages(
   await Promise.all(
     installed.map(async file => {
       const source = await readFile(file, 'utf8').catch(() => '')
-      if (readsBesideItself(source)) files.add(file)
+      if (readsBesideItself(file, source)) files.add(file)
     }),
   )
   return [
@@ -411,9 +431,9 @@ async function inPlacePackages(
  */
 function sharedCommonJsBody(file: string, code: string, texts: ReadonlyMap<string, string>) {
   const wrapper = /(?:^|\n)export default (require_[\w$]+)\(\);?/.exec(code)?.[1]
+  // The chunk that defines the wrapper, from the parsed imports: `$` in its name is no regex hazard.
   const chunk =
-    wrapper &&
-    new RegExp(`import\\s*\\{[^}]*\\b${wrapper}\\b[^}]*\\}\\s*from\\s*"([^"]+)"`).exec(code)?.[1]
+    wrapper && scanFacts(file, code).imports.find(edge => edge.exports.includes(wrapper))?.specifier
   const text = chunk && texts.get(path.resolve(path.dirname(file), chunk))
   if (!text) return code
   const start = text.indexOf(`var ${wrapper} = `)
@@ -742,7 +762,12 @@ const vendorPortablePath = (config: ResolvedConfig, file: string) =>
   devSourceIdentity(file, config.workspaceRoot)
 
 function vendorArtifactFile(config: ResolvedConfig, key: string) {
-  return path.join(config.outPath, 'cache', 'server', 'vendor', `${hashBundleSpecifier(key)}.mjs`)
+  return path.join(
+    outCachePath(config.outPath),
+    'server',
+    'vendor',
+    `${hashBundleSpecifier(key)}.mjs`,
+  )
 }
 
 /**
@@ -1041,7 +1066,7 @@ function reusableVendorContent(
   loadVendorSharedEntries(config)
   const id = vendorSharedFor(config).get(entry)
   if (!id) return undefined
-  const content = vendorContentFile(path.join(config.outPath, 'cache', 'server', 'vendor'), id)
+  const content = vendorContentFile(path.join(outCachePath(config.outPath), 'server', 'vendor'), id)
   return existsSync(content) ? content : undefined
 }
 
@@ -1704,9 +1729,6 @@ function packageExportSubpaths(packageRoot: string) {
 }
 
 /** A top-level binding created by `new` or a non-PURE call: an identity each copy would duplicate. */
-const MODULE_STATE =
-  /^(?:export\s+)?(?:const|let|var)\s[^=;]*=\s*(?:(?:\/\*\s*[#@]__PURE__\s*\*\/\s*)?new\s|(?!require\s*\()[\w$.]+\s*\()/m
-
 async function statefulPackageFiles(entry: string, packageRoot: string) {
   const files = [...(await packageReach(entry, packageRoot))]
   const sources = await Promise.all(files.map(file => packageFileScan(file)))
@@ -1728,7 +1750,7 @@ function packageFileScan(file: string) {
           .scanImports(source)
           .map(({ path: specifier }) => specifier)
           .filter(specifier => specifier.startsWith('.')),
-        stateful: MODULE_STATE.test(source),
+        stateful: hasModuleState(file, source),
       }))
       .catch(() => undefined)
     packageFileScans.set(file, scan)

package/src/types.ts

@@ -45,9 +45,8 @@ export interface PNextConfig {
 }
 
 /**
- * What a deployment adapter packs into the server function. It ships the closure the runtime can reach, minus
- * build debris and files no runtime reads - serverless size limits are hard. These lists are the escape hatch
- * when that classification is wrong for an app: `exclude` drops more, `keep` overrides a built-in drop.
+ * What `<outDir>/standalone` ships beyond the files its server imports. `exclude` drops traced
+ * `node_modules` files; `keep` ships app files the server reads at runtime, at their root-relative paths.
  * Entries are directory names (`storybook-static`) or file suffixes (`.map`).
  */
 export interface PNextAdapterConfig {