@wular/pnext 0.0.4 → 0.0.7

package/src/css/postcss.ts

@@ -2,17 +2,17 @@
 // on the CSS worker thread (./worker.ts) rather than the event loop:
 // Tailwind v4's postcss plugin is synchronous CPU work — its oxide scan and
 // compile starved every concurrent request while it ran in-process.
-import { createRequire } from 'node:module';
-import { existsSync, readFileSync } from 'node:fs';
-import { writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { readText } from '../utils/fs';
+import { createRequire } from 'node:module'
+import { existsSync, readFileSync } from 'node:fs'
+import { writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { readText } from '../utils/fs'
 
 export interface PostcssOptions {
-  dev?: boolean;
+  dev?: boolean
   /** pnext's output directory — kept out of Tailwind's content scan. */
-  outDir?: string;
+  outDir?: string
 }
 
 // One long-lived processor per root+mode. Keeping it alive is what makes dev fast: Tailwind v4's postcss
@@ -20,45 +20,45 @@ export interface PostcssOptions {
 // instead of a CLI spawn plus a full project re-scan. It also means other plugins in the config actually
 // execute - the old CLI path treated postcss.config purely as a Tailwind trigger. Config-file edits need a
 // dev-server restart; Tailwind tracks its own dependencies and refreshes them itself.
-const postcssProcessors = new Map<string, Promise<LoadedPostcss | undefined>>();
+const postcssProcessors = new Map<string, Promise<LoadedPostcss | undefined>>()
 
 interface PostcssProcessor {
-  process(css: string, options: { from: string; to: string }): PromiseLike<{ css: string }>;
+  process(css: string, options: { from: string; to: string }): PromiseLike<{ css: string }>
 }
 
 /** A processor plus the `@source not` directives to append for it (if any). */
 interface LoadedPostcss {
-  processor: PostcssProcessor;
-  sources: string;
+  processor: PostcssProcessor
+  sources: string
 }
 
-type PostcssPluginFactory = (options?: unknown) => unknown;
+type PostcssPluginFactory = (options?: unknown) => unknown
 
 interface PostcssConfig {
-  plugins?: Record<string, unknown> | unknown[];
+  plugins?: Record<string, unknown> | unknown[]
 }
 
 export function postcssConfigFile(root: string) {
   for (const file of ['postcss.config.cjs', 'postcss.config.js', 'postcss.config.mjs']) {
-    const full = path.join(root, file);
-    if (existsSync(full)) return full;
+    const full = path.join(root, file)
+    if (existsSync(full)) return full
   }
-  return undefined;
+  return undefined
 }
 
 /** Build (or reuse) the processor for this root+mode without processing a file. */
 export function loadPostcss(root: string, options: PostcssOptions) {
-  const key = `${root}\0${options.dev ? 'dev' : 'build'}\0${options.outDir ?? ''}`;
-  let processor = postcssProcessors.get(key);
+  const key = `${root}\0${options.dev ? 'dev' : 'build'}\0${options.outDir ?? ''}`
+  let processor = postcssProcessors.get(key)
   if (!processor) {
     processor = createPostcssProcessor(root, options).catch((error: unknown) => {
       // Drop failed setups so a fixed config or install is retried.
-      postcssProcessors.delete(key);
-      throw error;
-    });
-    postcssProcessors.set(key, processor);
+      postcssProcessors.delete(key)
+      throw error
+    })
+    postcssProcessors.set(key, processor)
   }
-  return processor;
+  return processor
 }
 
 export async function runPostcss(
@@ -67,43 +67,42 @@ export async function runPostcss(
   options: PostcssOptions,
   fromSource?: string,
 ) {
-  const loaded = await loadPostcss(root, options);
-  if (!loaded) return;
+  const loaded = await loadPostcss(root, options)
+  if (!loaded) return
   // `from` labels the input for postcss plugins' diagnostics/source maps. Point
   // it at the original CSS source (not the synthesized bundle outfile) so
   // plugins like `@tailwindcss/postcss` report the real path (e.g. its
   // `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 from = fromSource ?? 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, {
     from,
     to: cssFile,
-  });
-  await writeFile(cssFile, result.css);
+  })
+  await writeFile(cssFile, result.css)
 }
 
 async function createPostcssProcessor(root: string, options: PostcssOptions) {
-  const configFile = postcssConfigFile(root);
-  if (!configFile) return undefined;
+  const configFile = postcssConfigFile(root)
+  if (!configFile) return undefined
   const loaded = (await import(pathToFileURL(configFile).href)) as
-    | PostcssConfig
-    | { default: PostcssConfig };
-  const config = 'default' in loaded && loaded.default ? loaded.default : loaded;
-  const plugins = postcssPlugins(root, config as PostcssConfig, options);
-  if (plugins.length === 0) return undefined;
-  const appRequire = createRequire(path.join(root, 'package.json'));
+    PostcssConfig | { default: PostcssConfig }
+  const config = 'default' in loaded && loaded.default ? loaded.default : loaded
+  const plugins = postcssPlugins(root, config as PostcssConfig, options)
+  if (plugins.length === 0) return undefined
+  const appRequire = createRequire(path.join(root, 'package.json'))
   const postcss = interopDefault(resolvePostcss(appRequire)) as (
     plugins: unknown[],
-  ) => PostcssProcessor;
+  ) => PostcssProcessor
   const tailwind = pluginEntries(config as PostcssConfig).some(
     ([specifier, pluginOptions]) => specifier === '@tailwindcss/postcss' && pluginOptions !== false,
-  );
+  )
   return {
     processor: postcss(plugins),
     sources: tailwind ? scanExclusions(root, appRequire, options) : '',
-  };
+  }
 }
 
 /**
@@ -116,32 +115,32 @@ async function createPostcssProcessor(root: string, options: PostcssOptions) {
  */
 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 '';
+  if (process.env.PNEXT_TAILWIND_SCAN_ALL) return ''
   // `@source not` landed in Tailwind 4.1; older versions error on the at-rule.
-  const [major, minor] = packageVersion(appRequire, '@tailwindcss/postcss');
-  if (major < 4 || (major === 4 && minor < 1)) return '';
-  const dirs = ['node_modules', '.next', options.outDir ?? '.pnext'];
+  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),
-  );
-  if (excluded.length === 0) return '';
+  )
+  if (excluded.length === 0) return ''
   // Leading and trailing newlines keep the stylesheet's own first and last
   // lines exactly as they were, so the emitted CSS stays byte-identical.
   return `\n${excluded
     .map(dir => `@source not ${JSON.stringify(dir.split(path.sep).join('/'))};`)
-    .join('\n')}\n`;
+    .join('\n')}\n`
 }
 
 /** `[major, minor]` of a resolvable package, or `[0, 0]` when unknown. */
 function packageVersion(req: NodeJS.Require, name: string): [number, number] {
   try {
     const pkg = JSON.parse(readFileSync(req.resolve(`${name}/package.json`), 'utf8')) as {
-      version?: string;
-    };
-    const [major, minor] = (pkg.version ?? '').split('.');
-    return [Number.parseInt(major ?? '', 10) || 0, Number.parseInt(minor ?? '', 10) || 0];
+      version?: string
+    }
+    const [major, minor] = (pkg.version ?? '').split('.')
+    return [Number.parseInt(major ?? '', 10) || 0, Number.parseInt(minor ?? '', 10) || 0]
   } catch {
-    return [0, 0];
+    return [0, 0]
   }
 }
 
@@ -152,28 +151,28 @@ function pluginEntries(config: PostcssConfig): [unknown, unknown][] {
           ? ([entry[0], entry[1]] as [unknown, unknown])
           : ([entry, undefined] as [unknown, unknown]),
       )
-    : Object.entries(config.plugins ?? {});
+    : Object.entries(config.plugins ?? {})
 }
 
 function postcssPlugins(root: string, config: PostcssConfig, options: PostcssOptions) {
-  const appRequire = createRequire(path.join(root, 'package.json'));
-  const entries = pluginEntries(config);
+  const appRequire = createRequire(path.join(root, 'package.json'))
+  const entries = pluginEntries(config)
 
-  const plugins: unknown[] = [];
+  const plugins: unknown[] = []
   for (const [specifier, pluginOptions] of entries) {
-    if (pluginOptions === false) continue;
+    if (pluginOptions === false) continue
     if (typeof specifier !== 'string') {
       // Already-instantiated plugin object or factory in an array config.
-      if (specifier) plugins.push(specifier);
-      continue;
+      if (specifier) plugins.push(specifier)
+      continue
     }
-    const factory = interopDefault(appRequire(specifier) as unknown);
-    const resolvedOptions = pluginOptionsFor(root, specifier, pluginOptions, options);
+    const factory = interopDefault(appRequire(specifier) as unknown)
+    const resolvedOptions = pluginOptionsFor(root, specifier, pluginOptions, options)
     plugins.push(
       typeof factory === 'function' ? (factory as PostcssPluginFactory)(resolvedOptions) : factory,
-    );
+    )
   }
-  return plugins;
+  return plugins
 }
 
 function pluginOptionsFor(
@@ -182,14 +181,14 @@ function pluginOptionsFor(
   userOptions: unknown,
   options: PostcssOptions,
 ) {
-  if (specifier !== '@tailwindcss/postcss') return userOptions;
+  if (specifier !== '@tailwindcss/postcss') return userOptions
   // Scan candidates from the app root — the bundled css Tailwind reads lives
   // under .pnext, where a default input-relative scan would find nothing.
   return {
     base: root,
     optimize: options.dev ? false : { minify: true },
     ...(typeof userOptions === 'object' && userOptions !== null ? userOptions : {}),
-  };
+  }
 }
 
 function resolvePostcss(appRequire: NodeJS.Require): unknown {
@@ -198,39 +197,39 @@ function resolvePostcss(appRequire: NodeJS.Require): unknown {
   // dependency, which the package manager hoists to the app's top-level node_modules, so requiring
   // 'postcss' from the app would return PostCSS 7 and a modern app plugin using the v8 API throws. Prefer
   // the app's postcss only when it is already v8+, otherwise fall back to pnext's own.
-  let appPostcss: unknown;
+  let appPostcss: unknown
   try {
-    appPostcss = appRequire('postcss');
-    if (packageVersion(appRequire, 'postcss')[0] >= 8) return appPostcss;
+    appPostcss = appRequire('postcss')
+    if (packageVersion(appRequire, 'postcss')[0] >= 8) return appPostcss
   } catch {
     // App has no resolvable postcss; fall through to pnext's own / plugin copy.
   }
-  const ownPostcss = resolveOwnPostcss();
-  if (ownPostcss) return ownPostcss;
+  const ownPostcss = resolveOwnPostcss()
+  if (ownPostcss) return ownPostcss
   try {
     // A Tailwind-based app ships a v8 postcss under its plugin package.
-    const pluginPackage = appRequire.resolve('@tailwindcss/postcss/package.json');
-    return createRequire(pluginPackage)('postcss');
+    const pluginPackage = appRequire.resolve('@tailwindcss/postcss/package.json')
+    return createRequire(pluginPackage)('postcss')
   } catch {
     // Last resort: whatever the app resolved (even if <8) — better than nothing.
-    if (appPostcss) return appPostcss;
-    throw new Error('Could not resolve a PostCSS installation for the CSS pipeline.');
+    if (appPostcss) return appPostcss
+    throw new Error('Could not resolve a PostCSS installation for the CSS pipeline.')
   }
 }
 
 /** pnext's own PostCSS 8 (mirrors Next's bundled copy), or undefined. */
 function resolveOwnPostcss(): unknown {
   try {
-    const ownRequire = createRequire(import.meta.url);
-    if (packageVersion(ownRequire, 'postcss')[0] >= 8) return ownRequire('postcss');
+    const ownRequire = createRequire(import.meta.url)
+    if (packageVersion(ownRequire, 'postcss')[0] >= 8) return ownRequire('postcss')
   } catch {
     // pnext's install carries no resolvable postcss; caller falls back.
   }
-  return undefined;
+  return undefined
 }
 
 function interopDefault(mod: unknown): unknown {
-  if (typeof mod === 'function') return mod;
-  if (mod && typeof mod === 'object' && 'default' in mod && mod.default) return mod.default;
-  return mod;
+  if (typeof mod === 'function') return mod
+  if (mod && typeof mod === 'object' && 'default' in mod && mod.default) return mod.default
+  return mod
 }

package/src/css/worker.ts

@@ -1,27 +1,26 @@
 // CSS worker entry — runs the postcss/Tailwind pipeline off the event loop.
 // One message per built stylesheet; the processor cache in ./postcss.ts lives
 // here for the worker's lifetime, so Tailwind stays incremental across rebuilds.
-import { loadPostcss, runPostcss } from './postcss';
+import { loadPostcss, runPostcss } from './postcss'
 export type CssWorkerRequest = { id: number; root: string; dev: boolean; outDir?: string } & (
-  | { kind: 'warm' }
-  | { kind: 'process'; cssFile: string; from?: string }
-);
+  { kind: 'warm' } | { kind: 'process'; cssFile: string; from?: string }
+)
 
 export interface CssWorkerResponse {
-  id: number;
-  error?: { name: string; message: string; stack?: string };
+  id: number
+  error?: { name: string; message: string; stack?: string }
 }
 
-declare const self: Worker;
+declare const self: Worker
 
 self.onmessage = async (event: MessageEvent<CssWorkerRequest>) => {
-  const request = event.data;
-  const reply = (response: CssWorkerResponse) => postMessage(response);
+  const request = event.data
+  const reply = (response: CssWorkerResponse) => postMessage(response)
   try {
-    const options = { dev: request.dev, outDir: request.outDir };
-    if (request.kind === 'warm') await loadPostcss(request.root, options);
-    else await runPostcss(request.root, request.cssFile, options, request.from);
-    reply({ id: request.id });
+    const options = { dev: request.dev, outDir: request.outDir }
+    if (request.kind === 'warm') await loadPostcss(request.root, options)
+    else await runPostcss(request.root, request.cssFile, options, request.from)
+    reply({ id: request.id })
   } catch (error) {
     reply({
       id: request.id,
@@ -29,6 +28,6 @@ self.onmessage = async (event: MessageEvent<CssWorkerRequest>) => {
         error instanceof Error
           ? { name: error.name, message: error.message, stack: error.stack }
           : { name: 'Error', message: String(error) },
-    });
+    })
   }
-};
+}

package/src/dev/client-actions.ts

@@ -2,34 +2,34 @@
 //
 // The dev route-client bundle resolves every module into its own `pnext-route-client` esbuild namespace, so
 // a standalone esbuild plugin cannot intercept that graph the way it can a plain client build. This holder
-// is the extension point dev/imports reads to turn a client-side import of a `'use server'` module into the
+// is the extension point runtime/modules reads to turn a client-side import of a `'use server'` module into the
 // RPC stub, without core statically importing compat/actions.
 //
-// Compat populates it; a pure-core app leaves it unset, and dev/imports treats every module as a normal
-// source module. Mirrors the routing/request-runtime.ts holder pattern.
+// Compat populates it; a pure-core app leaves it unset, and runtime/modules treats every module as a normal
+// source module. Mirrors the routing/request-environment.ts holder pattern.
 
-/** Compat client-action bundler surface dev/imports consults. */
+/** Compat client-action bundler surface runtime/modules consults. */
 export interface ClientActionBundler {
   /**
    * Ensure the client-action module set is discovered for the active dev import version (a dev reload bumps
    * it). Awaited before a route-client build so the stub check below sees the current set - the discovery
    * that used to run inline at startup/reload now happens lazily here. Idempotent per version.
    */
-  ensureArmed: () => Promise<void>;
+  ensureArmed: () => Promise<void>
   /** True when `file` is a discovered `'use server'` module (stub it on the client). */
-  isClientActionModule: (file: string) => boolean;
+  isClientActionModule: (file: string) => boolean
   /** Generate the client fetch-stub source for an action module file. */
-  stubSource: (file: string) => Promise<string>;
+  stubSource: (file: string) => Promise<string>
 }
 
-let bundler: ClientActionBundler | undefined;
+let bundler: ClientActionBundler | undefined
 
 /** Publish the compat client-action bundler (register-actions). */
 export function setClientActionBundler(next: ClientActionBundler): void {
-  bundler = next;
+  bundler = next
 }
 
 /** The compat client-action bundler, or undefined for a pure-core app. */
 export function getClientActionBundler(): ClientActionBundler | undefined {
-  return bundler;
+  return bundler
 }

package/src/dev/client-chunk-store.ts

@@ -5,17 +5,17 @@
 // duplicates to one inode while every generation dir keeps a normal-looking
 // path; eviction of one generation just drops its link, leaving the others
 // (and the store's own link) intact.
-import { createHash } from 'node:crypto';
-import { link, mkdir, readFile, readdir, rm, stat, unlink } from 'node:fs/promises';
-import path from 'node:path';
-import { listFiles } from '../utils/fs';
+import { createHash } from 'node:crypto'
+import { link, mkdir, readFile, readdir, rm, stat, unlink } from 'node:fs/promises'
+import path from 'node:path'
+import { listFiles } from '../utils/fs'
 
 export function clientChunkStoreDir(outPath: string) {
-  return path.join(outPath, 'cache', 'client-store');
+  return path.join(outPath, 'cache', 'client-store')
 }
 
 function contentHash(data: Buffer) {
-  return createHash('sha1').update(data).digest('hex');
+  return createHash('sha1').update(data).digest('hex')
 }
 
 /**
@@ -25,31 +25,31 @@ function contentHash(data: Buffer) {
  * file always ends up in place either way.
  */
 export async function contentAddressDir(dir: string, storeDir: string) {
-  await mkdir(storeDir, { recursive: true });
-  const files = await listFiles(dir);
-  await Promise.all(files.map(file => contentAddressFile(file, storeDir)));
+  await mkdir(storeDir, { recursive: true })
+  const files = await listFiles(dir)
+  await Promise.all(files.map(file => contentAddressFile(file, storeDir)))
 }
 
 async function contentAddressFile(file: string, storeDir: string) {
-  const data = await readFile(file);
-  const storePath = path.join(storeDir, `${contentHash(data)}${path.extname(file)}`);
+  const data = await readFile(file)
+  const storePath = path.join(storeDir, `${contentHash(data)}${path.extname(file)}`)
   if (!(await pathExists(storePath))) {
     // Claim the store slot from this file's own bytes: link first (cheap, same
     // device), and only fall back to a copy if that's impossible. Either way the
     // original file stays at `file` — nothing below needs to re-link it there.
     try {
-      await link(file, storePath);
-      return;
+      await link(file, storePath)
+      return
     } catch {
-      await copyFileFallback(file, storePath);
-      return;
+      await copyFileFallback(file, storePath)
+      return
     }
   }
   // Store already holds this content: swap the freshly-written file for a link
   // to the shared inode so duplicate bytes stop being duplicate on disk.
   try {
-    await unlink(file);
-    await link(storePath, file);
+    await unlink(file)
+    await link(storePath, file)
   } catch {
     // Cross-device or racing unlink: leave the original file in place, it is
     // already correct content, just not deduped this time.
@@ -58,8 +58,8 @@ async function contentAddressFile(file: string, storeDir: string) {
 
 async function copyFileFallback(file: string, storePath: string) {
   try {
-    const data = await readFile(file);
-    await Bun.write(storePath, data);
+    const data = await readFile(file)
+    await Bun.write(storePath, data)
   } catch {
     // Best-effort: dedup is an optimization, not a correctness requirement.
   }
@@ -68,7 +68,7 @@ async function copyFileFallback(file: string, storePath: string) {
 async function pathExists(target: string) {
   return stat(target)
     .then(() => true)
-    .catch(() => false);
+    .catch(() => false)
 }
 
 /**
@@ -76,17 +76,17 @@ async function pathExists(target: string) {
  * store's own hardlink is the only one left - every generation that once pointed at it has been evicted.
  */
 export async function sweepClientChunkStore(storeDir: string) {
-  let entries: string[];
+  let entries: string[]
   try {
-    entries = await readdir(storeDir);
+    entries = await readdir(storeDir)
   } catch {
-    return;
+    return
   }
   await Promise.allSettled(
     entries.map(async entry => {
-      const full = path.join(storeDir, entry);
-      const info = await stat(full).catch(() => null);
-      if (info && info.nlink <= 1) await rm(full, { force: true });
+      const full = path.join(storeDir, entry)
+      const info = await stat(full).catch(() => null)
+      if (info && info.nlink <= 1) await rm(full, { force: true })
     }),
-  );
+  )
 }