vinext 1.1.0 → 1.2.1

package/dist/utils/domain-locale.js

@@ -42,7 +42,7 @@ function getDomainLocaleUrl(url, locale, { basePath, currentHostname, domainItem
 	const targetDomain = detectDomainLocale(domainItems, void 0, locale);
 	if (!targetDomain) return void 0;
 	const currentDomain = detectDomainLocale(domainItems, currentHostname ?? void 0);
-	const localizedPath = addLocalePrefix(url, locale, targetDomain.defaultLocale);
+	const localizedPath = addLocalePrefix(/^[/?#]/.test(url) ? url : `/${url}`, locale, targetDomain.defaultLocale);
 	if (currentDomain && normalizeDomainHostname(currentDomain.domain) === normalizeDomainHostname(targetDomain.domain)) return;
 	return `${`http${targetDomain.http ? "" : "s"}://`}${targetDomain.domain}${prefixBasePath(localizedPath, basePath)}`;
 }

package/dist/utils/hash.d.ts

@@ -20,4 +20,11 @@ export declare function fnv1a64(input: string): string;
  * key format and produces different values. Do not swap one for the other.
  */
 export declare function fnv1a52(str: string): number;
+/**
+ * Hex-encoded SHA-256 digest of a string's UTF-8 bytes, via Web Crypto so it
+ * runs unchanged in Node.js, Workers and browsers. Used for cache keys built
+ * from inputs a request can influence, where crafted inputs could collide
+ * under a non-cryptographic hash like `fnv1a64`.
+ */
+export declare function sha256Hex(input: string): Promise<string>;
 //#endregion

package/dist/utils/hash.js

@@ -51,5 +51,15 @@ function fnv1a52(str) {
 	}
 	return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
 }
+/**
+* Hex-encoded SHA-256 digest of a string's UTF-8 bytes, via Web Crypto so it
+* runs unchanged in Node.js, Workers and browsers. Used for cache keys built
+* from inputs a request can influence, where crafted inputs could collide
+* under a non-cryptographic hash like `fnv1a64`.
+*/
+async function sha256Hex(input) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+	return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
 //#endregion
-export { fnv1a52, fnv1a64 };
+export { fnv1a52, fnv1a64, sha256Hex };

package/dist/utils/package-name.d.ts

@@ -7,4 +7,10 @@ export declare const BARE_PACKAGE_SPECIFIER_RE: RegExp;
  * scoped names, and Node builtins are not npm package references.
  */
 export declare function packageNameFromSpecifier(specifier: string): string | null;
+/**
+ * Turbopack's "foreign code" condition: a module under node_modules whose
+ * package is not in the (Turbopack) transpile list. Next.js skips its
+ * app-code transforms, such as next/dynamic, for foreign code.
+ */
+export declare function isForeignNodeModule(id: string, transpiledPackages: readonly string[]): boolean;
 //#endregion

package/dist/utils/package-name.js

@@ -1,3 +1,4 @@
+import { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { builtinModules } from "node:module";
 //#region src/utils/package-name.ts
 const BUILTIN_MODULES = new Set(builtinModules.flatMap((name) => name.startsWith("node:") ? [name, name.slice(5)] : [name, `node:${name}`]));
@@ -14,5 +15,15 @@ function packageNameFromSpecifier(specifier) {
 	if (!packageName || BUILTIN_MODULES.has(packageName)) return null;
 	return packageName;
 }
+/**
+* Turbopack's "foreign code" condition: a module under node_modules whose
+* package is not in the (Turbopack) transpile list. Next.js skips its
+* app-code transforms, such as next/dynamic, for foreign code.
+*/
+function isForeignNodeModule(id, transpiledPackages) {
+	const normalizedId = toSlash(id);
+	if (!normalizedId.includes("/node_modules/")) return false;
+	return !transpiledPackages.some((packageName) => normalizedId.includes(`/node_modules/${packageName}/`));
+}
 //#endregion
-export { BARE_PACKAGE_SPECIFIER_RE, packageNameFromSpecifier };
+export { BARE_PACKAGE_SPECIFIER_RE, isForeignNodeModule, packageNameFromSpecifier };

package/dist/utils/plugin-rsc-version.d.ts

@@ -0,0 +1,6 @@
+//#region src/utils/plugin-rsc-version.d.ts
+/** Return the installed @vitejs/plugin-rsc version, or throw if it is unsupported. */
+export declare function assertPluginRscVersion(resolvedRscPath: string): string;
+/** Whether the package owning `dir` must install its own react-server-dom-webpack. */
+export declare function needsAppReactServerDom(dir: string, pluginRscVersion: string): boolean;
+//#endregion

package/dist/utils/plugin-rsc-version.js

@@ -0,0 +1,41 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { MINIMUM_REACT_VERSION, findPackageVersion, isVersionBelow } from "./react-version.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+//#region src/utils/plugin-rsc-version.ts
+const MINIMUM_PLUGIN_RSC_VERSION = [
+	0,
+	5,
+	37
+];
+/** Return the installed @vitejs/plugin-rsc version, or throw if it is unsupported. */
+function assertPluginRscVersion(resolvedRscPath) {
+	const version = findPackageVersion(resolvedRscPath, "@vitejs/plugin-rsc");
+	if (!version || isVersionBelow(version, MINIMUM_PLUGIN_RSC_VERSION)) throw new Error(`vinext: App Router requires @vitejs/plugin-rsc ${MINIMUM_PLUGIN_RSC_VERSION.join(".")} or newer (found ${version ?? "an unknown version"}). Upgrade @vitejs/plugin-rsc.`);
+	return version;
+}
+const FIRST_PLUGIN_RSC_WITH_SUPPORTED_RSDW = [
+	0,
+	5,
+	38
+];
+/** Whether the package owning `dir` must install its own react-server-dom-webpack. */
+function needsAppReactServerDom(dir, pluginRscVersion) {
+	if (!isVersionBelow(pluginRscVersion, FIRST_PLUGIN_RSC_WITH_SUPPORTED_RSDW)) return false;
+	let manifest = path.join(dir, "package.json");
+	while (!fs.existsSync(manifest)) {
+		const parent = path.dirname(path.dirname(manifest));
+		if (parent === path.dirname(manifest)) return true;
+		manifest = path.join(parent, "package.json");
+	}
+	try {
+		const pkg = JSON.parse(fs.readFileSync(manifest, "utf-8"));
+		if (!pkg.dependencies?.["react-server-dom-webpack"] && !pkg.devDependencies?.["react-server-dom-webpack"]) return true;
+		const version = findPackageVersion(createRequire(manifest).resolve("react-server-dom-webpack"), "react-server-dom-webpack");
+		return !version || isVersionBelow(version, MINIMUM_REACT_VERSION);
+	} catch {
+		return true;
+	}
+}
+//#endregion
+export { assertPluginRscVersion, needsAppReactServerDom };

package/dist/utils/prerender-output-paths.js

@@ -1,11 +1,22 @@
 //#region src/utils/prerender-output-paths.ts
 /**
+* Map a prerendered URL to the file path its artifacts are written under, as
+* Next.js's `normalizePagePath` does. `/index` becomes `/index/index` (and
+* `/index/foo` becomes `/index/index/foo`) so it never shares `/`'s files.
+* Unlike Next.js, dynamic fallback-shell paths such as `/index/[slug]` are
+* also prefixed; build and seed both use this mapping, so they stay in step.
+* Source: https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/page-path/normalize-page-path.ts
+*/
+function toOutputUrlPath(urlPath) {
+	return /^\/index(?:\/|$)/.test(urlPath) ? `/index${urlPath}` : urlPath;
+}
+/**
 * Determine the HTML output file path for a prerendered URL.
 * Respects trailingSlash config.
 */
 function getOutputPath(urlPath, trailingSlash, basePath = "") {
 	if (urlPath === "/" && basePath === "") return "index.html";
-	const clean = (basePath === "" ? urlPath : urlPath === "/" ? trailingSlash ? `${basePath}/` : basePath : `${basePath}${urlPath}`).replace(/^\//, "").replace(/\/$/, "");
+	const clean = (basePath === "" ? toOutputUrlPath(urlPath) : urlPath === "/" ? trailingSlash ? `${basePath}/` : basePath : `${basePath}${toOutputUrlPath(urlPath)}`).replace(/^\//, "").replace(/\/$/, "");
 	if (trailingSlash) return `${clean}/index.html`;
 	return `${clean}.html`;
 }
@@ -19,16 +30,16 @@ function getRscOutputPath(urlPath, options = {
 			const cleanBasePath = options.basePath?.replace(/^\//, "");
 			return cleanBasePath ? `${cleanBasePath}/index.txt` : "index.txt";
 		}
-		const clean = (options.basePath ? `${options.basePath}${urlPath}` : urlPath).replace(/^\//, "").replace(/\/$/, "");
+		const clean = `${options.basePath ?? ""}${toOutputUrlPath(urlPath)}`.replace(/^\//, "").replace(/\/$/, "");
 		return options.trailingSlash ? `${clean}/index.txt` : `${clean}.txt`;
 	}
 	if (urlPath === "/") return "index.rsc";
-	return urlPath.replace(/^\//, "") + ".rsc";
+	return toOutputUrlPath(urlPath).replace(/^\//, "") + ".rsc";
 }
 /** Determine the binary artifact path for a prerendered App Route response. */
 function getAppRouteOutputPath(urlPath) {
 	if (urlPath === "/") return "index.route";
-	return urlPath.replace(/^\//, "") + ".route";
+	return toOutputUrlPath(urlPath).replace(/^\//, "") + ".route";
 }
 //#endregion
 export { getAppRouteOutputPath, getOutputPath, getRscOutputPath };

package/dist/utils/public-file-path.d.ts

@@ -1,4 +1,12 @@
 //#region src/utils/public-file-path.d.ts
-/** Precompute keys for both encoded requests and decoded proxy/dev variants. */
-export declare function publicFilePathVariants(pathname: string): string[];
+/**
+ * Key a public file by the normalized pathname a request for it matches with.
+ *
+ * Request pathnames are decoded once per segment with path delimiters kept
+ * encoded, so `public/a b.txt` is `/a b.txt` and `public/C#.txt` is
+ * `/C%23.txt`. Keying only this form keeps a double-encoded alias such as
+ * `/a%2520b.txt`, which middleware matchers see as `/a%20b.txt`, from
+ * reaching `public/a b.txt`.
+ */
+export declare function publicFileRouteKey(pathname: string): string;
 //#endregion

package/dist/utils/public-file-path.js

@@ -1,12 +1,16 @@
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 //#region src/utils/public-file-path.ts
-/** Encode each pathname segment without encoding `/` separators. */
-function encodePublicFilePath(pathname) {
-	return pathname.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-}
-/** Precompute keys for both encoded requests and decoded proxy/dev variants. */
-function publicFilePathVariants(pathname) {
-	const encoded = encodePublicFilePath(pathname);
-	return encoded === pathname ? [pathname] : [pathname, encoded];
+/**
+* Key a public file by the normalized pathname a request for it matches with.
+*
+* Request pathnames are decoded once per segment with path delimiters kept
+* encoded, so `public/a b.txt` is `/a b.txt` and `public/C#.txt` is
+* `/C%23.txt`. Keying only this form keeps a double-encoded alias such as
+* `/a%2520b.txt`, which middleware matchers see as `/a%20b.txt`, from
+* reaching `public/a b.txt`.
+*/
+function publicFileRouteKey(pathname) {
+	return normalizePathnameForRouteMatch(pathname.split("/").map((segment) => encodeURIComponent(segment)).join("/"));
 }
 //#endregion
-export { publicFilePathVariants };
+export { publicFileRouteKey };

package/dist/utils/public-routes.js

@@ -1,5 +1,5 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { publicFilePathVariants } from "./public-file-path.js";
+import { publicFileRouteKey } from "./public-file-path.js";
 import fs from "node:fs";
 //#region src/utils/public-routes.ts
 function scanPublicFileRoutes(root, configuredPublicDir = "public") {
@@ -37,7 +37,7 @@ function scanPublicFileRoutes(root, configuredPublicDir = "public") {
 				if (!stat.isFile()) continue;
 			} else if (!entry.isFile()) continue;
 			const relativePath = path.relative(publicDir, fullPath);
-			routes.push(...publicFilePathVariants("/" + relativePath));
+			routes.push(publicFileRouteKey("/" + relativePath));
 		}
 	}
 	if (fs.existsSync(publicDir)) try {

package/dist/utils/react-version.d.ts

@@ -1,5 +1,15 @@
 //#region src/utils/react-version.d.ts
+/**
+ * Lowest React accepted for App Router builds. react-server-dom-webpack 19.3.0
+ * shares typed-array buffers across Flight chunks, fixed in 19.3.1.
+ */
+export declare const MINIMUM_REACT_VERSION: [number, number, number];
 export declare function getReactUpgradeDeps(root: string, options?: {
   fromManifest?: boolean;
+  installing?: boolean;
 }): string[];
+export declare function reactUpgradeRequiredMessage(installCommand: string, upgrades: string[], pluginRscVersion?: string): string;
+export declare function isVersionBelow(version: string, minimum: [number, number, number]): boolean;
+/** Walk up from a resolved module entry to find its package version. */
+export declare function findPackageVersion(resolvedEntry: string, packageName: string): string | null;
 //#endregion

package/dist/utils/react-version.js

@@ -12,17 +12,27 @@ function getDependencyUpgradeDeps(root, recommendations) {
 	}
 	return [];
 }
+/**
+* Lowest React accepted for App Router builds. react-server-dom-webpack 19.3.0
+* shares typed-array buffers across Flight chunks, fixed in 19.3.1.
+*/
+const MINIMUM_REACT_VERSION = [
+	19,
+	3,
+	1
+];
 function getReactUpgradeDeps(root, options = {}) {
 	if (options.fromManifest) {
 		const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
-		for (const name of ["react", "react-dom"]) {
+		for (const name of [
+			"react",
+			"react-dom",
+			"react-server-dom-webpack"
+		]) {
 			const declared = pkg.dependencies?.[name] ?? pkg.devDependencies?.[name];
-			const version = /^[~^]?([0-9]+(?:\.[0-9]+){0,2}(?:-[0-9A-Za-z.*-]+)?)(?:\.[x*])?$/.exec(declared ?? "")?.[1];
-			if (version && (version.includes("-") || isVersionBelow(version, [
-				19,
-				2,
-				6
-			]))) {
+			const version = (options.installing ? /^([0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?)$/ : /^[~^]?([0-9]+(?:\.[0-9]+){0,2}(?:-[0-9A-Za-z.*-]+)?)(?:\.[x*])?$/).exec(declared ?? "")?.[1];
+			const canary = !options.installing && version?.includes("-");
+			if (version && (canary || isVersionBelow(version, MINIMUM_REACT_VERSION))) {
 				const upgrades = ["react@latest", "react-dom@latest"];
 				const rsdw = pkg.dependencies?.["react-server-dom-webpack"] ?? pkg.devDependencies?.["react-server-dom-webpack"];
 				if (rsdw && rsdw !== "latest") upgrades.push("react-server-dom-webpack@latest");
@@ -31,14 +41,27 @@ function getReactUpgradeDeps(root, options = {}) {
 		}
 		return [];
 	}
-	return getDependencyUpgradeDeps(root, { react: {
-		minimumVersion: [
-			19,
-			2,
-			6
-		],
-		upgrades: ["react@latest", "react-dom@latest"]
-	} });
+	return getDependencyUpgradeDeps(root, {
+		"react-server-dom-webpack": {
+			minimumVersion: MINIMUM_REACT_VERSION,
+			upgrades: [
+				"react@latest",
+				"react-dom@latest",
+				"react-server-dom-webpack@latest"
+			]
+		},
+		react: {
+			minimumVersion: MINIMUM_REACT_VERSION,
+			upgrades: ["react@latest", "react-dom@latest"]
+		},
+		"react-dom": {
+			minimumVersion: MINIMUM_REACT_VERSION,
+			upgrades: ["react@latest", "react-dom@latest"]
+		}
+	});
+}
+function reactUpgradeRequiredMessage(installCommand, upgrades, pluginRscVersion) {
+	return `vinext: App Router requires react, react-dom, and react-server-dom-webpack ${MINIMUM_REACT_VERSION.join(".")} or later.\n` + (pluginRscVersion ? `@vitejs/plugin-rsc ${pluginRscVersion} bundles an older react-server-dom-webpack, so install the latest in your app.\n` : "") + `Run: ${installCommand} ${upgrades.join(" ")}`;
 }
 function isVersionBelow(version, minimum) {
 	const current = version.split(".").map((part) => parseInt(part, 10));
@@ -59,4 +82,4 @@ function findPackageVersion(resolvedEntry, packageName) {
 	return null;
 }
 //#endregion
-export { getReactUpgradeDeps };
+export { MINIMUM_REACT_VERSION, findPackageVersion, getReactUpgradeDeps, isVersionBelow, reactUpgradeRequiredMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",
@@ -98,6 +98,10 @@
       "types": "./dist/server/headers.d.ts",
       "import": "./dist/server/headers.js"
     },
+    "./internal/server/http-conditional": {
+      "types": "./dist/server/http-conditional.d.ts",
+      "import": "./dist/server/http-conditional.js"
+    },
     "./internal/server/isr-cache": {
       "types": "./dist/server/isr-cache.d.ts",
       "import": "./dist/server/isr-cache.js"
@@ -234,12 +238,12 @@
     "@types/react-dom": "^19.2.3",
     "@types/ua-parser-js": "0.7.36",
     "@vitejs/plugin-react": "^6.1.0",
-    "@vitejs/plugin-rsc": "^0.5.34",
+    "@vitejs/plugin-rsc": "^0.5.38",
     "am-i-vibing": "^0.5.0",
     "ignore": "5.3.2",
     "image-size": "2.0.2",
     "pathslash": "^0.1.0",
-    "react-server-dom-webpack": "^19.2.7",
+    "react-server-dom-webpack": "^19.3.1",
     "ua-parser-js": "1.0.35",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
     "vite-plus": "1.1.0"
@@ -247,10 +251,10 @@
   "peerDependencies": {
     "@mdx-js/rollup": "^3.0.0",
     "@vitejs/plugin-react": "^5.1.4 || ^6.0.0",
-    "@vitejs/plugin-rsc": "^0.5.34",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
-    "react-server-dom-webpack": "^19.2.6",
+    "@vitejs/plugin-rsc": "^0.5.37",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "react-server-dom-webpack": "^19.3.1",
     "vite": "^8.0.0"
   },
   "peerDependenciesMeta": {

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

@@ -1,47 +0,0 @@
-import { RouteRow } from "./report.js";
-//#region src/build/nitro-route-rules.d.ts
-export 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.
- */
-export declare function collectNitroRouteRules(options: {
-  appDir?: string | null;
-  pagesDir?: string | null;
-  pageExtensions: string[];
-}): Promise<NitroRouteRules>;
-export 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)
- */
-export declare function convertToNitroPattern(pattern: string): string;
-export declare function mergeNitroRouteRules(existingRouteRules: Record<string, NitroRouteRuleConfig> | undefined, generatedRouteRules: NitroRouteRules): {
-  routeRules: Record<string, NitroRouteRuleConfig>;
-  skippedRoutes: string[];
-};
-//#endregion

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

@@ -1,79 +0,0 @@
-import { appRouter } from "../routing/app-router.js";
-import { apiRouter, pagesRouter } from "../routing/pages-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/plugins/cache-flight-codec.d.ts

@@ -1,19 +0,0 @@
-import { MagicStringTransformResult } from "./transform-result.js";
-import { Plugin } from "vite";
-//#region src/plugins/cache-flight-codec.d.ts
-/**
- * Version of the Flight codec package that owns `id`. plugin-rsc resolves the
- * app's own react-server-dom-webpack when installed and its vendored copy
- * otherwise; reading the codec file's own package.json follows that choice.
- */
-export declare function readFlightCodecVersion(id: string): string;
-/**
- * Backport React 19.3's root-element temporary reference branch to older Flight
- * codecs, so a "use cache" argument like `Promise<ReactElement>` encodes as a
- * temporary reference instead of throwing. Remove it once React 19.3 is the
- * minimum supported version.
- * https://github.com/facebook/react/blob/v19.3.0/packages/react-client/src/ReactFlightReplyClient.js#L486
- */
-export declare function patchCacheFlightCodec(code: string, id: string, version?: string): MagicStringTransformResult | null;
-export declare function cacheFlightCodecPlugin(): Plugin;
-//#endregion

package/dist/plugins/cache-flight-codec.js

@@ -1,68 +0,0 @@
-import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { magicStringTransformResult } from "./transform-result.js";
-import fs from "node:fs";
-import MagicString from "magic-string";
-//#region src/plugins/cache-flight-codec.ts
-const CLIENT_CODEC = /\/react-server-dom-(?:webpack|turbopack)-client\.edge\.(?:development|production)\.js$/;
-const ELEMENT_CASE = /case REACT_ELEMENT_TYPE:[\s\S]*?throw Error\(\s*"React Element cannot be passed/;
-/**
-* Version of the Flight codec package that owns `id`. plugin-rsc resolves the
-* app's own react-server-dom-webpack when installed and its vendored copy
-* otherwise; reading the codec file's own package.json follows that choice.
-*/
-function readFlightCodecVersion(id) {
-	for (let dir = path.dirname(id);; dir = path.dirname(dir)) {
-		const manifest = path.join(dir, "package.json");
-		if (fs.existsSync(manifest)) {
-			const pkg = JSON.parse(fs.readFileSync(manifest, "utf8"));
-			if (/^react-server-dom-(?:webpack|turbopack)$/.test(pkg.name ?? "") && pkg.version) return pkg.version;
-		}
-		if (path.dirname(dir) === dir) throw new Error(`vinext: cannot find the react-server-dom package version for ${id}`);
-	}
-}
-/** React 19.3 ships the branch; 0.0.0-* experimental builds track main. */
-function needsElementTemporaryReferenceBackport(version) {
-	const match = /^(\d+)\.(\d+)\./.exec(version);
-	if (!match || version.startsWith("0.0.0-")) return false;
-	const [major, minor] = [Number(match[1]), Number(match[2])];
-	return major < 19 || major === 19 && minor < 3;
-}
-/**
-* Backport React 19.3's root-element temporary reference branch to older Flight
-* codecs, so a "use cache" argument like `Promise<ReactElement>` encodes as a
-* temporary reference instead of throwing. Remove it once React 19.3 is the
-* minimum supported version.
-* https://github.com/facebook/react/blob/v19.3.0/packages/react-client/src/ReactFlightReplyClient.js#L486
-*/
-function patchCacheFlightCodec(code, id, version = readFlightCodecVersion(id)) {
-	if (!needsElementTemporaryReferenceBackport(version)) return null;
-	const elementCase = ELEMENT_CASE.exec(code);
-	if (!elementCase) throw new Error(`vinext: react-server-dom-webpack ${version} (${id}) is not supported. Upgrade react, react-dom, and react-server-dom-webpack to 19.3 or later. If your app does not depend on react-server-dom-webpack directly, upgrade @vitejs/plugin-rsc to 0.5.35 or later instead.`);
-	const output = new MagicString(code);
-	output.appendLeft(elementCase.index + elementCase[0].lastIndexOf("throw Error("), "if (void 0 !== temporaryReferences && modelRoot === value) return (modelRoot = null), \"$T\";\n");
-	return magicStringTransformResult(output, {
-		hires: "boundary",
-		source: id
-	});
-}
-function cacheFlightCodecPlugin() {
-	const transform = {
-		filter: { id: CLIENT_CODEC },
-		handler: (code, id) => patchCacheFlightCodec(code, id)
-	};
-	return {
-		name: "vinext:cache-flight-codec",
-		enforce: "pre",
-		applyToEnvironment: (environment) => environment.name === "rsc",
-		configEnvironment(name) {
-			if (name !== "rsc") return;
-			return { optimizeDeps: { rolldownOptions: { plugins: [{
-				name: "vinext:cache-flight-codec-optimizer",
-				transform
-			}] } } };
-		},
-		transform
-	};
-}
-//#endregion
-export { cacheFlightCodecPlugin, patchCacheFlightCodec, readFlightCodecVersion };