@qzsy/vinext 0.1.7

package/dist/build/google-fonts/font-metadata.d.ts

@@ -0,0 +1,16 @@
+//#region src/build/google-fonts/font-metadata.d.ts
+type VariableAxisDescriptor = {
+  tag: string;
+  min: number;
+  max: number;
+  defaultValue: number;
+};
+type FontFamilyMetadata = {
+  /** Available weight values, plus the literal "variable" if a variable face exists. */weights: string[]; /** Available styles, e.g. ["normal"], ["italic"], or both. */
+  styles: string[]; /** Variable axes for this family. Absent when the family has no variable face. */
+  axes?: VariableAxisDescriptor[]; /** Preloadable subsets (e.g. "latin", "latin-ext", "vietnamese"). */
+  subsets: string[];
+};
+declare const googleFontsMetadata: Record<string, FontFamilyMetadata>;
+//#endregion
+export { googleFontsMetadata };

package/dist/build/google-fonts/font-metadata.js

@@ -0,0 +1,5 @@
+import font_data_default from "./font-data.js";
+//#region src/build/google-fonts/font-metadata.ts
+const googleFontsMetadata = font_data_default;
+//#endregion
+export { googleFontsMetadata };

package/dist/build/google-fonts/get-axes.d.ts

@@ -0,0 +1,6 @@
+import { FontAxes } from "./build-url.js";
+
+//#region src/build/google-fonts/get-axes.d.ts
+declare function getFontAxes(fontFamily: string, weights: string[], styles: string[], selectedVariableAxes?: string[]): FontAxes;
+//#endregion
+export { getFontAxes };

package/dist/build/google-fonts/get-axes.js

@@ -0,0 +1,37 @@
+import { googleFontsMetadata } from "./font-metadata.js";
+//#region src/build/google-fonts/get-axes.ts
+const formatAvailableValues = (values) => values.map((val) => `\`${val}\``).join(", ");
+function getFontAxes(fontFamily, weights, styles, selectedVariableAxes) {
+	const hasItalic = styles.includes("italic");
+	const hasNormal = styles.includes("normal");
+	const ital = hasItalic ? [...hasNormal ? ["0"] : [], "1"] : void 0;
+	if (weights[0] === "variable") {
+		const allAxes = googleFontsMetadata[fontFamily].axes;
+		if (!allAxes) throw new Error("invariant variable font without axes");
+		if (selectedVariableAxes) {
+			const definableAxes = allAxes.map(({ tag }) => tag).filter((tag) => tag !== "wght");
+			if (definableAxes.length === 0) throw new Error(`Font \`${fontFamily}\` has no definable \`axes\``);
+			if (!Array.isArray(selectedVariableAxes)) throw new Error(`Invalid axes value for font \`${fontFamily}\`, expected an array of axes.\nAvailable axes: ${formatAvailableValues(definableAxes)}`);
+			for (const key of selectedVariableAxes) if (!definableAxes.includes(key)) throw new Error(`Invalid axes value \`${key}\` for font \`${fontFamily}\`.\nAvailable axes: ${formatAvailableValues(definableAxes)}`);
+		}
+		let weightAxis;
+		let variableAxes;
+		for (const { tag, min, max } of allAxes) if (tag === "wght") weightAxis = `${min}..${max}`;
+		else if (selectedVariableAxes?.includes(tag)) {
+			if (!variableAxes) variableAxes = [];
+			variableAxes.push([tag, `${min}..${max}`]);
+		}
+		return {
+			wght: weightAxis ? [weightAxis] : void 0,
+			ital,
+			variableAxes
+		};
+	}
+	return {
+		wght: weights,
+		ital,
+		variableAxes: void 0
+	};
+}
+//#endregion
+export { getFontAxes };

package/dist/build/google-fonts/sort-variants.d.ts

@@ -0,0 +1,4 @@
+//#region src/build/google-fonts/sort-variants.d.ts
+declare function sortFontsVariantValues(valA: string, valB: string): number;
+//#endregion
+export { sortFontsVariantValues };

package/dist/build/google-fonts/sort-variants.js

@@ -0,0 +1,12 @@
+//#region src/build/google-fonts/sort-variants.ts
+function sortFontsVariantValues(valA, valB) {
+	if (valA.includes(",") && valB.includes(",")) {
+		const [aPrefix, aSuffix] = valA.split(",", 2);
+		const [bPrefix, bSuffix] = valB.split(",", 2);
+		if (aPrefix === bPrefix) return parseInt(aSuffix) - parseInt(bSuffix);
+		return parseInt(aPrefix) - parseInt(bPrefix);
+	}
+	return parseInt(valA) - parseInt(valB);
+}
+//#endregion
+export { sortFontsVariantValues };

package/dist/build/google-fonts/validate.d.ts

@@ -0,0 +1,27 @@
+//#region src/build/google-fonts/validate.d.ts
+type GoogleFontOptions = {
+  weight?: string | string[];
+  style?: string | string[];
+  preload?: boolean;
+  display?: string;
+  axes?: string[];
+  fallback?: string[];
+  adjustFontFallback?: boolean;
+  variable?: string;
+  subsets?: string[];
+};
+type ValidatedGoogleFontOptions = {
+  fontFamily: string;
+  weights: string[];
+  styles: string[];
+  display: string;
+  preload: boolean;
+  selectedVariableAxes?: string[];
+  fallback?: string[];
+  adjustFontFallback: boolean;
+  variable?: string;
+  subsets: string[];
+};
+declare function validateGoogleFontOptions(fontFamily: string, options: GoogleFontOptions): ValidatedGoogleFontOptions;
+//#endregion
+export { validateGoogleFontOptions };

package/dist/build/google-fonts/validate.js

@@ -0,0 +1,54 @@
+import { googleFontsMetadata } from "./font-metadata.js";
+//#region src/build/google-fonts/validate.ts
+const ALLOWED_DISPLAY_VALUES = [
+	"auto",
+	"block",
+	"swap",
+	"fallback",
+	"optional"
+];
+const formatAvailableValues = (values) => values.map((val) => `\`${val}\``).join(", ");
+const dedupe = (values) => Array.from(new Set(values));
+function validateGoogleFontOptions(fontFamily, options) {
+	const { weight, style, display = "swap", axes, fallback, adjustFontFallback = true, variable, subsets = [] } = options;
+	let preload = options.preload ?? true;
+	const fontFamilyData = googleFontsMetadata[fontFamily];
+	if (!fontFamilyData) throw new Error(`Unknown font \`${fontFamily}\``);
+	if (axes !== void 0 && !Array.isArray(axes)) throw new Error(`Invalid axes value for font \`${fontFamily}\`, expected an array of axis names.`);
+	const availableSubsets = fontFamilyData.subsets;
+	if (availableSubsets.length === 0) preload = false;
+	else if (preload) {
+		if (subsets.length === 0) throw new Error(`Preload is enabled but no subsets were specified for font \`${fontFamily}\`. Please specify subsets or disable preloading if your intended subset can't be preloaded.\nAvailable subsets: ${formatAvailableValues(availableSubsets)}`);
+		for (const subset of subsets) if (!availableSubsets.includes(subset)) throw new Error(`Unknown subset \`${subset}\` for font \`${fontFamily}\`.\nAvailable subsets: ${formatAvailableValues(availableSubsets)}`);
+	}
+	const fontWeights = fontFamilyData.weights;
+	const fontStyles = fontFamilyData.styles;
+	const weights = !weight ? [] : dedupe(Array.isArray(weight) ? weight : [weight]);
+	const styles = !style ? [] : dedupe(Array.isArray(style) ? style : [style]);
+	if (weights.length === 0) if (fontWeights.includes("variable")) weights.push("variable");
+	else throw new Error(`Missing weight for font \`${fontFamily}\`.\nAvailable weights: ${formatAvailableValues(fontWeights)}`);
+	if (weights.length > 1 && weights.includes("variable")) throw new Error(`Unexpected \`variable\` in weight array for font \`${fontFamily}\`. You only need \`variable\`, it includes all available weights.`);
+	for (const selectedWeight of weights) if (!fontWeights.includes(selectedWeight)) throw new Error(`Unknown weight \`${selectedWeight}\` for font \`${fontFamily}\`.\nAvailable weights: ${formatAvailableValues(fontWeights)}`);
+	if (styles.length === 0) if (fontStyles.length === 1) styles.push(fontStyles[0]);
+	else styles.push("normal");
+	for (const selectedStyle of styles) if (!fontStyles.includes(selectedStyle)) throw new Error(`Unknown style \`${selectedStyle}\` for font \`${fontFamily}\`.\nAvailable styles: ${formatAvailableValues(fontStyles)}`);
+	if (!ALLOWED_DISPLAY_VALUES.includes(display)) throw new Error(`Invalid display value \`${display}\` for font \`${fontFamily}\`.\nAvailable display values: ${formatAvailableValues(ALLOWED_DISPLAY_VALUES)}`);
+	if (axes) {
+		if (!fontWeights.includes("variable")) throw new Error("Axes can only be defined for variable fonts.");
+		if (weights[0] !== "variable") throw new Error("Axes can only be defined for variable fonts when the weight property is nonexistent or set to `variable`.");
+	}
+	return {
+		fontFamily,
+		weights,
+		styles,
+		display,
+		preload,
+		selectedVariableAxes: axes,
+		fallback,
+		adjustFontFallback,
+		variable,
+		subsets
+	};
+}
+//#endregion
+export { validateGoogleFontOptions };

package/dist/build/inline-css.d.ts

@@ -0,0 +1,6 @@
+//#region src/build/inline-css.d.ts
+type InlineCssManifest = Record<string, string>;
+declare function collectInlineCssManifest(clientDir: string, assetPrefix: string): InlineCssManifest;
+declare function injectInlineCssManifestGlobal(entryPath: string, manifest: InlineCssManifest): boolean;
+//#endregion
+export { collectInlineCssManifest, injectInlineCssManifestGlobal };

package/dist/build/inline-css.js

@@ -0,0 +1,48 @@
+import { resolveAssetUrlPrefix, resolveAssetsDir } from "../utils/asset-prefix.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/build/inline-css.ts
+const INLINE_CSS_GLOBAL_MARKER = "globalThis.__VINEXT_INLINE_CSS__ = ";
+function collectCssFiles(directory) {
+	const files = [];
+	for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+		const filePath = path.join(directory, entry.name);
+		if (entry.isDirectory()) files.push(...collectCssFiles(filePath));
+		else if (entry.isFile() && entry.name.endsWith(".css")) files.push(filePath);
+	}
+	return files;
+}
+function toUrlPath(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+function addPathnameAlias(manifest, href, css) {
+	try {
+		const url = new URL(href);
+		manifest[url.pathname] = css;
+	} catch {}
+}
+function collectInlineCssManifest(clientDir, assetPrefix) {
+	const assetsDir = path.join(clientDir, resolveAssetsDir(assetPrefix));
+	if (!fs.existsSync(assetsDir)) return {};
+	const urlPrefix = resolveAssetUrlPrefix(assetPrefix);
+	const manifest = {};
+	for (const filePath of collectCssFiles(assetsDir)) {
+		const href = `${urlPrefix}${toUrlPath(path.relative(assetsDir, filePath))}`;
+		const css = fs.readFileSync(filePath, "utf8");
+		manifest[href] = css;
+		addPathnameAlias(manifest, href, css);
+	}
+	return manifest;
+}
+function createInlineCssManifestGlobalCode(manifest) {
+	return `${INLINE_CSS_GLOBAL_MARKER}${JSON.stringify(manifest)};`;
+}
+function injectInlineCssManifestGlobal(entryPath, manifest) {
+	if (Object.keys(manifest).length === 0 || !fs.existsSync(entryPath)) return false;
+	const code = fs.readFileSync(entryPath, "utf8");
+	if (code.includes(INLINE_CSS_GLOBAL_MARKER)) return false;
+	fs.writeFileSync(entryPath, `${createInlineCssManifestGlobalCode(manifest)}\n${code}`);
+	return true;
+}
+//#endregion
+export { collectInlineCssManifest, injectInlineCssManifestGlobal };

package/dist/build/layout-classification-types.d.ts

@@ -0,0 +1,61 @@
+//#region src/build/layout-classification-types.d.ts
+/**
+ * Shared types for the layout classification pipeline.
+ *
+ * Kept in a leaf module so both `report.ts` (which implements segment-config
+ * classification) and `layout-classification.ts` (which composes the full
+ * pipeline) can import them without forming a cycle.
+ *
+ * The wire contract between build and runtime is intentionally narrow: the
+ * runtime only cares about the `"static" | "dynamic"` decision for a layout.
+ * Reasons live in a sidecar structure so operators can trace how each
+ * decision was made without bloating the hot-path payload.
+ */
+/**
+ * Structured record of which classifier layer produced a decision and what
+ * evidence it used. Kept as a discriminated union so each layer can carry
+ * its own diagnostic shape without the consumer having to fall back to
+ * stringly-typed `reason` fields.
+ */
+type ClassificationReason = {
+  layer: "segment-config";
+  key: "dynamic" | "revalidate";
+  value: string | number;
+} | {
+  layer: "module-graph";
+  result: "static" | "needs-probe";
+  firstShimMatch?: string;
+} | {
+  layer: "runtime-probe";
+  outcome: "static" | "dynamic";
+  error?: string;
+} | {
+  layer: "no-classifier";
+};
+type ModuleGraphStaticReason = {
+  layer: "module-graph";
+  result: "static";
+  firstShimMatch?: string;
+};
+/**
+ * Build-time classification outcome for a single layout. Tagged with `kind`
+ * so callers can branch exhaustively and carry diagnostic reasons alongside
+ * the decision.
+ *
+ * `absent` means no classifier layer had anything to say — the caller should
+ * defer to the next layer (or to the runtime probe).
+ */
+type LayoutBuildClassification = {
+  kind: "absent";
+} | {
+  kind: "static";
+  reason: ClassificationReason;
+} | {
+  kind: "dynamic";
+  reason: ClassificationReason;
+} | {
+  kind: "needs-probe";
+  reason: ClassificationReason;
+};
+//#endregion
+export { ClassificationReason, LayoutBuildClassification, ModuleGraphStaticReason };

package/dist/build/layout-classification-types.js

@@ -0,0 +1 @@
+export {};

package/dist/build/layout-classification.d.ts

@@ -0,0 +1,59 @@
+import { ClassificationReason, LayoutBuildClassification, ModuleGraphStaticReason } from "./layout-classification-types.js";
+
+//#region src/build/layout-classification.d.ts
+type ModuleGraphClassification = "static" | "needs-probe";
+type ModuleGraphClassificationResult = {
+  result: ModuleGraphClassification; /** First dynamic shim module ID encountered during BFS, when any. */
+  firstShimMatch?: string;
+};
+type ModuleInfoProvider = {
+  getModuleInfo(id: string): {
+    importedIds: string[];
+    dynamicImportedIds: string[];
+  } | null;
+};
+type LayoutEntry = {
+  /** Rollup/Vite module ID for the layout file. */moduleId: string; /** Directory depth from the app root, used to build the stable layout ID. */
+  treePosition: number; /** Segment config source code extracted at build time, or null when absent. */
+  segmentConfig?: {
+    code: string;
+  } | null;
+};
+type RouteForClassification = {
+  layouts: readonly LayoutEntry[];
+  routeSegments: string[];
+};
+/**
+ * BFS traversal of a layout's dependency tree. If any transitive import
+ * resolves to a dynamic shim path (headers, cache, server), the layout
+ * cannot be proven static at build time and needs a runtime probe.
+ *
+ * The returned object carries the classification plus the first matching
+ * shim module ID (when any). Operators use the shim ID via the debug
+ * channel to trace why a layout was flagged for probing.
+ */
+declare function classifyLayoutByModuleGraph(layoutModuleId: string, dynamicShimPaths: ReadonlySet<string>, moduleInfo: ModuleInfoProvider): ModuleGraphClassificationResult;
+declare function moduleGraphReason(graphResult: ModuleGraphClassificationResult & {
+  result: "static";
+}): ModuleGraphStaticReason;
+declare function moduleGraphReason(graphResult: ModuleGraphClassificationResult): ClassificationReason;
+declare function isStaticModuleGraphResult(graphResult: ModuleGraphClassificationResult): graphResult is ModuleGraphClassificationResult & {
+  result: "static";
+};
+/**
+ * Classifies all layouts across all routes using a two-layer strategy:
+ *
+ * 1. Segment config (Layer 1) — short-circuits to "static" or "dynamic"
+ * 2. Module graph (Layer 2) — BFS for dynamic shim imports → "static" or "needs-probe"
+ *
+ * Shared layouts (same file appearing in multiple routes) are classified once
+ * and deduplicated by layout ID.
+ *
+ * @internal Not called by production code. The `renderChunk` hook in
+ * `index.ts` calls `classifyLayoutByModuleGraph` directly and composes
+ * via the numeric-index manifest in `route-classification-manifest.ts`.
+ * Used only by `tests/layout-classification.test.ts`.
+ */
+declare function classifyAllRouteLayouts(routes: readonly RouteForClassification[], dynamicShimPaths: ReadonlySet<string>, moduleInfo: ModuleInfoProvider): Map<string, LayoutBuildClassification>;
+//#endregion
+export { ModuleInfoProvider, classifyAllRouteLayouts, classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason };

package/dist/build/layout-classification.js

@@ -0,0 +1,98 @@
+import { AppElementsWire } from "../server/app-elements-wire.js";
+import "../server/app-elements.js";
+import { classifyLayoutSegmentConfig } from "./report.js";
+import { createAppPageTreePath } from "../server/app-page-route-wiring.js";
+//#region src/build/layout-classification.ts
+/**
+* Layout classification — determines whether each layout in an App Router
+* route tree is static or dynamic via two complementary detection layers:
+*
+*   Layer 1: Segment config (`export const dynamic`, `export const revalidate`)
+*   Layer 2: Module graph traversal (checks for transitive dynamic shim imports)
+*
+* Layer 3 (probe-based runtime detection) is handled separately in
+* `app-page-execution.ts` at request time.
+*
+* Every result is carried as a `LayoutBuildClassification` tagged variant so
+* operators can trace which layer produced a decision via the structured
+* `ClassificationReason` sidecar without that metadata leaking onto the wire.
+*/
+/**
+* BFS traversal of a layout's dependency tree. If any transitive import
+* resolves to a dynamic shim path (headers, cache, server), the layout
+* cannot be proven static at build time and needs a runtime probe.
+*
+* The returned object carries the classification plus the first matching
+* shim module ID (when any). Operators use the shim ID via the debug
+* channel to trace why a layout was flagged for probing.
+*/
+function classifyLayoutByModuleGraph(layoutModuleId, dynamicShimPaths, moduleInfo) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [layoutModuleId];
+	let head = 0;
+	while (head < queue.length) {
+		const currentId = queue[head++];
+		if (visited.has(currentId)) continue;
+		visited.add(currentId);
+		if (dynamicShimPaths.has(currentId)) return {
+			result: "needs-probe",
+			firstShimMatch: currentId
+		};
+		const info = moduleInfo.getModuleInfo(currentId);
+		if (!info) continue;
+		for (const importedId of info.importedIds) if (!visited.has(importedId)) queue.push(importedId);
+		for (const dynamicId of info.dynamicImportedIds) if (!visited.has(dynamicId)) queue.push(dynamicId);
+	}
+	return { result: "static" };
+}
+function moduleGraphReason(graphResult) {
+	if (graphResult.firstShimMatch === void 0) return {
+		layer: "module-graph",
+		result: graphResult.result
+	};
+	return {
+		layer: "module-graph",
+		result: graphResult.result,
+		firstShimMatch: graphResult.firstShimMatch
+	};
+}
+function isStaticModuleGraphResult(graphResult) {
+	return graphResult.result === "static";
+}
+/**
+* Classifies all layouts across all routes using a two-layer strategy:
+*
+* 1. Segment config (Layer 1) — short-circuits to "static" or "dynamic"
+* 2. Module graph (Layer 2) — BFS for dynamic shim imports → "static" or "needs-probe"
+*
+* Shared layouts (same file appearing in multiple routes) are classified once
+* and deduplicated by layout ID.
+*
+* @internal Not called by production code. The `renderChunk` hook in
+* `index.ts` calls `classifyLayoutByModuleGraph` directly and composes
+* via the numeric-index manifest in `route-classification-manifest.ts`.
+* Used only by `tests/layout-classification.test.ts`.
+*/
+function classifyAllRouteLayouts(routes, dynamicShimPaths, moduleInfo) {
+	const result = /* @__PURE__ */ new Map();
+	for (const route of routes) for (const layout of route.layouts) {
+		const layoutId = AppElementsWire.encodeLayoutId(createAppPageTreePath(route.routeSegments, layout.treePosition));
+		if (result.has(layoutId)) continue;
+		if (layout.segmentConfig) {
+			const configResult = classifyLayoutSegmentConfig(layout.segmentConfig.code);
+			if (configResult.kind !== "absent") {
+				result.set(layoutId, configResult);
+				continue;
+			}
+		}
+		const graphResult = classifyLayoutByModuleGraph(layout.moduleId, dynamicShimPaths, moduleInfo);
+		const reason = moduleGraphReason(graphResult);
+		result.set(layoutId, {
+			kind: graphResult.result,
+			reason
+		});
+	}
+	return result;
+}
+//#endregion
+export { classifyAllRouteLayouts, classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason };

package/dist/build/next-client-runtime-manifests.d.ts

@@ -0,0 +1,14 @@
+import { ResolvedNextConfig } from "../config/next-config.js";
+
+//#region src/build/next-client-runtime-manifests.d.ts
+type EmitNextClientRuntimeManifestsOptions = {
+  clientDir: string;
+  assetsSubdir: string;
+  buildId: string;
+  rewrites: ResolvedNextConfig["rewrites"];
+};
+declare function buildNextClientBuildManifestContent(rewrites: ResolvedNextConfig["rewrites"]): string;
+declare function buildNextClientSsgManifestContent(): string;
+declare function emitNextClientRuntimeManifests(options: EmitNextClientRuntimeManifestsOptions): void;
+//#endregion
+export { buildNextClientBuildManifestContent, buildNextClientSsgManifestContent, emitNextClientRuntimeManifests };

package/dist/build/next-client-runtime-manifests.js

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/build/next-client-runtime-manifests.ts
+function normalizeRewriteForClientManifest(rewrite) {
+	if (rewrite.destination.startsWith("/")) return {
+		has: rewrite.has,
+		source: rewrite.source,
+		destination: rewrite.destination
+	};
+	return {
+		has: rewrite.has,
+		source: rewrite.source
+	};
+}
+function normalizeRewritesForClientManifest(rewrites) {
+	return {
+		beforeFiles: rewrites.beforeFiles.map(normalizeRewriteForClientManifest),
+		afterFiles: rewrites.afterFiles.map(normalizeRewriteForClientManifest),
+		fallback: rewrites.fallback.map(normalizeRewriteForClientManifest)
+	};
+}
+function buildNextClientBuildManifestContent(rewrites) {
+	const manifest = {
+		__rewrites: normalizeRewritesForClientManifest(rewrites),
+		sortedPages: []
+	};
+	return `self.__BUILD_MANIFEST = ${JSON.stringify(manifest)};self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB()`;
+}
+function buildNextClientSsgManifestContent() {
+	return "self.__SSG_MANIFEST=new Set;self.__SSG_MANIFEST_CB&&self.__SSG_MANIFEST_CB()";
+}
+function emitNextClientRuntimeManifests(options) {
+	const manifestDir = path.join(options.clientDir, options.assetsSubdir, options.buildId);
+	fs.mkdirSync(manifestDir, { recursive: true });
+	fs.writeFileSync(path.join(manifestDir, "_buildManifest.js"), buildNextClientBuildManifestContent(options.rewrites), "utf-8");
+	fs.writeFileSync(path.join(manifestDir, "_ssgManifest.js"), buildNextClientSsgManifestContent(), "utf-8");
+}
+//#endregion
+export { buildNextClientBuildManifestContent, buildNextClientSsgManifestContent, emitNextClientRuntimeManifests };

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

@@ -0,0 +1,49 @@
+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, collectNitroRouteRules, convertToNitroPattern, generateNitroRouteRules, mergeNitroRouteRules };

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

@@ -0,0 +1,79 @@
+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 };

package/dist/build/precompress.d.ts

@@ -0,0 +1,27 @@
+//#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/<assetsDir>/`.
+ *
+ * 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.
+ *
+ * `assetsDir` defaults to `"_next/static"` (Next.js's canonical convention,
+ * matching `resolveAssetsDir("")`). When `assetPrefix` is configured as a
+ * path prefix the build writes assets to a different directory (e.g.
+ * `"cdn/_next/static"`); callers should resolve that with
+ * `resolveAssetsDir(assetPrefix)` and thread it through. Without this,
+ * `assetPrefix` builds would walk an empty `_next/static/` directory and
+ * emit zero compressed variants.
+ */
+declare function precompressAssets(clientDir: string, options?: {
+  /** Subdirectory under `clientDir` containing hashed assets. Defaults to `"_next/static"`. */assetsDir?: string;
+  onProgress?: (completed: number, total: number, file: string) => void;
+}): Promise<PrecompressResult>;
+//#endregion
+export { precompressAssets };