@wular/pnext 0.0.4 → 0.0.7

package/src/dev/{client-key-cache.ts → restart/client-key.ts}

@@ -1,4 +1,4 @@
-// Persisted client cache keys - the restart half of dev/module-cache.ts. A route's client bundle
+// Persisted client cache keys - the restart half of runtime/module-cache.ts. A route's client bundle
 // already lives in a content-keyed out-dir, so a restart never has to rebuild it; deriving that key
 // did, by walking every source the route's client graph reaches and hashing the bytes. The bytes
 // cannot have moved while nothing was watching them *unless* the file did, so this persists the
@@ -10,66 +10,66 @@
 //   content differs   -> full walk, new key, new out-dir
 // so an edit made while the server was not running invalidates, and a touch that changed nothing
 // does not.
-import { readFileSync, writeFileSync } from 'node:fs';
-import { mkdir, readFile, stat } from 'node:fs/promises';
-import path from 'node:path';
+import { readFileSync, writeFileSync } from 'node:fs'
+import { mkdir, readFile, stat } from 'node:fs/promises'
+import path from 'node:path'
 import {
   clientCacheKeyParts,
   clientCacheStaticHash,
   clientSourceHash,
   type ClientCacheSource,
-} from '../client/build';
-import type { ResolvedConfig } from '../config';
-import type { RouteManifestEntry } from '../types';
-import { writeFileAtomic } from '../utils/fs';
-import { restartCacheEnabled } from './restart-cache';
+} from '../../client/build'
+import type { ResolvedConfig } from '../../config'
+import type { RouteManifestEntry } from '../../types'
+import { writeFileAtomic } from '../../utils/fs'
+import { restartCacheEnabled } from './enabled'
 
 /** `[file, mtimeMs, size, contentHash]` — the same record shape the module index uses. */
-type SourceEntry = [string, number, number, string];
+type SourceEntry = [string, number, number, string]
 
 interface RouteEntry {
   /** Hash of everything in the key that is not a walked source. */
-  static: string;
-  key: string;
-  files: SourceEntry[];
+  static: string
+  key: string
+  files: SourceEntry[]
 }
 
 interface IndexFile {
-  version: number;
-  routes: Record<string, RouteEntry>;
+  version: number
+  routes: Record<string, RouteEntry>
 }
 
 /** Bumped whenever a record's shape changes; an older index is simply ignored. */
-const INDEX_VERSION = 1;
+const INDEX_VERSION = 1
 
 interface KeyCache {
-  file: string;
-  routes: Map<string, RouteEntry>;
-  dirty: boolean;
-  flush?: Timer;
-  retries: number;
+  file: string
+  routes: Map<string, RouteEntry>
+  dirty: boolean
+  flush?: Timer
+  retries: number
 }
 
-const caches = new Map<string, KeyCache>();
+const caches = new Map<string, KeyCache>()
 
 function keyCache(config: ResolvedConfig): KeyCache {
-  const file = path.join(config.outPath, 'cache', 'client', 'keys.json');
-  const existing = caches.get(file);
-  if (existing) return existing;
-  const created: KeyCache = { file, routes: readIndex(file), dirty: false, retries: 0 };
-  caches.set(file, created);
+  const file = path.join(config.outPath, 'cache', 'client', 'keys.json')
+  const existing = caches.get(file)
+  if (existing) return existing
+  const created: KeyCache = { file, routes: readIndex(file), dirty: false, retries: 0 }
+  caches.set(file, created)
   // A short-lived process can exit before the debounce fires; without this its
   // walk would not survive to the next boot.
   process.on('exit', () => {
-    if (!created.dirty) return;
-    created.dirty = false;
+    if (!created.dirty) return
+    created.dirty = false
     try {
-      writeFileSync(created.file, serializeIndex(created.routes));
+      writeFileSync(created.file, serializeIndex(created.routes))
     } catch {
       // Best effort: a missing index only costs the next boot a walk.
     }
-  });
-  return created;
+  })
+  return created
 }
 
 /**
@@ -81,35 +81,35 @@ export async function devClientCacheKey(
   route: RouteManifestEntry,
   nextCompat: boolean,
 ): Promise<string> {
-  if (!restartCacheEnabled()) return (await clientCacheKeyParts(route, nextCompat, config)).key;
-  const cache = keyCache(config);
-  const staticHash = await clientCacheStaticHash(route, nextCompat, config);
-  const entry = cache.routes.get(route.id);
+  if (!restartCacheEnabled()) return (await clientCacheKeyParts(route, nextCompat, config)).key
+  const cache = keyCache(config)
+  const staticHash = await clientCacheStaticHash(route, nextCompat, config)
+  const entry = cache.routes.get(route.id)
   if (entry?.static === staticHash) {
-    const revalidated = await revalidate(entry.files);
+    const revalidated = await revalidate(entry.files)
     if (revalidated) {
       // Only the stats moved (a touch, a checkout): keep the key, record the
       // new stats so the next boot takes the O(1) path again.
       if (revalidated !== entry.files) {
-        cache.routes.set(route.id, { ...entry, files: revalidated });
-        persist(cache);
+        cache.routes.set(route.id, { ...entry, files: revalidated })
+        persist(cache)
       }
-      return entry.key;
+      return entry.key
     }
   }
 
-  const parts = await clientCacheKeyParts(route, nextCompat, config, staticHash);
+  const parts = await clientCacheKeyParts(route, nextCompat, config, staticHash)
   cache.routes.set(route.id, {
     static: parts.staticHash,
     key: parts.key,
     files: parts.sources.map(sourceEntry),
-  });
-  persist(cache);
-  return parts.key;
+  })
+  persist(cache)
+  return parts.key
 }
 
 function sourceEntry(source: ClientCacheSource): SourceEntry {
-  return [source.file, source.mtimeMs, source.size, source.hash];
+  return [source.file, source.mtimeMs, source.size, source.hash]
 }
 
 /**
@@ -118,61 +118,61 @@ function sourceEntry(source: ClientCacheSource): SourceEntry {
  * walk has to run again.
  */
 async function revalidate(files: SourceEntry[]): Promise<SourceEntry[] | undefined> {
-  let moved = false;
+  let moved = false
   const checked = await Promise.all(
     files.map(async (entry): Promise<SourceEntry | undefined> => {
-      const [file, mtimeMs, size, hash] = entry;
-      const stats = await stat(file).catch(() => undefined);
-      if (!stats) return undefined;
-      if (stats.mtimeMs === mtimeMs && stats.size === size) return entry;
-      const source = await readFile(file, 'utf8').catch(() => undefined);
-      if (source === undefined || clientSourceHash(source) !== hash) return undefined;
-      moved = true;
-      return [file, stats.mtimeMs, stats.size, hash];
+      const [file, mtimeMs, size, hash] = entry
+      const stats = await stat(file).catch(() => undefined)
+      if (!stats) return undefined
+      if (stats.mtimeMs === mtimeMs && stats.size === size) return entry
+      const source = await readFile(file, 'utf8').catch(() => undefined)
+      if (source === undefined || clientSourceHash(source) !== hash) return undefined
+      moved = true
+      return [file, stats.mtimeMs, stats.size, hash]
     }),
-  );
-  if (checked.some(entry => entry === undefined)) return undefined;
-  return moved ? (checked as SourceEntry[]) : files;
+  )
+  if (checked.some(entry => entry === undefined)) return undefined
+  return moved ? (checked as SourceEntry[]) : files
 }
 
 function persist(cache: KeyCache) {
-  cache.dirty = true;
-  if (cache.flush) return;
+  cache.dirty = true
+  if (cache.flush) return
   cache.flush = setTimeout(async () => {
-    cache.flush = undefined;
-    if (!cache.dirty) return;
-    const contents = serializeIndex(cache.routes);
+    cache.flush = undefined
+    if (!cache.dirty) return
+    const contents = serializeIndex(cache.routes)
     try {
-      await mkdir(path.dirname(cache.file), { recursive: true });
-      await writeFileAtomic(cache.file, contents);
-      cache.dirty = false;
+      await mkdir(path.dirname(cache.file), { recursive: true })
+      await writeFileAtomic(cache.file, contents)
+      cache.dirty = false
     } catch {
       // A write that lost a race with a cache wipe must not look persisted.
-      if (++cache.retries < 3) persist(cache);
+      if (++cache.retries < 3) persist(cache)
     }
-  }, 50);
+  }, 50)
   // The index is a pure optimization; never hold the process open for it.
-  cache.flush.unref?.();
+  cache.flush.unref?.()
 }
 
 function readIndex(file: string) {
-  const routes = new Map<string, RouteEntry>();
-  let parsed: IndexFile | undefined;
+  const routes = new Map<string, RouteEntry>()
+  let parsed: IndexFile | undefined
   try {
-    parsed = JSON.parse(readFileSync(file, 'utf8')) as IndexFile;
+    parsed = JSON.parse(readFileSync(file, 'utf8')) as IndexFile
   } catch {
-    return routes;
+    return routes
   }
-  if (parsed?.version !== INDEX_VERSION) return routes;
+  if (parsed?.version !== INDEX_VERSION) return routes
   for (const [id, entry] of Object.entries(parsed.routes ?? {})) {
-    if (entry?.key && entry.static && Array.isArray(entry.files)) routes.set(id, entry);
+    if (entry?.key && entry.static && Array.isArray(entry.files)) routes.set(id, entry)
   }
-  return routes;
+  return routes
 }
 
 function serializeIndex(routes: Map<string, RouteEntry>) {
   return JSON.stringify({
     version: INDEX_VERSION,
     routes: Object.fromEntries(routes),
-  } satisfies IndexFile);
+  } satisfies IndexFile)
 }

package/src/dev/{restart-cache.ts → restart/enabled.ts}

@@ -6,5 +6,5 @@
  */
 export function restartCacheEnabled() {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  return process.env.PNEXT_DEV_RESTART_CACHE !== '0';
+  return process.env.PNEXT_DEV_RESTART_CACHE !== '0'
 }

package/src/dev/{global-css-cache.ts → restart/global-css.ts}

@@ -4,34 +4,34 @@
 // first page: the warm tier builds global.css and the render asks `globalCssHref` whether there is
 // any.
 //
-// The same three-step ladder route-facts-cache.ts uses:
+// The same three-step ladder restart/route-facts.ts uses:
 //   stat matches      -> reuse (the common case, and the only O(1) one)
 //   stat moved        -> read + hash; equal content still reuses the answer
 //   content differs   -> discard, walk again, record the new answer
 // Paths the walk found ABSENT are re-checked too: a stylesheet restored while the server was not
 // running adds an edge that no importer's bytes record.
-import { mkdirSync, existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import type { ResolvedConfig } from '../config';
-import { setGlobalCssSourceStore, type GlobalCssSourceStore } from '../css';
-import { restartCacheEnabled } from './restart-cache';
+import { mkdirSync, existsSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import type { ResolvedConfig } from '../../config'
+import { setGlobalCssSourceStore, type GlobalCssSourceStore } from '../../css/build'
+import { restartCacheEnabled } from './enabled'
 
 /** `[file, mtimeMs, size, contentHash]` — the shape the other restart caches use. */
-type SourceEntry = [string, number, number, string];
+type SourceEntry = [string, number, number, string]
 
 interface RecordFile {
-  version: number;
+  version: number
   /** Everything the answer depends on that is not a walked source (see cacheKey). */
-  key: string;
-  files: SourceEntry[];
-  missing: string[];
-  sources: string[];
+  key: string
+  files: SourceEntry[]
+  missing: string[]
+  sources: string[]
 }
 
 /** Bumped whenever a record's shape changes; an older record is simply ignored. */
-const RECORD_VERSION = 1;
+const RECORD_VERSION = 1
 
-const hash = (value: string) => Bun.hash(value).toString(36);
+const hash = (value: string) => Bun.hash(value).toString(36)
 
 /**
  * The walk's answer can change without any app file moving, when the thing that
@@ -43,83 +43,91 @@ function cacheKey(config: ResolvedConfig): string | undefined {
   try {
     const shape = JSON.stringify(config, (_key, value: unknown) =>
       typeof value === 'function' ? '[fn]' : value,
-    );
-    return hash(`${RECORD_VERSION}\n${pnextBuildStamp()}\n${shape}`);
+    )
+    return hash(`${RECORD_VERSION}\n${pnextBuildStamp()}\n${shape}`)
   } catch {
-    return undefined; // a config that will not serialize simply opts out
+    return undefined // a config that will not serialize simply opts out
   }
 }
 
-/** mtime+size of the walk this process is running (see route-facts-cache.ts). */
+/** mtime+size of the walk this process is running (see restart/route-facts.ts). */
 function pnextBuildStamp() {
   try {
-    const self = Bun.fileURLToPath(import.meta.url);
-    const walk = path.join(path.dirname(path.dirname(self)), 'css', 'build.ts');
-    const info = statSync(walk, { throwIfNoEntry: false });
-    return info ? `${info.mtimeMs}:${info.size}` : self;
+    const self = Bun.fileURLToPath(import.meta.url)
+    const walk = path.join(path.dirname(path.dirname(self)), 'css', 'build.ts')
+    const info = statSync(walk, { throwIfNoEntry: false })
+    return info ? `${info.mtimeMs}:${info.size}` : self
   } catch {
-    return 'unknown';
+    return 'unknown'
   }
 }
 
 export function installGlobalCssCache(config: ResolvedConfig) {
-  if (!restartCacheEnabled()) return;
+  if (!restartCacheEnabled()) return
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (process.env.PNEXT_DEV_GLOBAL_CSS_CACHE === '0') return;
-  const key = cacheKey(config);
-  if (!key) return;
-  setGlobalCssSourceStore(createStore(path.join(config.outPath, 'cache', 'global-css'), key));
+  if (process.env.PNEXT_DEV_GLOBAL_CSS_CACHE === '0') return
+  const key = cacheKey(config)
+  if (!key) return
+  setGlobalCssSourceStore(createStore(path.join(config.outPath, 'cache', 'global-css'), key))
 }
 
 function createStore(dir: string, key: string): GlobalCssSourceStore {
   // Last payload written per walk, so a save that re-runs the walk with an
   // unchanged answer costs no write, and one with a changed answer does.
-  const written = new Map<string, string>();
-  const recordFile = (walkKey: string) => path.join(dir, `${hash(walkKey)}.json`);
+  const written = new Map<string, string>()
+  const recordFile = (walkKey: string) => path.join(dir, `${hash(walkKey)}.json`)
 
   return {
     load(walkKey) {
-      const record = readRecord(recordFile(walkKey), key);
+      const record = readRecord(recordFile(walkKey), key)
       if (!record) {
-        stats.misses += 1;
-        return undefined;
+        stats.misses += 1
+        return undefined
       }
       if (record.missing.some(file => existsSync(file))) {
-        stats.misses += 1;
-        return undefined;
+        stats.misses += 1
+        return undefined
       }
-      const revalidated = revalidate(record.files);
+      const revalidated = revalidate(record.files)
       if (!revalidated) {
-        stats.misses += 1;
-        return undefined;
+        stats.misses += 1
+        return undefined
       }
-      stats.hits += 1;
+      stats.hits += 1
       // Only the stats moved (a touch, a checkout): keep the answer, record the
       // new stats so the next boot takes the O(1) path again.
       if (revalidated !== record.files) {
-        write(recordFile(walkKey), key, written, walkKey, revalidated, record.missing, record.sources);
+        write(
+          recordFile(walkKey),
+          key,
+          written,
+          walkKey,
+          revalidated,
+          record.missing,
+          record.sources,
+        )
       }
-      return record.sources;
+      return record.sources
     },
     save(walkKey, sources, visited, missing) {
-      const files = sourceEntries(visited);
-      if (!files) return;
-      write(recordFile(walkKey), key, written, walkKey, files, missing, sources);
+      const files = sourceEntries(visited)
+      if (!files) return
+      write(recordFile(walkKey), key, written, walkKey, files, missing, sources)
     },
-  };
+  }
 }
 
 function readRecord(file: string, key: string): RecordFile | undefined {
-  let parsed: RecordFile | undefined;
+  let parsed: RecordFile | undefined
   try {
-    parsed = JSON.parse(readFileSync(file, 'utf8')) as RecordFile;
+    parsed = JSON.parse(readFileSync(file, 'utf8')) as RecordFile
   } catch {
-    return undefined;
+    return undefined
   }
-  if (parsed?.version !== RECORD_VERSION || parsed.key !== key) return undefined;
-  if (!Array.isArray(parsed.files) || !Array.isArray(parsed.sources)) return undefined;
-  if (!Array.isArray(parsed.missing)) return undefined;
-  return parsed;
+  if (parsed?.version !== RECORD_VERSION || parsed.key !== key) return undefined
+  if (!Array.isArray(parsed.files) || !Array.isArray(parsed.sources)) return undefined
+  if (!Array.isArray(parsed.missing)) return undefined
+  return parsed
 }
 
 /**
@@ -141,37 +149,37 @@ function write(
     files,
     missing,
     sources,
-  } satisfies RecordFile);
-  if (written.get(walkKey) === contents) return;
-  written.set(walkKey, contents);
+  } satisfies RecordFile)
+  if (written.get(walkKey) === contents) return
+  written.set(walkKey, contents)
   try {
-    mkdirSync(path.dirname(file), { recursive: true });
-    writeFileSync(file, contents);
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(file, contents)
   } catch {
     // Best effort: a missing record only costs the next boot a walk.
   }
 }
 
 function sourceEntries(files: string[]): SourceEntry[] | undefined {
-  const entries: SourceEntry[] = [];
+  const entries: SourceEntry[] = []
   for (const file of files) {
-    const entry = sourceEntry(file);
-    if (!entry) return undefined;
-    entries.push(entry);
+    const entry = sourceEntry(file)
+    if (!entry) return undefined
+    entries.push(entry)
   }
-  return entries;
+  return entries
 }
 
 function sourceEntry(file: string): SourceEntry | undefined {
   try {
-    const source = readFileSync(file, 'utf8');
+    const source = readFileSync(file, 'utf8')
     // Stat AFTER the read: a file that changes between the two records the
     // older stat, so the next boot re-hashes rather than trusting a stale one.
-    const info = statSync(file, { throwIfNoEntry: false });
-    if (!info) return undefined;
-    return [file, info.mtimeMs, info.size, hash(source)];
+    const info = statSync(file, { throwIfNoEntry: false })
+    if (!info) return undefined
+    return [file, info.mtimeMs, info.size, hash(source)]
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
@@ -181,32 +189,32 @@ function sourceEntry(file: string): SourceEntry | undefined {
  * walk has to run again.
  */
 function revalidate(files: SourceEntry[]): SourceEntry[] | undefined {
-  let moved = false;
-  const checked: SourceEntry[] = [];
+  let moved = false
+  const checked: SourceEntry[] = []
   for (const entry of files) {
-    const [file, mtimeMs, size, contentHash] = entry;
-    const info = statSync(file, { throwIfNoEntry: false });
-    if (!info) return undefined;
+    const [file, mtimeMs, size, contentHash] = entry
+    const info = statSync(file, { throwIfNoEntry: false })
+    if (!info) return undefined
     if (info.mtimeMs === mtimeMs && info.size === size) {
-      checked.push(entry);
-      continue;
+      checked.push(entry)
+      continue
     }
-    let source: string;
+    let source: string
     try {
-      source = readFileSync(file, 'utf8');
+      source = readFileSync(file, 'utf8')
     } catch {
-      return undefined;
+      return undefined
     }
-    if (hash(source) !== contentHash) return undefined;
-    moved = true;
-    checked.push([file, info.mtimeMs, info.size, contentHash]);
+    if (hash(source) !== contentHash) return undefined
+    moved = true
+    checked.push([file, info.mtimeMs, info.size, contentHash])
   }
-  return moved ? checked : files;
+  return moved ? checked : files
 }
 
 /** Bisect seam: `PNEXT_DEV_GLOBAL_CSS_STATS=1` prints the hit/miss split at exit. */
-const stats = { hits: 0, misses: 0 };
+const stats = { hits: 0, misses: 0 }
 // eslint-disable-next-line turbo/no-undeclared-env-vars
 if (process.env.PNEXT_DEV_GLOBAL_CSS_STATS === '1') {
-  process.on('exit', () => console.log(`global-css hits=${stats.hits} misses=${stats.misses}`));
+  process.on('exit', () => console.log(`global-css hits=${stats.hits} misses=${stats.misses}`))
 }

package/src/dev/{node-module-bundle-cache.ts → restart/node-modules.ts}

@@ -1,4 +1,4 @@
-// Persisted node_modules bundles - the restart half of runtime/server.ts' `transformNodeModuleSource`.
+// Persisted node_modules bundles - the restart half of runtime/loader.ts' `transformNodeModuleSource`.
 // The node_modules load plugin esbuild-bundles each ESM package file it matches and remembers the
 // result in memory only, so every restart re-runs those builds on the request path while the route
 // bundle it is evaluating waits.
@@ -8,37 +8,37 @@
 // Anything else - a missing input, an unparseable record, a vanished file - is a miss, never a
 // stale hit: the bundle it names is imported directly, and Bun caches a bad import for the life of
 // the process.
-import { mkdir, readFile, stat } from 'node:fs/promises';
-import path from 'node:path';
-import { writeFileAtomic } from '../utils/fs';
+import { mkdir, readFile, stat } from 'node:fs/promises'
+import path from 'node:path'
+import { writeFileAtomic } from '../../utils/fs'
 
 /** `[file, mtimeMs, size]` for one esbuild input of the bundle. */
-type InputEntry = [string, number, number];
+type InputEntry = [string, number, number]
 
 interface BundleRecord {
-  inputs: InputEntry[];
-  code: string;
+  inputs: InputEntry[]
+  code: string
 }
 
 /** The recorded bundle when every input it was built from is unchanged. */
 export async function readNodeModuleBundle(recordFile: string): Promise<string | undefined> {
-  const contents = await readFile(recordFile, 'utf8').catch(() => undefined);
-  if (contents === undefined) return undefined;
-  let record: BundleRecord | undefined;
+  const contents = await readFile(recordFile, 'utf8').catch(() => undefined)
+  if (contents === undefined) return undefined
+  let record: BundleRecord | undefined
   try {
-    record = JSON.parse(contents) as BundleRecord;
+    record = JSON.parse(contents) as BundleRecord
   } catch {
-    return undefined;
+    return undefined
   }
-  if (typeof record?.code !== 'string' || !Array.isArray(record.inputs)) return undefined;
-  if (record.inputs.length === 0) return undefined;
+  if (typeof record?.code !== 'string' || !Array.isArray(record.inputs)) return undefined
+  if (record.inputs.length === 0) return undefined
   const held = await Promise.all(
     record.inputs.map(async ([input, mtimeMs, size]) => {
-      const stats = await stat(input).catch(() => undefined);
-      return stats?.mtimeMs === mtimeMs && stats.size === size;
+      const stats = await stat(input).catch(() => undefined)
+      return stats?.mtimeMs === mtimeMs && stats.size === size
     }),
-  );
-  return held.every(Boolean) ? record.code : undefined;
+  )
+  return held.every(Boolean) ? record.code : undefined
 }
 
 export async function writeNodeModuleBundle(
@@ -48,16 +48,16 @@ export async function writeNodeModuleBundle(
 ): Promise<void> {
   const stated = await Promise.all(
     inputs.map(async (input): Promise<InputEntry | undefined> => {
-      const stats = await stat(input).catch(() => undefined);
-      return stats ? [input, stats.mtimeMs, stats.size] : undefined;
+      const stats = await stat(input).catch(() => undefined)
+      return stats ? [input, stats.mtimeMs, stats.size] : undefined
     }),
-  );
+  )
   // An input that vanished between the build and here would make the record
   // unvalidatable forever; leaving it unwritten costs the next boot one bundle.
-  if (stated.length === 0 || stated.some(entry => entry === undefined)) return;
-  await mkdir(path.dirname(recordFile), { recursive: true }).catch(() => undefined);
+  if (stated.length === 0 || stated.some(entry => entry === undefined)) return
+  await mkdir(path.dirname(recordFile), { recursive: true }).catch(() => undefined)
   await writeFileAtomic(
     recordFile,
     JSON.stringify({ inputs: stated as InputEntry[], code } satisfies BundleRecord),
-  ).catch(() => undefined);
+  ).catch(() => undefined)
 }