vinext 1.1.0 → 1.2.1

package/dist/plugins/use-cache-callable.js

@@ -1,9 +1,9 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { parseProgramAsync } from "./ast-utils.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { NODE_MODULES_PATH_RE } from "../utils/path.js";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
-import { parseAstAsync } from "vite";
 import { createHmac, randomBytes } from "node:crypto";
 //#region src/plugins/use-cache-callable.ts
 const PLUGIN_NAME = "vinext:server-function-directives";
@@ -72,9 +72,46 @@ function getFunctionDirectiveExportNames(transforms, ast, directive) {
 }
 function getCacheWrapperOptions(meta) {
 	const argumentCount = getArgumentCount(meta);
+	const captureCount = "bindVars" in meta ? meta.bindVars.length : 0;
 	return {
 		acceptsSecondArgument: acceptsSecondArgument(meta),
-		...argumentCount === void 0 ? {} : { argumentCount }
+		...argumentCount === void 0 ? {} : { argumentCount },
+		...captureCount === 0 ? {} : { captureCount }
+	};
+}
+/**
+* Compile a module for a browser graph: module-level cache functions become
+* server references, and inline ones are rejected as in Next.js Client
+* Components. Returns undefined when the module is unchanged.
+*/
+function transformBrowserModule(transforms, code, ast, id, moduleDirective, options) {
+	if (!moduleDirective) {
+		transforms.transformHoistInlineDirective(code, ast, {
+			directive: USE_CACHE_DIRECTIVE_CANDIDATE,
+			rejectNonAsyncFunction: true,
+			runtime: (_value, _name, meta) => {
+				matchUseCacheDirective(meta.directiveMatch[0]);
+				throw new Error(`It is not allowed to define inline "use cache" annotated functions in Client Components. Export them from a separate file with a module-level "use cache" or "use server" directive, or pass them down through props from a Server Component. (${options.environmentName}: ${id})`);
+			}
+		});
+		return;
+	}
+	const useServerExportNames = getFunctionDirectiveExportNames(transforms, ast, "use server");
+	const referenceName = (name) => useServerExportNames.has(name) ? name : options.secureExportName(name);
+	const result = transforms.transformDirectiveProxyExport(ast, {
+		code,
+		directive: moduleDirective,
+		filter: (name, meta) => {
+			if (!shouldTransformModuleExport(name, id, meta)) return false;
+			validateModuleExport(transforms, meta);
+			return true;
+		},
+		runtime: (name) => options.createReference(`${options.reference.referenceKey}#${referenceName(name)}`, name)
+	});
+	if (!result?.output.hasChanged()) return;
+	return {
+		output: result.output,
+		referenceNames: result.exportNames.map(referenceName)
 	};
 }
 async function createUseCacheCallablePlugin(options) {
@@ -84,8 +121,39 @@ async function createUseCacheCallablePlugin(options) {
 	const transforms = await import(pathToFileURL(transformsPath).href);
 	const referenceSecret = randomBytes(32);
 	let manager;
+	async function analyzeModule(manager, code, id) {
+		const ast = await parseProgramAsync(code);
+		const moduleDirective = findModuleUseCacheDirective(ast);
+		const useServerBoundary = transforms.hasDirective(ast.body, "use server");
+		if (moduleDirective && useServerBoundary) throw new Error(`A module cannot contain both ${JSON.stringify(moduleDirective)} and "use server" directives.`);
+		const reference = manager.serverReferences.resolve(id, "rsc");
+		const relativeImportId = manager.toRelativeId(reference.importId);
+		const secureExportName = (name) => `$$vinext_cache_${createHmac("sha256", referenceSecret).update(relativeImportId).update("\0").update(name).digest("hex")}`;
+		return {
+			ast,
+			moduleDirective,
+			useServerBoundary,
+			reference,
+			secureExportName
+		};
+	}
 	return {
 		name: PLUGIN_NAME,
+		api: { async transformWorkerModule(code, id, createReference) {
+			if (!code.includes("use cache")) return;
+			if (!manager) {
+				if (findModuleUseCacheDirective(await parseProgramAsync(code))) throw new Error("vinext: cannot compile a \"use cache\" module in a Web Worker without @vitejs/plugin-rsc.");
+				return;
+			}
+			const { ast, moduleDirective, useServerBoundary, reference, secureExportName } = await analyzeModule(manager, code, id);
+			if (useServerBoundary) return;
+			return transformBrowserModule(transforms, code, ast, id, moduleDirective, {
+				environmentName: "worker",
+				reference,
+				secureExportName,
+				createReference
+			})?.output;
+		} },
 		configResolved(config) {
 			const pluginApi = rscModule.getPluginApi(config);
 			const hasRscPlugin = config.plugins.some((plugin) => plugin.name === "rsc");
@@ -109,48 +177,25 @@ async function createUseCacheCallablePlugin(options) {
 					manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
 					return;
 				}
-				const ast = await parseAstAsync(code);
-				const moduleDirective = findModuleUseCacheDirective(ast);
-				const useServerBoundary = transforms.hasDirective(ast.body, "use server");
-				if (moduleDirective && useServerBoundary) throw new Error(`A module cannot contain both ${JSON.stringify(moduleDirective)} and "use server" directives.`);
-				const reference = manager.serverReferences.resolve(id, "rsc");
-				const relativeImportId = manager.toRelativeId(reference.importId);
-				const secureExportName = (name) => `$$vinext_cache_${createHmac("sha256", referenceSecret).update(relativeImportId).update("\0").update(name).digest("hex")}`;
+				const { ast, moduleDirective, useServerBoundary, reference, secureExportName } = await analyzeModule(manager, code, id);
 				if (!(this.environment.name === "rsc")) {
 					if (useServerBoundary) {
 						manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
 						return;
 					}
-					if (!moduleDirective) {
-						transforms.transformHoistInlineDirective(code, ast, {
-							directive: USE_CACHE_DIRECTIVE_CANDIDATE,
-							rejectNonAsyncFunction: true,
-							runtime: (_value, _name, meta) => {
-								matchUseCacheDirective(meta.directiveMatch[0]);
-								throw new Error(`It is not allowed to define inline "use cache" annotated functions in Client Components. Export them from a separate file with a module-level "use cache" or "use server" directive, or pass them down through props from a Server Component. (${this.environment.name}: ${id})`);
-							}
-						});
-						manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
-						return;
-					}
-					const useServerExportNames = getFunctionDirectiveExportNames(transforms, ast, "use server");
-					const result = transforms.transformDirectiveProxyExport(ast, {
-						code,
-						directive: moduleDirective,
-						filter: (name, meta) => {
-							if (!shouldTransformModuleExport(name, id, meta)) return false;
-							validateModuleExport(transforms, meta);
-							return true;
-						},
-						runtime: (name) => `$$ReactClient.createServerReference(${JSON.stringify(`${reference.referenceKey}#${useServerExportNames.has(name) ? name : secureExportName(name)}`)},$$ReactClient.callServer,undefined,${this.environment.mode === "dev" ? "$$ReactClient.findSourceMapURL" : "undefined"},${JSON.stringify(name)})`
+					const result = transformBrowserModule(transforms, code, ast, id, moduleDirective, {
+						environmentName: this.environment.name,
+						reference,
+						secureExportName,
+						createReference: (referenceId, name) => `$$ReactClient.createServerReference(${JSON.stringify(referenceId)},$$ReactClient.callServer,undefined,${this.environment.mode === "dev" ? "$$ReactClient.findSourceMapURL" : "undefined"},${JSON.stringify(name)})`
 					});
-					if (!result?.output.hasChanged()) {
+					if (!result) {
 						manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
 						return;
 					}
 					manager.serverReferences.replaceClaim(PLUGIN_NAME, id, {
 						...reference,
-						exportNames: result.exportNames.map((name) => useServerExportNames.has(name) ? name : secureExportName(name))
+						exportNames: result.referenceNames
 					});
 					const runtimeEnvironment = this.environment.name === "client" ? "browser" : "ssr";
 					result.output.prepend(`import * as $$ReactClient from "@vitejs/plugin-rsc/react/${runtimeEnvironment}";\n`);
@@ -190,7 +235,11 @@ async function createUseCacheCallablePlugin(options) {
 					hoistRuntime: true,
 					noExport: true,
 					runtime: (value, name, meta) => runtime(value, name, matchUseCacheDirective(meta.directiveMatch[0]), meta),
-					encode: (value) => `$$cacheRuntime.encryptCacheCaptures(${value})`,
+					encode: (value, name) => {
+						if (name === void 0) throw new Error("vinext: inline \"use cache\" functions require @vitejs/plugin-rsc 0.5.37 or newer.");
+						const referenceId = `${reference.referenceKey}#${secureExportName(name)}`;
+						return `$$cacheRuntime.encryptCacheCaptures(${JSON.stringify(referenceId)}, ${value})`;
+					},
 					decode: (value) => value
 				});
 				if (!result.output.hasChanged()) {
@@ -217,4 +266,4 @@ async function createUseCacheCallablePlugin(options) {
 	};
 }
 //#endregion
-export { createUseCacheCallablePlugin };
+export { PLUGIN_NAME as USE_CACHE_PLUGIN_NAME, createUseCacheCallablePlugin };

package/dist/plugins/worker-image-imports.js

@@ -1,10 +1,9 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { staticStringValue, walkAst } from "./ast-utils.js";
+import { parseModuleRecord, quotedStringAt } from "./ast-utils.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { appendDeploymentIdQuery } from "../utils/deployment-id.js";
 import { NODE_MODULES_PATH_RE, stripViteModuleQuery } from "../utils/path.js";
 import fs from "node:fs";
-import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/worker-image-imports.ts
 const WORKER_IMAGE_METADATA_PREFIX = "\0vinext-worker-image-meta:";
@@ -70,24 +69,19 @@ function createWorkerImageImportsPlugin(options = {}) {
 			},
 			async handler(code, id) {
 				const sourceId = toSlash(stripViteModuleQuery(id));
-				let ast;
-				try {
-					ast = parseAst(code, { lang: /\.(?:[cm]?ts)$/.test(sourceId) ? "ts" : "tsx" });
-				} catch {
-					return null;
-				}
+				const record = parseModuleRecord(code, /\.(?:[cm]?ts)$/.test(sourceId) ? "ts" : "tsx");
+				if (!record) return null;
 				const output = new MagicString(code);
 				const imageImports = [];
-				walkAst(ast, (node) => {
-					if (node.type === "ImportExpression" && node.source.type === "Literal" && typeof node.source.value === "string" && WORKER_IMAGE_EXTENSION_RE.test(node.source.value)) {
-						imageImports.push({
-							end: node.end,
-							importPath: node.source.value,
-							start: node.start
-						});
-						return false;
-					}
-				});
+				for (const dynamicImport of record.dynamicImports) {
+					const importPath = quotedStringAt(code, dynamicImport.moduleRequest);
+					if (importPath === null || !WORKER_IMAGE_EXTENSION_RE.test(importPath)) continue;
+					imageImports.push({
+						end: dynamicImport.end,
+						importPath,
+						start: dynamicImport.start
+					});
+				}
 				let changed = false;
 				for (const imageImport of imageImports) {
 					const resolved = await this.resolve(imageImport.importPath, sourceId, { skipSelf: true });
@@ -107,23 +101,26 @@ function createWorkerImageImportsPlugin(options = {}) {
 				if (!options.deploymentId) return null;
 				const chunkSpecifiers = new Set([...chunk.imports, ...chunk.dynamicImports].map((target) => workerChunkSpecifier(chunk.fileName, target)));
 				if (chunkSpecifiers.size === 0) return null;
-				let ast;
-				try {
-					ast = parseAst(code);
-				} catch {
-					return null;
-				}
+				const record = parseModuleRecord(code, "js");
+				if (!record) return null;
+				const sources = [
+					...record.staticImports.map((statement) => statement.moduleRequest),
+					...record.staticExports.flatMap((statement) => statement.entries[0]?.moduleRequest ?? []),
+					...record.dynamicImports.map((dynamicImport) => {
+						const value = quotedStringAt(code, dynamicImport.moduleRequest);
+						return value === null ? [] : {
+							...dynamicImport.moduleRequest,
+							value
+						};
+					})
+				].flat();
 				const output = new MagicString(code);
 				let changed = false;
-				walkAst(ast, (node) => {
-					const source = node.type === "ImportExpression" || node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration" ? node.source : null;
-					const specifier = staticStringValue(source);
-					if (specifier !== null && chunkSpecifiers.has(specifier) && source) {
-						output.overwrite(source.start, source.end, JSON.stringify(appendDeploymentIdQuery(specifier, options.deploymentId)));
-						changed = true;
-						return false;
-					}
-				});
+				for (const source of sources) {
+					if (!chunkSpecifiers.has(source.value)) continue;
+					output.overwrite(source.start, source.end, JSON.stringify(appendDeploymentIdQuery(source.value, options.deploymentId)));
+					changed = true;
+				}
 				if (!changed) return null;
 				return magicStringTransformResult(output);
 			}

package/dist/plugins/worker-server-only-imports.d.ts

@@ -0,0 +1,20 @@
+import { Plugin } from "vite";
+//#region src/plugins/worker-server-only-imports.d.ts
+export declare const SERVER_ONLY_SPECIFIER_RE: RegExp;
+/**
+ * Reject `server-only` imports inside browser Web Worker bundles.
+ *
+ * Vite bundles every worker in a fresh plugin container built from
+ * `worker.plugins`, so neither `vinext:validate-server-only-client-imports`
+ * nor @vitejs/plugin-rsc's `rsc:validate-imports` sees worker modules in
+ * production builds. Next.js compiles workers as part of the browser graph
+ * and fails the build for these imports with both webpack and Turbopack.
+ *
+ * Like `rsc:validate-imports`, this guards resolution rather than scanning
+ * source, so every specifier form (static, dynamic, re-export, require) is
+ * caught before vinext's no-op `server-only` alias applies. `"use server"`
+ * modules need no exemption: `vinext:worker-use-server` replaces them with
+ * Server Function references, so their imports are never resolved.
+ */
+export declare function createWorkerServerOnlyImportsPlugin(): Plugin;
+//#endregion

package/dist/plugins/worker-server-only-imports.js

@@ -0,0 +1,31 @@
+//#region src/plugins/worker-server-only-imports.ts
+const SERVER_ONLY_SPECIFIER_RE = /^server-only$/;
+/**
+* Reject `server-only` imports inside browser Web Worker bundles.
+*
+* Vite bundles every worker in a fresh plugin container built from
+* `worker.plugins`, so neither `vinext:validate-server-only-client-imports`
+* nor @vitejs/plugin-rsc's `rsc:validate-imports` sees worker modules in
+* production builds. Next.js compiles workers as part of the browser graph
+* and fails the build for these imports with both webpack and Turbopack.
+*
+* Like `rsc:validate-imports`, this guards resolution rather than scanning
+* source, so every specifier form (static, dynamic, re-export, require) is
+* caught before vinext's no-op `server-only` alias applies. `"use server"`
+* modules need no exemption: `vinext:worker-use-server` replaces them with
+* Server Function references, so their imports are never resolved.
+*/
+function createWorkerServerOnlyImportsPlugin() {
+	return {
+		name: "vinext:worker-validate-server-only-imports",
+		resolveId: {
+			order: "pre",
+			filter: { id: SERVER_ONLY_SPECIFIER_RE },
+			handler(_source, importer) {
+				throw new Error(`You're importing a module that depends on "server-only". This API is only available in Server Components in the App Router, but ${importer ?? "this module"} is reachable from a browser Web Worker bundle.`);
+			}
+		}
+	};
+}
+//#endregion
+export { SERVER_ONLY_SPECIFIER_RE, createWorkerServerOnlyImportsPlugin };

package/dist/plugins/worker-use-server.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from "vite";
+//#region src/plugins/worker-use-server.d.ts
+type RscPluginModule = typeof import("@vitejs/plugin-rsc");
+/**
+ * Replace `"use server"` modules in browser Web Worker bundles with Server
+ * Function reference proxies.
+ *
+ * Vite bundles every worker in a fresh plugin container built from
+ * `worker.plugins`, so @vitejs/plugin-rsc's `rsc:use-server` transform never
+ * sees worker modules in production builds and the module bodies would be
+ * emitted verbatim. Next.js compiles workers as part of the browser graph,
+ * where `"use server"` exports become `createServerReference(...)` proxies.
+ * This mirrors the client-environment branch of `rsc:use-server` with the
+ * same reference keys, without claiming references.
+ *
+ * The worker realm has no router to dispatch Server Function calls. Next.js's
+ * `callServer` dispatches inside `startTransition`, so the dispatch error is
+ * reported globally and the call's promise never settles; the worker
+ * references reproduce that instead of reaching the server.
+ */
+export declare function createWorkerUseServerPlugins(options: {
+  rscPluginModule: Promise<RscPluginModule>;
+  rscPluginPath: string;
+}): Promise<Plugin[]>;
+//#endregion

package/dist/plugins/worker-use-server.js

@@ -0,0 +1,153 @@
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { escapeRegExp } from "../utils/regex.js";
+import { parseProgramAsync } from "./ast-utils.js";
+import { magicStringTransformResult } from "./transform-result.js";
+import { USE_CACHE_PLUGIN_NAME as PLUGIN_NAME } from "./use-cache-callable.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { isCSSRequest, transformWithOxc } from "vite";
+//#region src/plugins/worker-use-server.ts
+const WORKER_REFERENCE_RUNTIME_ID = "\0vinext:worker-server-reference";
+const WORKER_REFERENCE_RUNTIME_ID_RE = /^\0vinext:worker-server-reference$/;
+function workerReferenceRuntime(browserRuntime) {
+	return `import { createServerReference } from ${JSON.stringify(browserRuntime)};
+
+function callServer() {
+  return new Promise(() => {
+    reportError(new Error("Server Functions cannot be called from a browser Web Worker."));
+  });
+}
+
+export function createWorkerServerReference(id, name) {
+  return createServerReference(id, callServer, undefined, undefined, name);
+}
+`;
+}
+/** A module-local binding that cannot collide with any name in `code`. */
+function uniqueBinding(code, base) {
+	let binding = base;
+	while (code.includes(binding)) binding += "_";
+	return binding;
+}
+function isPlainFilePath(id) {
+	return !/[\0?#]/.test(id) && fs.existsSync(id);
+}
+function withPositionedError(ctx, run) {
+	return Promise.resolve().then(run).catch((error) => {
+		if (error instanceof Error && "pos" in error && typeof error.pos === "number") ctx.error(error.message, error.pos);
+		throw error;
+	});
+}
+/**
+* Replace `"use server"` modules in browser Web Worker bundles with Server
+* Function reference proxies.
+*
+* Vite bundles every worker in a fresh plugin container built from
+* `worker.plugins`, so @vitejs/plugin-rsc's `rsc:use-server` transform never
+* sees worker modules in production builds and the module bodies would be
+* emitted verbatim. Next.js compiles workers as part of the browser graph,
+* where `"use server"` exports become `createServerReference(...)` proxies.
+* This mirrors the client-environment branch of `rsc:use-server` with the
+* same reference keys, without claiming references.
+*
+* The worker realm has no router to dispatch Server Function calls. Next.js's
+* `callServer` dispatches inside `startTransition`, so the dispatch error is
+* reported globally and the call's promise never settles; the worker
+* references reproduce that instead of reaching the server.
+*/
+async function createWorkerUseServerPlugins(options) {
+	const rscRequire = createRequire(options.rscPluginPath);
+	const importRscModule = (specifier) => import(pathToFileURL(rscRequire.resolve(specifier)).href);
+	const browserRuntime = pathToFileURL(rscRequire.resolve("@vitejs/plugin-rsc/react/browser")).href;
+	const [transforms, rscCore] = await Promise.all([importRscModule("@vitejs/plugin-rsc/transforms"), importRscModule("@vitejs/plugin-rsc/core/plugin")]);
+	let manager;
+	let useCacheApi;
+	const useServerPlugin = {
+		name: "vinext:worker-use-server",
+		async configResolved(config) {
+			// @vitejs/plugin-rsc's plugin API (and its reference manager) lives.
+			const mainConfig = config.mainConfig;
+			manager = (await options.rscPluginModule).getPluginApi(mainConfig ?? config)?.manager;
+			useCacheApi = (mainConfig ?? config).plugins.find((plugin) => plugin.name === PLUGIN_NAME)?.api;
+		},
+		resolveId: {
+			filter: { id: WORKER_REFERENCE_RUNTIME_ID_RE },
+			handler: (source) => source
+		},
+		load: {
+			filter: { id: WORKER_REFERENCE_RUNTIME_ID_RE },
+			handler: () => workerReferenceRuntime(browserRuntime)
+		},
+		transform: {
+			filter: { code: "use server" },
+			async handler(code, id) {
+				let ast = await parseProgramAsync(code);
+				if (!transforms.hasDirective(ast.body, "use server")) return null;
+				if (!manager) throw new Error("vinext: cannot compile a \"use server\" module in a Web Worker without @vitejs/plugin-rsc.");
+				const expanded = await withPositionedError(this, () => transforms.transformExpandExportAll({
+					code,
+					ast,
+					importer: id,
+					resolve: async (source, importer) => (await this.resolve(source, importer))?.id,
+					load: async (target) => {
+						if (!isPlainFilePath(target)) throw new Error(`vinext: a "use server" module imported by a Web Worker cannot \`export *\` from ${JSON.stringify(target)}; re-export its names explicitly.`);
+						this.addWatchFile(target);
+						const source = await fs.promises.readFile(target, "utf-8");
+						return parseProgramAsync((await transformWithOxc(source, target, { sourcemap: false })).code);
+					}
+				}));
+				if (expanded) {
+					code = expanded.code;
+					ast = await parseProgramAsync(code);
+				}
+				const { referenceKey } = manager.serverReferences.resolve(id, "rsc");
+				const runtime = uniqueBinding(code, "$$vinextWorkerReference");
+				const result = await withPositionedError(this, () => transforms.transformDirectiveProxyExport(ast, {
+					code,
+					directive: "use server",
+					rejectNonAsyncFunction: true,
+					runtime: (name) => `${runtime}(${JSON.stringify(`${referenceKey}#${name}`)}, ${JSON.stringify(name)})`
+				}));
+				if (!result?.output.hasChanged()) return null;
+				result.output.prepend(`import { createWorkerServerReference as ${runtime} } from ${JSON.stringify(WORKER_REFERENCE_RUNTIME_ID)};\n`);
+				return magicStringTransformResult(result.output);
+			}
+		}
+	};
+	const useCachePlugin = {
+		name: "vinext:worker-use-cache",
+		transform: {
+			filter: { code: "use cache" },
+			async handler(code, id) {
+				if (isCSSRequest(id)) return null;
+				const api = useCacheApi;
+				if (!api) throw new Error("vinext: cannot compile a \"use cache\" module in a Web Worker without vinext's \"use cache\" plugin.");
+				const runtime = uniqueBinding(code, "$$vinextWorkerReference");
+				const output = await withPositionedError(this, () => api.transformWorkerModule(code, id, (referenceId, name) => `${runtime}(${JSON.stringify(referenceId)}, ${JSON.stringify(name)})`));
+				if (!output) return null;
+				output.prepend(`import { createWorkerServerReference as ${runtime} } from ${JSON.stringify(WORKER_REFERENCE_RUNTIME_ID)};\n`);
+				return magicStringTransformResult(output);
+			}
+		}
+	};
+	const patchHook = rscCore.default().find((plugin) => plugin.name === "rsc:patch-react-server-dom-webpack")?.transform;
+	if (!patchHook || typeof patchHook !== "object") throw new Error("vinext: @vitejs/plugin-rsc no longer exposes its Flight client patch plugin.");
+	const flightClientDir = path.dirname(rscRequire.resolve("@vitejs/plugin-rsc/vendor/react-server-dom/client.browser"));
+	return [
+		{
+			name: "vinext:worker-patch-react-server-dom",
+			transform: {
+				filter: {
+					id: new RegExp(`^${escapeRegExp(`${toSlash(flightClientDir)}/`)}`),
+					code: "__webpack_require__"
+				},
+				handler: patchHook.handler
+			}
+		},
+		useCachePlugin,
+		useServerPlugin
+	];
+}
+//#endregion
+export { createWorkerUseServerPlugins };

package/dist/server/api-handler.d.ts

@@ -13,5 +13,6 @@ export declare function handleApiRoute(runner: ModuleImporter, req: IncomingMess
   trustedRevalidateOrigin?: string;
   allowedRevalidateHeaderKeys?: readonly string[];
   trailingSlash?: boolean;
+  skipTrailingSlashRedirect?: boolean;
 }): Promise<boolean>;
 //#endregion

package/dist/server/api-handler.js

@@ -1,13 +1,13 @@
 import { hasBasePath } from "../utils/base-path.js";
 import { matchRoute } from "../routing/pages-router.js";
 import "./server-globals.js";
+import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { NextRequest } from "../shims/server.js";
 import { importModule, reportRequestError } from "./instrumentation.js";
 import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
 import { tracePagesApiHandler } from "./pages-execution-tracing.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT, resolveBodyParserConfig } from "./pages-body-parser-config.js";
 import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
-import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { attachPagesPreviewApi, attachPagesRequestCookies } from "./pages-node-compat.js";
 import { finalizeEdgeApiResponse, isEdgeApiRuntime } from "./edge-api-runtime.js";
@@ -237,7 +237,8 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 			const nextRequest = new NextRequest(createEdgeApiRequest(req, res, url, params, nextConfig), nextConfig ? { nextConfig: {
 				basePath: nextConfig.basePath,
 				i18n: nextConfig.i18n ?? void 0,
-				trailingSlash: nextConfig.trailingSlash
+				trailingSlash: nextConfig.trailingSlash,
+				skipTrailingSlashRedirect: nextConfig.skipTrailingSlashRedirect
 			} } : void 0);
 			const handlerResponse = await tracePagesApiHandler(route.pattern, () => apiModule.default(nextRequest));
 			if (!(handlerResponse instanceof Response)) throw new Error("Edge API route did not return a Response");

package/dist/server/app-action-forwarding.js

@@ -1,8 +1,8 @@
 import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
-import { patternToNextFormat } from "../routing/route-validation.js";
 import "./headers.js";
-import { RequestCookies, ResponseCookies } from "../shims/server.js";
 import { attachRequestCfMetadata, processMiddlewareHeaders, validateCsrfOrigin } from "./request-pipeline.js";
+import { patternToNextFormat } from "../routing/route-validation.js";
+import { RequestCookies, ResponseCookies } from "../shims/server.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { getSetCookieName } from "./cookie-utils.js";
 import "../shims/internal/cookies.js";

package/dist/server/app-browser-action-result.d.ts

@@ -25,7 +25,7 @@ export declare function isServerActionResult<TRoot>(value: unknown): value is Ap
 export declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
 export declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
 export declare function resolveServerActionOperationLane(revalidation: ServerActionRevalidationKind): Extract<OperationLane, "refresh" | "server-action">;
-export declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
+export declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): Promise<unknown>;
 export declare function shouldSyncServerActionHttpFallbackHead<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot): boolean;
 export declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
 export type ServerActionResultResponseFactsInput = {

package/dist/server/app-browser-action-result.js

@@ -41,8 +41,15 @@ function createServerActionHttpFallbackError(status) {
 	const error = /* @__PURE__ */ new Error(status === 404 ? "NEXT_NOT_FOUND" : `NEXT_HTTP_ERROR_FALLBACK;${status}`);
 	return Object.assign(error, { digest });
 }
-function normalizeServerActionThrownValue(data, responseStatus) {
-	return createServerActionHttpFallbackError(responseStatus) ?? data;
+async function normalizeServerActionThrownValue(data, responseStatus) {
+	const fallbackError = createServerActionHttpFallbackError(responseStatus);
+	if (fallbackError) return fallbackError;
+	try {
+		await data;
+	} catch (error) {
+		return error;
+	}
+	return data;
 }
 function shouldSyncServerActionHttpFallbackHead(result) {
 	if (!isServerActionResult(result) || result.root !== void 0) return false;

package/dist/server/app-browser-entry.js

@@ -1,6 +1,6 @@
-import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { addBasePathToPathname, stripBasePath } from "../utils/base-path.js";
 import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
+import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { matchRoutePattern } from "../routing/route-pattern.js";
 import { installWindowNext, setWindowNextInternalSourcePage } from "../client/window-next.js";
@@ -15,7 +15,7 @@ import { DevRecoveryBoundary, GlobalErrorBoundary, RedirectBoundary } from "../s
 import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
 import { BfcacheIdentityMapContext, ElementsContext, Slot, bindAppElementsRenderedSearch, setAppElementsRenderedSearch } from "../shims/slot.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import "../client/instrumentation-client.js";
 import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
@@ -1122,7 +1122,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						}
 					});
 					const rewrittenNavigationHref = navigationKind === "navigate" && HAS_CLIENT_REWRITES ? resolveLoadedHybridClientRewriteHref(currentHref, __basePath) : null;
-					const targetPathAndSearch = url.pathname + url.search;
+					const targetPathAndSearch = formatRscRequestPath(url);
 					const additionalPrefetchPathAndSearch = rewrittenNavigationHref && rewrittenNavigationHref !== currentHref ? [rewrittenNavigationHref] : [];
 					const settledPrefetchedResponse = peekSettledPrefetchResponseForNavigation({
 						additionalRscUrls: additionalPrefetchPathAndSearch,

package/dist/server/app-browser-interception-context.js

@@ -1,5 +1,5 @@
-import { normalizePathnameForRouteMatch, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
+import { normalizePathnameForRouteMatch, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { normalizePath } from "./normalize-path.js";
 import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.js";
 //#region src/server/app-browser-interception-context.ts

package/dist/server/app-browser-navigation-controller.js

@@ -583,7 +583,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			} else notifyDiscardedServerActionRevalidation(lifecycleOptions);
 		} else if (decision.disposition === "no-commit") notifyDiscardedServerActionRevalidation(lifecycleOptions);
 		if (returnValue) {
-			if (!returnValue.ok) throw returnValue.data;
+			if (!returnValue.ok) throw await returnValue.data;
 			return returnValue.data;
 		}
 	}

package/dist/server/app-browser-prefetch-response.js

@@ -1,4 +1,4 @@
-import { stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
+import { formatRscRequestPath, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { peekPrefetchResponseForNavigation } from "../shims/navigation.js";
 //#region src/server/app-browser-prefetch-response.ts
 function peekSettledPrefetchResponseForNavigation(options) {
@@ -25,7 +25,7 @@ function isSameOriginBrowserRscUrl(url, origin) {
 function canonicalizeBrowserRscResponseUrl(responseUrl, origin) {
 	try {
 		const parsed = new URL(responseUrl, origin);
-		if (parsed.origin === new URL(origin).origin) return `${parsed.pathname}${parsed.search}`;
+		if (parsed.origin === new URL(origin).origin) return formatRscRequestPath(parsed);
 	} catch {}
 	return responseUrl;
 }

package/dist/server/app-browser-server-action-client.js

@@ -123,7 +123,7 @@ async function invokeClientServerAction(id, args, actionInitiation, deps) {
 			return deps.commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result.root)), actionInitiation, returnValue, revalidation, renderedPathAndSearch);
 		}
 		if (result.returnValue) {
-			if (!result.returnValue.ok) throw normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status);
+			if (!result.returnValue.ok) throw await normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status);
 			return result.returnValue.data;
 		}
 		return;