@wular/pnext 0.1.6 → 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'
@@ -13,9 +15,11 @@ import { getBuildExtensions } from '../extensions'
 import { drainWorkUnits } from '../request/context'
 import { markErrorLogged } from '../utils/error-log'
 import { isPostpone } from '../render/postpone'
+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
@@ -33,8 +37,25 @@ type RequestHandler = (request: Request, server?: PeerAddressSource) => Promise<
 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(
@@ -49,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)
 
@@ -108,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.")
@@ -120,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') {
@@ -140,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/chunk-fold.ts

@@ -91,8 +91,15 @@ async function foldGroup(
   const memberNames = members.map(output => path.basename(output))
   if (memberNames.some(name => !existsSync(path.join(chunksDir, name)))) return metafile
 
-  const sources = new Map<string, string>()
-  for (const name of memberNames) sources.set(name, await readText(path.join(chunksDir, name)))
+  // The state holds every output's current text, in step with what earlier groups wrote.
+  const sources = new Map(
+    await Promise.all(
+      memberNames.map(async name => {
+        const file = path.join(chunksDir, name)
+        return [name, state.outputs.get(file)?.text ?? (await readText(file))] as const
+      }),
+    ),
+  )
 
   const aliases = memberAliases(memberNames, sources)
   if (!aliases) return metafile
@@ -503,14 +510,20 @@ async function createFoldState(outDir: string, metafile: Metafile): Promise<Fold
     }
   }
 
+  const files = new Set<string>()
   for (const name of Object.keys(metafile.outputs)) {
     if (!name.endsWith('.js')) continue
     const resolved = path.resolve(name)
     const local = existsSync(resolved) ? resolved : path.join(outDir, path.basename(name))
-    if (outputs.has(local) || !existsSync(local)) continue
-    const output = foldOutput(await readText(local))
-    outputs.set(local, output)
-    index(local, output, true)
+    if (existsSync(local)) files.add(local)
+  }
+  // Read concurrently, indexed in metafile order.
+  const list = [...files]
+  const texts = await Promise.all(list.map(file => readText(file)))
+  for (const [at, file] of list.entries()) {
+    const output = foldOutput(texts[at]!)
+    outputs.set(file, output)
+    index(file, output, true)
   }
 
   return {

package/src/client/react-tier.ts

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync, statSync } from 'node:fs'
+import { existsSync, statSync } from 'node:fs'
 import path from 'node:path'
+import { readSourceSync } from '../resolve/source-text'
 
 /**
  * Conservative static scan of a compat app's client graph deciding whether the client bundle can ship
@@ -87,7 +88,7 @@ export function clientSuspenseFree(seeds: Iterable<string>): boolean {
     if (!SOURCE_EXTENSION.test(file) || !existsSync(file)) return false
     let source: string
     try {
-      source = readFileSync(file, 'utf8')
+      source = readSourceSync(file)
     } catch {
       return false
     }

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')
 
@@ -22,6 +23,12 @@ export interface ClientReferenceModuleOptions {
    * inlined lookup is the same symbol the renderer tests for.
    */
   inlineSymbol?: boolean
+  /**
+   * For a release: the reference names its source relative to the stub (`from`), at `target` - the
+   * source itself, or its path through the app's node_modules (`real`: resolved to the installed file).
+   * A moved build then still identifies the module its release indexed.
+   */
+  portable?: { from: string; target: string; real: boolean }
 }
 
 export function clientReferenceModuleSource(
@@ -29,8 +36,17 @@ export function clientReferenceModuleSource(
   exportNames: string[],
   options: ClientReferenceModuleOptions = {},
 ) {
+  const portable = options.portable
+  const located = portable
+    ? `decodeURIComponent(new URL(${JSON.stringify(path.relative(path.dirname(portable.from), portable.target).split(path.sep).join('/'))}, import.meta.url).pathname)`
+    : undefined
+  const file = !located
+    ? JSON.stringify(sourceFile)
+    : portable?.real
+      ? `__pnextRealpath(${located})`
+      : located
   const reference = (exportName: string) =>
-    `createReference({ id: ${JSON.stringify(`c-${clientReferenceId(sourceFile, exportName)}`)}, file: ${JSON.stringify(sourceFile)}, exportName: ${JSON.stringify(exportName)} })`
+    `createReference({ id: ${JSON.stringify(`c-${clientReferenceId(sourceFile, exportName)}`)}, file: ${file}, exportName: ${JSON.stringify(exportName)} })`
   const defaultExport = exportNames.includes('default')
     ? `export default ${reference('default')};`
     : ''
@@ -41,7 +57,11 @@ export function clientReferenceModuleSource(
     ? `const clientReferenceSymbol = Symbol.for('pnext.clientReference');`
     : `import { clientReferenceSymbol } from ${JSON.stringify(pathToFileHref(clientReferenceRuntimeFile))};`
 
-  return `${symbol}
+  const realpath = portable?.real
+    ? `import { realpathSync as __pnextRealpath } from 'node:fs';\n`
+    : ''
+
+  return `${realpath}${symbol}
 
 function createReference(reference) {
   function ClientReference({ children }) {
@@ -103,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/client-plugin.ts

@@ -1,7 +1,7 @@
 import path from 'node:path'
 import { realpathSync } from 'node:fs'
 import type { Plugin } from 'esbuild'
-import { readText } from '../../utils/fs'
+import { readText, toPosixPath } from '../../utils/fs'
 import { escapeRegex } from '../../utils/code'
 import { actionId } from './ids'
 import { moduleActionExports, moduleLevelUseCache, moduleLevelUseServer } from './detect'
@@ -125,7 +125,9 @@ export function stubSourceFromSource(file: string, source: string, root?: string
   const exports = moduleActionExports(source)
   const actionIds: Record<string, string> = {}
   for (const name of exports) actionIds[name] = canonicalActionId(file, name, root)
-  return clientStubSource({ modulePath: file, exports, actionIds })
+  // Root-relative: the stub ships in client bundles and release artifacts.
+  const modulePath = root ? toPosixPath(path.relative(root, file)) : file
+  return clientStubSource({ modulePath, exports, actionIds })
 }
 
 export async function loadClientActionSource(file: string, root?: string) {

package/src/compat/actions/config.ts

@@ -3,6 +3,7 @@ import { createRequire } from 'node:module'
 import path from 'node:path'
 import { pathToFileHref } from '../../config'
 import { DEFAULT_BODY_LIMIT_BYTES } from './endpoint'
+import { getNextConfig, nextConfigReleased } from '../next/config-loader'
 
 /**
  * Server-actions options read from the app's next.config in compat mode:
@@ -39,7 +40,7 @@ export async function loadServerActionsConfig(root: string): Promise<ServerActio
 }
 
 export async function loadResolvedNextConfig(root: string): Promise<NextConfigShape | undefined> {
-  return (await loadNextConfigFromStore()) ?? (await loadNextConfig(root))
+  return loadNextConfigFromStore() ?? (await loadNextConfig(root))
 }
 
 /**
@@ -50,9 +51,8 @@ export async function loadResolvedNextConfig(root: string): Promise<NextConfigSh
  * silently dropped the configured bodySizeLimit. Returns undefined when the store is empty so the
  * caller falls back to a direct file read.
  */
-async function loadNextConfigFromStore(): Promise<NextConfigShape | undefined> {
+function loadNextConfigFromStore(): NextConfigShape | undefined {
   try {
-    const { getNextConfig } = await import('../next/config-loader')
     const store: NextConfigShape = getNextConfig()
     return store && Object.keys(store).length > 0 ? store : undefined
   } catch {
@@ -61,6 +61,7 @@ async function loadNextConfigFromStore(): Promise<NextConfigShape | undefined> {
 }
 
 export async function loadNextConfig(root: string): Promise<NextConfigShape | undefined> {
+  if (nextConfigReleased()) return getNextConfig()
   for (const name of ['next.config.js', 'next.config.mjs', 'next.config.cjs']) {
     const file = path.join(root, name)
     if (!existsSync(file)) continue
@@ -109,9 +110,9 @@ export async function loadNextConfig(root: string): Promise<NextConfigShape | un
  * skipped here - the lazy per-request path still validates.
  */
 export function validateServerActionsConfigSync(root: string): void {
-  let config: NextConfigShape | undefined
+  let config: NextConfigShape | undefined = nextConfigReleased() ? getNextConfig() : undefined
   const requireFrom = createRequire(path.join(root, 'noop.js'))
-  for (const name of ['next.config.js', 'next.config.cjs']) {
+  for (const name of config ? [] : ['next.config.js', 'next.config.cjs']) {
     const file = path.join(root, name)
     if (!existsSync(file)) continue
     try {

package/src/compat/actions/extensions.ts

@@ -21,8 +21,7 @@ import {
 import { getRequestRuntime, type RequestRuntime } from '../../routing/request-environment'
 import { toPosixPath } from '../../utils/fs'
 import type { ActionManifestEntry, BuildManifest, RouteManifestEntry } from '../../types'
-import { devServerModuleHref } from '../../runtime/modules'
-import { serverBundleTargetForRuntime } from '../../runtime/loader'
+import { devServerModuleHref, serverBundleTargetForRuntime } from '../../runtime/load'
 import {
   renderActionReturnElement,
   renderGlobalNotFoundResponse,
@@ -31,7 +30,7 @@ import {
   renderPageResponse,
 } from '../../render/renderer'
 import { routeParamsFromPath } from '../../routing/handler'
-import { selectRouteForRequest } from '../../routing/routes'
+import { selectRouteForRequest } from '../../routing/match'
 import { discoverActions, registerDiscoveredActions } from './discovery'
 import { clearActions, lookupActionSource, registerActionModule } from './registry'
 import {
@@ -71,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.
@@ -542,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
@@ -701,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/aliases.ts

@@ -1,4 +1,6 @@
 import path from 'node:path'
+import { isReleaseCompile } from '../runtime/load'
+import { toPosixPath } from '../utils/fs'
 import { createRequire } from 'node:module'
 import type { Plugin } from 'esbuild'
 import { frameworkRuntimeAliasEntries, pnextAliases, type CompatAliasTarget } from '../config'
@@ -329,7 +331,12 @@ export function rewriteNextFontSource(
   let next = rewriteNextGoogleFontImports(source, runtimePath)
   const localFontNames = nextLocalFontImportNames(next)
   if (localFontNames.size === 0) return next
-  const callerFile = localFontCallerFile(file, root)
+  // A release names the caller root-relative, so its font identity survives moving the build.
+  const absoluteCaller = localFontCallerFile(file, root)
+  const callerFile =
+    isReleaseCompile() && root && path.isAbsolute(absoluteCaller)
+      ? toPosixPath(path.relative(root, absoluteCaller))
+      : absoluteCaller
   // Rewrite each `NAME(...)` call to `NAME.withFile(<file>)(...)` so the runtime
   // gets the caller path (for `src` resolution + a stable per-caller hash). The
   // client runtime only uses `callerFile` for the hash (which must match the

package/src/compat/bundler/config.ts

@@ -20,6 +20,89 @@ const PREDEFINED_SERVER_EXTERNAL_PACKAGES = [
   '@node-rs/bcrypt',
 ]
 
+/** Next's `next/dist/lib/server-external-packages.jsonc`. */
+const NEXT_SERVER_EXTERNAL_PACKAGES = new Set([
+  '@alinea/generated',
+  '@appsignal/nodejs',
+  '@aws-sdk/client-s3',
+  '@aws-sdk/s3-presigned-post',
+  '@blockfrost/blockfrost-js',
+  '@highlight-run/node',
+  '@huggingface/transformers',
+  '@jpg-store/lucid-cardano',
+  '@libsql/client',
+  '@mikro-orm/core',
+  '@mikro-orm/knex',
+  '@node-rs/argon2',
+  '@node-rs/bcrypt',
+  '@prisma/client',
+  '@react-pdf/renderer',
+  '@sentry/profiling-node',
+  '@sparticuz/chromium',
+  '@sparticuz/chromium-min',
+  '@statsig/statsig-node-core',
+  '@swc/core',
+  '@xenova/transformers',
+  '@zenstackhq/runtime',
+  'argon2',
+  'autoprefixer',
+  'aws-crt',
+  'bcrypt',
+  'better-sqlite3',
+  'canvas',
+  'chromadb-default-embed',
+  'config',
+  'cpu-features',
+  'cypress',
+  'dd-trace',
+  'eslint',
+  'express',
+  'firebase-admin',
+  'htmlrewriter',
+  'import-in-the-middle',
+  'isolated-vm',
+  'jest',
+  'jsdom',
+  'keyv',
+  'libsql',
+  'mdx-bundler',
+  'mongodb',
+  'mongoose',
+  'newrelic',
+  'next-mdx-remote',
+  'next-seo',
+  'node-cron',
+  'node-pty',
+  'node-web-audio-api',
+  'onnxruntime-node',
+  'oslo',
+  'pg',
+  'pino',
+  'pino-pretty',
+  'pino-roll',
+  'playwright',
+  'playwright-core',
+  'postcss',
+  'prettier',
+  'prisma',
+  'puppeteer',
+  'puppeteer-core',
+  'ravendb',
+  'require-in-the-middle',
+  'rimraf',
+  'sharp',
+  'shiki',
+  'sqlite3',
+  'thread-stream',
+  'ts-morph',
+  'ts-node',
+  'typescript',
+  'vscode-oniguruma',
+  'webpack',
+  'websocket',
+  'zeromq',
+])
+
 function stringArray(value: unknown): string[] {
   return Array.isArray(value)
     ? value.filter((item): item is string => typeof item === 'string')
@@ -51,6 +134,11 @@ export function deploymentId(): string | undefined {
   return fromEnv && fromEnv.length > 0 ? fromEnv : undefined
 }
 
+/** Next's built-in server externals, which a release keeps out of its dependency graph. */
+export function builtInServerExternalPackages(): ReadonlySet<string> {
+  return NEXT_SERVER_EXTERNAL_PACKAGES
+}
+
 /** `publicRuntimeConfig`: the subset of runtime config safe to inline into client bundles. */
 export function publicRuntimeConfig(): Record<string, unknown> {
   const config = getNextConfig().publicRuntimeConfig

package/src/compat/bundler/optimize-package-imports.ts

@@ -181,9 +181,33 @@ function parseGeneratedBarrel(entry: string): BarrelMap | undefined {
   if (isGeneratedFontAwesomePackage(packageDir)) {
     return parseGeneratedFontAwesomeBarrel(entry, source)
   }
+  const plain = plainReExports(source)
+  const exported = plain
+    ? { exports: plain, count: plain.size, reExportsOnly: () => true }
+    : parsedReExports(entry, source)
+  if (!exported || exported.count < GENERATED_BARREL_MIN_EXPORTS) return undefined
+  const { exports, count: exportCount } = exported
+  const siblings = siblingFilesByStem(path.dirname(entry), entry)
+  const members = new Map<string, BarrelMember>()
+  for (const [name, member] of exports) {
+    const files = siblings.get(name)
+    const file = files?.[0]
+    if (
+      file &&
+      files.length === 1 &&
+      path.resolve(path.dirname(entry), member.source) === path.resolve(path.dirname(entry), file)
+    ) {
+      members.set(name, member)
+    }
+  }
+  if (members.size / exportCount >= GENERATED_BARREL_LEAF_RATIO) return members
+  return exported.reExportsOnly() ? manyToFewBarrelMembers(exports, entry) : undefined
+}
+
+/** The entry's re-export records off oxc's module record; the AST is read only if asked for. */
+function parsedReExports(entry: string, source: string) {
   const parsed = parseSync(entry, source, { lang: 'js' })
   if (parsed.errors.length > 0) return undefined
-  const siblings = siblingFilesByStem(path.dirname(entry), entry)
   const exports = new Map<string, BarrelMember>()
   const exportNames = new Set<string>()
   let exportCount = 0
@@ -206,22 +230,56 @@ function parseGeneratedBarrel(entry: string): BarrelMap | undefined {
       exports.set(name, { source: request, imported })
     }
   }
-  if (exportCount < GENERATED_BARREL_MIN_EXPORTS) return undefined
+  return {
+    exports,
+    count: exportCount,
+    // Re-exports and nothing else: no statement runs code or declares a binding.
+    reExportsOnly: () =>
+      parsed.program.body.every(
+        node => node.type === 'ExportNamedDeclaration' && !node.declaration,
+      ),
+  }
+}
 
-  const members = new Map<string, BarrelMember>()
-  for (const [name, member] of exports) {
-    const files = siblings.get(name)
-    const file = files?.[0]
-    if (
-      file &&
-      files.length === 1 &&
-      path.resolve(path.dirname(entry), member.source) === path.resolve(path.dirname(entry), file)
-    ) {
-      members.set(name, member)
+const PLAIN_RE_EXPORT = /export\s*\{([^{}]*)\}\s*from\s*(['"])([^'"\\\n]*)\2[ \t]*;?/y
+const PLAIN_GAP = /(?:\s+|\/\/[^\n]*|\/\*[\s\S]*?\*\/)*/y
+const PLAIN_SPECIFIER = /^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/
+
+/**
+ * A generated catalogue is usually nothing but `export { a as b } from './x'` lines. Read that
+ * exact shape without building an AST (oxc's module record alone costs more than the parse on a
+ * 1 MB entry); anything else - or a repeated name - answers undefined and takes the oxc path.
+ */
+function plainReExports(source: string): Map<string, BarrelMember> | undefined {
+  // The scan knows only LF as a line end; CR, U+2028 and U+2029 also end a `//` comment.
+  if (/[\r\u2028\u2029]/.test(source)) return undefined
+  const exports = new Map<string, BarrelMember>()
+  let at = 0
+  for (;;) {
+    PLAIN_GAP.lastIndex = at
+    PLAIN_GAP.exec(source)
+    if (PLAIN_GAP.lastIndex >= source.length) break
+    // Without a `;`, only a line break can end the statement before the next one.
+    if (at > 0 && source[at - 1] !== ';' && !source.slice(at, PLAIN_GAP.lastIndex).includes('\n'))
+      return undefined
+    PLAIN_RE_EXPORT.lastIndex = PLAIN_GAP.lastIndex
+    const statement = PLAIN_RE_EXPORT.exec(source)
+    if (!statement) return undefined
+    at = PLAIN_RE_EXPORT.lastIndex
+    const parts = statement[1]!.split(',')
+    for (const [index, part] of parts.entries()) {
+      const specifier = PLAIN_SPECIFIER.exec(part.trim())
+      if (!specifier) {
+        if (part.trim() === '' && index === parts.length - 1 && index > 0) continue
+        return undefined
+      }
+      const imported = specifier[1]!
+      const name = specifier[2] ?? imported
+      if (exports.has(name)) return undefined
+      exports.set(name, { source: statement[3]!, imported })
     }
   }
-  if (members.size / exportCount >= GENERATED_BARREL_LEAF_RATIO) return members
-  return manyToFewBarrelMembers(parsed.program.body, exports, entry)
+  return exports
 }
 
 /**
@@ -234,26 +292,28 @@ function parseGeneratedBarrel(entry: string): BarrelMap | undefined {
  * read for demanded members.
  */
 function manyToFewBarrelMembers(
-  body: readonly { type: string; declaration?: unknown }[],
   exports: ReadonlyMap<string, BarrelMember>,
   entry: string,
 ): BarrelMap | undefined {
-  for (const node of body) {
-    if (node.type !== 'ExportNamedDeclaration' || node.declaration) return undefined
-  }
   const byDirectory = new Map<string, Map<string, string[]>>()
+  // Thousands of names share a handful of leaves: judge each leaf once.
+  const unambiguous = new Map<string, boolean>()
   const members = new Map<string, BarrelMember>()
   for (const [name, member] of exports) {
     if (!member.source.startsWith('.')) continue
-    const file = path.resolve(path.dirname(entry), member.source)
-    const directory = path.dirname(file)
-    let siblings = byDirectory.get(directory)
-    if (!siblings) {
-      siblings = siblingFilesByStem(directory, entry)
-      byDirectory.set(directory, siblings)
+    let leaf = unambiguous.get(member.source)
+    if (leaf === undefined) {
+      const file = path.resolve(path.dirname(entry), member.source)
+      const directory = path.dirname(file)
+      let siblings = byDirectory.get(directory)
+      if (!siblings) {
+        siblings = siblingFilesByStem(directory, entry)
+        byDirectory.set(directory, siblings)
+      }
+      leaf = siblings.get(path.basename(file).replace(/\.(?:c|m)?js$/, ''))?.length === 1
+      unambiguous.set(member.source, leaf)
     }
-    if (siblings.get(path.basename(file).replace(/\.(?:c|m)?js$/, ''))?.length !== 1) continue
-    members.set(name, member)
+    if (leaf) members.set(name, member)
   }
   return members.size > 0 ? members : undefined
 }