@wular/pnext 0.1.4 → 0.1.5

package/src/routing/routes.ts

@@ -181,6 +181,7 @@ interface ModuleEdge {
 
 interface ScanContext {
   root: string
+  workspaceRoot?: string
   appPath: string
   sources: Map<string, string>
   edges: Map<string, ModuleEdge[]>
@@ -198,11 +199,16 @@ interface ScanContext {
   globalCssImports(): Set<string>
 }
 
-function createScanContext(appPath: string, globalCss?: () => Set<string>): ScanContext {
+function createScanContext(
+  appPath: string,
+  globalCss?: () => Set<string>,
+  workspaceRoot?: string,
+): ScanContext {
   const root = rootFromAppPath(appPath)
   let memo: Set<string> | undefined
   return {
     root,
+    workspaceRoot,
     appPath,
     sources: new Map(),
     edges: new Map(),
@@ -213,7 +219,8 @@ function createScanContext(appPath: string, globalCss?: () => Set<string>): Scan
     usesNavigation: new Map(),
     entryReasons: new Map(),
     globalCssImports:
-      globalCss ?? (() => (memo ??= new Set(globalCssSourcesForPaths(root, appPath)))),
+      globalCss ??
+      (() => (memo ??= new Set(globalCssSourcesForPaths(root, appPath, workspaceRoot)))),
   }
 }
 
@@ -375,14 +382,21 @@ function withDeferredFacts(
   return entry
 }
 
-export async function scanRoutes(appPath: string): Promise<RouteManifestEntry[]> {
+export async function scanRoutes(
+  appPath: string,
+  workspaceRoot?: string,
+): Promise<RouteManifestEntry[]> {
   const files = await listFiles(appPath)
-  return withDirCache(() => buildRouteTable(appPath, files))
+  return withDirCache(() => buildRouteTable(appPath, files, workspaceRoot))
 }
 
 /** The path pass: file paths in, route table out — no file content is read. */
-function buildRouteTable(appPath: string, files: string[]): RouteManifestEntry[] {
-  const context = createScanContext(appPath)
+function buildRouteTable(
+  appPath: string,
+  files: string[],
+  workspaceRoot?: string,
+): RouteManifestEntry[] {
+  const context = createScanContext(appPath, undefined, workspaceRoot)
   const routes: RouteManifestEntry[] = []
   const slotPageFiles: { file: string; relative: string }[] = []
   const defaultPageFiles: { file: string; relative: string }[] = []
@@ -1893,7 +1907,7 @@ function defaultReexportsClientModule(
     if (importBinding?.[1]) specifiers.push(importBinding[1])
   }
   for (const specifier of specifiers) {
-    const resolved = resolveModuleEdge(context.root, file, specifier)
+    const resolved = resolveModuleEdge(context, file, specifier)
     if (!resolved || !fileExists(context, resolved)) continue
     if (isClientModule(context, resolved)) return true
     if (defaultReexportsClientModule(context, resolved, visited)) return true
@@ -2126,7 +2140,7 @@ function readScanSource(context: ScanContext, file: string, visited = new Set<st
   const parts = [source]
   for (const edge of scanFacts(file, source).imports) {
     if (!edge.reexport || !edge.specifier.startsWith('.')) continue
-    const resolved = resolveModuleEdge(context.root, file, edge.specifier)
+    const resolved = resolveModuleEdge(context, file, edge.specifier)
     if (!resolved || !existsSync(resolved)) continue
     parts.push(readScanSource(context, resolved, visited))
   }
@@ -2274,12 +2288,12 @@ function moduleEdges(context: ScanContext, file: string) {
 // `next` package, plain resolveImport finds the real package's directive-less re-export stub and the
 // 'use client' boundary of the compat module is silently missed, so the route never gets its client
 // reference or entry.
-function resolveModuleEdge(root: string, file: string, specifier: string) {
+function resolveModuleEdge(context: ScanContext, file: string, specifier: string) {
   return (
     resolveModuleAlias(specifier) ??
-    resolveImport(root, file, specifier) ??
-    getBundlerExtensions().resolveRouteDependency(root, file, specifier) ??
-    getCssExtensions().resolveCssDependency(root, file, specifier)
+    resolveImport(context.root, file, specifier, context.workspaceRoot) ??
+    getBundlerExtensions().resolveRouteDependency(context.root, file, specifier) ??
+    getCssExtensions().resolveCssDependency(context.root, file, specifier)
   )
 }
 
@@ -2288,7 +2302,7 @@ function publishedClientImports(context: ScanContext, file: string) {
   const source = readSource(context, file)
   const found: ModuleEdge[] = []
   for (const edge of scanFacts(file, source).imports) {
-    if (resolveModuleEdge(context.root, file, edge.specifier)) continue
+    if (resolveModuleEdge(context, file, edge.specifier)) continue
     found.push(...publishedClientEdges(context, file, edge.specifier, edge.exports))
   }
   return found
@@ -2316,7 +2330,7 @@ function resolvePublishedEdge(
   kind: 'import' | 'require',
 ) {
   return (
-    resolveModuleEdge(context.root, file, specifier) ??
+    resolveModuleEdge(context, file, specifier) ??
     resolvePackageSpecifier(context.root, file, specifier, [kind, 'default'])
   )
 }
@@ -2376,7 +2390,7 @@ function moduleEdgesFromSource(context: ScanContext, file: string, source: strin
   const facts = scanFacts(file, source)
 
   for (const edge of facts.imports) {
-    const resolved = resolveModuleEdge(context.root, file, edge.specifier)
+    const resolved = resolveModuleEdge(context, file, edge.specifier)
     if (!resolved) continue
     ordered.push({
       file: resolved,
@@ -2389,7 +2403,7 @@ function moduleEdgesFromSource(context: ScanContext, file: string, source: strin
   ordered.sort((a, b) => a.index - b.index)
   const imports: ModuleEdge[] = ordered.map(({ index: _index, ...edge }) => edge)
 
-  for (const imported of dynamicImportEdgesFromSource(context.root, file, source, dynamicNames))
+  for (const imported of dynamicImportEdgesFromSource(context, file, source, dynamicNames))
     imports.push(imported)
 
   return imports
@@ -2488,7 +2502,7 @@ function assertSupportedDynamicCalls(file: string, source: string, dynamicNames:
 }
 
 function dynamicImportEdgesFromSource(
-  root: string,
+  context: ScanContext,
   file: string,
   source: string,
   dynamicNames: Set<string>,
@@ -2499,7 +2513,7 @@ function dynamicImportEdgesFromSource(
   const optionObjects = dynamicOptionObjects(source)
   for (const fact of dynamicCallFacts(source, file)) {
     if (!dynamicNames.has(fact.name)) continue
-    const resolved = resolveModuleEdge(root, file, fact.specifier)
+    const resolved = resolveModuleEdge(context, file, fact.specifier)
     if (!resolved) continue
     imports.push({
       file: resolved,

package/src/runtime/loader.ts

@@ -187,6 +187,7 @@ export function registerServerRuntime(config: ResolvedConfig, sourceFiles: strin
 
   const aliases = aliasesForConfig(config)
   const roots = [
+    ...rootPaths(config.root),
     ...rootPaths(config.appPath),
     ...rootPaths(path.join(config.outPath, 'cache', 'server')),
     // The pnext src root, so the framework's own source transforms too.
@@ -219,7 +220,7 @@ export function registerServerRuntime(config: ResolvedConfig, sourceFiles: strin
   }
   registerResolvePlugin()
   registerNodeModulesLoadPlugin()
-  for (const root of roots) registerLoadPlugin(root)
+  for (const root of roots) registerLoadPlugin(root, rootPaths(config.root).includes(root))
 }
 
 /**
@@ -236,7 +237,12 @@ export function installServerRuntimePlugins(): void {
   pluginsDeferred = false
   registerResolvePlugin()
   registerNodeModulesLoadPlugin()
-  for (const root of deferredPluginRoots) registerLoadPlugin(root)
+  for (const root of deferredPluginRoots) {
+    const projectRoot = [...runtimeConfigs.values()].some(config =>
+      rootPaths(config.root).includes(root),
+    )
+    registerLoadPlugin(root, projectRoot)
+  }
   deferredPluginRoots.clear()
 }
 
@@ -302,7 +308,7 @@ function registerResolvePlugin() {
   })
 }
 
-function registerLoadPlugin(root: string) {
+function registerLoadPlugin(root: string, projectRoot = false) {
   if (registeredLoadRoots.has(root)) return
   registeredLoadRoots.add(root)
   if (traceEnabled('server')) {
@@ -312,7 +318,7 @@ function registerLoadPlugin(root: string) {
   Bun.plugin({
     name: `pnext-server-runtime-load-${hashRoot(root)}`,
     setup(plugin) {
-      plugin.onLoad({ filter: rootFilter(root) }, async ({ path: file }) => ({
+      plugin.onLoad({ filter: rootFilter(root, projectRoot) }, async ({ path: file }) => ({
         contents: await transformSource(file),
         loader: 'js',
       }))
@@ -594,12 +600,17 @@ async function inlineModuleScopeRequires(
 function requireCallTarget(root: string, file: string, specifier: string): string | undefined {
   if (specifier.startsWith('file://')) {
     try {
-      return resolveImport(root, file, fileURLToPath(specifier))
+      return resolveImport(
+        root,
+        file,
+        fileURLToPath(specifier),
+        runtimeConfigForFile(file)?.resolved.workspaceRoot,
+      )
     } catch {
       return undefined
     }
   }
-  return resolveImport(root, file, specifier)
+  return resolveImport(root, file, specifier, runtimeConfigForFile(file)?.resolved.workspaceRoot)
 }
 
 // Compile an app module to a sibling `.pnext-require.cjs` (CommonJS), reusing a
@@ -751,7 +762,8 @@ export function rewriteServerSource(
   const rewritten = sourceHasDynamicImport(source)
     ? rewriteDynamicCallTargets(
         rewriteLiteralDynamicCalls(source, file),
-        specifier => resolveImport(root, file, specifier),
+        specifier =>
+          resolveImport(root, file, specifier, runtimeConfigForFile(file)?.resolved.workspaceRoot),
         file,
       )
     : source
@@ -867,12 +879,13 @@ function rootPaths(root: string) {
   return resolved
 }
 
-function rootFilter(root: string) {
+function rootFilter(root: string, projectRoot = false) {
   // Base source extensions plus any extra loadable extensions registered by
   // compat (e.g. mdx/md via pageExtensions). Without these, `.mdx` modules skip
   // the transform load hook and resolve as raw assets (default export = path).
   const extras = currentLoadExtras().map(escapeRegex)
-  const exts = ['[jt]sx?', ...extras].join('|')
+  // Project-wide coverage handles JSX/TS; plain JS tools and build output keep their own loaders.
+  const exts = [projectRoot ? 'tsx?|jsx' : '[jt]sx?', ...extras].join('|')
   // Exclude `next.config.{js,cjs,mjs,ts}`: it is loaded for its exported value (often CommonJS
   // `module.exports = ...`), not as part of the app's server module graph. Routing it through the
   // ES-module source transform drops the CJS exports, silently disabling next.config
@@ -884,8 +897,14 @@ function rootFilter(root: string) {
   const vendorGuard = vendorLoadsNatively()
     ? `${root.endsWith(`${path.sep}cache${path.sep}server`) ? '(?!\\/vendor\\/)' : ''}(?!.*\\/cache\\/server\\/vendor\\/)`
     : ''
+  // Project-wide roots include precompiled server output. Keep its chunks native: transforming
+  // them loads compiler libraries and starts an esbuild service on the first production request.
+  const serverGuard = [...runtimeConfigs.values()]
+    .flatMap(runtime => rootPaths(path.join(runtime.resolved.outPath, 'server')))
+    .map(serverRoot => `(?!${escapeRegex(serverRoot)}(?:/|$))`)
+    .join('')
   return new RegExp(
-    `^${escapeRegex(root)}${vendorGuard}(?!.*\\/node_modules\\/)(?!\\/next\\.config\\.(?:js|cjs|mjs|ts)$)(?:/.*)?\\.(?:${exts})$`,
+    `^${serverGuard}${escapeRegex(root)}${vendorGuard}(?!.*\\/node_modules\\/)(?!\\/next\\.config\\.(?:js|cjs|mjs|ts)$)(?:/.*)?\\.(?:${exts})$`,
   )
 }
 

package/src/runtime/modules.ts

@@ -1420,6 +1420,24 @@ export const compiledSpecifiersManifestSuffix = '.pnext-specifiers.json'
 const compiledScriptFilePattern = /\.(?:m?js|cjs|jsx|tsx?)$/
 
 async function writeCompiledFile(file: string, contents: string) {
+  const profileRoot = compiledArtifactProfileRoot(file)
+  if (profileRoot && contents.includes('file://')) {
+    const cacheRoot = path.dirname(profileRoot)
+    const edits: { start: number; end: number; value: string }[] = []
+    for (const found of outputSpecifiers(contents)) {
+      const { sourcePath, hash } = splitHash(found.value)
+      if (!sourcePath.startsWith('file://')) continue
+      const target = fileURLToPath(sourcePath)
+      if (!isInside(cacheRoot, target)) continue
+      const relative = toPosixPath(path.relative(path.dirname(file), target))
+      edits.push({
+        start: found.start,
+        end: found.end,
+        value: JSON.stringify(`${relative.startsWith('.') ? relative : `./${relative}`}${hash}`),
+      })
+    }
+    contents = spliceSource(contents, edits)
+  }
   await writeFileAtomic(file, contents)
   noteDevArtifactWritten(file)
   if (emitCompiledSpecifiersManifest && compiledScriptFilePattern.test(file)) {
@@ -1431,7 +1449,7 @@ async function writeCompiledFile(file: string, contents: string) {
 }
 
 /**
- * Whether every file URL reachable from a compiled artifact is already on
+ * Whether every module reachable from a compiled artifact is already on
  * disk. Individual files publish atomically, but the graph is a set of files:
  * the build's warm child can expose an importer to the parent before it has
  * exposed that importer's slower sibling. A mere existsSync(importer) is
@@ -1474,10 +1492,12 @@ function missingCompiledArtifact(entry: string): string | undefined {
       // profile directory. Static imports must be complete before evaluation.
       if (kind === 'dynamic') continue
       const { sourcePath } = splitHash(specifier)
-      if (!sourcePath.startsWith('file://')) continue
+      if (!sourcePath.startsWith('file://') && !sourcePath.startsWith('.')) continue
       let target: string
       try {
-        target = fileURLToPath(sourcePath)
+        target = sourcePath.startsWith('file://')
+          ? fileURLToPath(sourcePath)
+          : path.resolve(path.dirname(file), sourcePath)
       } catch {
         return sourcePath
       }
@@ -2433,6 +2453,7 @@ async function resolveDevModuleSpecifier(
     config.root,
     importer && !importer.startsWith('<') ? importer : file,
     sourcePath,
+    config.workspaceRoot,
   )
   // A relative specifier that resolved names first-party source next to its importer, so compile it
   // through the normal pipeline even outside workspaceRoot (compat's own runtime files live inside
@@ -2806,7 +2827,7 @@ function shouldBundleExternalPackage(
   if (options.aliases[specifier]) return false
   if (specifier === 'server-only') return false
   if (!isPackageSpecifier(specifier)) return false
-  const resolved = resolveImport(config.root, file, specifier)
+  const resolved = resolveImport(config.root, file, specifier, config.workspaceRoot)
   const inWorkspace = resolved !== undefined && isInside(config.workspaceRoot, resolved)
   // transpilePackages force-bundle; serverExternalPackages force-external (never bundled). A
   // transpiled package that resolves INSIDE the workspace is first-party source, not a registry
@@ -2859,7 +2880,7 @@ function localImportTargets(
     // compiling them as modules would fail the import scan. Css keeps its
     // copy-through so compiled css module paths stay importable.
     if (isServerIgnoredAssetSpecifier(sourcePath) && !isCssFile(sourcePath)) continue
-    const resolved = resolveImport(config.root, file, sourcePath)
+    const resolved = resolveImport(config.root, file, sourcePath, config.workspaceRoot)
     // `resolveExtensions` can land an extensionless specifier on an asset
     // (`import img from './image'` -> image.png), which the specifier check
     // above misses — compiling the image bytes as a module fails the build.
@@ -2894,7 +2915,7 @@ async function writeClientReferenceModules(
   for (const specifier of importSpecifiers(source, file)) {
     const { sourcePath } = splitHash(specifier)
     if (aliases[specifier] || aliases[sourcePath]) continue
-    const resolved = resolveImport(config.root, file, sourcePath)
+    const resolved = resolveImport(config.root, file, sourcePath, config.workspaceRoot)
     if (!resolved || !isInside(config.workspaceRoot, resolved) || isCssFile(resolved)) continue
     if (!(await fileHasUseClientDirective(resolved))) continue
 
@@ -3107,7 +3128,7 @@ function packageNameFromSpecifier(specifier: string) {
 
 function resolveLocalImport(config: ResolvedConfig, fromFile: string, specifier: string) {
   if (path.isAbsolute(specifier)) return existsSync(specifier) ? specifier : undefined
-  return resolveImport(config.root, fromFile, specifier)
+  return resolveImport(config.root, fromFile, specifier, config.workspaceRoot)
 }
 
 async function linkAssetContext(config: ResolvedConfig, file: string, profile: string) {

package/src/runtime/vendor-build.ts

@@ -1754,8 +1754,8 @@ function nearestManifestDir(from: string) {
     const manifest = path.join(dir, 'package.json')
     if (existsSync(manifest)) {
       try {
-        const parsed = JSON.parse(readFileSync(manifest, 'utf8')) as { name?: unknown }
-        if (typeof parsed.name === 'string') {
+        const parsed: unknown = JSON.parse(readFileSync(manifest, 'utf8'))
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
           nearestManifestDirs.set(from, dir)
           return dir
         }

package/src/types.ts

@@ -658,7 +658,9 @@ export interface StaticRouteMetadata {
 
 export interface BuildManifest {
   version: 0
+  /** Source root relative to outDir on disk; resolved at load. */
   root: string
+  /** App directory relative to root on disk; resolved at load. */
   appDir: string
   outDir: string
   routes: RouteManifestEntry[]

package/src/utils/fs.ts

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { mkdir, readdir, rename, rm, stat, readFile, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import type { BuildManifest } from '../types'
 
 // Write-then-rename so a concurrent import never observes a truncated file; Bun caches a failed load for the
 // life of the process. The temp name must be unique per CALL, not per process: two writers of the same output
@@ -145,6 +146,34 @@ export function toPosixPath(value: string) {
   return value.split(path.sep).join('/')
 }
 
+export function cssModuleScopePath(file: string) {
+  const normalized = toPosixPath(file)
+  const appIndex = normalized.lastIndexOf('/app/')
+  if (appIndex !== -1) return normalized.slice(appIndex + 1)
+  let dir = path.dirname(file)
+  let fallback: string | undefined
+  while (true) {
+    const packageFile = path.join(dir, 'package.json')
+    if (
+      existsSync(packageFile) ||
+      existsSync(path.join(dir, 'pnext.config.ts')) ||
+      existsSync(path.join(dir, 'node_modules'))
+    ) {
+      const relative = toPosixPath(path.relative(dir, file))
+      try {
+        const { name } = JSON.parse(readFileSync(packageFile, 'utf8')) as { name?: unknown }
+        if (typeof name === 'string') return `${name}/${relative}`
+      } catch {
+        // Unnamed projects still have a root-relative identity.
+      }
+      fallback ??= relative
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) return fallback ?? path.basename(file)
+    dir = parent
+  }
+}
+
 /** '^' + pnext's own running version, read from its package.json (this module lives at src/utils/). */
 export function pnextVersionRange() {
   const pkgPath = fileURLToPath(new URL('../../package.json', import.meta.url))
@@ -164,3 +193,96 @@ export function pnextOptionalDependencyRange(name: string) {
   }
   return pkg.optionalDependencies?.[name]
 }
+
+export function includeTypes(config: { include?: unknown }, files: string[], defaults: string[]) {
+  if (!('include' in config)) {
+    config.include = [...files, ...defaults]
+    return files
+  }
+  const include = config.include
+  if (!Array.isArray(include)) return []
+  const added = files.filter(file => !include.includes(file))
+  include.push(...added)
+  return added
+}
+
+/** Relativize only source-path fields while writing; build hooks keep absolute paths. */
+export function serializeBuildManifest(data: BuildManifest): string {
+  const { root, appDir, outDir } = data
+  const stored = {
+    ...mapSourcePaths(data, file => toPosixPath(path.relative(root, file))),
+    root: toPosixPath(path.relative(outDir, root)) || '.',
+    appDir: toPosixPath(path.relative(root, appDir)),
+    outDir: '.',
+  }
+  return `${JSON.stringify(stored, null, 2)}\n`
+}
+
+export function resolveManifest(data: BuildManifest, outPath: string, root: string): BuildManifest {
+  if (path.isAbsolute(data.root)) return data
+  const absolute = (file: string) => path.join(root, file)
+  return {
+    ...mapSourcePaths(data, absolute),
+    root,
+    appDir: absolute(data.appDir),
+    outDir: outPath,
+  }
+}
+
+const sourcePathFields = [
+  'file',
+  'sourceFiles',
+  'cssImports',
+  'templateFiles',
+  'forbiddenFiles',
+  'unauthorizedFiles',
+  'slotDirs',
+  'slotDir',
+  'syntheticSlotDir',
+  'childrenDefault',
+  'serverActionFile',
+  'globalErrorFile',
+] as const
+
+type SourcePathFields = Partial<Record<(typeof sourcePathFields)[number], string | string[]>>
+
+function mapSourcePaths(data: BuildManifest, map: (file: string) => string): BuildManifest {
+  // Only schema path owners are visited; params and user metadata remain data.
+  function owner<T extends SourcePathFields | undefined>(value: T): T {
+    if (!value) return value
+    const mapped = { ...value }
+    for (const key of sourcePathFields) {
+      const field = value[key]
+      if (field !== undefined) mapped[key] = Array.isArray(field) ? field.map(map) : map(field)
+    }
+    return mapped
+  }
+  const mapped = owner(data)
+  mapped.routes = data.routes.map(route => ({
+    ...owner(route),
+    clientReferences: route.clientReferences.map(owner),
+    ...(route.interception && { interception: owner(route.interception) }),
+  }))
+  if (data.staticMetadataFiles) mapped.staticMetadataFiles = data.staticMetadataFiles.map(owner)
+  if (data.staticRouteMetadata) {
+    mapped.staticRouteMetadata = Object.fromEntries(
+      Object.entries(data.staticRouteMetadata).map(([route, entry]) => [
+        route,
+        {
+          ...entry,
+          favicon: owner(entry.favicon),
+          manifest: owner(entry.manifest),
+          icons: entry.icons.map(owner),
+          appleIcons: entry.appleIcons.map(owner),
+          rootIcons: entry.rootIcons.map(owner),
+        },
+      ]),
+    )
+  }
+  if (data.staticModuleMetadata) {
+    mapped.staticModuleMetadata = Object.fromEntries(
+      Object.entries(data.staticModuleMetadata).map(([file, metadata]) => [map(file), metadata]),
+    )
+  }
+  return mapped
+}