@wular/pnext 0.0.3 → 0.0.6

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

@@ -1,55 +1,55 @@
-// Persisted route-bundle names - the restart half of dev/imports.ts' devRouteBundlePath. A route's
+// Persisted route-bundle names - the restart half of runtime/modules.ts' devRouteBundlePath. A route's
 // bundle already lives at a content-addressed path, so a restart never has to rebuild it; deriving
 // that path did, by walking the whole source graph of the route and its layouts breadth-first, with
 // a stat round trip per level, on the first page of every restart. The sources cannot have moved
 // while nothing was watching them *unless* the file did, so this persists the walk's answer and
 // re-validates it with one flat stat per source.
 //
-// The same three-step ladder dev/client-key-cache.ts and dev/route-facts-cache.ts use:
+// The same three-step ladder dev/restart/client-key.ts and dev/restart/route-facts.ts use:
 //   stat matches      -> reuse (the common case, and the only O(1) one)
 //   stat moved        -> read + hash; equal content still reuses the path
 //   content differs   -> discard, walk again, record the new answer
 // A missing source is a miss too, which is what keeps a deleted file from naming an artifact whose
 // edges are gone.
 //
-// One file PER ROUTE, not one index, for the reason route-facts-cache records: the source lists are
+// One file PER ROUTE, not one index, for the reason restart/route-facts.ts records: the source lists are
 // large across the whole table and the first page only ever asks about the route it is serving.
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { readFile, stat } from 'node:fs/promises';
-import path from 'node:path';
-import type { ResolvedConfig } from '../config';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { readFile, stat } from 'node:fs/promises'
+import path from 'node:path'
+import type { ResolvedConfig } from '../../config'
 import {
   DEV_SOURCE_MISSING,
   devTextSourceHash,
   isBinaryDevSource,
   type DevGraphSource,
-} from './module-cache';
-import { restartCacheEnabled } from './restart-cache';
+} from '../../runtime/module-cache'
+import { restartCacheEnabled } from './enabled'
 
 interface RecordFile {
-  version: number;
+  version: number
   /** Hash of everything in the name that is not a walked source (see recordKey). */
-  key: string;
+  key: string
   /** The named bundle path itself — the whole point of the record. */
-  bundle: string;
-  files: DevGraphSource[];
+  bundle: string
+  files: DevGraphSource[]
 }
 
 /** 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)
 
 /** Records written this process (by record file), so a repeat naming does not re-serialize. */
-const written = new Map<string, string>();
+const written = new Map<string, string>()
 
 function enabled() {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  return restartCacheEnabled() && process.env.PNEXT_DEV_BUNDLE_KEY_CACHE !== '0';
+  return restartCacheEnabled() && process.env.PNEXT_DEV_BUNDLE_KEY_CACHE !== '0'
 }
 
 function recordFile(config: ResolvedConfig, routeId: string) {
-  return path.join(config.outPath, 'cache', 'route-bundles', `${hash(routeId)}.json`);
+  return path.join(config.outPath, 'cache', 'route-bundles', `${hash(routeId)}.json`)
 }
 
 /**
@@ -58,7 +58,7 @@ function recordFile(config: ResolvedConfig, routeId: string) {
  * the record read as a miss instead of half-validating it.
  */
 function recordKey(graphKey: string, files: string[]) {
-  return hash(`${RECORD_VERSION}\n${graphKey}\n${files.join('\0')}`);
+  return hash(`${RECORD_VERSION}\n${graphKey}\n${files.join('\0')}`)
 }
 
 /** The persisted bundle path when every source it was named for is unchanged. */
@@ -68,25 +68,25 @@ export async function cachedRouteBundlePath(
   graphKey: string,
   files: string[],
 ): Promise<string | undefined> {
-  if (!enabled()) return undefined;
-  const key = recordKey(graphKey, files);
-  let record: RecordFile | undefined;
+  if (!enabled()) return undefined
+  const key = recordKey(graphKey, files)
+  let record: RecordFile | undefined
   try {
-    record = JSON.parse(readFileSync(recordFile(config, routeId), 'utf8')) as RecordFile;
+    record = JSON.parse(readFileSync(recordFile(config, routeId), 'utf8')) as RecordFile
   } catch {
-    return undefined;
+    return undefined
   }
-  if (record?.version !== RECORD_VERSION || record.key !== key) return undefined;
-  if (typeof record.bundle !== 'string' || !Array.isArray(record.files)) return undefined;
-  const revalidated = await revalidate(record.files);
-  if (!revalidated) return undefined;
+  if (record?.version !== RECORD_VERSION || record.key !== key) return undefined
+  if (typeof record.bundle !== 'string' || !Array.isArray(record.files)) return undefined
+  const revalidated = await revalidate(record.files)
+  if (!revalidated) return undefined
   // Only the stats moved (a touch, a checkout): keep the name, record the new
   // stats so the next boot takes the O(1) path again.
   if (revalidated !== record.files) {
-    written.delete(recordFile(config, routeId));
-    write(config, routeId, key, record.bundle, revalidated);
+    written.delete(recordFile(config, routeId))
+    write(config, routeId, key, record.bundle, revalidated)
   }
-  return record.bundle;
+  return record.bundle
 }
 
 export function saveRouteBundlePath(
@@ -97,11 +97,11 @@ export function saveRouteBundlePath(
   bundle: string,
   sources: DevGraphSource[],
 ): void {
-  if (!enabled()) return;
+  if (!enabled()) return
   // A source the walk could not read describes a tree that no longer exists;
   // the next boot walking again is the safe answer.
-  if (sources.some(([, , , srcHash]) => srcHash === DEV_SOURCE_MISSING)) return;
-  write(config, routeId, recordKey(graphKey, files), bundle, sources);
+  if (sources.some(([, , , srcHash]) => srcHash === DEV_SOURCE_MISSING)) return
+  write(config, routeId, recordKey(graphKey, files), bundle, sources)
 }
 
 function write(
@@ -111,18 +111,18 @@ function write(
   bundle: string,
   files: DevGraphSource[],
 ) {
-  const file = recordFile(config, routeId);
-  if (written.get(file) === bundle) return;
-  written.set(file, bundle);
+  const file = recordFile(config, routeId)
+  if (written.get(file) === bundle) return
+  written.set(file, bundle)
   const contents = JSON.stringify({
     version: RECORD_VERSION,
     key,
     bundle,
     files,
-  } satisfies RecordFile);
+  } satisfies RecordFile)
   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.
   }
@@ -134,21 +134,21 @@ function write(
  * walk has to run again.
  */
 async function revalidate(files: DevGraphSource[]): Promise<DevGraphSource[] | undefined> {
-  let moved = false;
+  let moved = false
   const checked = await Promise.all(
     files.map(async (entry): Promise<DevGraphSource | undefined> => {
-      const [file, mtimeMs, size, srcHash] = entry;
-      const stats = await stat(file).catch(() => undefined);
-      if (!stats) return undefined;
-      if (stats.mtimeMs === mtimeMs && stats.size === size) return entry;
+      const [file, mtimeMs, size, srcHash] = entry
+      const stats = await stat(file).catch(() => undefined)
+      if (!stats) return undefined
+      if (stats.mtimeMs === mtimeMs && stats.size === size) return entry
       // A binary source is hashed from its stat, so a moved stat IS a new hash.
-      if (isBinaryDevSource(file)) return undefined;
-      const source = await readFile(file, 'utf8').catch(() => undefined);
-      if (source === undefined || devTextSourceHash(source) !== srcHash) return undefined;
-      moved = true;
-      return [file, stats.mtimeMs, stats.size, srcHash];
+      if (isBinaryDevSource(file)) return undefined
+      const source = await readFile(file, 'utf8').catch(() => undefined)
+      if (source === undefined || devTextSourceHash(source) !== srcHash) return undefined
+      moved = true
+      return [file, stats.mtimeMs, stats.size, srcHash]
     }),
-  );
-  if (checked.some(entry => entry === undefined)) return undefined;
-  return moved ? (checked as DevGraphSource[]) : files;
+  )
+  if (checked.some(entry => entry === undefined)) return undefined
+  return moved ? (checked as DevGraphSource[]) : files
 }

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

@@ -5,7 +5,7 @@
 // cannot have moved while nothing was watching them *unless* the file did, so this persists the
 // walk's result next to the compiled cache and re-validates it with one stat per source.
 //
-// The same three-step ladder dev/client-key-cache.ts uses:
+// The same three-step ladder dev/restart/client-key.ts uses:
 //   stat matches      -> reuse (the common case, and the only O(1) one)
 //   stat moved        -> read + hash; equal content still reuses the facts
 //   content differs   -> discard, walk again, record the new facts
@@ -13,27 +13,27 @@
 // One file PER ROUTE, not one index: the whole table is large and the first page only ever asks
 // about the route it is serving, so as a single index its JSON.parse landed, in full, on that
 // request and gave most of the walk back.
-import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import type { ResolvedConfig } from '../config';
-import { setRouteFactsStore, type RouteFacts, type RouteFactsStore } from '../routing/routes';
-import { restartCacheEnabled } from './restart-cache';
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import type { ResolvedConfig } from '../../config'
+import { setRouteFactsStore, type RouteFacts, type RouteFactsStore } from '../../routing/routes'
+import { restartCacheEnabled } from './enabled'
 
 /** `[file, mtimeMs, size, contentHash]` — the same record shape the key cache uses. */
-type SourceEntry = [string, number, number, string];
+type SourceEntry = [string, number, number, string]
 
 interface RecordFile {
-  version: number;
+  version: number
   /** Everything the facts depend on that is not a walked source (see cacheKey). */
-  key: string;
-  files: SourceEntry[];
-  facts: RouteFacts;
+  key: string
+  files: SourceEntry[]
+  facts: RouteFacts
 }
 
 /** 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 facts of a route whose own sources did not move can still change when the
@@ -45,11 +45,11 @@ 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 {
     // A config that will not serialize (cycles, exotic values) simply opts out.
-    return undefined;
+    return undefined
   }
 }
 
@@ -60,80 +60,80 @@ function cacheKey(config: ResolvedConfig): string | undefined {
  */
 function pnextBuildStamp() {
   try {
-    const self = Bun.fileURLToPath(import.meta.url);
-    const scanner = path.join(path.dirname(path.dirname(self)), 'routing', 'routes.ts');
-    const info = statSync(scanner, { throwIfNoEntry: false });
-    return info ? `${info.mtimeMs}:${info.size}` : self;
+    const self = Bun.fileURLToPath(import.meta.url)
+    const scanner = path.join(path.dirname(path.dirname(self)), 'routing', 'routes.ts')
+    const info = statSync(scanner, { throwIfNoEntry: false })
+    return info ? `${info.mtimeMs}:${info.size}` : self
   } catch {
-    return 'unknown';
+    return 'unknown'
   }
 }
 
 interface FactsCache {
-  dir: string;
-  key: string;
+  dir: string
+  key: string
   /** Records written this process, so a repeat save does not re-serialize. */
-  written: Set<string>;
+  written: Set<string>
 }
 
 export function installRouteFactsCache(config: ResolvedConfig) {
-  if (!restartCacheEnabled()) return;
+  if (!restartCacheEnabled()) return
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (process.env.PNEXT_DEV_FACTS_CACHE === '0') return;
-  const key = cacheKey(config);
-  if (!key) return;
+  if (process.env.PNEXT_DEV_FACTS_CACHE === '0') return
+  const key = cacheKey(config)
+  if (!key) return
   const cache: FactsCache = {
     dir: path.join(config.outPath, 'cache', 'route-facts'),
     key,
     written: new Set(),
-  };
-  setRouteFactsStore(createStore(cache));
+  }
+  setRouteFactsStore(createStore(cache))
 }
 
 function recordFile(cache: FactsCache, routeId: string) {
-  return path.join(cache.dir, `${hash(routeId)}.json`);
+  return path.join(cache.dir, `${hash(routeId)}.json`)
 }
 
 function createStore(cache: FactsCache): RouteFactsStore {
   return {
     load(routeId) {
-      const record = readRecord(cache, routeId);
+      const record = readRecord(cache, routeId)
       if (!record) {
-        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 facts, record the
       // new stats so the next boot takes the O(1) path again.
       if (revalidated !== record.files) {
-        cache.written.delete(routeId);
-        write(cache, routeId, revalidated, record.facts);
+        cache.written.delete(routeId)
+        write(cache, routeId, revalidated, record.facts)
       }
-      return record.facts;
+      return record.facts
     },
     save(routeId, facts) {
-      const files = factsSources(facts);
-      if (!files) return;
-      write(cache, routeId, files, facts);
+      const files = factsSources(facts)
+      if (!files) return
+      write(cache, routeId, files, facts)
     },
-  };
+  }
 }
 
 function readRecord(cache: FactsCache, routeId: string): RecordFile | undefined {
-  let parsed: RecordFile | undefined;
+  let parsed: RecordFile | undefined
   try {
-    parsed = JSON.parse(readFileSync(recordFile(cache, routeId), 'utf8')) as RecordFile;
+    parsed = JSON.parse(readFileSync(recordFile(cache, routeId), 'utf8')) as RecordFile
   } catch {
-    return undefined;
+    return undefined
   }
-  if (parsed?.version !== RECORD_VERSION || parsed.key !== cache.key) return undefined;
-  if (!parsed.facts || !Array.isArray(parsed.files)) return undefined;
-  return parsed;
+  if (parsed?.version !== RECORD_VERSION || parsed.key !== cache.key) return undefined
+  if (!parsed.facts || !Array.isArray(parsed.files)) return undefined
+  return parsed
 }
 
 /**
@@ -142,17 +142,17 @@ function readRecord(cache: FactsCache, routeId: string): RecordFile | undefined
  * once per process per route.
  */
 function write(cache: FactsCache, routeId: string, files: SourceEntry[], facts: RouteFacts) {
-  if (cache.written.has(routeId)) return;
-  cache.written.add(routeId);
+  if (cache.written.has(routeId)) return
+  cache.written.add(routeId)
   const contents = JSON.stringify({
     version: RECORD_VERSION,
     key: cache.key,
     files,
     facts,
-  } satisfies RecordFile);
+  } satisfies RecordFile)
   try {
-    mkdirSync(cache.dir, { recursive: true });
-    writeFileSync(recordFile(cache, routeId), contents);
+    mkdirSync(cache.dir, { recursive: true })
+    writeFileSync(recordFile(cache, routeId), contents)
   } catch {
     // Best effort: a missing record only costs the next boot a walk.
   }
@@ -164,25 +164,25 @@ function write(cache: FactsCache, routeId: string, files: SourceEntry[], facts:
  * answer.
  */
 function factsSources(facts: RouteFacts): SourceEntry[] | undefined {
-  const entries: SourceEntry[] = [];
+  const entries: SourceEntry[] = []
   for (const file of facts.sourceFiles) {
-    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
   }
 }
 
@@ -192,32 +192,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_FACTS_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_FACTS_STATS === '1') {
-  process.on('exit', () => console.log(`route-facts hits=${stats.hits} misses=${stats.misses}`));
+  process.on('exit', () => console.log(`route-facts hits=${stats.hits} misses=${stats.misses}`))
 }