@wular/pnext 0.1.5 → 0.1.7

package/src/runtime/vendor.ts

@@ -44,6 +44,7 @@ import { esbuildEntryExportNames, isIdentifier, uniqueIdentifier } from '../util
 import { cachedExistsSync } from '../utils/fs-cache'
 import { traceEnabled, traceValue } from '../utils/trace-flags'
 import { writeFileAtomic } from '../utils/fs'
+import { setPreplanDrain } from './load'
 
 // --------------------------------------------------------------------------
 // demand scheduling
@@ -61,6 +62,8 @@ export interface VendorGroupPlan {
   key: string
   /** The demanded subpath — the only thing a group is ever allowed to compile. */
   member: VendorGroupMember
+  /** Unbuilt subpaths that must compile in the member's round: they reach a stateful file it reaches. */
+  companions?: () => Promise<VendorGroupMember[]>
   /** `external` are siblings already on disk: referenced, never re-parsed. */
   build: (
     members: VendorGroupMember[],
@@ -455,10 +458,13 @@ function vendorGroupingEnabled() {
  * may not even have installed), so compiling the published set fans one demand out into hundreds of
  * foreign builds. A later sibling therefore grows the entry set and triggers another round;
  * artifacts from earlier rounds stay valid and are referenced as externals, so a growth round costs
- * what that sibling's own build would have cost.
+ * what that sibling's own build would have cost. The exception is `companions`: subpaths sharing a
+ * stateful file with the demand compile in its round, so that file is one chunk, one instance.
  */
 async function joinVendorGroup(group: VendorGroupPlan, nested: boolean, ticket: VendorPromotable) {
   if (!vendorGroupingEnabled()) return false
+  // Resolved before joining, so the companions land in the same round's snapshot.
+  const companions = (await group.companions?.()) ?? []
   let state = vendorGroups.get(group.key)
   if (!state) {
     state = {
@@ -480,6 +486,12 @@ async function joinVendorGroup(group: VendorGroupPlan, nested: boolean, ticket:
     return false
   }
   state.pending.set(specifier, group.member)
+  for (const companion of companions) {
+    const known = (members: Map<string, VendorGroupMember>) => members.has(companion.specifier)
+    if (!known(state.pending) && !known(state.produced) && !known(state.solo)) {
+      state.pending.set(companion.specifier, companion)
+    }
+  }
   // While this demand waits on a shared round, promoting IT has to promote the
   // round — that is the only work its result depends on.
   const groupState = state
@@ -572,6 +584,7 @@ export async function drainPreplanBuilds() {
     throw error
   }
 }
+setPreplanDrain(drainPreplanBuilds)
 
 /**
  * Forget a bundle whose artifact turned out to be gone (a `pnext build` wiping
@@ -727,9 +740,9 @@ export function emittedExportNames(code: string): Set<string> | undefined {
  * Republish a bundled CommonJS entry's named exports off its default export.
  * Applied to the bundle itself (not a separate module) for the inlined case.
  */
-export function addCommonJsNamedExports(code: string) {
+export function addCommonJsNamedExports(code: string, body = code) {
   if (hasNonDefaultExport(code)) return code
-  const names = [...new Set([...commonJsExportNames(code), ...esbuildEntryExportNames(code)])]
+  const names = [...new Set([...commonJsExportNames(body), ...esbuildEntryExportNames(body)])]
     .filter(name => name !== 'default' && name !== '__esModule')
     .sort()
   if (names.length === 0) return code

package/src/types.ts

@@ -667,6 +667,8 @@ export interface BuildManifest {
   staticFiles?: Record<string, StaticFileMetadata>
   /** Logical build-asset name -> the content-hashed name emitted (`global.css` -> `global-<hash>.css`). */
   assetNames?: Record<string, string>
+  /** App `public/` files under an immutable asset prefix; they stay revalidating. */
+  publicAssets?: string[]
   staticMetadataFiles?: StaticMetadataFileEntry[]
   staticModuleMetadata?: Record<string, StaticModuleMetadata>
   staticRouteMetadata?: Record<string, StaticRouteMetadata>

package/src/utils/fs.ts

@@ -1,7 +1,8 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { type Dirent, 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 { frozenDirListing } from '../runtime/production'
 import type { BuildManifest } from '../types'
 
 // Write-then-rename so a concurrent import never observes a truncated file; Bun caches a failed load for the
@@ -75,6 +76,8 @@ export function withDirCache<T>(run: () => T): T {
 
 /** File and subdirectory names of `dir` (both empty when it does not exist). */
 export function readDirListing(dir: string): DirListing {
+  const frozen = frozenDirListing(dir)
+  if (frozen) return frozen
   const cached = dirListings?.get(dir)
   if (cached) return cached
   let listing: DirListing
@@ -94,6 +97,75 @@ export function readDirListing(dir: string): DirListing {
   return listing
 }
 
+/** On-disk names per directory and recent wrong-case misses, kept by one server; undefined on a case-sensitive filesystem. */
+export type ExactNames = { dirs: Map<string, Set<string>>; misses: Set<string> } | undefined
+
+const maxExactNameMisses = 1024
+
+/** Only a case-insensitive filesystem (macOS, Windows) needs `hasExactName`; one probe per server, on `dir`'s own mount. */
+export function exactNameIndex(dir: string): ExactNames {
+  let entries: Dirent[] = []
+  try {
+    entries = readdirSync(dir, { withFileTypes: true })
+  } catch {
+    // Probe `dir` itself under its parent.
+  }
+  // A symlink's flipped name answers for its target, and a dangling one never exists.
+  const entry = entries.find(item => !item.isSymbolicLink() && hasCase(item.name))
+  const probe = entry ? path.join(dir, entry.name) : dir
+  const name = path.basename(probe)
+  if (!hasCase(name)) return undefined
+  return existsSync(path.join(path.dirname(probe), flipCase(name)))
+    ? { dirs: new Map(), misses: new Set() }
+    : undefined
+}
+
+function flipCase(name: string) {
+  return name === name.toUpperCase() ? name.toLowerCase() : name.toUpperCase()
+}
+
+function hasCase(name: string) {
+  return flipCase(name) !== name
+}
+
+/** Whether `relative` under `root` is spelled exactly as on disk (Next serves static files by exact name). */
+export function hasExactName(names: NonNullable<ExactNames>, root: string, relative: string) {
+  let dir = root
+  for (const name of relative.split(path.sep)) {
+    const file = `${dir}${path.sep}${name}`
+    const listing = dirNames(names, dir)
+    // An unreadable directory fails this request only; nothing about it is remembered.
+    if (!listing) return false
+    if (!listing.has(name)) {
+      if (names.misses.has(file)) return false
+      // A miss re-reads the directory once: the server may have written the file since.
+      const fresh = dirNames(names, dir, true)
+      if (!fresh?.has(name)) {
+        if (fresh) {
+          if (names.misses.size >= maxExactNameMisses) names.misses.clear()
+          names.misses.add(file)
+        }
+        return false
+      }
+    }
+    dir = file
+  }
+  return true
+}
+
+function dirNames(names: NonNullable<ExactNames>, dir: string, refresh = false) {
+  let entries = refresh ? undefined : names.dirs.get(dir)
+  if (!entries) {
+    try {
+      entries = new Set(readdirSync(dir))
+    } catch {
+      return undefined
+    }
+    names.dirs.set(dir, entries)
+  }
+  return entries
+}
+
 /** listFiles for callers already running synchronously (route fact scans). */
 export function listFilesSync(root: string): string[] {
   if (!existsSync(root)) return []
@@ -206,11 +278,22 @@ export function includeTypes(config: { include?: unknown }, files: string[], def
   return added
 }
 
+// pnext's own files outside the app (a linked or store install) are named from the framework root,
+// so a build moved to another machine finds them wherever pnext is installed there.
+const frameworkRoot = path.resolve(import.meta.dirname, '..', '..')
+const frameworkPrefix = 'pnext:'
+
 /** Relativize only source-path fields while writing; build hooks keep absolute paths. */
 export function serializeBuildManifest(data: BuildManifest): string {
   const { root, appDir, outDir } = data
+  const relative = (file: string) => {
+    const inRoot = toPosixPath(path.relative(root, file))
+    if (!inRoot.startsWith('..')) return inRoot
+    const inFramework = toPosixPath(path.relative(frameworkRoot, file))
+    return inFramework.startsWith('..') ? inRoot : `${frameworkPrefix}${inFramework}`
+  }
   const stored = {
-    ...mapSourcePaths(data, file => toPosixPath(path.relative(root, file))),
+    ...mapSourcePaths(data, relative),
     root: toPosixPath(path.relative(outDir, root)) || '.',
     appDir: toPosixPath(path.relative(root, appDir)),
     outDir: '.',
@@ -220,7 +303,10 @@ export function serializeBuildManifest(data: BuildManifest): string {
 
 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)
+  const absolute = (file: string) =>
+    file.startsWith(frameworkPrefix)
+      ? path.join(frameworkRoot, file.slice(frameworkPrefix.length))
+      : path.join(root, file)
   return {
     ...mapSourcePaths(data, absolute),
     root,