vinext 0.0.38 → 0.0.39

package/README.md

@@ -74,6 +74,16 @@ Options: `-p / --port <port>`, `-H / --hostname <host>`, `--turbopack` (accepted
 
 `vinext init` options: `--port <port>` (default: 3001), `--skip-check`, `--force`.
 
+If your `next.config.*` sets `output: "standalone"`, `vinext build` emits a self-hosting bundle at `dist/standalone/`. Start it with:
+
+```bash
+node dist/standalone/server.js
+```
+
+Environment variables: `PORT` (default `3000`), `HOST` (default `0.0.0.0`).
+
+> **Note:** Next.js standalone uses `HOSTNAME` for the bind address, but vinext uses `HOST` to avoid collision with the system-set `HOSTNAME` variable on Linux. Update your deployment config accordingly.
+
 ### Starting a new vinext project
 
 Run `npm create next-app@latest` to create a new Next.js project, and then follow these instructions to migrate it to vinext.
@@ -94,7 +104,7 @@ This will:
 2. Install `vite`, `@vitejs/plugin-react`, and App Router-only deps (`@vitejs/plugin-rsc`, `react-server-dom-webpack`) as devDependencies
 3. Rename CJS config files (e.g. `postcss.config.js` -> `.cjs`) to avoid ESM conflicts
 4. Add `"type": "module"` to `package.json`
-5. Add `dev:vinext` and `build:vinext` scripts to `package.json`
+5. Add `dev:vinext`, `build:vinext`, and `start:vinext` scripts to `package.json`
 6. Generate a minimal `vite.config.ts`
 
 The migration is non-destructive -- your existing Next.js setup continues to work alongside vinext. It does not modify `next.config`, `tsconfig.json`, or any source files, and it does not remove Next.js dependencies.
@@ -103,6 +113,8 @@ vinext targets Vite 8, which defaults to Rolldown, Oxc, Lightning CSS, and a new
 
 ```bash
 npm run dev:vinext    # Start the vinext dev server (port 3001)
+npm run build:vinext  # Build production output with vinext
+npm run start:vinext  # Start vinext production server
 npm run dev           # Still runs Next.js as before
 ```
 
@@ -458,25 +470,26 @@ Every `next/*` import is shimmed to a Vite-compatible implementation.
 
 ### Server features
 
-| Feature                            |     | Notes                                                                                       |
-| ---------------------------------- | --- | ------------------------------------------------------------------------------------------- |
-| SSR (Pages Router)                 | ✅  | Streaming, `_app`/`_document`, `__NEXT_DATA__`, hydration                                   |
-| SSR (App Router)                   | ✅  | RSC pipeline, nested layouts, streaming, nav context for client components                  |
-| `getStaticProps`                   | ✅  | Props, redirect, notFound, revalidate                                                       |
-| `getStaticPaths`                   | ✅  | `fallback: false`, `true`, `"blocking"`                                                     |
-| `getServerSideProps`               | ✅  | Full context including locale                                                               |
-| ISR                                | ✅  | Stale-while-revalidate, pluggable `CacheHandler`, background regeneration                   |
-| Server Actions (`"use server"`)    | ✅  | Action execution, FormData, re-render after mutation, `redirect()` in actions               |
-| React Server Components            | ✅  | Via `@vitejs/plugin-rsc`. `"use client"` boundaries work correctly                          |
-| Streaming SSR                      | ✅  | Both routers                                                                                |
-| Metadata API                       | ✅  | `metadata`, `generateMetadata`, `viewport`, `generateViewport`, title templates             |
-| `generateStaticParams`             | ✅  | With `dynamicParams` enforcement                                                            |
-| Metadata file routes               | ✅  | sitemap.xml, robots.txt, manifest, favicon, OG images (static + dynamic)                    |
-| Static export (`output: 'export'`) | ✅  | Generates static HTML/JSON for all routes                                                   |
-| `connection()`                     | ✅  | Forces dynamic rendering                                                                    |
-| `"use cache"` directive            | ✅  | File-level and function-level. `cacheLife()` profiles, `cacheTag()`, stale-while-revalidate |
-| `instrumentation.ts`               | ✅  | `register()` and `onRequestError()` callbacks                                               |
-| Route segment config               | 🟡  | `revalidate`, `dynamic`, `dynamicParams`. `runtime` and `preferredRegion` are ignored       |
+| Feature                                    |     | Notes                                                                                       |
+| ------------------------------------------ | --- | ------------------------------------------------------------------------------------------- |
+| SSR (Pages Router)                         | ✅  | Streaming, `_app`/`_document`, `__NEXT_DATA__`, hydration                                   |
+| SSR (App Router)                           | ✅  | RSC pipeline, nested layouts, streaming, nav context for client components                  |
+| `getStaticProps`                           | ✅  | Props, redirect, notFound, revalidate                                                       |
+| `getStaticPaths`                           | ✅  | `fallback: false`, `true`, `"blocking"`                                                     |
+| `getServerSideProps`                       | ✅  | Full context including locale                                                               |
+| ISR                                        | ✅  | Stale-while-revalidate, pluggable `CacheHandler`, background regeneration                   |
+| Server Actions (`"use server"`)            | ✅  | Action execution, FormData, re-render after mutation, `redirect()` in actions               |
+| React Server Components                    | ✅  | Via `@vitejs/plugin-rsc`. `"use client"` boundaries work correctly                          |
+| Streaming SSR                              | ✅  | Both routers                                                                                |
+| Metadata API                               | ✅  | `metadata`, `generateMetadata`, `viewport`, `generateViewport`, title templates             |
+| `generateStaticParams`                     | ✅  | With `dynamicParams` enforcement                                                            |
+| Metadata file routes                       | ✅  | sitemap.xml, robots.txt, manifest, favicon, OG images (static + dynamic)                    |
+| Static export (`output: 'export'`)         | ✅  | Generates static HTML/JSON for all routes                                                   |
+| Standalone output (`output: 'standalone'`) | ✅  | Generates `dist/standalone` with `server.js`, build artifacts, and runtime deps             |
+| `connection()`                             | ✅  | Forces dynamic rendering                                                                    |
+| `"use cache"` directive                    | ✅  | File-level and function-level. `cacheLife()` profiles, `cacheTag()`, stale-while-revalidate |
+| `instrumentation.ts`                       | ✅  | `register()` and `onRequestError()` callbacks                                               |
+| Route segment config                       | 🟡  | `revalidate`, `dynamic`, `dynamicParams`. `runtime` and `preferredRegion` are ignored       |
 
 ### Configuration
 

package/dist/build/nitro-route-rules.d.ts

@@ -0,0 +1,50 @@
+import { RouteRow } from "./report.js";
+
+//#region src/build/nitro-route-rules.d.ts
+type NitroRouteRuleConfig = Record<string, unknown> & {
+  swr?: boolean | number;
+  cache?: unknown;
+  static?: boolean;
+  isr?: boolean | number;
+  prerender?: boolean;
+};
+type NitroRouteRules = Record<string, {
+  swr: number;
+}>;
+/**
+ * Scans the filesystem for route files and generates Nitro `routeRules` for ISR routes.
+ *
+ * Note: this duplicates the filesystem scanning that `printBuildReport` also performs.
+ * The `nitro.setup` hook runs during Nitro initialization (before the build), while
+ * `printBuildReport` runs after the build, so sharing results is non-trivial. This is
+ * a future optimization target.
+ *
+ * Unlike `printBuildReport`, this path does not receive `prerenderResult`, so routes
+ * classified as `unknown` by static analysis (which `printBuildReport` might upgrade
+ * to `static` via speculative prerender) are skipped here.
+ */
+declare function collectNitroRouteRules(options: {
+  appDir?: string | null;
+  pagesDir?: string | null;
+  pageExtensions: string[];
+}): Promise<NitroRouteRules>;
+declare function generateNitroRouteRules(rows: RouteRow[]): NitroRouteRules;
+/**
+ * Converts vinext's internal `:param` route syntax to Nitro's rou3
+ * pattern format. Nitro uses `rou3` for routeRules matching, which
+ * supports `*` (single-segment) and `**` (multi-segment) wildcards.
+ *
+ *   /blog/:slug   -> /blog/*   (single segment)
+ *   /docs/:slug+  -> /docs/**  (one or more segments — catch-all)
+ *   /docs/:slug*  -> /docs/**  (zero or more segments — optional catch-all)
+ *   /about        -> /about    (unchanged)
+ *   /:a/:b produces `/*`/`/*` (consecutive single-segment params)
+ */
+declare function convertToNitroPattern(pattern: string): string;
+declare function mergeNitroRouteRules(existingRouteRules: Record<string, NitroRouteRuleConfig> | undefined, generatedRouteRules: NitroRouteRules): {
+  routeRules: Record<string, NitroRouteRuleConfig>;
+  skippedRoutes: string[];
+};
+//#endregion
+export { NitroRouteRuleConfig, NitroRouteRules, collectNitroRouteRules, convertToNitroPattern, generateNitroRouteRules, mergeNitroRouteRules };
+//# sourceMappingURL=nitro-route-rules.d.ts.map

package/dist/build/nitro-route-rules.js

@@ -0,0 +1,81 @@
+import { apiRouter, pagesRouter } from "../routing/pages-router.js";
+import { appRouter } from "../routing/app-router.js";
+import { buildReportRows } from "./report.js";
+//#region src/build/nitro-route-rules.ts
+/**
+* Scans the filesystem for route files and generates Nitro `routeRules` for ISR routes.
+*
+* Note: this duplicates the filesystem scanning that `printBuildReport` also performs.
+* The `nitro.setup` hook runs during Nitro initialization (before the build), while
+* `printBuildReport` runs after the build, so sharing results is non-trivial. This is
+* a future optimization target.
+*
+* Unlike `printBuildReport`, this path does not receive `prerenderResult`, so routes
+* classified as `unknown` by static analysis (which `printBuildReport` might upgrade
+* to `static` via speculative prerender) are skipped here.
+*/
+async function collectNitroRouteRules(options) {
+	const { appDir, pageExtensions, pagesDir } = options;
+	let appRoutes = [];
+	let pageRoutes = [];
+	let apiRoutes = [];
+	if (appDir) appRoutes = await appRouter(appDir, pageExtensions);
+	if (pagesDir) {
+		const [pages, apis] = await Promise.all([pagesRouter(pagesDir, pageExtensions), apiRouter(pagesDir, pageExtensions)]);
+		pageRoutes = pages;
+		apiRoutes = apis;
+	}
+	return generateNitroRouteRules(buildReportRows({
+		appRoutes,
+		pageRoutes,
+		apiRoutes
+	}));
+}
+function generateNitroRouteRules(rows) {
+	const rules = {};
+	for (const row of rows) if (row.type === "isr" && typeof row.revalidate === "number" && Number.isFinite(row.revalidate) && row.revalidate > 0) rules[convertToNitroPattern(row.pattern)] = { swr: row.revalidate };
+	return rules;
+}
+/**
+* Converts vinext's internal `:param` route syntax to Nitro's rou3
+* pattern format. Nitro uses `rou3` for routeRules matching, which
+* supports `*` (single-segment) and `**` (multi-segment) wildcards.
+*
+*   /blog/:slug   -> /blog/*   (single segment)
+*   /docs/:slug+  -> /docs/**  (one or more segments — catch-all)
+*   /docs/:slug*  -> /docs/**  (zero or more segments — optional catch-all)
+*   /about        -> /about    (unchanged)
+*   /:a/:b produces `/*`/`/*` (consecutive single-segment params)
+*/
+function convertToNitroPattern(pattern) {
+	return pattern.split("/").map((segment) => {
+		if (segment.startsWith(":")) return segment.endsWith("+") || segment.endsWith("*") ? "**" : "*";
+		return segment;
+	}).join("/");
+}
+function mergeNitroRouteRules(existingRouteRules, generatedRouteRules) {
+	const routeRules = { ...existingRouteRules };
+	const skippedRoutes = [];
+	for (const [route, generatedRule] of Object.entries(generatedRouteRules)) {
+		const existingRule = routeRules[route];
+		if (existingRule && hasUserDefinedCacheRule(existingRule)) {
+			skippedRoutes.push(route);
+			continue;
+		}
+		routeRules[route] = {
+			...existingRule,
+			...generatedRule
+		};
+	}
+	return {
+		routeRules,
+		skippedRoutes
+	};
+}
+function hasUserDefinedCacheRule(rule) {
+	return rule.swr !== void 0 || rule.cache !== void 0 || rule.static !== void 0 || rule.isr !== void 0 || rule.prerender !== void 0;
+}
+//#endregion
+export { collectNitroRouteRules, convertToNitroPattern, generateNitroRouteRules, mergeNitroRouteRules };
+
+//# sourceMappingURL=nitro-route-rules.js.map

package/dist/build/nitro-route-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nitro-route-rules.js","names":[],"sources":["../../src/build/nitro-route-rules.ts"],"sourcesContent":["import { appRouter, type AppRoute } from \"../routing/app-router.js\";\nimport { apiRouter, pagesRouter, type Route } from \"../routing/pages-router.js\";\nimport { buildReportRows, type RouteRow } from \"./report.js\";\n\n// Mirrors Nitro's NitroRouteConfig — hand-rolled because nitropack is not a direct dependency.\nexport type NitroRouteRuleConfig = Record<string, unknown> & {\n  swr?: boolean | number;\n  cache?: unknown;\n  static?: boolean;\n  isr?: boolean | number;\n  prerender?: boolean;\n};\n\nexport type NitroRouteRules = Record<string, { swr: number }>;\n\n/**\n * Scans the filesystem for route files and generates Nitro `routeRules` for ISR routes.\n *\n * Note: this duplicates the filesystem scanning that `printBuildReport` also performs.\n * The `nitro.setup` hook runs during Nitro initialization (before the build), while\n * `printBuildReport` runs after the build, so sharing results is non-trivial. This is\n * a future optimization target.\n *\n * Unlike `printBuildReport`, this path does not receive `prerenderResult`, so routes\n * classified as `unknown` by static analysis (which `printBuildReport` might upgrade\n * to `static` via speculative prerender) are skipped here.\n */\nexport async function collectNitroRouteRules(options: {\n  appDir?: string | null;\n  pagesDir?: string | null;\n  pageExtensions: string[];\n}): Promise<NitroRouteRules> {\n  const { appDir, pageExtensions, pagesDir } = options;\n\n  let appRoutes: AppRoute[] = [];\n  let pageRoutes: Route[] = [];\n  let apiRoutes: Route[] = [];\n\n  if (appDir) {\n    appRoutes = await appRouter(appDir, pageExtensions);\n  }\n\n  if (pagesDir) {\n    const [pages, apis] = await Promise.all([\n      pagesRouter(pagesDir, pageExtensions),\n      apiRouter(pagesDir, pageExtensions),\n    ]);\n    pageRoutes = pages;\n    apiRoutes = apis;\n  }\n\n  return generateNitroRouteRules(buildReportRows({ appRoutes, pageRoutes, apiRoutes }));\n}\n\nexport function generateNitroRouteRules(rows: RouteRow[]): NitroRouteRules {\n  const rules: NitroRouteRules = {};\n\n  for (const row of rows) {\n    if (\n      row.type === \"isr\" &&\n      typeof row.revalidate === \"number\" &&\n      Number.isFinite(row.revalidate) &&\n      row.revalidate > 0\n    ) {\n      rules[convertToNitroPattern(row.pattern)] = { swr: row.revalidate };\n    }\n  }\n\n  return rules;\n}\n\n/**\n * Converts vinext's internal `:param` route syntax to Nitro's rou3\n * pattern format. Nitro uses `rou3` for routeRules matching, which\n * supports `*` (single-segment) and `**` (multi-segment) wildcards.\n *\n *   /blog/:slug   -> /blog/*   (single segment)\n *   /docs/:slug+  -> /docs/**  (one or more segments — catch-all)\n *   /docs/:slug*  -> /docs/**  (zero or more segments — optional catch-all)\n *   /about        -> /about    (unchanged)\n *   /:a/:b produces `/*`/`/*` (consecutive single-segment params)\n */\nexport function convertToNitroPattern(pattern: string): string {\n  return pattern\n    .split(\"/\")\n    .map((segment) => {\n      if (segment.startsWith(\":\")) {\n        // Catch-all (:param+) and optional catch-all (:param*) match multiple segments → **\n        // Single dynamic param (:param) matches one segment → *\n        return segment.endsWith(\"+\") || segment.endsWith(\"*\") ? \"**\" : \"*\";\n      }\n      return segment;\n    })\n    .join(\"/\");\n}\n\nexport function mergeNitroRouteRules(\n  existingRouteRules: Record<string, NitroRouteRuleConfig> | undefined,\n  generatedRouteRules: NitroRouteRules,\n): {\n  routeRules: Record<string, NitroRouteRuleConfig>;\n  skippedRoutes: string[];\n} {\n  const routeRules = { ...existingRouteRules };\n  const skippedRoutes: string[] = [];\n\n  for (const [route, generatedRule] of Object.entries(generatedRouteRules)) {\n    const existingRule = routeRules[route];\n\n    if (existingRule && hasUserDefinedCacheRule(existingRule)) {\n      skippedRoutes.push(route);\n      continue;\n    }\n\n    routeRules[route] = {\n      ...existingRule,\n      ...generatedRule,\n    };\n  }\n\n  return { routeRules, skippedRoutes };\n}\n\nfunction hasUserDefinedCacheRule(rule: NitroRouteRuleConfig): boolean {\n  return (\n    rule.swr !== undefined ||\n    rule.cache !== undefined ||\n    rule.static !== undefined ||\n    rule.isr !== undefined ||\n    rule.prerender !== undefined\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA2BA,eAAsB,uBAAuB,SAIhB;CAC3B,MAAM,EAAE,QAAQ,gBAAgB,aAAa;CAE7C,IAAI,YAAwB,EAAE;CAC9B,IAAI,aAAsB,EAAE;CAC5B,IAAI,YAAqB,EAAE;AAE3B,KAAI,OACF,aAAY,MAAM,UAAU,QAAQ,eAAe;AAGrD,KAAI,UAAU;EACZ,MAAM,CAAC,OAAO,QAAQ,MAAM,QAAQ,IAAI,CACtC,YAAY,UAAU,eAAe,EACrC,UAAU,UAAU,eAAe,CACpC,CAAC;AACF,eAAa;AACb,cAAY;;AAGd,QAAO,wBAAwB,gBAAgB;EAAE;EAAW;EAAY;EAAW,CAAC,CAAC;;AAGvF,SAAgB,wBAAwB,MAAmC;CACzE,MAAM,QAAyB,EAAE;AAEjC,MAAK,MAAM,OAAO,KAChB,KACE,IAAI,SAAS,SACb,OAAO,IAAI,eAAe,YAC1B,OAAO,SAAS,IAAI,WAAW,IAC/B,IAAI,aAAa,EAEjB,OAAM,sBAAsB,IAAI,QAAQ,IAAI,EAAE,KAAK,IAAI,YAAY;AAIvE,QAAO;;;;;;;;;;;;;AAcT,SAAgB,sBAAsB,SAAyB;AAC7D,QAAO,QACJ,MAAM,IAAI,CACV,KAAK,YAAY;AAChB,MAAI,QAAQ,WAAW,IAAI,CAGzB,QAAO,QAAQ,SAAS,IAAI,IAAI,QAAQ,SAAS,IAAI,GAAG,OAAO;AAEjE,SAAO;GACP,CACD,KAAK,IAAI;;AAGd,SAAgB,qBACd,oBACA,qBAIA;CACA,MAAM,aAAa,EAAE,GAAG,oBAAoB;CAC5C,MAAM,gBAA0B,EAAE;AAElC,MAAK,MAAM,CAAC,OAAO,kBAAkB,OAAO,QAAQ,oBAAoB,EAAE;EACxE,MAAM,eAAe,WAAW;AAEhC,MAAI,gBAAgB,wBAAwB,aAAa,EAAE;AACzD,iBAAc,KAAK,MAAM;AACzB;;AAGF,aAAW,SAAS;GAClB,GAAG;GACH,GAAG;GACJ;;AAGH,QAAO;EAAE;EAAY;EAAe;;AAGtC,SAAS,wBAAwB,MAAqC;AACpE,QACE,KAAK,QAAQ,KAAA,KACb,KAAK,UAAU,KAAA,KACf,KAAK,WAAW,KAAA,KAChB,KAAK,QAAQ,KAAA,KACb,KAAK,cAAc,KAAA"}

package/dist/build/precompress.d.ts

@@ -0,0 +1,17 @@
+//#region src/build/precompress.d.ts
+type PrecompressResult = {
+  filesCompressed: number;
+  totalOriginalBytes: number; /** Sum of brotli-compressed sizes (used for compression ratio reporting). */
+  totalBrotliBytes: number;
+};
+/**
+ * Precompress all compressible hashed assets under `clientDir/assets/`.
+ *
+ * Writes `.br`, `.gz`, and `.zst` files alongside each original.
+ * Safe to re-run — overwrites existing compressed variants with identical
+ * output, and never compresses `.br`, `.gz`, or `.zst` files themselves.
+ */
+declare function precompressAssets(clientDir: string, onProgress?: (completed: number, total: number, file: string) => void): Promise<PrecompressResult>;
+//#endregion
+export { PrecompressResult, precompressAssets };
+//# sourceMappingURL=precompress.d.ts.map

package/dist/build/precompress.js

@@ -0,0 +1,102 @@
+import path from "node:path";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import zlib from "node:zlib";
+import { promisify } from "node:util";
+//#region src/build/precompress.ts
+/**
+* Build-time precompression for hashed static assets.
+*
+* Generates .br (brotli q5), .gz (gzip l8), and .zst (zstd l8) files
+* alongside compressible assets in dist/client/assets/. Served directly by
+* the production server — no per-request compression needed for immutable
+* build output.
+*
+* Only targets assets/ (hashed, immutable) — public directory files use
+* on-the-fly compression since they may change between deploys.
+*/
+const brotliCompress = promisify(zlib.brotliCompress);
+const gzip = promisify(zlib.gzip);
+const zstdCompress = typeof zlib.zstdCompress === "function" ? promisify(zlib.zstdCompress) : null;
+/** File extensions worth compressing (text-based, not already compressed). */
+const COMPRESSIBLE_EXTENSIONS = new Set([
+	".js",
+	".mjs",
+	".css",
+	".html",
+	".json",
+	".xml",
+	".svg",
+	".txt",
+	".map",
+	".wasm"
+]);
+/** Below this size, compression overhead exceeds savings. */
+const MIN_SIZE = 1024;
+/**
+* Past ~8 parallel files, mixed-size asset sets spend more time queueing zlib
+* work than making forward progress. Keep the batch size bounded even on
+* higher-core machines.
+*/
+const CONCURRENCY = Math.min(os.availableParallelism(), 8);
+/**
+* Walk a directory recursively, yielding relative paths for regular files.
+*/
+async function* walkFiles(dir, base = dir) {
+	let entries;
+	try {
+		entries = await fsp.readdir(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) yield* walkFiles(fullPath, base);
+		else if (entry.isFile()) yield path.relative(base, fullPath);
+	}
+}
+/**
+* Precompress all compressible hashed assets under `clientDir/assets/`.
+*
+* Writes `.br`, `.gz`, and `.zst` files alongside each original.
+* Safe to re-run — overwrites existing compressed variants with identical
+* output, and never compresses `.br`, `.gz`, or `.zst` files themselves.
+*/
+async function precompressAssets(clientDir, onProgress) {
+	const assetsDir = path.join(clientDir, "assets");
+	const result = {
+		filesCompressed: 0,
+		totalOriginalBytes: 0,
+		totalBrotliBytes: 0
+	};
+	const filePaths = [];
+	for await (const relativePath of walkFiles(assetsDir)) {
+		const ext = path.extname(relativePath).toLowerCase();
+		if (!COMPRESSIBLE_EXTENSIONS.has(ext)) continue;
+		filePaths.push(path.join(assetsDir, relativePath));
+	}
+	let processed = 0;
+	for (let i = 0; i < filePaths.length; i += CONCURRENCY) {
+		const chunk = filePaths.slice(i, i + CONCURRENCY);
+		await Promise.all(chunk.map(async (fullPath) => {
+			const content = await fsp.readFile(fullPath);
+			if (content.length < MIN_SIZE) return;
+			const compressions = [brotliCompress(content, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 5 } }), gzip(content, { level: 8 })];
+			if (zstdCompress) compressions.push(zstdCompress(content, { params: { [zlib.constants.ZSTD_c_compressionLevel]: 8 } }));
+			const [brContent, gzContent, zstdContent] = await Promise.all(compressions);
+			const writes = [fsp.writeFile(fullPath + ".br", brContent), fsp.writeFile(fullPath + ".gz", gzContent)];
+			if (zstdContent) writes.push(fsp.writeFile(fullPath + ".zst", zstdContent));
+			await Promise.all(writes);
+			result.filesCompressed++;
+			result.totalOriginalBytes += content.length;
+			result.totalBrotliBytes += brContent.length;
+		}));
+		processed += chunk.length;
+		onProgress?.(processed, filePaths.length, path.basename(chunk[chunk.length - 1]));
+	}
+	return result;
+}
+//#endregion
+export { precompressAssets };
+
+//# sourceMappingURL=precompress.js.map

package/dist/build/precompress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"precompress.js","names":[],"sources":["../../src/build/precompress.ts"],"sourcesContent":["/**\n * Build-time precompression for hashed static assets.\n *\n * Generates .br (brotli q5), .gz (gzip l8), and .zst (zstd l8) files\n * alongside compressible assets in dist/client/assets/. Served directly by\n * the production server — no per-request compression needed for immutable\n * build output.\n *\n * Only targets assets/ (hashed, immutable) — public directory files use\n * on-the-fly compression since they may change between deploys.\n */\nimport fsp from \"node:fs/promises\";\nimport os from \"node:os\";\nimport path from \"node:path\";\nimport zlib from \"node:zlib\";\nimport { promisify } from \"node:util\";\n\nconst brotliCompress = promisify(zlib.brotliCompress);\nconst gzip = promisify(zlib.gzip);\nconst zstdCompress = typeof zlib.zstdCompress === \"function\" ? promisify(zlib.zstdCompress) : null;\n\n/** File extensions worth compressing (text-based, not already compressed). */\nconst COMPRESSIBLE_EXTENSIONS = new Set([\n  \".js\",\n  \".mjs\",\n  \".css\",\n  \".html\",\n  \".json\",\n  \".xml\",\n  \".svg\",\n  \".txt\",\n  \".map\",\n  \".wasm\",\n]);\n\n/** Below this size, compression overhead exceeds savings. */\nconst MIN_SIZE = 1024;\n\n/**\n * Past ~8 parallel files, mixed-size asset sets spend more time queueing zlib\n * work than making forward progress. Keep the batch size bounded even on\n * higher-core machines.\n */\nconst CONCURRENCY = Math.min(os.availableParallelism(), 8);\n\nexport type PrecompressResult = {\n  filesCompressed: number;\n  totalOriginalBytes: number;\n  /** Sum of brotli-compressed sizes (used for compression ratio reporting). */\n  totalBrotliBytes: number;\n};\n\n/**\n * Walk a directory recursively, yielding relative paths for regular files.\n */\nasync function* walkFiles(dir: string, base: string = dir): AsyncGenerator<string> {\n  let entries;\n  try {\n    entries = await fsp.readdir(dir, { withFileTypes: true });\n  } catch {\n    return; // directory doesn't exist\n  }\n  for (const entry of entries) {\n    const fullPath = path.join(dir, entry.name);\n    if (entry.isDirectory()) {\n      yield* walkFiles(fullPath, base);\n    } else if (entry.isFile()) {\n      yield path.relative(base, fullPath);\n    }\n  }\n}\n\n/**\n * Precompress all compressible hashed assets under `clientDir/assets/`.\n *\n * Writes `.br`, `.gz`, and `.zst` files alongside each original.\n * Safe to re-run — overwrites existing compressed variants with identical\n * output, and never compresses `.br`, `.gz`, or `.zst` files themselves.\n */\nexport async function precompressAssets(\n  clientDir: string,\n  onProgress?: (completed: number, total: number, file: string) => void,\n): Promise<PrecompressResult> {\n  const assetsDir = path.join(clientDir, \"assets\");\n  const result: PrecompressResult = {\n    filesCompressed: 0,\n    totalOriginalBytes: 0,\n    totalBrotliBytes: 0,\n  };\n\n  // Collect compressible file paths, then read + compress in bounded chunks\n  // to keep peak memory at O(CONCURRENCY * max_file_size) instead of\n  // O(total_assets).\n  const filePaths: string[] = [];\n\n  for await (const relativePath of walkFiles(assetsDir)) {\n    const ext = path.extname(relativePath).toLowerCase();\n\n    if (!COMPRESSIBLE_EXTENSIONS.has(ext)) continue;\n    // .br/.gz/.zst are intentionally absent from COMPRESSIBLE_EXTENSIONS, so\n    // precompressed variants generated by a previous run are never re-compressed.\n\n    filePaths.push(path.join(assetsDir, relativePath));\n  }\n\n  let processed = 0;\n  for (let i = 0; i < filePaths.length; i += CONCURRENCY) {\n    const chunk = filePaths.slice(i, i + CONCURRENCY);\n    await Promise.all(\n      chunk.map(async (fullPath) => {\n        const content = await fsp.readFile(fullPath);\n        // readFile already done before this check — stat()-first would save\n        // the read for tiny files but costs an extra syscall per file;\n        // sub-1KB hashed assets are rare enough that read-first is cheaper.\n        if (content.length < MIN_SIZE) return;\n\n        // Compress all variants concurrently within each file\n        const compressions: Promise<Buffer>[] = [\n          brotliCompress(content, {\n            params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 5 },\n          }),\n          gzip(content, { level: 8 }),\n        ];\n        if (zstdCompress) {\n          compressions.push(\n            zstdCompress(content, {\n              params: { [zlib.constants.ZSTD_c_compressionLevel]: 8 },\n            }),\n          );\n        }\n\n        const results = await Promise.all(compressions);\n        const [brContent, gzContent, zstdContent] = results;\n\n        const writes = [\n          fsp.writeFile(fullPath + \".br\", brContent),\n          fsp.writeFile(fullPath + \".gz\", gzContent),\n        ];\n        if (zstdContent) {\n          writes.push(fsp.writeFile(fullPath + \".zst\", zstdContent));\n        }\n        await Promise.all(writes);\n\n        // Increment counters only after all writes succeed, so partial\n        // failures (e.g. ENOSPC mid-write) don't inflate the reported totals.\n        result.filesCompressed++;\n        result.totalOriginalBytes += content.length;\n        result.totalBrotliBytes += brContent.length;\n      }),\n    );\n    // Report progress once per chunk to avoid non-deterministic ordering\n    // within Promise.all (smaller files complete before larger ones).\n    // Progress tracks all files (including skipped ones below MIN_SIZE),\n    // which differs from filesCompressed (only files actually compressed).\n    processed += chunk.length;\n    onProgress?.(processed, filePaths.length, path.basename(chunk[chunk.length - 1]));\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,MAAM,iBAAiB,UAAU,KAAK,eAAe;AACrD,MAAM,OAAO,UAAU,KAAK,KAAK;AACjC,MAAM,eAAe,OAAO,KAAK,iBAAiB,aAAa,UAAU,KAAK,aAAa,GAAG;;AAG9F,MAAM,0BAA0B,IAAI,IAAI;CACtC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;AAGF,MAAM,WAAW;;;;;;AAOjB,MAAM,cAAc,KAAK,IAAI,GAAG,sBAAsB,EAAE,EAAE;;;;AAY1D,gBAAgB,UAAU,KAAa,OAAe,KAA6B;CACjF,IAAI;AACJ,KAAI;AACF,YAAU,MAAM,IAAI,QAAQ,KAAK,EAAE,eAAe,MAAM,CAAC;SACnD;AACN;;AAEF,MAAK,MAAM,SAAS,SAAS;EAC3B,MAAM,WAAW,KAAK,KAAK,KAAK,MAAM,KAAK;AAC3C,MAAI,MAAM,aAAa,CACrB,QAAO,UAAU,UAAU,KAAK;WACvB,MAAM,QAAQ,CACvB,OAAM,KAAK,SAAS,MAAM,SAAS;;;;;;;;;;AAYzC,eAAsB,kBACpB,WACA,YAC4B;CAC5B,MAAM,YAAY,KAAK,KAAK,WAAW,SAAS;CAChD,MAAM,SAA4B;EAChC,iBAAiB;EACjB,oBAAoB;EACpB,kBAAkB;EACnB;CAKD,MAAM,YAAsB,EAAE;AAE9B,YAAW,MAAM,gBAAgB,UAAU,UAAU,EAAE;EACrD,MAAM,MAAM,KAAK,QAAQ,aAAa,CAAC,aAAa;AAEpD,MAAI,CAAC,wBAAwB,IAAI,IAAI,CAAE;AAIvC,YAAU,KAAK,KAAK,KAAK,WAAW,aAAa,CAAC;;CAGpD,IAAI,YAAY;AAChB,MAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,aAAa;EACtD,MAAM,QAAQ,UAAU,MAAM,GAAG,IAAI,YAAY;AACjD,QAAM,QAAQ,IACZ,MAAM,IAAI,OAAO,aAAa;GAC5B,MAAM,UAAU,MAAM,IAAI,SAAS,SAAS;AAI5C,OAAI,QAAQ,SAAS,SAAU;GAG/B,MAAM,eAAkC,CACtC,eAAe,SAAS,EACtB,QAAQ,GAAG,KAAK,UAAU,uBAAuB,GAAG,EACrD,CAAC,EACF,KAAK,SAAS,EAAE,OAAO,GAAG,CAAC,CAC5B;AACD,OAAI,aACF,cAAa,KACX,aAAa,SAAS,EACpB,QAAQ,GAAG,KAAK,UAAU,0BAA0B,GAAG,EACxD,CAAC,CACH;GAIH,MAAM,CAAC,WAAW,WAAW,eADb,MAAM,QAAQ,IAAI,aAAa;GAG/C,MAAM,SAAS,CACb,IAAI,UAAU,WAAW,OAAO,UAAU,EAC1C,IAAI,UAAU,WAAW,OAAO,UAAU,CAC3C;AACD,OAAI,YACF,QAAO,KAAK,IAAI,UAAU,WAAW,QAAQ,YAAY,CAAC;AAE5D,SAAM,QAAQ,IAAI,OAAO;AAIzB,UAAO;AACP,UAAO,sBAAsB,QAAQ;AACrC,UAAO,oBAAoB,UAAU;IACrC,CACH;AAKD,eAAa,MAAM;AACnB,eAAa,WAAW,UAAU,QAAQ,KAAK,SAAS,MAAM,MAAM,SAAS,GAAG,CAAC;;AAGnF,QAAO"}

package/dist/build/prerender.d.ts

@@ -5,10 +5,9 @@ import { readPrerenderSecret } from "./server-manifest.js";
 import { Server } from "node:http";
 
 //#region src/build/prerender.d.ts
-interface PrerenderResult {
-  /** One entry per route (including skipped/error routes). */
-  routes: PrerenderRouteResult[];
-}
+type PrerenderResult = {
+  /** One entry per route (including skipped/error routes). */routes: PrerenderRouteResult[];
+};
 type PrerenderRouteResult = {
   /** The route's file-system pattern, e.g. `/blog/:slug`. */route: string;
   status: "rendered";
@@ -37,13 +36,12 @@ type PrerenderProgressCallback = (update: {
   route: string; /** Its final status. */
   status: PrerenderRouteResult["status"];
 }) => void;
-interface PrerenderOptions {
+type PrerenderOptions = {
   /**
    * 'default' — prerender static/ISR routes; skip SSR routes
    * 'export'  — same as default but SSR routes are errors
    */
-  mode: "default" | "export";
-  /** Output directory for generated HTML/RSC files. */
+  mode: "default" | "export"; /** Output directory for generated HTML/RSC files. */
   outDir: string;
   /**
    * Directory where `vinext-prerender.json` is written.
@@ -51,8 +49,7 @@ interface PrerenderOptions {
    * Set this when the manifest should land in a different location than the
    * generated HTML/RSC files (e.g. `dist/server/` while HTML goes to `dist/server/prerendered-routes/`).
    */
-  manifestDir?: string;
-  /** Resolved next.config.js. */
+  manifestDir?: string; /** Resolved next.config.js. */
   config: ResolvedNextConfig;
   /**
    * Maximum number of routes rendered in parallel.
@@ -70,13 +67,10 @@ interface PrerenderOptions {
    * multiple phases and write a single unified manifest itself.
    */
   skipManifest?: boolean;
-}
-interface PrerenderPagesOptions extends PrerenderOptions {
-  /** Discovered page routes (non-API). */
-  routes: Route[];
-  /** Discovered API routes. */
-  apiRoutes: Route[];
-  /** Pages directory path. */
+};
+type PrerenderPagesOptions = {
+  /** Discovered page routes (non-API). */routes: Route[]; /** Discovered API routes. */
+  apiRoutes: Route[]; /** Pages directory path. */
   pagesDir: string;
   /**
    * Absolute path to the pre-built Pages Router server bundle
@@ -86,15 +80,14 @@ interface PrerenderPagesOptions extends PrerenderOptions {
    * `runPrerender` passes a shared `_prodServer` instead.
    */
   pagesBundlePath?: string;
-}
-interface PrerenderAppOptions extends PrerenderOptions {
-  /** Discovered app routes. */
-  routes: AppRoute[];
+} & PrerenderOptions;
+type PrerenderAppOptions = {
+  /** Discovered app routes. */routes: AppRoute[];
   /**
    * Absolute path to the pre-built RSC handler bundle (e.g. `dist/server/index.js`).
    */
   rscBundlePath: string;
-}
+} & PrerenderOptions;
 type PrerenderPagesOptionsInternal = PrerenderPagesOptions & {
   _prodServer?: {
     server: Server;
@@ -124,6 +117,18 @@ declare function buildUrlFromParams(pattern: string, params: Record<string, stri
  * Respects trailingSlash config.
  */
 declare function getOutputPath(urlPath: string, trailingSlash: boolean): string;
+/** Map of route patterns to generateStaticParams functions (or null/undefined). */
+type StaticParamsMap = Record<string, ((opts: {
+  params: Record<string, string | string[]>;
+}) => Promise<Record<string, string | string[]>[]>) | null | undefined>;
+/**
+ * Resolve parent dynamic segment params for a route.
+ * Handles top-down generateStaticParams resolution for nested dynamic routes.
+ *
+ * Uses the `staticParamsMap` (pattern → generateStaticParams) exported from
+ * the production bundle.
+ */
+declare function resolveParentParams(childRoute: AppRoute, routeIndex: ReadonlyMap<string, AppRoute>, staticParamsMap: StaticParamsMap): Promise<Record<string, string | string[]>[]>;
 /**
  * Run the prerender phase for Pages Router.
  *
@@ -189,5 +194,5 @@ declare function writePrerenderIndex(routes: PrerenderRouteResult[], outDir: str
   trailingSlash?: boolean;
 }): void;
 //#endregion
-export { PrerenderAppOptions, PrerenderOptions, PrerenderPagesOptions, PrerenderProgressCallback, PrerenderResult, PrerenderRouteResult, buildUrlFromParams, getOutputPath, getRscOutputPath, prerenderApp, prerenderPages, readPrerenderSecret, writePrerenderIndex };
+export { PrerenderAppOptions, PrerenderOptions, PrerenderPagesOptions, PrerenderProgressCallback, PrerenderResult, PrerenderRouteResult, StaticParamsMap, buildUrlFromParams, getOutputPath, getRscOutputPath, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };
 //# sourceMappingURL=prerender.d.ts.map

package/dist/build/prerender.js

@@ -86,31 +86,30 @@ function getOutputPath(urlPath, trailingSlash) {
 * Uses the `staticParamsMap` (pattern → generateStaticParams) exported from
 * the production bundle.
 */
-async function resolveParentParams(childRoute, allRoutes, staticParamsMap) {
-	const patternParts = childRoute.pattern.split("/").filter(Boolean);
+async function resolveParentParams(childRoute, routeIndex, staticParamsMap) {
+	const { patternParts } = childRoute;
+	let lastDynamicIdx = -1;
+	for (let i = patternParts.length - 1; i >= 0; i--) if (patternParts[i].startsWith(":")) {
+		lastDynamicIdx = i;
+		break;
+	}
 	const parentSegments = [];
-	for (let i = 0; i < patternParts.length; i++) {
+	let prefixPattern = "";
+	for (let i = 0; i < lastDynamicIdx; i++) {
 		const part = patternParts[i];
+		prefixPattern += "/" + part;
 		if (!part.startsWith(":")) continue;
-		if (!patternParts.slice(i + 1).some((p) => p.startsWith(":"))) break;
-		const prefixPattern = "/" + patternParts.slice(0, i + 1).join("/");
-		if (allRoutes.find((r) => r.pattern === prefixPattern)?.pagePath) {
+		if (routeIndex.get(prefixPattern)?.pagePath) {
 			const fn = staticParamsMap[prefixPattern];
-			if (typeof fn === "function") {
-				const paramName = part.replace(/^:/, "").replace(/[+*]$/, "");
-				parentSegments.push({
-					params: [paramName],
-					generateStaticParams: fn
-				});
-			}
+			if (typeof fn === "function") parentSegments.push(fn);
 		}
 	}
 	if (parentSegments.length === 0) return [];
 	let currentParams = [{}];
-	for (const segment of parentSegments) {
+	for (const generateStaticParams of parentSegments) {
 		const nextParams = [];
 		for (const parentParams of currentParams) {
-			const results = await segment.generateStaticParams({ params: parentParams });
+			const results = await generateStaticParams({ params: parentParams });
 			if (Array.isArray(results)) for (const result of results) nextParams.push({
 				...parentParams,
 				...result
@@ -414,6 +413,7 @@ async function prerenderApp({ routes, outDir, config, mode, rscBundlePath, ...op
 				return false;
 			}
 		});
+		const routeIndex = new Map(routes.map((r) => [r.pattern, r]));
 		const urlsToRender = [];
 		for (const route of routes) {
 			if (route.routePath && !route.pagePath) {
@@ -463,7 +463,7 @@ async function prerenderApp({ routes, outDir, config, mode, rscBundlePath, ...op
 					});
 					continue;
 				}
-				const parentParamSets = await resolveParentParams(route, routes, staticParamsMap);
+				const parentParamSets = await resolveParentParams(route, routeIndex, staticParamsMap);
 				let paramSets;
 				if (parentParamSets.length > 0) {
 					paramSets = [];
@@ -688,6 +688,6 @@ function writePrerenderIndex(routes, outDir, options) {
 	fs.writeFileSync(path.join(outDir, "vinext-prerender.json"), JSON.stringify(index, null, 2), "utf-8");
 }
 //#endregion
-export { buildUrlFromParams, getOutputPath, getRscOutputPath, prerenderApp, prerenderPages, readPrerenderSecret, writePrerenderIndex };
+export { buildUrlFromParams, getOutputPath, getRscOutputPath, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };
 
 //# sourceMappingURL=prerender.js.map