@wular/pnext 0.1.6 → 0.1.8

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

@@ -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 {
@@ -667,6 +666,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/directive.ts

@@ -0,0 +1,40 @@
+/**
+ * Whether `source` opens with the `directive` prologue string. Linear and allocation-free: a regex
+ * over leading comments backtracks catastrophically on files with many comments and no directive.
+ */
+export function hasModuleDirective(source: string, directive: 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) === directive) return true
+    i = end + 1
+    while (i < source.length && isSpace(i)) i += 1
+    if (source[i] === ';') i += 1
+  }
+}

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: '.',
@@ -218,9 +301,17 @@ export function serializeBuildManifest(data: BuildManifest): string {
   return `${JSON.stringify(stored, null, 2)}\n`
 }
 
-export function resolveManifest(data: BuildManifest, outPath: string, root: string): BuildManifest {
+export function resolveManifest(
+  data: BuildManifest,
+  outPath: string,
+  root: string,
+  framework = frameworkRoot,
+): 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(framework, file.slice(frameworkPrefix.length))
+      : path.join(root, file)
   return {
     ...mapSourcePaths(data, absolute),
     root,

package/src/utils/resource-query.ts

@@ -0,0 +1,12 @@
+/**
+ * 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) }
+}

package/src/cli/serve/entry.ts

@@ -1,45 +0,0 @@
-/**
- * Server entry for hosts that serve a build through `createRequestHandler`: a thin loader that
- * resolves `@wular/pnext` from the output's own location (as `.next/server` loads `next`), so the
- * output carries no framework code and no build-machine paths.
- */
-import { readFileSync } from 'node:fs'
-import { mkdir, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import { frameworkFingerprint } from '../../runtime/fingerprint'
-
-const frameworkRoot = path.resolve(import.meta.dirname, '..', '..', '..')
-
-/** Stamped into the filename so an upgraded framework never runs a stale bundle. */
-function frameworkVersion(): string {
-  try {
-    const pkg = readFileSync(path.join(frameworkRoot, 'package.json'), 'utf8')
-    return (JSON.parse(pkg) as { version?: string }).version ?? '0'
-  } catch {
-    return '0'
-  }
-}
-
-/**
- * Version AND framework fingerprint: the version alone let an edited `src` keep serving the bundle
- * built from the previous source, so a fix appeared to have no effect until the app was rebuilt.
- * The fingerprint is the same one every other compiled artifact is keyed on, taken through the
- * cache-root record so a restart pays one stat per file rather than re-reading the tree.
- */
-export function serverEntryDir(outPath: string): string {
-  const generation = frameworkFingerprint(path.join(outPath, 'cache', 'server'))
-  return path.join(outPath, 'server', `bundle-${frameworkVersion()}-${generation}`)
-}
-
-/** Write `<outPath>/server/bundle-<version>-<fingerprint>/entry.js`, re-exporting src/cli/start.ts. */
-export async function emitServerEntry(outPath: string): Promise<void> {
-  const start = await Bun.file(path.join(import.meta.dirname, '..', 'start.ts')).text()
-  const names = new Bun.Transpiler({ loader: 'ts' }).scan(start).exports
-  const dir = serverEntryDir(outPath)
-  await mkdir(dir, { recursive: true })
-  await writeFile(
-    path.join(dir, 'entry.js'),
-    `const pnext = await import(new URL('./cli/start.ts', import.meta.resolve('@wular/pnext')).href)\n` +
-      `export const { ${names.join(', ')} } = pnext\n`,
-  )
-}