vinext 1.2.1 → 1.3.1

package/dist/plugins/rsc-client-reference-loaders.js

@@ -1,46 +1,466 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { magicStringTransformResult, omitUnusedBuildSourcemap } from "./transform-result.js";
+import { resolveShimRuntimeModule } from "../entries/runtime-entry-module.js";
+import { CLIENT_REFERENCE_GROUP_MAX_COST_BYTES, collectClientReferencePreloadPlan, collectClientReferenceRouteSignatures, measureClientReferenceGroupCosts, planClientReferenceGroups, readClientModuleBindings } from "../build/client-reference-groups.js";
+import { collectAsyncModules, createSideEffectsDeclarationCheck } from "../build/client-reference-async.js";
+import { RESOLVED_EAGER_CLIENT_REFERENCES_ID, hasUserClientChunkGroups } from "../build/client-build-config.js";
+import fs from "node:fs";
+import { isCSSRequest } from "vite";
+import { randomBytes } from "node:crypto";
+import MagicString from "magic-string";
 //#region src/plugins/rsc-client-reference-loaders.ts
 const CLIENT_REFERENCES_ID = "\0virtual:vite-rsc/client-references";
 const RESOLVED_ID_PROXY_PREFIX = "virtual:vite-rsc/resolved-id/";
+const RESOLVED_CLIENT_REFERENCE_GROUP_PREFIX = `\0virtual:vinext-client-reference-group-`;
+/** Prefixes the module that registers one client reference outside every group. */
+const RESOLVED_CLIENT_REFERENCE_MODULE_PREFIX = `\0virtual:vinext-client-reference-module/`;
+const CLIENT_REFERENCES_ID_RE = /^\0virtual:vite-rsc\/client-references$/;
+const CLIENT_REFERENCE_MODULE_RE = /^virtual:vinext-client-reference-(?:group-|module\/)|^virtual:vinext-client-reference-(?:chunks|eager)$/;
+const RESOLVED_CLIENT_REFERENCE_MODULE_RE = /^\0virtual:vinext-client-reference-(?:group-|module\/)|^\0virtual:vinext-client-reference-(?:chunks|eager)$/;
+const CLIENT_REFERENCE_CHUNKS_ID = "virtual:vinext-client-reference-chunks";
+const RESOLVED_CLIENT_REFERENCE_CHUNKS_ID = `\0${CLIENT_REFERENCE_CHUNKS_ID}`;
+const NO_ROUTE_CLIENT_REFERENCES_EXPORT = "export const routeClientReferences = null;\n";
+/**
+* Whether the cost estimate loads a module. Rolldown keeps externals and
+* unresolved `require()`s in `importedIds` under their specifier (a bare name
+* or URL), and never settles a load of one, so only files and `\0` virtual
+* modules are measured.
+*/
+function isMeasured(id) {
+	return id.startsWith("\0") || path.isAbsolute(id);
+}
+/**
+* Whether `id` shares the package `sideEffects` flag of `owner`: it is in the
+* same package, and the package's `sideEffects` field is not a list of files.
+* `uniformSideEffects` caches that last check per package.json path.
+*/
+function isInPackage(id, owner, uniformSideEffects) {
+	const packageJsonPath = owner.packageJsonPath;
+	if (!packageJsonPath) return false;
+	const relative = path.relative(path.dirname(packageJsonPath), id);
+	if (relative.startsWith("..") || relative.split("/").includes("node_modules")) return false;
+	let uniform = uniformSideEffects.get(packageJsonPath);
+	if (uniform === void 0) {
+		try {
+			const { sideEffects } = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+			uniform = sideEffects === void 0 || typeof sideEffects === "boolean";
+		} catch {
+			uniform = false;
+		}
+		uniformSideEffects.set(packageJsonPath, uniform);
+	}
+	return uniform;
+}
 function withResolvedIdProxy(resolvedId) {
 	return resolvedId.startsWith("\0") ? RESOLVED_ID_PROXY_PREFIX + encodeURIComponent(resolvedId) : resolvedId;
 }
-function generateClientReferenceObject(meta) {
-	const exports = meta.renderedExports.slice().sort().map((name) => `      get ${JSON.stringify(name)}() { return m[${JSON.stringify(name)}]; },`).join("\n");
-	return exports ? `{\n${exports}\n    }` : "{}";
-}
-function generateDirectClientReferenceLoaders(metas) {
-	return `export default {\n${metas.slice().sort((a, b) => a.referenceKey.localeCompare(b.referenceKey)).map((meta) => {
-		const importId = withResolvedIdProxy(meta.importId);
-		return [
-			`  ${JSON.stringify(meta.referenceKey)}: async () => {`,
-			`    const m = await import(${JSON.stringify(importId)});`,
-			`    return ${generateClientReferenceObject(meta)};`,
-			`  },`
-		].join("\n");
-	}).join("\n")}\n};\n`;
-}
-function createRscClientReferenceLoadersPlugin() {
+function sortedRenderedExports(meta) {
+	return meta.renderedExports.slice().sort();
+}
+/**
+* The exports of a client reference, read from the module namespace `binding`.
+* Keep them lazy. In async or cyclic client module evaluation, eagerly copying
+* module namespace values can observe an uninitialized binding.
+*/
+function generateClientReferenceObject(meta, binding) {
+	const exports = sortedRenderedExports(meta).map((name) => `  get ${JSON.stringify(name)}() { return ${binding}[${JSON.stringify(name)}]; },`).join("\n");
+	return exports ? `{\n${exports}\n}` : "{}";
+}
+function generateClientReferenceLoaders(metas) {
+	return `export default {\n${metas.slice().sort((a, b) => a.referenceKey.localeCompare(b.referenceKey)).map((meta) => [
+		`${JSON.stringify(meta.referenceKey)}: async () => {`,
+		`  const m = await import(${JSON.stringify(withResolvedIdProxy(meta.importId))});`,
+		`  return ${generateClientReferenceObject(meta, "m")};`,
+		`},`
+	].join("\n")).join("\n")}\n};\n`;
+}
+/**
+* The client build's client-references module, which the App browser entry
+* imports. It names no client reference chunk, so the entry neither grows nor
+* changes its hash with the app's client references: each reference's Flight
+* row names the chunks it loads (see shims/internal/client-reference-loader.ts).
+*/
+function generateBrowserClientReferencesModule(loaderPath, eager) {
+	return `${eager ? `import ${JSON.stringify(RESOLVED_EAGER_CLIENT_REFERENCES_ID.slice(1))};\n` : ""}export { clientReferences as default } from ${JSON.stringify(loaderPath)};\n`;
+}
+/**
+* A client build module that registers client references as it evaluates:
+* a route group's members, the references in chunks every page loads, or one
+* other reference outside every group. It imports
+* only each member's rendered exports, so unused exports and their
+* dependencies still tree-shake as they do with direct loaders. A member
+* without rendered exports is imported for its side effects. The last member
+* is imported last (see build/client-reference-chunks.ts).
+*/
+function generateClientReferenceModule(metas, loaderPath) {
+	const imports = metas.map((meta, index) => {
+		const source = JSON.stringify(withResolvedIdProxy(meta.importId));
+		return meta.renderedExports.length > 0 ? `import * as m${index} from ${source};` : `import ${source};`;
+	});
+	const registrations = metas.map((meta, index) => `registerClientReference(${JSON.stringify(meta.referenceKey)}, ${generateClientReferenceObject(meta, `m${index}`)});`);
+	return [
+		`import { registerClientReference } from ${JSON.stringify(loaderPath)};`,
+		...imports,
+		...registrations,
+		""
+	].join("\n");
+}
+/**
+* The browser never loads this module. Its dynamic imports make each client
+* reference module a chunk of its own that only a Flight row names.
+*/
+function generateClientReferenceChunksModule(moduleIds) {
+	return `export default [\n${moduleIds.map((id) => `  () => import(${JSON.stringify(id.slice(1))}),`).join("\n")}\n];\n`;
+}
+/**
+* The SSR build's `routeClientReferences` export: the reference keys each route
+* preloads before it renders (see server/app-client-reference-preloader.ts),
+* stored as indices into `references`. Client references the plan doesn't know
+* join `always`. `async` holds `asyncPlaceholder`, which renderChunk replaces
+* with the candidates whose SSR modules evaluate asynchronously.
+*/
+function generateRouteClientReferencesExport(plan, metaEntries, asyncPlaceholder) {
+	if (!plan) return {
+		code: NO_ROUTE_CLIENT_REFERENCES_EXPORT,
+		asyncCandidates: []
+	};
+	const metaById = new Map(metaEntries);
+	const references = [];
+	const indices = /* @__PURE__ */ new Map();
+	const toIndices = (referenceIds) => referenceIds.flatMap((referenceId) => {
+		const meta = metaById.get(referenceId);
+		if (!meta) return [];
+		let index = indices.get(referenceId);
+		if (index === void 0) {
+			index = references.length;
+			indices.set(referenceId, index);
+			references.push(meta.referenceKey);
+		}
+		return [index];
+	});
+	const always = toIndices([...plan.preloads.always, ...metaEntries.map(([referenceId]) => referenceId).filter((referenceId) => !plan.referenceIds.has(referenceId))]);
+	const files = plan.preloads.files.map(toIndices);
+	const asyncCandidates = plan.preloads.staticOnly.flatMap((referenceId) => {
+		const index = indices.get(referenceId);
+		const meta = metaById.get(referenceId);
+		return index === void 0 || !meta ? [] : [{
+			index,
+			importId: meta.importId
+		}];
+	});
+	const manifest = {
+		references,
+		always,
+		files,
+		routes: Object.fromEntries(plan.preloads.routes),
+		routeless: plan.preloads.routeless,
+		async: asyncPlaceholder
+	};
+	return {
+		code: `export const routeClientReferences = ${JSON.stringify(manifest)};\n`,
+		asyncCandidates
+	};
+}
+/**
+* Replaces @vitejs/plugin-rsc's client-reference facades with per-reference
+* loaders. With `routes`, the SSR build also exports the client references
+* each App Router route preloads. With `grouping`, production client builds
+* additionally load references that the same App Router routes reach through
+* one shared route group module (see build/client-reference-groups.ts), so a
+* page fetches one chunk per route group instead of one per `"use client"`
+* module.
+*/
+function createRscClientReferenceLoadersPlugin(options = {}) {
+	const { routes: routeOptions } = options;
+	const grouping = routeOptions && options.grouping;
+	const loaderPath = resolveShimRuntimeModule("internal/client-reference-loader");
 	let rscApi;
+	let root = "";
+	let groupingEnabled = false;
+	let routeSignatures = /* @__PURE__ */ new Map();
+	// @vitejs/plugin-rsc also builds before the SSR environment.
+	let preloadPlan = null;
+	const referenceModules = /* @__PURE__ */ new Map();
+	let asyncCandidates = [];
+	const asyncPlaceholder = `__vinext_async_client_references_${randomBytes(8).toString("hex")}__`;
+	const asyncPlaceholderRe = new RegExp(`(["'])${asyncPlaceholder}\\1`, "g");
 	return {
 		name: "vinext:rsc-client-reference-loaders",
 		enforce: "post",
 		configResolved(config) {
+			root = config.root;
 			rscApi = config.plugins.find((plugin) => plugin.name === "rsc:minimal")?.api;
 		},
-		transform(_code, id) {
-			if (id !== CLIENT_REFERENCES_ID) return null;
+		outputOptions: {
+			order: "post",
+			handler(output) {
+				if (this.environment?.name !== "client") return;
+				groupingEnabled = !!grouping && !hasUserClientChunkGroups(output, grouping.ownClientChunkGroups);
+			}
+		},
+		buildStart() {
+			if (this.environment.name === "rsc") {
+				routeSignatures = /* @__PURE__ */ new Map();
+				preloadPlan = null;
+			}
+			if (this.environment.name === "client") {
+				referenceModules.clear();
+				options.onClientReferenceModules?.(/* @__PURE__ */ new Map());
+			}
+		},
+		buildEnd(error) {
+			if (error || !routeOptions) return;
+			if (this.environment.name !== "rsc" || this.environment.mode !== "build") return;
 			const manager = rscApi?.manager;
-			if (!manager || manager.isScanBuild) return null;
-			const metaEntries = Object.entries(manager.clientReferenceMetaMap).filter(([, meta]) => meta.serverChunk);
-			const metas = metaEntries.map(([, meta]) => meta);
-			if (metas.length === 0) return null;
-			for (const [id, meta] of metaEntries) meta.groupChunkId = id;
-			return {
-				code: generateDirectClientReferenceLoaders(metas),
-				map: null
+			const routes = routeOptions.getRoutes();
+			if (!manager || manager.isScanBuild || !routes) return;
+			const clientReferenceIds = new Set(Object.keys(manager.clientReferenceMetaMap));
+			const getModuleInfo = (id) => this.getModuleInfo(id);
+			preloadPlan = {
+				referenceIds: clientReferenceIds,
+				preloads: collectClientReferencePreloadPlan({
+					alwaysRoots: routeOptions.getAlwaysRenderedFiles(),
+					canonicalizeModuleId: routeOptions.canonicalizeModuleId,
+					clientReferenceIds,
+					entryIds: [...this.getModuleIds()].filter((id) => this.getModuleInfo(id)?.isEntry),
+					getModuleInfo,
+					routelessFiles: routeOptions.getRoutelessFiles(),
+					routes
+				})
 			};
+			if (!grouping) return;
+			routeSignatures = collectClientReferenceRouteSignatures({
+				canonicalizeModuleId: routeOptions.canonicalizeModuleId,
+				clientReferenceIds,
+				getModuleInfo,
+				root,
+				routes,
+				sharedRoots: routeOptions.getSharedRoots()
+			});
+		},
+		resolveId: {
+			filter: { id: CLIENT_REFERENCE_MODULE_RE },
+			handler(source) {
+				return referenceModules.has(`\0${source}`) ? `\0${source}` : null;
+			}
+		},
+		load: {
+			filter: { id: RESOLVED_CLIENT_REFERENCE_MODULE_RE },
+			handler(id) {
+				return referenceModules.get(id) ?? null;
+			}
+		},
+		transform: {
+			filter: { id: CLIENT_REFERENCES_ID_RE },
+			async handler(code) {
+				const manager = rscApi?.manager;
+				if (!manager || manager.isScanBuild) return null;
+				const isServer = this.environment.config.consumer === "server";
+				const metaEntries = Object.entries(manager.clientReferenceMetaMap).filter(([, meta]) => meta.serverChunk);
+				const metas = metaEntries.map(([, meta]) => meta);
+				let routeClientReferencesExport = "";
+				if (isServer) {
+					const generated = generateRouteClientReferencesExport(preloadPlan, metaEntries, asyncPlaceholder);
+					routeClientReferencesExport = generated.code;
+					asyncCandidates = generated.asyncCandidates;
+				}
+				if (metas.length === 0) return isServer ? {
+					code: `${code}\n${routeClientReferencesExport}`,
+					map: null
+				} : null;
+				for (const [id, meta] of metaEntries) meta.groupChunkId = id;
+				const isClientBuild = this.environment.name === "client" && this.environment.mode === "build";
+				const moduleKeys = /* @__PURE__ */ new Map();
+				const grouped = /* @__PURE__ */ new Set();
+				const referenceIds = new Set(metaEntries.map(([referenceId]) => referenceId));
+				const referenceKeys = new Map(metaEntries.map(([referenceId, meta]) => [referenceId, meta.referenceKey]));
+				if (grouping && groupingEnabled && isClientBuild && planClientReferenceGroups({
+					referenceIds,
+					referenceKeys,
+					signatures: routeSignatures,
+					costs: new Map([...referenceIds].map((referenceId) => [referenceId, 0])),
+					maxCostBytes: 0
+				}).length > 0) {
+					const references = /* @__PURE__ */ new Map();
+					const resolutions = /* @__PURE__ */ new Map();
+					const packages = /* @__PURE__ */ new Map();
+					const externalIds = /* @__PURE__ */ new Set();
+					const uniformSideEffects = /* @__PURE__ */ new Map();
+					const resolveCache = /* @__PURE__ */ new Map();
+					const addResolution = (resolved) => {
+						resolutions.set(resolved.id, resolved);
+						packages.set(resolved.id, resolved);
+					};
+					await Promise.all(metaEntries.map(async ([referenceId, meta]) => {
+						if (meta.importId.startsWith("\0")) {
+							references.set(referenceId, meta.importId);
+							return;
+						}
+						const resolved = await this.resolve(meta.importId);
+						if (!resolved || resolved.external) return;
+						references.set(referenceId, resolved.id);
+						addResolution(resolved);
+					}));
+					const { external } = this.environment.config.build.rolldownOptions;
+					const excludedById = /* @__PURE__ */ new Map();
+					const isExcludedById = (moduleId) => {
+						let excluded = excludedById.get(moduleId);
+						if (excluded === void 0) {
+							excluded = !isMeasured(moduleId) || moduleId === CLIENT_REFERENCES_ID || moduleId.startsWith(RESOLVED_CLIENT_REFERENCE_GROUP_PREFIX) || isCSSRequest(moduleId) || grouping.isAlwaysLoadedClientModule(moduleId);
+							excludedById.set(moduleId, excluded);
+						}
+						return excluded;
+					};
+					const costs = await measureClientReferenceGroupCosts({
+						references,
+						loadModule: async (moduleId) => {
+							if (external && !resolutions.has(moduleId) && !moduleId.startsWith("\0")) {
+								const resolved = await this.resolve(moduleId);
+								if (!resolved || resolved.external) return {
+									code: "",
+									importedIds: []
+								};
+							}
+							const { code, importedIds } = await this.load(resolutions.get(moduleId) ?? { id: moduleId });
+							if (code === null) return {
+								code,
+								importedIds
+							};
+							const importedIdSet = new Set(importedIds);
+							const owner = packages.get(moduleId);
+							return {
+								code,
+								importedIds,
+								bindings: await readClientModuleBindings({
+									code,
+									importedIds,
+									resolve: async (specifier) => {
+										if (owner && path.isAbsolute(moduleId) && (specifier.startsWith("./") || specifier.startsWith("../"))) {
+											const candidate = path.resolve(path.dirname(moduleId), specifier);
+											if (importedIdSet.has(candidate) && isInPackage(candidate, owner, uniformSideEffects)) {
+												packages.set(candidate, owner);
+												return candidate;
+											}
+										}
+										const key = `${path.dirname(moduleId)}\0${specifier}`;
+										let resolving = resolveCache.get(key);
+										if (!resolving) {
+											resolving = this.resolve(specifier, moduleId).then((resolved) => {
+												if (!resolved) return null;
+												if (resolved.external) externalIds.add(resolved.id);
+												else addResolution(resolved);
+												return resolved.id;
+											});
+											resolveCache.set(key, resolving);
+										}
+										return resolving;
+									}
+								})
+							};
+						},
+						isSideEffectFree: (moduleId) => packages.get(moduleId)?.moduleSideEffects === false,
+						isExcluded: (moduleId) => externalIds.has(moduleId) || isExcludedById(moduleId)
+					});
+					const groups = planClientReferenceGroups({
+						referenceIds,
+						referenceKeys,
+						signatures: routeSignatures,
+						costs,
+						maxCostBytes: CLIENT_REFERENCE_GROUP_MAX_COST_BYTES
+					});
+					const metaById = new Map(metaEntries);
+					for (const group of groups) {
+						const groupMetas = group.referenceIds.map((referenceId) => metaById.get(referenceId));
+						const resolvedGroupId = `${RESOLVED_CLIENT_REFERENCE_GROUP_PREFIX}${group.key}`;
+						referenceModules.set(resolvedGroupId, generateClientReferenceModule(groupMetas, loaderPath));
+						moduleKeys.set(resolvedGroupId, groupMetas.map((meta) => meta.referenceKey));
+						for (const meta of groupMetas) {
+							meta.groupChunkId = resolvedGroupId;
+							grouped.add(meta);
+						}
+					}
+				}
+				if (isClientBuild) {
+					const eager = [];
+					for (const [referenceId, meta] of metaEntries) {
+						if (grouped.has(meta)) continue;
+						if (grouping && groupingEnabled && grouping.isAlwaysLoadedClientModule(referenceId)) {
+							eager.push(meta);
+							continue;
+						}
+						const fileName = path.basename(meta.importId).replace(/\.[^.]*$/, "");
+						const moduleId = `${RESOLVED_CLIENT_REFERENCE_MODULE_PREFIX}${meta.referenceKey}/${fileName}`;
+						referenceModules.set(moduleId, generateClientReferenceModule([meta], loaderPath));
+						moduleKeys.set(moduleId, [meta.referenceKey]);
+						meta.groupChunkId = moduleId;
+					}
+					if (eager.length > 0) referenceModules.set(RESOLVED_EAGER_CLIENT_REFERENCES_ID, generateClientReferenceModule(eager, loaderPath));
+					referenceModules.set(RESOLVED_CLIENT_REFERENCE_CHUNKS_ID, generateClientReferenceChunksModule([...moduleKeys.keys()].sort()));
+					this.emitFile({
+						type: "chunk",
+						id: CLIENT_REFERENCE_CHUNKS_ID,
+						preserveSignature: "strict"
+					});
+					options.onClientReferenceModules?.(moduleKeys);
+					return {
+						code: generateBrowserClientReferencesModule(loaderPath, eager.length > 0),
+						map: null
+					};
+				}
+				return {
+					code: generateClientReferenceLoaders(metas) + routeClientReferencesExport,
+					map: null
+				};
+			}
+		},
+		async renderChunk(code, _chunk, _outputOptions, meta) {
+			if (this.environment.config.consumer !== "server") return null;
+			if (!code.includes(asyncPlaceholder)) return null;
+			const roots = /* @__PURE__ */ new Map();
+			await Promise.all(asyncCandidates.map(async ({ index, importId }) => {
+				let id = importId;
+				if (!importId.startsWith("\0") && !path.isAbsolute(importId)) {
+					const resolved = await this.resolve(importId);
+					id = resolved && !resolved.external ? resolved.id : void 0;
+				}
+				if (id === void 0) return;
+				let list = roots.get(id);
+				if (!list) roots.set(id, list = []);
+				list.push(index);
+			}));
+			const asyncIndices = [...collectAsyncModules({
+				roots: [...roots.keys()],
+				getModuleInfo: (id) => this.getModuleInfo(id),
+				chunks: Object.values(meta.chunks),
+				declaresSideEffects: createSideEffectsDeclarationCheck()
+			})].flatMap((id) => roots.get(id)).sort((a, b) => a - b);
+			const output = new MagicString(code);
+			for (const match of code.matchAll(asyncPlaceholderRe)) output.overwrite(match.index, match.index + match[0].length, JSON.stringify(asyncIndices));
+			return omitUnusedBuildSourcemap(this.environment, magicStringTransformResult(output));
+		}
+	};
+}
+/**
+* Exports a null preload plan from the client-references virtual module when
+* the app registers @vitejs/plugin-rsc itself (`rsc: false`), where vinext
+* doesn't add the loaders plugin above. The App Router SSR entry imports the
+* plan, and null makes it preload every client reference.
+*/
+function createRouteClientReferencesFallbackPlugin() {
+	return {
+		name: "vinext:route-client-references-fallback",
+		enforce: "post",
+		transform: {
+			filter: { id: CLIENT_REFERENCES_ID_RE },
+			handler(code) {
+				if (this.environment.config.consumer !== "server") return null;
+				return {
+					code: `${code}\n${NO_ROUTE_CLIENT_REFERENCES_EXPORT}`,
+					map: null
+				};
+			}
 		}
 	};
 }
 //#endregion
-export { createRscClientReferenceLoadersPlugin };
+export { RESOLVED_CLIENT_REFERENCE_CHUNKS_ID, RESOLVED_CLIENT_REFERENCE_MODULE_PREFIX, createRouteClientReferencesFallbackPlugin, createRscClientReferenceLoadersPlugin };

package/dist/plugins/rsc-client-shim-excludes.js

@@ -18,7 +18,9 @@ const VINEXT_OPTIMIZE_DEPS_EXCLUDE = Object.freeze([
 const SSR_EXTERNAL_REACT_ENTRIES = Object.freeze([
 	"react",
 	"react-dom",
+	"react-dom/server",
 	"react-dom/server.edge",
+	"react-dom/static",
 	"react-dom/static.edge",
 	"react/jsx-runtime",
 	"react/jsx-dev-runtime",

package/dist/plugins/sass.d.ts

@@ -102,4 +102,5 @@ export declare function createSassAwareFileSystemLoader(): {
   };
   setResolvedConfig: (config: ResolvedConfig) => void;
 };
-//#endregion
+//#endregion
+export {};

package/dist/plugins/strip-server-exports.d.ts

@@ -18,4 +18,5 @@ type StripServerExportsResult = {
  * - crates/next-custom-transforms/src/transforms/strip_page_exports.rs
  */
 export declare function stripServerExports(code: string): StripServerExportsResult | null;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/styled-jsx.d.ts

@@ -11,4 +11,5 @@ type StyledJsxPluginOptions = {
   importModule?: (url: string) => Promise<NextSwcModule>;
 };
 export declare function createStyledJsxPlugin(initialProjectRoot: string, options?: StyledJsxPluginOptions): Plugin;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/transform-result.d.ts

@@ -28,4 +28,5 @@ export declare function omitUnusedBuildSourcemap<TMap = ReturnType<MagicString["
   code: string;
   map: TMap | null;
 } | null;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/typeof-window.d.ts

@@ -25,4 +25,5 @@ export declare function getTypeofWindowReplacement(environment: EnvironmentLike)
 export declare function mayFoldChangeScannedImports(code: string): boolean;
 export declare function replaceTypeofWindow(code: string, replacement: WindowType, id?: string): MagicStringTransformResult<import("magic-string").SourceMap> | null;
 export declare function replaceConsumerEnvironmentConditions(code: string, replacements: ConsumerEnvironmentReplacements, id?: string): MagicStringTransformResult<import("magic-string").SourceMap> | null;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/use-cache-callable.d.ts

@@ -5,6 +5,11 @@ type Options = {
   projectRoot: string;
   cacheRuntime: string;
   allowMissingRsc?: boolean;
+  /**
+   * The Server Actions encryption key vinext loaded for an auto-registered
+   * @vitejs/plugin-rsc, so reference names derive from the same key.
+   */
+  getEncryptionKey?: () => string | undefined;
 };
 type BrowserTransformOptions = {
   environmentName: string;

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

@@ -2,9 +2,10 @@ 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 { getServerActionsKeyCacheFsDeny, loadOrGenerateServerActionsEncryptionKey } from "../build/server-actions-encryption-key.js";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
-import { createHmac, randomBytes } from "node:crypto";
+import { createHmac } from "node:crypto";
 //#region src/plugins/use-cache-callable.ts
 const PLUGIN_NAME = "vinext:server-function-directives";
 const SOURCE_MODULE_ID_RE = /\.(?:tsx?|jsx?|mjs)(?:\?.*)?$/;
@@ -114,21 +115,33 @@ function transformBrowserModule(transforms, code, ast, id, moduleDirective, opti
 		referenceNames: result.exportNames.map(referenceName)
 	};
 }
+/**
+* Ported from Next.js: crates/next-custom-transforms/src/transforms/server_actions.rs
+* salts server-reference IDs with the encryption key (`serverReferenceHashSalt`
+* in packages/next/src/build/webpack-config.ts), so rebuilds of identical
+* source emit identical client chunks. See
+* loadOrGenerateServerActionsEncryptionKey for where the key comes from. The
+* secret is derived under a label rather than used directly so the reference
+* names reveal nothing about the key.
+*/
+function createReferenceSecret(encryptionKey) {
+	return createHmac("sha256", encryptionKey).update("vinext use cache reference").digest();
+}
 async function createUseCacheCallablePlugin(options) {
 	const rscModulePath = resolvePluginRscModule(options.projectRoot, "@vitejs/plugin-rsc");
 	const transformsPath = resolvePluginRscModule(options.projectRoot, "@vitejs/plugin-rsc/transforms");
 	const rscModule = await import(pathToFileURL(rscModulePath).href);
 	const transforms = await import(pathToFileURL(transformsPath).href);
-	const referenceSecret = randomBytes(32);
+	let referenceSecret;
 	let manager;
-	async function analyzeModule(manager, code, id) {
+	async function analyzeModule(manager, secret, 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")}`;
+		const secureExportName = (name) => `$$vinext_cache_${createHmac("sha256", secret).update(relativeImportId).update("\0").update(name).digest("hex")}`;
 		return {
 			ast,
 			moduleDirective,
@@ -141,11 +154,12 @@ async function createUseCacheCallablePlugin(options) {
 		name: PLUGIN_NAME,
 		api: { async transformWorkerModule(code, id, createReference) {
 			if (!code.includes("use cache")) return;
-			if (!manager) {
+			const secret = referenceSecret;
+			if (!manager || !secret) {
 				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);
+			const { ast, moduleDirective, useServerBoundary, reference, secureExportName } = await analyzeModule(manager, secret, code, id);
 			if (useServerBoundary) return;
 			return transformBrowserModule(transforms, code, ast, id, moduleDirective, {
 				environmentName: "worker",
@@ -154,10 +168,17 @@ async function createUseCacheCallablePlugin(options) {
 				createReference
 			})?.output;
 		} },
+		config(config) {
+			return { server: { fs: { deny: getServerActionsKeyCacheFsDeny(config.server?.fs?.deny) } } };
+		},
 		configResolved(config) {
 			const pluginApi = rscModule.getPluginApi(config);
 			const hasRscPlugin = config.plugins.some((plugin) => plugin.name === "rsc");
 			if (!pluginApi && options.allowMissingRsc && !hasRscPlugin) return;
+			referenceSecret ??= createReferenceSecret(options.getEncryptionKey?.() ?? loadOrGenerateServerActionsEncryptionKey({
+				root: config.root,
+				isBuild: config.command === "build"
+			}));
 			if (!pluginApi?.manager.serverReferences) throw new Error("vinext: callable use cache requires @vitejs/plugin-rsc 0.5.34 or newer.");
 			if (options.allowMissingRsc) {
 				const useCacheIndex = config.plugins.findIndex((plugin) => plugin.name === PLUGIN_NAME);
@@ -172,12 +193,13 @@ async function createUseCacheCallablePlugin(options) {
 				exclude: [NODE_MODULES_PATH_RE, RESOLVED_VIRTUAL_MODULE_ID_RE]
 			} },
 			async handler(code, id) {
-				if (!manager) return;
+				const secret = referenceSecret;
+				if (!manager || !secret) return;
 				if (!code.includes("use cache")) {
 					manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
 					return;
 				}
-				const { ast, moduleDirective, useServerBoundary, reference, secureExportName } = await analyzeModule(manager, code, id);
+				const { ast, moduleDirective, useServerBoundary, reference, secureExportName } = await analyzeModule(manager, secret, code, id);
 				if (!(this.environment.name === "rsc")) {
 					if (useServerBoundary) {
 						manager.serverReferences.deleteClaim(PLUGIN_NAME, id);

package/dist/plugins/worker-image-imports.d.ts

@@ -1,5 +1,6 @@
 import { Plugin } from "vite";
 //#region src/plugins/worker-image-imports.d.ts
+export declare const WORKER_IMAGE_METADATA_PREFIX = "\0vinext-worker-image-meta:";
 /**
  * Preserve Next.js's StaticImageData shape for dynamic image imports inside
  * Vite worker graphs. Worker builds use their own plugin container, so the