@wular/pnext 0.0.1

package/src/dev/global-css-cache.ts

@@ -0,0 +1,212 @@
+// Persisted global-CSS source list - the restart half of css/build.ts' walk.
+// `globalCssSourcesForPaths` answers "which stylesheets does the ROOT LAYOUT's import graph pull
+// in", and it answers by reading and resolving that whole graph synchronously, twice over on the
+// 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:
+//   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';
+
+/** `[file, mtimeMs, size, contentHash]` — the shape the other restart caches use. */
+type SourceEntry = [string, number, number, string];
+
+interface RecordFile {
+  version: number;
+  /** Everything the answer depends on that is not a walked source (see cacheKey). */
+  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 hash = (value: string) => Bun.hash(value).toString(36);
+
+/**
+ * The walk's answer can change without any app file moving, when the thing that
+ * *interprets* the graph does: the resolver's config (aliases, conditions, page
+ * extensions) or pnext itself. Both go in the key, so either one moving makes
+ * the record read as a miss instead of half-validating it.
+ */
+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}`);
+  } catch {
+    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). */
+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;
+  } catch {
+    return 'unknown';
+  }
+}
+
+export function installGlobalCssCache(config: ResolvedConfig) {
+  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));
+}
+
+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`);
+
+  return {
+    load(walkKey) {
+      const record = readRecord(recordFile(walkKey), key);
+      if (!record) {
+        stats.misses += 1;
+        return undefined;
+      }
+      if (record.missing.some(file => existsSync(file))) {
+        stats.misses += 1;
+        return undefined;
+      }
+      const revalidated = revalidate(record.files);
+      if (!revalidated) {
+        stats.misses += 1;
+        return undefined;
+      }
+      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);
+      }
+      return record.sources;
+    },
+    save(walkKey, sources, visited, missing) {
+      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;
+  try {
+    parsed = JSON.parse(readFileSync(file, 'utf8')) as RecordFile;
+  } catch {
+    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;
+}
+
+/**
+ * Written from a synchronous getter, so the write is synchronous too - a debounce would have to
+ * survive an exit the walk's caller never awaits. One small file, written once per process.
+ */
+function write(
+  file: string,
+  key: string,
+  written: Map<string, string>,
+  walkKey: string,
+  files: SourceEntry[],
+  missing: string[],
+  sources: string[],
+) {
+  const contents = JSON.stringify({
+    version: RECORD_VERSION,
+    key,
+    files,
+    missing,
+    sources,
+  } satisfies RecordFile);
+  if (written.get(walkKey) === contents) return;
+  written.set(walkKey, contents);
+  try {
+    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[] = [];
+  for (const file of files) {
+    const entry = sourceEntry(file);
+    if (!entry) return undefined;
+    entries.push(entry);
+  }
+  return entries;
+}
+
+function sourceEntry(file: string): SourceEntry | undefined {
+  try {
+    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)];
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The recorded sources, re-stated: `files` itself when nothing moved, a fresh list when only stats moved,
+ * `undefined` when any content actually differs - or a source is gone, which is the same thing, since the
+ * walk has to run again.
+ */
+function revalidate(files: SourceEntry[]): SourceEntry[] | undefined {
+  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;
+    if (info.mtimeMs === mtimeMs && info.size === size) {
+      checked.push(entry);
+      continue;
+    }
+    let source: string;
+    try {
+      source = readFileSync(file, 'utf8');
+    } catch {
+      return undefined;
+    }
+    if (hash(source) !== contentHash) return undefined;
+    moved = true;
+    checked.push([file, info.mtimeMs, info.size, contentHash]);
+  }
+  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 };
+// 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}`));
+}