@wular/pnext 0.1.7 → 0.1.9

package/src/config.ts

@@ -1,12 +1,21 @@
 import { existsSync, realpathSync } from 'node:fs'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import path from 'node:path'
+import { outCachePath, standaloneOutSegment } from './out-paths'
 import { loadEnv } from './env'
 import { findWorkspaceRoot } from './resolve/package-json'
 import { PREFETCH_MODES, type PNextConfig } from './types'
 import { setCacheComponents } from './render/ppr'
 import { setLegacyRequestAPIs } from './request/context'
-import { attachRelease, locateRelease, readBuildIndex, releaseConfig } from './runtime/production'
+import {
+  attachRelease,
+  buildIndexFile,
+  linkStandaloneOrigins,
+  readBuildIndex,
+  releaseConfig,
+  releaseSourceRoot,
+  servingReleaseDir,
+} from './runtime/production'
 
 export type ResolvedConfig = Required<Pick<PNextConfig, 'outDir' | 'basePath'>> &
   Omit<PNextConfig, 'outDir' | 'basePath'> & {
@@ -16,7 +25,7 @@ export type ResolvedConfig = Required<Pick<PNextConfig, 'outDir' | 'basePath'>>
     publicDir: 'public'
     appPath: string
     publicPath: string
-    /** Where this process writes and serves from: the out root, or `<outRoot>/dev` in dev. */
+    /** Where this process writes and serves from: `<outRoot>/standalone`, or `<outRoot>/dev` in dev. */
     outPath: string
     /** The out root itself (`.pnext`), identical in dev and build. */
     outRootPath: string
@@ -97,7 +106,7 @@ export async function loadConfig(
   options: { dev?: boolean; serve?: boolean; warnings?: boolean } = {},
 ): Promise<ResolvedConfig> {
   const root = canonicalRoot(path.resolve(rootInput))
-  const released = options.serve ? locateRelease(root, DEFAULT_OUT_DIR) : undefined
+  const released = options.serve ? servingReleaseDir() : undefined
   if (released) return loadReleasedConfig(root, released, options)
   await loadEnv(root, options)
   const configPath = path.join(root, 'pnext.config.ts')
@@ -129,6 +138,12 @@ export async function loadConfig(
   const sourceOverrides = stripUndefined(await resolveConfigSource(config, root, options))
   const merged = { ...defaultConfig, ...config, ...sourceOverrides }
   const outRootPath = path.resolve(root, merged.outDir)
+  // `pnext start` reads outDir from the config, as `next start` reads distDir, then serves the release.
+  const release = path.join(outRootPath, standaloneOutSegment)
+  if (options.serve && existsSync(buildIndexFile(release))) {
+    // The source config above already warned; its compiled copy must not warn again.
+    return loadReleasedConfig(root, release, { ...options, warnings: false })
+  }
   // A build materializes pages into its output, so the release names them portably.
   const appPath = await resolveAppPath(
     root,
@@ -163,7 +178,7 @@ export async function loadConfig(
     // Dev owns `<outRoot>/dev` exclusively so a concurrent `pnext build` — which
     // wipes its own outputs under the out root — can never pull a running dev
     // server's cache, manifest or assets out from under it.
-    outPath: options.dev ? path.join(outRootPath, devOutSegment) : outRootPath,
+    outPath: path.join(outRootPath, options.dev ? devOutSegment : standaloneOutSegment),
     outRootPath,
     typesPath: path.join(outRootPath, 'types'),
     checksPath: path.join(outRootPath, 'typecheck', 'checks'),
@@ -180,7 +195,9 @@ async function loadReleasedConfig(
   options: { dev?: boolean; serve?: boolean; warnings?: boolean },
 ): Promise<ResolvedConfig> {
   const index = readBuildIndex(outPath)
-  const config = releaseConfig(index.config, root, outPath)
+  linkStandaloneOrigins(outPath)
+  const sourceRoot = releaseSourceRoot(outPath, index.config.outPath as string)
+  const config = releaseConfig(index.config, sourceRoot, outPath)
   await loadEnv(root, options)
   setLegacyRequestAPIs(
     typeof config.compat?.next === 'object' && config.compat.next.legacyRequestAPIs === true,
@@ -219,6 +236,8 @@ function validateConfig(config: PNextConfig) {
 /** Dev's private subtree under the out root. Build never touches it. */
 export const devOutSegment = 'dev'
 
+export { outCachePath, standaloneOutSegment }
+
 // Relative-import resolution realpaths the importing file (so a materialized shim resolves `./sibling`
 // against real source), so every containment check against root/workspaceRoot compares realpaths.
 // Canonicalize the roots to match - otherwise an app served through a symlinked directory (a macOS
@@ -297,6 +316,10 @@ export function frameworkRuntimeAliasEntries(): Record<FrameworkRuntimeAlias, st
   return frameworkRuntimeAliases
 }
 
+/** Packages the framework resolves at runtime by name, not by import. */
+export const frameworkRuntimeSpecifiers = (): string[] =>
+  Object.keys(frameworkRuntimeAliasEntries())
+
 function resolveRuntimeModule(specifier: string) {
   return fileURLToPath(import.meta.resolve(specifier))
 }

package/src/css/assets.ts

@@ -116,7 +116,7 @@ export async function emitFontCssStylesheet(
   baseAsset: string | undefined,
   options: { dev: boolean },
 ) {
-  const outDir = path.join(config.outPath, options.dev ? 'cache' : 'public', 'assets')
+  const outDir = path.join(config.outPath, options.dev ? 'cache' : 'static', 'assets')
   await ensureDir(outDir)
   const baseFile = baseAsset ? path.join(outDir, baseAsset) : undefined
   const baseCss = baseFile && existsSync(baseFile) ? await readFile(baseFile, 'utf8') : ''

package/src/css/build.ts

@@ -40,6 +40,7 @@ export {
   withAssetPrefix,
   type AssetHrefConfig,
 } from './assets'
+import { outCachePath } from '../out-paths'
 
 interface Pending {
   resolve: () => void
@@ -114,14 +115,20 @@ export async function stopCssWorker(): Promise<void> {
   if (active) await Promise.resolve(active.terminate())
 }
 
+// Tailwind skips the out root and caches candidates in it; dev keeps its own subtree.
+function scanOutDir(config: Pick<ResolvedConfig, 'outPath' | 'outRootPath'>, dev: boolean) {
+  return dev ? config.outPath : config.outRootPath
+}
+
 export async function runPostcssOffThread(
-  config: Pick<ResolvedConfig, 'root' | 'outPath'>,
+  config: Pick<ResolvedConfig, 'root' | 'outPath' | 'outRootPath'>,
   cssFile: string,
   options: { dev?: boolean },
   from?: string,
 ) {
-  const { root, outPath: outDir } = config
   const dev = options.dev ?? false
+  const { root } = config
+  const outDir = scanOutDir(config, dev)
   const sent = send(id => ({ kind: 'process', id, root, dev, outDir, cssFile, from }))
   if (sent) return sent
   return runPostcss(root, cssFile, { dev, outDir }, from)
@@ -132,7 +139,7 @@ export async function runPostcssOffThread(
  * stylesheet, so a cold Tailwind boot overlaps with the rest of dev startup.
  */
 export function warmCssWorker(
-  config: Pick<ResolvedConfig, 'root' | 'outPath'>,
+  config: Pick<ResolvedConfig, 'root' | 'outPath' | 'outRootPath'>,
   options: { dev?: boolean } = {},
 ) {
   send(id => ({
@@ -140,7 +147,7 @@ export function warmCssWorker(
     id,
     root: config.root,
     dev: options.dev ?? false,
-    outDir: config.outPath,
+    outDir: scanOutDir(config, options.dev ?? false),
   }))?.catch(() => {
     // A broken postcss config surfaces on the real build; warming stays quiet.
   })
@@ -265,7 +272,7 @@ function rootLayoutFile(appPath: string, missing?: Set<string>) {
  * instead of landing on the first request. No-op without a postcss config.
  */
 export function warmCssPipeline(
-  config: Pick<ResolvedConfig, 'root' | 'outPath'>,
+  config: Pick<ResolvedConfig, 'root' | 'outPath' | 'outRootPath'>,
   options: CssBuildOptions = {},
 ) {
   if (!hasPostcssConfig(config.root)) return
@@ -281,8 +288,8 @@ export async function buildGlobalCss(config: ResolvedConfig, options: CssBuildOp
   }
 
   const outDir = options.dev
-    ? path.join(config.outPath, 'cache', 'assets')
-    : path.join(config.outPath, 'public', 'assets')
+    ? path.join(outCachePath(config.outPath), 'assets')
+    : path.join(config.outPath, 'static', 'assets')
   const outfile = path.join(outDir, 'global.css')
   await ensureDir(outDir)
 
@@ -606,8 +613,8 @@ async function writeCssChunk(
   const log = createVerboseLogger(options.verbose ?? false, 'css')
 
   const outDir = options.dev
-    ? path.join(config.outPath, 'cache', 'assets')
-    : path.join(config.outPath, 'public', 'assets')
+    ? path.join(outCachePath(config.outPath), 'assets')
+    : path.join(config.outPath, 'static', 'assets')
   const outfile = path.join(outDir, assetName)
   await ensureDir(outDir)
 

package/src/dev/client-chunk-store.ts

@@ -9,9 +9,10 @@ import { createHash } from 'node:crypto'
 import { link, mkdir, readFile, readdir, rm, stat, unlink } from 'node:fs/promises'
 import path from 'node:path'
 import { listFiles } from '../utils/fs'
+import { outCachePath } from '../out-paths'
 
 export function clientChunkStoreDir(outPath: string) {
-  return path.join(outPath, 'cache', 'client-store')
+  return path.join(outCachePath(outPath), 'client-store')
 }
 
 function contentHash(data: Buffer) {

package/src/dev/restart/client-key.ts

@@ -23,6 +23,7 @@ import type { ResolvedConfig } from '../../config'
 import type { RouteManifestEntry } from '../../types'
 import { writeFileAtomic } from '../../utils/fs'
 import { restartCacheEnabled } from './enabled'
+import { outCachePath } from '../../out-paths'
 
 /** `[file, mtimeMs, size, contentHash]` — the same record shape the module index uses. */
 type SourceEntry = [string, number, number, string]
@@ -53,7 +54,7 @@ interface KeyCache {
 const caches = new Map<string, KeyCache>()
 
 function keyCache(config: ResolvedConfig): KeyCache {
-  const file = path.join(config.outPath, 'cache', 'client', 'keys.json')
+  const file = path.join(outCachePath(config.outPath), 'client', 'keys.json')
   const existing = caches.get(file)
   if (existing) return existing
   const created: KeyCache = { file, routes: readIndex(file), dirty: false, retries: 0 }

package/src/dev/restart/global-css.ts

@@ -17,6 +17,7 @@ import { setGlobalCssSourceStore, type GlobalCssSourceStore } from '../../css/bu
 import { traceEnabled } from '../../utils/trace-flags'
 import { restartCacheEnabled } from './enabled'
 import { hash, lazyRecordCacheKey, revalidate, sourceEntries, type SourceEntry } from './record'
+import { outCachePath } from '../../out-paths'
 
 interface RecordFile {
   version: number
@@ -34,7 +35,7 @@ export function installGlobalCssCache(config: ResolvedConfig) {
   if (!restartCacheEnabled()) return
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   if (process.env.PNEXT_DEV_GLOBAL_CSS_CACHE === '0') return
-  const dir = path.join(config.outPath, 'cache', 'global-css')
+  const dir = path.join(outCachePath(config.outPath), 'global-css')
   setGlobalCssSourceStore(createStore(dir, lazyRecordCacheKey(config, RECORD_VERSION)))
 }
 

package/src/dev/restart/route-bundle-key.ts

@@ -25,6 +25,7 @@ import {
   type DevGraphSource,
 } from '../../runtime/module-cache'
 import { restartCacheEnabled } from './enabled'
+import { outCachePath } from '../../out-paths'
 
 interface RecordFile {
   version: number
@@ -49,7 +50,7 @@ function enabled() {
 }
 
 function recordFile(config: ResolvedConfig, routeId: string) {
-  return path.join(config.outPath, 'cache', 'route-bundles', `${hash(routeId)}.json`)
+  return path.join(outCachePath(config.outPath), 'route-bundles', `${hash(routeId)}.json`)
 }
 
 /**

package/src/dev/restart/route-facts.ts

@@ -20,6 +20,7 @@ import { setRouteFactsStore, type RouteFacts, type RouteFactsStore } from '../..
 import { traceEnabled } from '../../utils/trace-flags'
 import { restartCacheEnabled } from './enabled'
 import { hash, lazyRecordCacheKey, revalidate, sourceEntry, type SourceEntry } from './record'
+import { outCachePath } from '../../out-paths'
 
 interface RecordFile {
   version: number
@@ -45,7 +46,7 @@ export function installRouteFactsCache(config: ResolvedConfig) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   if (process.env.PNEXT_DEV_FACTS_CACHE === '0') return
   const cache: FactsCache = {
-    dir: path.join(config.outPath, 'cache', 'route-facts'),
+    dir: path.join(outCachePath(config.outPath), 'route-facts'),
     key: lazyRecordCacheKey(config, RECORD_VERSION),
     written: new Set(),
   }

package/src/dev/server.ts

@@ -121,6 +121,7 @@ import { cacheRoot, setDevWatcherFreshness } from '../runtime/module-cache'
 import { abortUpstreamFetchOnDisconnect } from '../runtime/fetch-host'
 import { markBoot } from '../cli/boot/trace'
 import { formatDuration } from '../utils/verbose'
+import { outCachePath } from '../out-paths'
 
 interface DevServerOptions {
   config: ResolvedConfig
@@ -217,7 +218,7 @@ async function evictStaleClientCaches(outPath: string) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   const keep = Number(process.env.PNEXT_DEV_CLIENT_CACHE_KEEP || 32)
   if (!Number.isFinite(keep) || keep <= 0) return
-  const clientRoot = path.join(outPath, 'cache', 'client')
+  const clientRoot = path.join(outCachePath(outPath), 'client')
   try {
     const entries = await readdir(clientRoot)
     if (entries.length <= keep) return
@@ -597,7 +598,7 @@ export async function startDevServer(options: DevServerOptions) {
           .some(prefix => url.pathname.startsWith(prefix))
       ) {
         const emitted = await maybeStaticFile(
-          path.join(config.outPath, 'public'),
+          path.join(config.outPath, 'static'),
           url.pathname,
           exactNames,
         )
@@ -613,7 +614,7 @@ export async function startDevServer(options: DevServerOptions) {
       )
       if (staticAssetPathname) {
         const outPublicStatic = await maybeStaticFile(
-          path.join(config.outPath, 'public'),
+          path.join(config.outPath, 'static'),
           staticAssetPathname,
           exactNames,
         )
@@ -1274,7 +1275,7 @@ async function buildDevClient(config: ResolvedConfig, route: RouteManifestEntry)
     batchRoutes.length === 1
       ? cacheKeys[0]!
       : `batch-${clientSourceHash([...cacheKeys].sort().join('\n'))}`
-  const outDir = path.join(config.outPath, 'cache', 'client', cacheKey)
+  const outDir = path.join(outCachePath(config.outPath), 'client', cacheKey)
   const outFile = path.join(outDir, `${clientEntryName(route)}.js`)
 
   // Dedup in-flight builds first. A single page view fires up to three requests
@@ -1361,7 +1362,7 @@ async function resolveDevClientChunk(config: ResolvedConfig, name: string) {
   const settled = clientChunks.get(name)
   if (settled && existsSync(settled)) return settled
 
-  const clientRoot = path.join(config.outPath, 'cache', 'client')
+  const clientRoot = path.join(outCachePath(config.outPath), 'client')
   for (const generation of await readdir(clientRoot).catch(() => [])) {
     const chunksDir = path.join(clientRoot, generation, 'chunks')
     const file = path.join(chunksDir, name)
@@ -1500,8 +1501,8 @@ async function maybeBuiltAsset(
   }
 
   const outPath = config.outPath
-  const filePath = path.join(outPath, 'cache', pathname.replace(/^\/+/, ''))
-  if (!isInside(path.join(outPath, 'cache'), filePath) || !existsSync(filePath)) return null
+  const filePath = path.join(outCachePath(outPath), pathname.replace(/^\/+/, ''))
+  if (!isInside(path.join(outCachePath(outPath)), filePath) || !existsSync(filePath)) return null
   const fileStat = await stat(filePath)
   if (!fileStat.isFile()) return null
   return new Response(await readFile(filePath), {

package/src/out-paths.ts

@@ -0,0 +1,10 @@
+import path from 'node:path'
+
+/** The release a build writes under the out root: everything a production server reads. */
+export const standaloneOutSegment = 'standalone'
+
+/** The build cache beside a release (`<outRoot>/cache`); dev keeps its own. */
+export function outCachePath(outPath: string) {
+  const owner = path.basename(outPath) === standaloneOutSegment ? path.dirname(outPath) : outPath
+  return path.join(owner, 'cache')
+}

package/src/render/renderer.ts

@@ -3403,7 +3403,7 @@ export function withDevReloadScript(html: string, request?: Request): string {
 }
 
 function withGlobalErrorStylesheet(html: string, config: ResolvedConfig): string {
-  const asset = `${config.outPath}/public/assets/${emittedAssetName(config, 'global-error.css')}`
+  const asset = `${config.outPath}/static/assets/${emittedAssetName(config, 'global-error.css')}`
   if (!existsSync(asset)) return html
   const link = `<link rel="stylesheet" href="${assetHref(config, 'global-error.css')}">`
   if (html.includes('</head>')) return html.replace('</head>', `${link}</head>`)

package/src/resolve/dynamic.ts

@@ -224,6 +224,7 @@ export function deferredDynamicImportSpecifiers(source: string, file?: string) {
   }
 
   const facts = dynamicCallFacts(source, file)
+  const rendered = new Set<string>()
   for (const call of dynamicCallsFromSource(source, dynamicNames)) {
     const target = loaderImportTargetForCall(call, facts)
     if (!target) continue
@@ -239,7 +240,10 @@ export function deferredDynamicImportSpecifiers(source: string, file?: string) {
     const visible =
       /\bload\s*:\s*['"]visible['"]/.test(options) && !/\bssr\s*:\s*true\b/.test(options)
     if (ssrFalse || visible) deferred.add(target.specifier)
+    else rendered.add(target.specifier)
   }
+  // A target another call server-renders must compile for the server.
+  for (const specifier of rendered) deferred.delete(specifier)
   return deferred
 }
 

package/src/resolve/engine.ts

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs'
 import path from 'node:path'
 import type { ResolverFactory, NapiResolveOptions } from 'oxc-resolver'
 import { loadNative } from '../utils/native-require'
+import { splitResourceQuery } from '../utils/resource-query'
 
 // Lazy: the native binding costs ~1.3 MB RSS and a prod server may never resolve.
 function createResolverFactory(options: NapiResolveOptions): ResolverFactory {
@@ -95,18 +96,7 @@ export function tsConfigFileFor(root: string): string | undefined {
   return file
 }
 
-/**
- * Split a webpack resource specifier into its file request and its `?query#fragment` suffix - loader
- * plumbing (turbopack rules, `.wasm?module`) that takes no part in the on-disk lookup. A leading `#` is a
- * package-imports specifier, not a fragment.
- */
-export function splitResourceQuery(specifier: string): { path: string; query: string } {
-  const offset = specifier.startsWith('#') ? 1 : 0
-  const match = /[?#]/.exec(specifier.slice(offset))
-  if (!match) return { path: specifier, query: '' }
-  const index = offset + match.index
-  return { path: specifier.slice(0, index), query: specifier.slice(index) }
-}
+export { splitResourceQuery }
 
 /**
  * Resolve `specifier` from `dir`. `tsConfigRoot` opts the lookup into that

package/src/resolve/scan-facts.ts

@@ -76,6 +76,8 @@ export interface RewriteFacts {
   edges: SpecifierEdge[]
   imports: ImportStatement[]
   importMetas: { start: number; end: number }[]
+  /** `import()` calls whose argument is not a plain string literal. */
+  computedImports: { start: number; end: number }[]
   /**
    * The parse recovered from errors, so the record may be incomplete — folded
    * passes fall back to their textual form rather than silently under-rewrite.
@@ -146,6 +148,7 @@ const emptyRewriteFacts: RewriteFacts = {
   edges: [],
   imports: [],
   importMetas: [],
+  computedImports: [],
   unreliable: false,
 }
 
@@ -373,10 +376,14 @@ function parseFacts(file: string, source: string, lang: ParserLang) {
   imports.sort((a, b) => a.index - b.index)
 
   const dynamicImports: { specifier: string; index: number }[] = []
+  const computedImports: { start: number; end: number }[] = []
   for (const entry of result.module.dynamicImports) {
     const raw = source.slice(entry.moduleRequest.start, entry.moduleRequest.end)
     const specifier = literalSpecifier(raw)
-    if (specifier === undefined) continue
+    if (specifier === undefined) {
+      computedImports.push({ start: entry.start, end: entry.end })
+      continue
+    }
     dynamicImports.push({ specifier, index: entry.start })
     // The literal's own span, without the whitespace `moduleRequest` includes.
     const lead = raw.length - raw.trimStart().length
@@ -419,6 +426,7 @@ function parseFacts(file: string, source: string, lang: ParserLang) {
       edges,
       imports: importStatements,
       importMetas: result.module.importMetas.map(meta => ({ start: meta.start, end: meta.end })),
+      computedImports,
       unreliable: result.errors.length > 0,
     },
   }
@@ -581,6 +589,182 @@ function child(node: AstNode | undefined, key: string): AstNode | undefined {
   return isNode(value) ? value : undefined
 }
 
+/** A string literal argument: its cooked value and the span of its quoted text. */
+export interface LiteralSpan {
+  specifier: string
+  start: number
+  end: number
+}
+
+/** How a module refers to its own location (see `importMetaRefs`). */
+export interface ImportMetaRefs {
+  /** `new URL('<literal>', import.meta.url)`. */
+  urls: LiteralSpan[]
+  /** `import.meta.resolve('<literal>')`. */
+  resolves: LiteralSpan[]
+  /** Reads `import.meta.url`/`dirname`/`filename`/`resolve`, or takes `import.meta` whole. */
+  readsLocation: boolean
+  /** Spans of each `import()` whose argument is not a string literal. */
+  computedImports: { start: number; end: number }[]
+  /** The parse recovered from errors: callers keep their conservative answer. */
+  unreliable: boolean
+}
+
+const noMetaRefs: ImportMetaRefs = {
+  urls: [],
+  resolves: [],
+  readsLocation: false,
+  computedImports: [],
+  unreliable: false,
+}
+const metaRefMemo = new Map<string, ImportMetaRefs>()
+const locationMembers = new Set(['url', 'dirname', 'filename', 'resolve'])
+
+/** Every reference a module makes to its own location, from the AST: never a comment or a string. */
+export function importMetaRefs(file: string, source: string): ImportMetaRefs {
+  if (stylesheetOrData.test(file)) return noMetaRefs
+  if (!source.includes('import.meta') && !source.includes('import(')) return noMetaRefs
+  // The memoized module record answers computed imports and whether `import.meta` occurs at all;
+  // only a module that really uses it pays for the AST.
+  const record = rewriteFacts(file, source)
+  if (record.importMetas.length === 0)
+    return { ...noMetaRefs, computedImports: record.computedImports, unreliable: record.unreliable }
+  const lang = langForFile(file)
+  const key = `${lang}\0${source.length}\0${bun.hash(source).toString()}`
+  const cached = metaRefMemo.get(key)
+  if (cached) return cached
+  const result = parseSync(file, source, { lang })
+  const refs: ImportMetaRefs = {
+    ...noMetaRefs,
+    urls: [],
+    resolves: [],
+    computedImports: record.computedImports,
+  }
+  refs.unreliable = result.errors.length > 0
+  const isImportMeta = (node: AstNode | undefined) =>
+    node?.type === 'MetaProperty' &&
+    child(node, 'meta')?.name === 'import' &&
+    child(node, 'property')?.name === 'meta'
+  const memberName = (node: AstNode) =>
+    node.computed ? stringValue(child(node, 'property')) : (child(node, 'property')?.name as string)
+  const literal = (node: AstNode | undefined): LiteralSpan | undefined => {
+    if (!node) return undefined
+    const value =
+      stringValue(node) ??
+      (node.type === 'TemplateLiteral' && (node.expressions as unknown[]).length === 0
+        ? ((node.quasis as AstNode[])[0]?.value as { cooked?: string } | undefined)?.cooked
+        : undefined)
+    return value === undefined ? undefined : { specifier: value, start: node.start, end: node.end }
+  }
+  const visit = (value: unknown, parent: AstNode | undefined) => {
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item, parent)
+      return
+    }
+    if (!isNode(value)) return
+    if (isImportMeta(value)) {
+      const member = parent?.type === 'MemberExpression' && parent.object === value
+      if (!member || locationMembers.has(memberName(parent) ?? '')) refs.readsLocation = true
+    } else if (value.type === 'NewExpression' && child(value, 'callee')?.name === 'URL') {
+      const [target, base] = value.arguments as AstNode[]
+      const span = literal(target)
+      if (span && base?.type === 'MemberExpression' && isImportMeta(child(base, 'object')))
+        if (memberName(base) === 'url') refs.urls.push(span)
+    } else if (value.type === 'CallExpression') {
+      const callee = child(value, 'callee')
+      if (callee?.type === 'MemberExpression' && isImportMeta(child(callee, 'object'))) {
+        const span = literal((value.arguments as AstNode[])[0])
+        if (span && memberName(callee) === 'resolve') refs.resolves.push(span)
+      }
+    }
+    for (const key in value) {
+      if (key !== 'start' && key !== 'end' && key !== 'type') visit(value[key], value)
+    }
+  }
+  visit(result.program, undefined)
+  metaRefMemo.set(key, refs)
+  return refs
+}
+
+/**
+ * Whether the module declares top-level state: a `const`/`let`/`var` initialized by `new`, or by a
+ * call through a plain name (not `require`, not `/* @__PURE__ *\/`), from the AST: never a line
+ * inside a string, and every declarator counts.
+ */
+export function hasModuleState(file: string, source: string): boolean {
+  const result = parseSync(file, source, { lang: langForFile(file) })
+  const pureEnds = new Set(
+    result.comments
+      .filter(comment => /^\s*[#@]__PURE__\s*$/.test(comment.value))
+      .map(comment => comment.end),
+  )
+  const annotatedPure = (node: AstNode) => {
+    for (let index = node.start - 1; index >= 0; index -= 1) {
+      if (pureEnds.has(index + 1)) return true
+      if (!/\s/.test(source[index]!)) return false
+    }
+    return false
+  }
+  const plainCallee = (node: AstNode | undefined): boolean =>
+    node?.type === 'Identifier' ||
+    (node?.type === 'MemberExpression' && !node.computed && plainCallee(child(node, 'object')))
+  const declarations = (result.program.body as unknown as AstNode[]).flatMap(statement => {
+    const declaration =
+      statement.type === 'ExportNamedDeclaration' ? child(statement, 'declaration') : statement
+    return declaration?.type === 'VariableDeclaration'
+      ? (declaration.declarations as AstNode[])
+      : []
+  })
+  return declarations.some(declarator => {
+    const init = unwrapExpression(child(declarator, 'init'))
+    if (init?.type === 'NewExpression') return true
+    if (init?.type !== 'CallExpression') return false
+    const callee = child(init, 'callee')
+    return plainCallee(callee) && callee?.name !== 'require' && !annotatedPure(init)
+  })
+}
+
+/** A string literal holding an absolute path or `file:` URL, and whether it is an object key. */
+export interface PathLiteral {
+  value: string
+  start: number
+  end: number
+  key: boolean
+}
+
+/** Absolute path literals in emitted code, from the AST; undefined when the parse recovered. */
+export function absolutePathLiterals(file: string, source: string): PathLiteral[] | undefined {
+  const result = parseSync(file, source, { lang: langForFile(file) })
+  if (result.errors.length > 0) return undefined
+  const found: PathLiteral[] = []
+  const visit = (value: unknown, parent: AstNode | undefined) => {
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item, parent)
+      return
+    }
+    if (!isNode(value)) return
+    const literal = stringValue(value)
+    if (literal !== undefined && (literal.startsWith('/') || literal.startsWith('file:///'))) {
+      const key = parent?.type === 'Property' && parent.key === value && !parent.computed
+      found.push({ value: literal, start: value.start, end: value.end, key })
+    }
+    for (const key in value) {
+      if (key !== 'start' && key !== 'end' && key !== 'type') visit(value[key], value)
+    }
+  }
+  visit(result.program, undefined)
+  return found
+}
+
+/** Line comments (`// …`), from the parse; undefined when it recovered. */
+export function lineComments(file: string, source: string) {
+  const result = parseSync(file, source, { lang: langForFile(file) })
+  if (result.errors.length > 0) return undefined
+  return result.comments
+    .filter(comment => comment.type === 'Line')
+    .map(comment => ({ value: comment.value, start: comment.start, end: comment.end }))
+}
+
 /**
  * Drop `type: "json"` attributes from the import declarations and `import()` calls whose target
  * `compiled` claims: the target is JS, which a native load would parse as JSON.

package/src/routing/metadata-files.ts

@@ -216,7 +216,7 @@ export function staticMetadataLink(file: StaticMetadataFile): MetadataLink {
 }
 
 export function staticMetadataOutputFile(outPath: string, file: StaticMetadataFile) {
-  return path.join(outPath, 'public', file.outputPath)
+  return path.join(outPath, 'static', file.outputPath)
 }
 
 export function metadataHasOwnImages(metadata: Metadata, field: 'openGraph' | 'twitter') {