@wular/pnext 0.0.1

package/src/compat/next/font/cache.ts

@@ -0,0 +1,171 @@
+// Persisted next/font resolutions - the restart half of the in-memory `resolvedFontCache`. The
+// bytes a resolution emits are already content-addressed on disk, but the resolution itself is not,
+// so a dev restart would re-fetch every Google Fonts stylesheet and font file just to re-derive
+// URLs it already emitted. This records the finished resolution next to those bytes and
+// re-validates it with stats only:
+//   - every emitted file must still exist (a `pnext build` empties the dir), and
+//   - every local source file must still match the stat it was read at, so a font swapped while the
+//     server was not running re-resolves and re-emits.
+// Nothing here is used by `pnext build`, which owns the directory it just wiped.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdir, stat } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import type { ResolvedConfig } from '../../../config';
+import { restartCacheEnabled } from '../../../dev/restart-cache';
+import { writeFileAtomic } from '../../../utils/fs';
+import type { MetadataLink } from '../../../types';
+
+export interface PersistableFont {
+  css: string;
+  preloads: MetadataLink[];
+  usesFonts: boolean;
+  files: string[];
+  /** Local font files the resolution read (google resolutions have none). */
+  sources?: string[];
+}
+
+/** `[file, mtimeMs, size]` — a local source and the stat it was resolved at. */
+type SourceStat = [string, number, number];
+
+interface Entry extends PersistableFont {
+  sourceStats: SourceStat[];
+}
+
+interface IndexFile {
+  version: number;
+  /** Content hash of the font runtime, so an upgrade never serves its output. */
+  runtime: string;
+  fonts: Record<string, Entry>;
+}
+
+/** Bumped whenever a record's shape changes; an older index is simply ignored. */
+const INDEX_VERSION = 1;
+
+interface FontIndex {
+  file: string;
+  fonts: Map<string, Entry>;
+  dirty: boolean;
+  flush?: Timer;
+}
+
+const indexes = new Map<string, FontIndex>();
+
+function fontIndex(config: ResolvedConfig): FontIndex {
+  const file = path.join(config.outPath, 'cache', 'fonts', 'index.json');
+  const existing = indexes.get(file);
+  if (existing) return existing;
+  const created: FontIndex = { file, fonts: readIndex(file), dirty: false };
+  indexes.set(file, created);
+  process.on('exit', () => {
+    if (!created.dirty) return;
+    created.dirty = false;
+    try {
+      writeFileSync(created.file, serializeIndex(created.fonts));
+    } catch {
+      // Best effort: a missing index only costs the next boot a re-resolve.
+    }
+  });
+  return created;
+}
+
+/** The recorded resolution for `key`, or undefined when it no longer describes disk. */
+export async function persistedFont(
+  config: ResolvedConfig,
+  key: string,
+): Promise<PersistableFont | undefined> {
+  if (!restartCacheEnabled()) return undefined;
+  const entry = fontIndex(config).fonts.get(key);
+  if (!entry) return undefined;
+  if (!entry.files.every(file => existsSync(file))) return undefined;
+  const stats = await Promise.all(
+    entry.sourceStats.map(async ([file, mtimeMs, size]) => {
+      const current = await stat(file).catch(() => undefined);
+      return current?.mtimeMs === mtimeMs && current.size === size;
+    }),
+  );
+  if (!stats.every(Boolean)) return undefined;
+  return entry;
+}
+
+/** Record a finished resolution. Failures are non-fatal — they cost a re-resolve. */
+export async function persistFont(config: ResolvedConfig, key: string, font: PersistableFont) {
+  const index = fontIndex(config);
+  const sourceStats = await Promise.all(
+    (font.sources ?? []).map(async (file): Promise<SourceStat | undefined> => {
+      const stats = await stat(file).catch(() => undefined);
+      return stats ? [file, stats.mtimeMs, stats.size] : undefined;
+    }),
+  );
+  // A source that vanished mid-resolve must not be recorded as validated.
+  if (sourceStats.some(entry => entry === undefined)) return;
+  index.fonts.set(key, { ...font, sourceStats: sourceStats as SourceStat[] });
+  persist(index);
+}
+
+function persist(index: FontIndex) {
+  index.dirty = true;
+  if (index.flush) return;
+  index.flush = setTimeout(async () => {
+    index.flush = undefined;
+    if (!index.dirty) return;
+    const contents = serializeIndex(index.fonts);
+    try {
+      await mkdir(path.dirname(index.file), { recursive: true });
+      await writeFileAtomic(index.file, contents);
+      index.dirty = false;
+    } catch {
+      // A write that lost a race with a cache wipe must not look persisted.
+    }
+  }, 50);
+  // NOT unref'd: under the dev server this timer never fired, so the index was never written and
+  // every restart re-resolved every font over the network. The `exit` handler above still covers a
+  // process exit inside the window.
+}
+
+function readIndex(file: string) {
+  const fonts = new Map<string, Entry>();
+  let parsed: IndexFile | undefined;
+  try {
+    parsed = JSON.parse(readFileSync(file, 'utf8')) as IndexFile;
+  } catch {
+    return fonts;
+  }
+  if (parsed?.version !== INDEX_VERSION || parsed.runtime !== runtimeFingerprint()) {
+    return fonts;
+  }
+  for (const [key, entry] of Object.entries(parsed.fonts ?? {})) {
+    if (entry && Array.isArray(entry.files) && Array.isArray(entry.sourceStats)) {
+      fonts.set(key, entry);
+    }
+  }
+  return fonts;
+}
+
+function serializeIndex(fonts: Map<string, Entry>) {
+  return JSON.stringify({
+    version: INDEX_VERSION,
+    runtime: runtimeFingerprint(),
+    fonts: Object.fromEntries(fonts),
+  } satisfies IndexFile);
+}
+
+// The CSS a resolution emits is shaped entirely by this directory's sources, so
+// editing the font runtime must retire its records the same way editing a font
+// does. Four small files, once per process.
+let fingerprint: string | undefined;
+
+function runtimeFingerprint() {
+  if (fingerprint !== undefined) return fingerprint;
+  const hash = createHash('sha256');
+  for (const entry of ['runtime.ts', 'google.ts', 'local.ts', 'shared.ts']) {
+    const file = new URL(entry, import.meta.url).pathname;
+    try {
+      hash.update(`${entry}:${Bun.hash(readFileSync(file)).toString(36)}\0`);
+    } catch {
+      // ignore unreadable entries
+    }
+  }
+  fingerprint = hash.digest('hex').slice(0, 16);
+  return fingerprint;
+}

package/src/compat/next/font/google.ts

@@ -0,0 +1,2 @@
+export * from 'next-font/google';
+export type { FontDisplay, GoogleFontOptions, NextFont, NextFontWithVariable } from './runtime';

package/src/compat/next/font/index.ts

@@ -0,0 +1,8 @@
+export type {
+  FontDisplay as Display,
+  GoogleFontOptions,
+  LocalFontOptions,
+  LocalFontSource,
+  NextFont,
+  NextFontWithVariable,
+} from './runtime';

package/src/compat/next/font/local.ts

@@ -0,0 +1,5 @@
+import { localFont } from './runtime';
+
+export type { LocalFontOptions, LocalFontSource, NextFont, NextFontWithVariable } from './runtime';
+
+export default localFont;

package/src/compat/next/font/runtime-client.ts

@@ -0,0 +1,71 @@
+/**
+ * Client-bundle variant of the next/font runtime.
+ *
+ * A `'use client'` component that calls `next/font/google` or `next/font/local` needs ONLY the
+ * pre-hashed className/variable/style off the font object - the actual CSS and font files are emitted
+ * and served by the SERVER runtime and already present in the SSR'd HTML. So this entry imports NOTHING
+ * from `node:*`, registers NO response finalizers at module scope, and derives className/variable/style
+ * from the SAME client-safe shared logic the server uses, so the hashes match exactly.
+ *
+ * rewriteNextFontSource targets this file for CLIENT builds and runtime.ts for SERVER builds.
+ */
+
+import {
+  googleFontNaming,
+  localFontNaming,
+  fontStyle,
+  type GoogleFontOptions,
+  type LocalFontOptions,
+  type NextFontWithVariable,
+} from './shared';
+
+export type {
+  FontDisplay,
+  GoogleFontOptions,
+  LocalFontOptions,
+  LocalFontSource,
+  NextFont,
+  NextFontWithVariable,
+} from './shared';
+
+function fontObject(naming: {
+  className: string;
+  variable: string;
+  hasVariable: boolean;
+  style: NextFontWithVariable['style'];
+}): NextFontWithVariable {
+  // Plain data object: no registration side effects (the server already emitted
+  // the CSS/assets). Client code reads className/variable/style off this. The
+  // `variable` key is omitted when the loader call passed no `variable` option,
+  // matching Next (a `toEqual` on the font object would otherwise see an extra
+  // key).
+  const font: NextFontWithVariable = {
+    className: naming.className,
+    style: naming.style,
+  } as NextFontWithVariable;
+  if (naming.hasVariable) font.variable = naming.variable;
+  return font;
+}
+
+export function googleFont(family: string) {
+  return (options: GoogleFontOptions = {}): NextFontWithVariable =>
+    fontObject(googleFontNaming(family, options));
+}
+
+export interface LocalFontLoader {
+  (options: LocalFontOptions): NextFontWithVariable;
+  withFile: typeof localFontWithFile;
+}
+
+export function localFontWithFile(callerFile: string | undefined, family?: string) {
+  return (options: LocalFontOptions): NextFontWithVariable =>
+    fontObject({
+      ...localFontNaming(callerFile, options),
+      ...(family ? { fontFamily: family, style: fontStyle(family, options, options.fallback ?? []) } : {}),
+    });
+}
+
+export const localFont: LocalFontLoader = Object.assign(
+  (options: LocalFontOptions) => localFontWithFile(undefined)(options),
+  { withFile: localFontWithFile },
+);