@wular/pnext 0.0.19 → 0.0.20

package/src/css/postcss.ts

@@ -75,9 +75,10 @@ export async function runPostcss(
   // `DEBUG=tailwindcss` marker keys off `result.opts.from`). We still write the
   // processed output back to the bundle outfile via `to`.
   const from = fromSource ?? cssFile
+  const css = await readText(cssFile)
   // The scan directives go last so they don't shift the line numbers plugins
   // report against the real source; `@source` is order-independent to Tailwind.
-  const result = await loaded.processor.process((await readText(cssFile)) + loaded.sources, {
+  const result = await loaded.processor.process(css + keptExclusions(loaded.sources, css, from), {
     from,
     to: cssFile,
   })
@@ -112,7 +113,35 @@ async function createPostcssProcessor(root: string, options: PostcssOptions) {
  * Excluding these three by name restores that behaviour without narrowing what a correctly-ignored
  * checkout already scans. Apps that really do keep Tailwind-classed sources in one of them set
  * `PNEXT_TAILWIND_SCAN_ALL`.
+ *
+ * A pure function of (root, outDir) — deliberately NOT of what is on disk. The processor is built
+ * once and cached, and `warmCssPipeline` builds it before the build has written its output, so an
+ * `existsSync` here made the exclusion set depend on which of the two got there first: the same
+ * stylesheet compiled with or without utilities minted out of pnext's own emitted JS.
  */
+/**
+ * An appended `@source not <dir>` silences every explicit `@source` glob the stylesheet points
+ * under that dir - Tailwind gives `not` precedence - so an app opting INTO scanning a package
+ * (`@source '../../node_modules/x/dist/...'`) lost those utilities entirely. Keep only the
+ * exclusions that no explicit `@source` in this stylesheet reaches into.
+ */
+export function keptExclusions(exclusions: string, css: string, fromFile: string): string {
+  if (!exclusions) return exclusions
+  const dir = path.dirname(fromFile)
+  const globs = [...css.matchAll(/@source\s+(?!not\s)['"]([^'"]+)['"]/g)].map(m =>
+    path.resolve(dir, m[1]!.replace(/[*{[].*$/, '')),
+  )
+  if (globs.length === 0) return exclusions
+  const kept = exclusions
+    .split('\n')
+    .filter(line => {
+      const m = /@source not "([^"]+)"/.exec(line)
+      return !m || !globs.some(glob => glob === m[1] || glob.startsWith(m[1] + '/'))
+    })
+    .join('\n')
+  return kept.includes('@source not') ? kept : ''
+}
+
 function scanExclusions(root: string, appRequire: NodeJS.Require, options: PostcssOptions) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   if (process.env.PNEXT_TAILWIND_SCAN_ALL) return ''
@@ -120,8 +149,8 @@ function scanExclusions(root: string, appRequire: NodeJS.Require, options: Postc
   const [major, minor] = packageVersion(appRequire, '@tailwindcss/postcss')
   if (major < 4 || (major === 4 && minor < 1)) return ''
   const dirs = ['node_modules', '.next', options.outDir ?? '.pnext']
-  const excluded = [...new Set(dirs.map(dir => path.resolve(root, dir)))].filter(
-    dir => dir.startsWith(root + path.sep) && existsSync(dir),
+  const excluded = [...new Set(dirs.map(dir => path.resolve(root, dir)))].filter(dir =>
+    dir.startsWith(root + path.sep),
   )
   if (excluded.length === 0) return ''
   // Leading and trailing newlines keep the stylesheet's own first and last

package/src/dev/restart/client-key.ts

@@ -83,7 +83,7 @@ export async function devClientCacheKey(
 ): Promise<string> {
   if (!restartCacheEnabled()) return (await clientCacheKeyParts(route, nextCompat, config)).key
   const cache = keyCache(config)
-  const staticHash = await clientCacheStaticHash(route, nextCompat, config)
+  const staticHash = clientCacheStaticHash(route, nextCompat, config)
   const entry = cache.routes.get(route.id)
   if (entry?.static === staticHash) {
     const revalidated = await revalidate(entry.files)

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

@@ -10,19 +10,17 @@
 //   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 { mkdirSync, existsSync, readFileSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import type { ResolvedConfig } from '../../config'
 import { setGlobalCssSourceStore, type GlobalCssSourceStore } from '../../css/build'
 import { traceEnabled } from '../../utils/trace-flags'
 import { restartCacheEnabled } from './enabled'
-
-/** `[file, mtimeMs, size, contentHash]` — the shape the other restart caches use. */
-type SourceEntry = [string, number, number, string]
+import { hash, lazyRecordCacheKey, revalidate, sourceEntries, type SourceEntry } from './record'
 
 interface RecordFile {
   version: number
-  /** Everything the answer depends on that is not a walked source (see cacheKey). */
+  /** Everything the answer depends on that is not a walked source (see restart/record.ts). */
   key: string
   files: SourceEntry[]
   missing: string[]
@@ -32,47 +30,15 @@ interface RecordFile {
 /** 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 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
-  } 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))
+  const dir = path.join(config.outPath, 'cache', 'global-css')
+  setGlobalCssSourceStore(createStore(dir, lazyRecordCacheKey(config, RECORD_VERSION)))
 }
 
-function createStore(dir: string, key: string): GlobalCssSourceStore {
+function createStore(dir: string, cacheKey: () => string | undefined): 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>()
@@ -80,8 +46,10 @@ function createStore(dir: string, key: string): GlobalCssSourceStore {
 
   return {
     load(walkKey) {
-      const record = readRecord(recordFile(walkKey), key)
-      if (!record) {
+      // A config that will not serialize has no key, so it simply always walks.
+      const key = cacheKey()
+      const record = key ? readRecord(recordFile(walkKey), key) : undefined
+      if (!key || !record) {
         stats.misses += 1
         return undefined
       }
@@ -111,6 +79,8 @@ function createStore(dir: string, key: string): GlobalCssSourceStore {
       return record.sources
     },
     save(walkKey, sources, visited, missing) {
+      const key = cacheKey()
+      if (!key) return
       const files = sourceEntries(visited)
       if (!files) return
       write(recordFile(walkKey), key, written, walkKey, files, missing, sources)
@@ -161,58 +131,6 @@ function write(
   }
 }
 
-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_TRACE=server` prints the hit/miss split at exit. */
 const stats = { hits: 0, misses: 0 }
 if (traceEnabled('server')) {

package/src/dev/restart/record.ts

@@ -0,0 +1,106 @@
+// Shared spine of the persisted restart records (global-css, route-facts): the key everything a
+// record depends on that is NOT a walked source folds into, and the stat->hash ladder that
+// revalidates the sources themselves. Both halves were duplicated per record; a key rule that lives
+// in two copies is a key rule that gets fixed in one of them.
+import { readFileSync, statSync } from 'node:fs'
+import type { ResolvedConfig } from '../../config'
+import { frameworkFingerprint } from '../../runtime/fingerprint'
+import { cacheRoot } from '../../runtime/module-cache'
+
+/** `[file, mtimeMs, size, contentHash]` — the shape every restart cache records. */
+export type SourceEntry = [string, number, number, string]
+
+export const hash = (value: string) => Bun.hash(value).toString(36)
+
+/**
+ * A record'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.
+ *
+ * The framework half is the CONTENT of pnext's whole shipped tree, never the mtime+size of one
+ * hand-picked walker file. A record derived by reading many framework files cannot be keyed on one
+ * of them - the stamp is blind to an edit in any of the others - and mtime+size is not content: a
+ * same-length edit landing in the same mtime tick moved nothing the stamp could see. The tree
+ * fingerprint is already computed at boot for the module cache and memoized per process, so this
+ * costs a memo read.
+ */
+export function recordCacheKey(config: ResolvedConfig, version: number): string | undefined {
+  try {
+    const shape = JSON.stringify(config, (_key, value: unknown) =>
+      typeof value === 'function' ? '[fn]' : value,
+    )
+    return hash(`${version}\n${frameworkFingerprint(cacheRoot(config.outPath))}\n${shape}`)
+  } catch {
+    // A config that will not serialize (cycles, exotic values) simply opts out.
+    return undefined
+  }
+}
+
+/**
+ * The same key, on first USE rather than at install. The stores are installed during boot but first
+ * read on the first page, and the fingerprint the key folds in is paid by the module cache on that
+ * same page - so computing it eagerly does not save the work, it just moves it in front of the
+ * server being ready to serve.
+ */
+export function lazyRecordCacheKey(config: ResolvedConfig, version: number) {
+  let key: string | undefined
+  let computed = false
+  return () => {
+    if (!computed) {
+      computed = true
+      key = recordCacheKey(config, version)
+    }
+    return key
+  }
+}
+
+export 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
+}
+
+export 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.
+ */
+export 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
+}

package/src/dev/restart/route-facts.ts

@@ -13,19 +13,17 @@
 // 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 { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import type { ResolvedConfig } from '../../config'
 import { setRouteFactsStore, type RouteFacts, type RouteFactsStore } from '../../routing/routes'
 import { traceEnabled } from '../../utils/trace-flags'
 import { restartCacheEnabled } from './enabled'
-
-/** `[file, mtimeMs, size, contentHash]` — the same record shape the key cache uses. */
-type SourceEntry = [string, number, number, string]
+import { hash, lazyRecordCacheKey, revalidate, sourceEntry, type SourceEntry } from './record'
 
 interface RecordFile {
   version: number
-  /** Everything the facts depend on that is not a walked source (see cacheKey). */
+  /** Everything the facts depend on that is not a walked source (see restart/record.ts). */
   key: string
   files: SourceEntry[]
   facts: RouteFacts
@@ -34,45 +32,10 @@ interface RecordFile {
 /** 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 facts of a route whose own sources did not move can still change when the
- * thing that *interprets* them does: the resolved config (compat on/off, route
- * extensions, aliases) or pnext itself. Both go in the record's key, so either
- * one moving makes every 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 {
-    // A config that will not serialize (cycles, exotic values) simply opts out.
-    return undefined
-  }
-}
-
-/**
- * mtime+size of the route scanner this process is running. The facts are the framework's own reading of
- * the app's sources, so a pnext that changed since the record was written must re-derive them rather than
- * inherit the old answers - which is what keeps this safe while pnext itself is being edited.
- */
-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
-  } catch {
-    return 'unknown'
-  }
-}
-
 interface FactsCache {
   dir: string
-  key: string
+  /** Resolved on first use, not at install; see restart/record.ts. */
+  key: () => string | undefined
   /** Records written this process, so a repeat save does not re-serialize. */
   written: Set<string>
 }
@@ -81,11 +44,9 @@ export function installRouteFactsCache(config: ResolvedConfig) {
   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
   const cache: FactsCache = {
     dir: path.join(config.outPath, 'cache', 'route-facts'),
-    key,
+    key: lazyRecordCacheKey(config, RECORD_VERSION),
     written: new Set(),
   }
   setRouteFactsStore(createStore(cache))
@@ -132,7 +93,7 @@ function readRecord(cache: FactsCache, routeId: string): RecordFile | undefined
   } catch {
     return undefined
   }
-  if (parsed?.version !== RECORD_VERSION || parsed.key !== cache.key) return undefined
+  if (parsed?.version !== RECORD_VERSION || parsed.key !== cache.key()) return undefined
   if (!parsed.facts || !Array.isArray(parsed.files)) return undefined
   return parsed
 }
@@ -143,11 +104,13 @@ 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
+  const key = cache.key()
+  // A config that will not serialize has no key, so nothing is recorded for it.
+  if (!key || cache.written.has(routeId)) return
   cache.written.add(routeId)
   const contents = JSON.stringify({
     version: RECORD_VERSION,
-    key: cache.key,
+    key,
     files,
     facts,
   } satisfies RecordFile)
@@ -174,48 +137,6 @@ function factsSources(facts: RouteFacts): SourceEntry[] | undefined {
   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_TRACE=server` prints the hit/miss split at exit. */
 const stats = { hits: 0, misses: 0 }
 if (traceEnabled('server')) {