vike-react-rsc-rudder 1.0.0

package/dist/config.js

@@ -0,0 +1,875 @@
+import { tinyassert } from "@hiogawa/utils";
+import { defaultServerConditions, normalizePath, parseAstAsync } from "vite";
+import { serverEntryVirtualId } from "@brillout/vite-plugin-server-entry/plugin";
+import path from "path";
+import { hasDirective, transformDirectiveProxyExport, transformServerActionServer } from "@hiogawa/transforms";
+import { createHash } from "node:crypto";
+import path$1 from "node:path";
+import assert from "node:assert";
+import rscCore from "@vitejs/plugin-rsc/core/plugin";
+
+//#region src/plugin/plugins/clientDepTrackerPlugin.ts
+const jsFileRE$1 = /\.(jsx?|tsx?|m?js|cjs)$/;
+/**
+* Creates a client dependency tracker for handling client component dependencies
+* Works in both development and build modes with on-demand dependency tracking
+*/
+function clientDepTrackerPlugin() {
+	const jsImportMapBuild = {};
+	let staticGraph = null;
+	function buildGraph() {
+		const clientDependencies = new Set();
+		const collectClientDependencies = (moduleId, visited = new Set()) => {
+			if (visited.has(moduleId)) return;
+			visited.add(moduleId);
+			clientDependencies.add(moduleId);
+			for (const jsImport of jsImportMapBuild[moduleId] || []) collectClientDependencies(jsImport, new Set(visited));
+		};
+		for (const clientRefPath of Object.values(global.vikeReactRscGlobalState.clientReferences || {})) collectClientDependencies(clientRefPath, new Set());
+		console.log(`[Client Dependency Tracker] Found ${clientDependencies.size} client reference dependencies`);
+		return clientDependencies;
+	}
+	const plugin = {
+		name: "vike-rsc:client-dependency-tracker",
+		enforce: "pre",
+		resolveId: {
+			order: "pre",
+			async handler(source, importer, options) {
+				if (!importer || source.includes("\0") || source.includes("node_modules")) return;
+				try {
+					const resolved = await this.resolve(source, importer, {
+						skipSelf: true,
+						...options
+					});
+					if (!resolved) return;
+					const resolvedId = resolved.id;
+					if (!jsImportMapBuild[importer]) jsImportMapBuild[importer] = [];
+					if (jsFileRE$1?.test(resolvedId)) {
+						if (!jsImportMapBuild[importer].includes(resolvedId)) jsImportMapBuild[importer].push(resolvedId);
+					}
+				} catch (error) {}
+			}
+		},
+		buildEnd() {
+			if (this.environment.name === "rsc" && !global.vikeReactRscGlobalState.disableUseClientPlugin) staticGraph = buildGraph();
+		}
+	};
+	global.vikeReactRscGlobalState.isClientDependency = (id) => {
+		const dependencies = staticGraph || buildGraph();
+		if (Object.values(global.vikeReactRscGlobalState.clientReferences || {}).includes(id)) {
+			console.log(`[Client Dependency Tracker] ${id} is a client reference`);
+			return true;
+		}
+		const isClientDep = dependencies.has(id);
+		if (isClientDep && true) console.log(`[Client Dependency Tracker] ${id} is a client dependency`);
+		return isClientDep;
+	};
+	return plugin;
+}
+
+//#endregion
+//#region src/constants.ts
+const PKG_NAME = "vike-react-rsc-rudder";
+
+//#endregion
+//#region src/plugin/plugins/config.ts
+const distRsc = "dist/rsc";
+const configs = [
+	{
+		name: "vike-rsc:config:pre",
+		enforce: "pre",
+		config() {
+			const noExternal = [
+				"react",
+				"react-dom",
+				PKG_NAME,
+				"@vitejs/plugin-rsc",
+				"react-streaming"
+			];
+			return { environments: {
+				client: { optimizeDeps: {
+					include: ["react-dom/client", "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser"],
+					exclude: [
+						PKG_NAME,
+						"@vitejs/plugin-rsc",
+						"virtual:enviroment-name"
+					]
+				} },
+				ssr: {
+					optimizeDeps: {
+						include: [
+							"react",
+							"react-dom",
+							"react/jsx-runtime",
+							"react/jsx-dev-runtime",
+							"react-dom/server.edge",
+							"react-dom/static.edge",
+							"react-streaming/server.web",
+							"@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
+						],
+						exclude: [
+							PKG_NAME,
+							"@vitejs/plugin-rsc",
+							"virtual:enviroment-name"
+						]
+					},
+					resolve: { noExternal },
+					build: { rollupOptions: { input: {
+						ssr: "virtual:build-ssr-entry",
+						entry: serverEntryVirtualId
+					} } }
+				},
+				rsc: {
+					resolve: {
+						conditions: ["react-server", ...defaultServerConditions],
+						noExternal
+					},
+					optimizeDeps: {
+						include: [
+							"react",
+							"react-dom",
+							"react/jsx-runtime",
+							"react/jsx-dev-runtime",
+							"@vitejs/plugin-rsc/vendor/react-server-dom/server.edge",
+							"@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
+						],
+						exclude: [
+							PKG_NAME,
+							"@vitejs/plugin-rsc",
+							"virtual:enviroment-name"
+						]
+					},
+					build: {
+						outDir: distRsc,
+						ssr: true,
+						rollupOptions: { input: { index: "virtual:build-rsc-entry" } }
+					}
+				}
+			} };
+		},
+		sharedDuringBuild: false
+	},
+	{
+		name: "vike-rsc:config-rsc",
+		applyToEnvironment(env) {
+			return env.name === "rsc";
+		},
+		config() {
+			return { vitePluginServerEntry: { disableServerEntryEmit: true } };
+		}
+	},
+	{
+		name: "vike-rsc:config:post",
+		config() {
+			return { builder: { async buildApp(builder) {
+				global.vikeReactRscGlobalState.disableUseClientPlugin = true;
+				await builder.build(builder.environments.rsc);
+				global.vikeReactRscGlobalState.disableUseClientPlugin = false;
+				await builder.build(builder.environments.rsc);
+				await builder.build(builder.environments.client);
+				await builder.build(builder.environments.ssr);
+			} } };
+		}
+	}
+];
+
+//#endregion
+//#region src/plugin/plugins/cssTrackerPlugin.ts
+const styleFileRE$2 = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;
+const jsFileRE = /\.(jsx?|tsx?|m?js|cjs)$/;
+/**
+* Creates a CSS dependency tracker for proxying CSS imports from rsc to client
+*/
+function cssTrackerPlugin() {
+	const cssImportMapBuild = {};
+	const jsImportMapBuild = {};
+	const originalSourceMap = {};
+	let root;
+	const plugin = {
+		name: "vike-rsc:collect-css-dependencies",
+		applyToEnvironment(environment) {
+			return environment.name === "rsc";
+		},
+		configResolved(config$1) {
+			root = config$1.root;
+		},
+		resolveId: {
+			order: "pre",
+			async handler(source, importer, options) {
+				if (!importer || source.includes("\0") || source.includes("node_modules")) return;
+				try {
+					const resolved = await this.resolve(source, importer, {
+						skipSelf: true,
+						...options
+					});
+					if (!resolved) return;
+					const resolvedId = resolved.id;
+					originalSourceMap[resolvedId] = source;
+					if (!cssImportMapBuild[importer]) cssImportMapBuild[importer] = [];
+					if (!jsImportMapBuild[importer]) jsImportMapBuild[importer] = [];
+					if (styleFileRE$2?.test(resolvedId)) {
+						if (!cssImportMapBuild[importer].includes(resolvedId)) cssImportMapBuild[importer].push(resolvedId);
+					} else if (jsFileRE?.test(resolvedId)) {
+						if (!jsImportMapBuild[importer].includes(resolvedId)) jsImportMapBuild[importer].push(resolvedId);
+					}
+				} catch (error) {}
+			}
+		},
+		buildEnd() {
+			if (!global.vikeReactRscGlobalState.disableUseClientPlugin) staticGraph = buildGraph();
+		}
+	};
+	let staticGraph = null;
+	function buildGraph() {
+		const graph = {};
+		const processedModules = new Set();
+		const collectCssDependencies = (moduleId, visited = new Set()) => {
+			if (visited.has(moduleId) || processedModules.has(moduleId)) return;
+			visited.add(moduleId);
+			processedModules.add(moduleId);
+			graph[moduleId] = graph[moduleId] || new Set();
+			for (const cssImport of cssImportMapBuild[moduleId] || []) graph[moduleId].add({
+				importee: cssImport,
+				importer: moduleId
+			});
+			for (const jsImport of jsImportMapBuild[moduleId] || []) {
+				collectCssDependencies(jsImport, new Set(visited));
+				for (const cssImportInfo of graph[jsImport] || []) graph[moduleId].add(cssImportInfo);
+			}
+		};
+		const allModuleIds = [...new Set([...Object.keys(cssImportMapBuild), ...Object.keys(jsImportMapBuild)])];
+		for (const moduleId of allModuleIds) collectCssDependencies(moduleId);
+		{
+			const totalCssImports = Object.values(graph).reduce((sum, set) => sum + set.size, 0);
+			console.log(`[CSS Dependency Tracker] Built graph with ${Object.keys(graph).length} modules and ${totalCssImports} CSS imports`);
+		}
+		return graph;
+	}
+	global.vikeReactRscGlobalState.pruneCssRegistry = (id) => {
+		const removedModuleIds = new Set();
+		function removeModuleAndDependencies(moduleId) {
+			if (removedModuleIds.has(moduleId)) return;
+			removedModuleIds.add(moduleId);
+			const jsDependencies = [...jsImportMapBuild[moduleId] || []];
+			delete cssImportMapBuild[moduleId];
+			delete jsImportMapBuild[moduleId];
+			for (const jsDepId of jsDependencies) removeModuleAndDependencies(jsDepId);
+		}
+		removeModuleAndDependencies(id);
+		for (const [moduleId, jsDeps] of Object.entries(jsImportMapBuild)) jsImportMapBuild[moduleId] = jsDeps.filter((depId) => !removedModuleIds.has(depId));
+		staticGraph = null;
+		console.log(`[CSS Dependency Tracker] Removed module ${id} and ${removedModuleIds.size - 1} dependencies from the graph`);
+	};
+	global.vikeReactRscGlobalState.getCssDependencies = async (id) => {
+		if (!staticGraph) await traverse(global.vikeReactRscGlobalState.devServer.environments.rsc, id);
+		const graph = staticGraph || buildGraph();
+		const cssImportInfos = Array.from(graph[id] || new Set());
+		const cssIds = new Set();
+		const jsIds = new Set();
+		for (const { importee, importer } of cssImportInfos) {
+			cssIds.add(importee);
+			jsIds.add(importer);
+		}
+		const uniqueCssIds = Array.from(cssIds);
+		if (uniqueCssIds.length > 0) console.log(`[CSS Dependency Tracker] Found ${uniqueCssIds.length} CSS dependencies for ${id} from ${jsIds.size} JS modules`);
+		const normalizedCss = await Promise.all(uniqueCssIds.map((cssId) => normalizeId({
+			id: cssId,
+			server: global.vikeReactRscGlobalState.devServer?.environments.rsc,
+			root
+		})));
+		const normalizedJs = await Promise.all(Array.from(jsIds).map((jsId) => normalizeId({
+			id: jsId,
+			server: global.vikeReactRscGlobalState.devServer?.environments.rsc,
+			root
+		})));
+		return {
+			cssIds: normalizedCss,
+			jsIds: normalizedJs
+		};
+	};
+	return plugin;
+}
+async function traverse(server, entry) {
+	try {
+		const mod = await server.transformRequest(entry);
+		const deps = new Set(mod?.deps ?? []);
+		for (const dep of deps) try {
+			const mod$1 = await server.transformRequest(dep);
+			for (const element of mod$1?.deps ?? []) deps.add(element);
+		} catch (error) {}
+	} catch (e) {}
+}
+async function normalizeId({ id, server, root }) {
+	root ??= server?.config.root;
+	tinyassert(root);
+	if (id.startsWith(root)) id = id.slice(root.length);
+	return id.replace("\0", "");
+}
+
+//#endregion
+//#region src/plugin/plugins/dev.ts
+const exposeDevServer = {
+	name: "rsc-dev",
+	configureServer(server) {
+		global.vikeReactRscGlobalState.devServer = server;
+		try {
+			if (server.environments.rsc) server.environments.rsc.runner;
+			if (server.environments.ssr) server.environments.ssr.runner;
+			console.log("[RSC Plugin] Dev server runners initialized");
+		} catch (e) {
+			console.error("[RSC Plugin] Failed to initialize runners:", e);
+		}
+	}
+};
+
+//#endregion
+//#region src/plugin/plugins/injectManifestBuild.ts
+/**
+* Vite plugin that generates a manifest for React Server Components during build.
+* Creates a mapping of page IDs to their corresponding config loaders.
+*/
+function vikeRscManifestPluginBuild() {
+	const PLACEHOLDER = "__VIKE_RSC_PAGES_MANIFEST__";
+	return {
+		name: "vike-rsc-manifest-build",
+		apply: "build",
+		applyToEnvironment(environment) {
+			return environment.name === "rsc";
+		},
+		generateBundle(_outputOptions, bundle) {
+			const placeholderChunks = [];
+			const pageEntries = {};
+			for (const [fileName, output] of Object.entries(bundle)) {
+				if (output.type !== "chunk") continue;
+				const chunk = output;
+				if (chunk.isEntry && chunk.facadeModuleId) {
+					const pageId = chunk.facadeModuleId.split("virtual:vike:page-entry:server:")[1];
+					if (pageId) pageEntries[chunk.name] = {
+						chunkName: chunk.name,
+						fileName,
+						pageId
+					};
+				}
+				if (chunk.code && chunk.code.includes(PLACEHOLDER)) placeholderChunks.push(chunk);
+			}
+			for (const chunk of placeholderChunks) {
+				const manifestContent = generateManifestCode(pageEntries, chunk.fileName);
+				chunk.code = chunk.code.replace(new RegExp(PLACEHOLDER, "g"), manifestContent);
+			}
+		}
+	};
+}
+/**
+* Generates the manifest code with an IIFE containing a helper function
+* and the page entries map.
+*
+* @param pageEntries - Record of page entries with their metadata
+* @param chunkFileName - The file name of the current chunk
+* @returns The generated manifest code as a string
+*/
+function generateManifestCode(pageEntries, chunkFileName) {
+	let code = `(function() {
+  /**
+   * Helper function that extracts config values from the imported module
+   * @param {Object} module - The imported module containing configValuesSerialized
+   * @returns {Object} - The extracted configuration object
+   */
+  function extractConfig(module) {
+    return Object.fromEntries(
+      Object.entries(module.configValuesSerialized).map(([key, value]) => [
+        key,
+        [Array.isArray(value.valueSerialized)
+          ? value.valueSerialized.map(v => v.exportValues?.default || v.exportValues?.[key])
+          : value.valueSerialized.exportValues?.default || value.valueSerialized.exportValues?.[key]].flat(1)
+      ])
+    );
+  }
+
+  return {`;
+	let isFirst = true;
+	const chunkDir = path.dirname(chunkFileName);
+	for (const entry of Object.values(pageEntries)) {
+		if (!isFirst) code += ",";
+		isFirst = false;
+		const entryPath = path.relative(chunkDir, entry.fileName);
+		const normalizedPath = normalizePath(entryPath);
+		const importPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
+		code += `
+    "${entry.pageId}": {
+      getConfig: () => import("${importPath}").then(extractConfig)
+    }`;
+	}
+	code += `
+  };
+})()`;
+	return code;
+}
+
+//#endregion
+//#region src/plugin/plugins/serverComponentExclusionPlugin.ts
+const styleFileRE$1 = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;
+/**
+* Plugin to exclude server components from client and SSR bundles
+* while preserving CSS imports for proper styling.
+*/
+const serverComponentExclusionPlugin = () => {
+	const debug = true;
+	let devServer;
+	return [{
+		name: "vike-rsc:server-component-exclusion",
+		applyToEnvironment(environment) {
+			return environment.name === "client";
+		},
+		configureServer(server) {
+			devServer = server;
+		},
+		async transform(code, id) {
+			if (this.environment?.name !== "client") return null;
+			if (!code) return null;
+			if (id.includes("\0") || id.includes("node_modules") || styleFileRE$1.test(id) || !/\.(jsx?|tsx?|mjs|cjs)($|\?)/.test(id)) return null;
+			try {
+				const relPath = path.relative(this.environment.config.root, id);
+				if (relPath.startsWith("..") || path.isAbsolute(relPath)) return null;
+				const boundaries = [...Object.values(global.vikeReactRscGlobalState.clientReferences), ...Object.values(global.vikeReactRscGlobalState.serverReferences)];
+				if (boundaries.includes(id)) return null;
+				if (global.vikeReactRscGlobalState.isClientDependency(id)) {
+					if (debug) console.log(`[RSC Plugin] Preserving client dependency in client bundle: ${relPath}`);
+					return null;
+				}
+				const ast = await parseAstAsync(code);
+				if (hasDirective(ast.body, "use client") || hasDirective(ast.body, "use server")) {
+					if (debug) console.log(`[RSC Plugin] ${relPath} has use client/server directive, preserving in client bundle`);
+					return null;
+				}
+				const proxyCode = `
+// Server component asset proxy (original code excluded from client bundle)
+// Original file: ${id}
+export default {};
+export {};
+${devServer ? "import \"virtual:css-proxy.css?id=" + encodeURIComponent(id) + "\"" : "import \"virtual:css-proxy?id=" + encodeURIComponent(id) + "\""}
+if (import.meta.hot) {
+        import.meta.hot.accept();
+}
+`;
+				return {
+					code: proxyCode,
+					map: { mappings: "" }
+				};
+			} catch (error) {
+				console.error(`[RSC Plugin] Error in server component exclusion for ${id}:`, error);
+			}
+			return null;
+		}
+	}, {
+		name: "vike-rsc:css-proxy",
+		resolveId(source) {
+			if (source.startsWith("virtual:css-proxy")) return "\0" + source;
+		},
+		async load(id) {
+			if (!id.includes("virtual:css-proxy")) return;
+			const parsedUrl = new URL(id);
+			const externalId = parsedUrl.searchParams.get("id");
+			const res = await global.vikeReactRscGlobalState.getCssDependencies(externalId);
+			console.log(res);
+			const cssIds = res.cssIds;
+			if (debug && cssIds.length > 0) console.log(`[RSC Plugin] Found ${cssIds.length} CSS dependencies for ${externalId}`);
+			if (!devServer) return cssIds.map((cssPath) => `import "${cssPath}";`).join("\n") + "\n";
+			global.vikeReactRscGlobalState.excludedModuleMap[externalId] = res.jsIds;
+			const cssStrings = await Promise.all(cssIds.map((url) => devServer.environments.client.transformRequest(url + "?direct").then((res$1) => res$1?.code))).then((res$1) => res$1.filter(Boolean));
+			return cssStrings.join("\n");
+		}
+	}];
+};
+
+//#endregion
+//#region src/plugin/utils.ts
+function hashString(value) {
+	return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+async function normalizeReferenceId(id, name, server, config$1) {
+	if (!server) return hashString(path$1.relative(config$1.root, id));
+	const environment = server.environments[name];
+	const transformed = await environment.transformRequest("virtual:normalize-reference-id/" + encodeURIComponent(id));
+	assert(transformed);
+	const m = transformed.code.match(/(?:__vite_ssr_dynamic_import__|import)\("(.*)"\)/);
+	const newId = m?.[1];
+	if (!newId) {
+		console.error("[normalizeReferenceId]", {
+			name,
+			id,
+			code: transformed.code
+		});
+		throw new Error("normalizeReferenceId");
+	}
+	return newId;
+}
+function createVirtualPlugin(name, load) {
+	name = "virtual:" + name;
+	return {
+		name: `virtual-${name}`,
+		resolveId(source) {
+			return source === name ? "\0" + name : void 0;
+		},
+		load(id) {
+			if (id === "\0" + name) return load.apply(this);
+		}
+	};
+}
+function virtualNormalizeReferenceIdPlugin() {
+	const prefix = "virtual:normalize-reference-id/";
+	return {
+		name: "virtual-normalize-reference-id",
+		apply: "serve",
+		resolveId(source) {
+			if (source.startsWith(prefix)) return "\0" + source;
+		},
+		load(id) {
+			if (id.startsWith("\0" + prefix)) {
+				const decodedId = decodeURIComponent(id.slice(prefix.length + 1));
+				return `export default () => import("${decodedId}")`;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/plugin/plugins/useClientPlugin.ts
+const useClientPlugin = () => {
+	let resolvedConfig;
+	let devServer;
+	return [{
+		name: "vike-rsc:transform-client-directive",
+		configResolved(config$1) {
+			resolvedConfig = config$1;
+		},
+		configureServer(server) {
+			devServer = server;
+		},
+		async transform(code, id) {
+			if (this.environment?.name !== "rsc") return;
+			if (!code.includes("use client")) return;
+			if (global.vikeReactRscGlobalState.disableUseClientPlugin) return;
+			try {
+				const ast = await parseAstAsync(code);
+				const normalizedId = await normalizeReferenceId(id, "client", devServer, resolvedConfig);
+				const output = await transformDirectiveProxyExport(ast, {
+					directive: "use client",
+					id: normalizedId,
+					runtime: "$$register"
+				});
+				if (!output) return;
+				global.vikeReactRscGlobalState.clientReferences[normalizedId] = id;
+				output.prepend(`
+                import { registerClientReference } from "${PKG_NAME}/__internal/register/server";
+                const $$register = (id, name) => registerClientReference({}, id, name);
+              `);
+				return {
+					code: output.toString(),
+					map: { mappings: "" }
+				};
+			} catch (error) {
+				console.error(`[RSC Plugin] Error transforming client directive in ${id}:`, error);
+				return;
+			}
+		}
+	}, createVirtualPlugin("client-references", function() {
+		if (this.environment.name === "rsc" && this.environment?.mode !== "build") return "export default {};";
+		return [
+			`export default {`,
+			...Object.entries(global.vikeReactRscGlobalState.clientReferences).map(([normalizedId, id]) => `${JSON.stringify(normalizedId)}: () => import(${JSON.stringify(id)}),\n`),
+			`}`
+		].join("\n");
+	})];
+};
+
+//#endregion
+//#region src/plugin/plugins/useServerPlugin.ts
+const useServerPlugin = () => {
+	let resolvedConfig;
+	let devServer;
+	return [{
+		name: "vike-rsc:transform-server-directive",
+		configResolved(config$1) {
+			resolvedConfig = config$1;
+		},
+		configureServer(server) {
+			devServer = server;
+		},
+		async transform(code, id) {
+			if (id.includes("/.vite/")) return;
+			if (!code.includes("use server")) return;
+			try {
+				const ast = await parseAstAsync(code);
+				const normalizedId = await normalizeReferenceId(id, "rsc", devServer, resolvedConfig);
+				if (this.environment.name === "rsc") {
+					const { output } = await transformServerActionServer(code, ast, {
+						id: normalizedId,
+						runtime: "$$register"
+					});
+					if (!output.hasChanged()) return;
+					global.vikeReactRscGlobalState.serverReferences[normalizedId] = id;
+					output.prepend(`
+              import { registerServerReference } from "${PKG_NAME}/__internal/register/server";
+              const $$register = (value, id, name) => {
+                if (typeof value !== 'function') return value;
+                return registerServerReference(value, id, name);
+              }
+            `);
+					return {
+						code: output.toString(),
+						map: output.generateMap({ hires: "boundary" })
+					};
+				} else {
+					const output = await transformDirectiveProxyExport(ast, {
+						id: normalizedId,
+						runtime: "$$proxy",
+						directive: "use server"
+					});
+					if (!output) return;
+					global.vikeReactRscGlobalState.serverReferences[normalizedId] = id;
+					const res = await global.vikeReactRscGlobalState.getCssDependencies(id);
+					console.log(res);
+					for (const cssId of res.cssIds) output.prepend(`import "${cssId}";`);
+					const name = this.environment.name === "client" ? "browser" : "ssr";
+					output.prepend(`
+              import { createServerReference, callServer } from "${PKG_NAME}/__internal/register/${name}";
+              const $$proxy = (id, name) => {
+                  const r = createServerReference(${JSON.stringify(normalizedId)} + "#" + name, (...args) =>{ "${normalizedId}"; return callServer(...args)})
+                  Object.defineProperty(r, "name", { value: ${JSON.stringify(normalizedId)}});
+                  return r;
+              }
+            `);
+					return {
+						code: output.toString(),
+						map: { mappings: "" }
+					};
+				}
+			} catch (error) {
+				console.error(`[RSC Plugin] Error transforming server directive in ${id}:`, error);
+				return;
+			}
+		}
+	}, createVirtualPlugin("server-references", function() {
+		if (this.environment.name !== "rsc" || this.environment?.mode !== "build") return "export default {};";
+		return [
+			`export default {`,
+			...Object.entries(global.vikeReactRscGlobalState.serverReferences).map(([normalizedId, id]) => `${JSON.stringify(normalizedId)}: () => import(${JSON.stringify(id)}),\n`),
+			`}`
+		].join("\n");
+	})];
+};
+
+//#endregion
+//#region src/plugin/plugins/virtuals.ts
+const importRsc = `
+              import * as serverModule from "${PKG_NAME}/__internal/runtime/server";
+              export * from "${PKG_NAME}/__internal/runtime/server";
+              export default serverModule;
+            `;
+const importSsr = `
+              import * as ssrModule from "${PKG_NAME}/__internal/runtime/ssr";
+              export * from "${PKG_NAME}/__internal/runtime/ssr";
+              export default ssrModule;
+            `;
+const virtuals = [
+	createVirtualPlugin("enviroment-name", function() {
+		return `export default "${this.environment.name}"`;
+	}),
+	createVirtualPlugin("build-rsc-entry", () => importRsc),
+	createVirtualPlugin("build-ssr-entry", () => importSsr),
+	createVirtualPlugin("runtime/ssr", function() {
+		if (this.environment.name === "ssr") return importSsr;
+		if (this.environment.mode === "dev") return `
+            const devServer = global.vikeReactRscGlobalState.devServer;
+            const ssrRunner = devServer?.environments.ssr?.runner;
+            const ssrModule = await ssrRunner?.import("${PKG_NAME}/__internal/runtime/ssr");
+            const moduleProxy = new Proxy({}, {
+              get(target, prop) {
+                return ssrModule[prop];
+              }
+            });
+            export default moduleProxy;
+            `;
+		return `
+          import * as ssrModule from "virtual:dist-importer?server";
+          export * from "virtual:dist-importer?server";
+          export default ssrModule;
+        `;
+	}),
+	createVirtualPlugin("runtime/server", function() {
+		if (this.environment.name === "rsc") return importRsc;
+		if (this.environment.mode === "dev") return `
+            const devServer = global.vikeReactRscGlobalState.devServer;
+            const serverRunner = devServer?.environments.rsc?.runner;
+            const serverModule = await serverRunner?.import("${PKG_NAME}/__internal/runtime/server");
+            const moduleProxy = new Proxy({}, {
+              get(target, prop) {
+                return serverModule[prop];
+              }
+            });
+            export default moduleProxy;
+            `;
+		return `
+          import * as serverModule from "virtual:dist-importer?rsc";
+          export * from "virtual:dist-importer?rsc";
+          export default serverModule;
+        `;
+	}),
+	{
+		name: "virtual:dist-importer",
+		resolveId(source) {
+			if (source.includes("virtual:dist-importer")) return {
+				id: `__VIRTUAL_BUILD_ENTRY__?${source.split("?")[1]}`,
+				external: true
+			};
+			return;
+		},
+		renderChunk(code, chunk) {
+			if (code.includes("__VIRTUAL_BUILD_ENTRY__")) {
+				const importerPath = path.join(this.environment.config.build.outDir, chunk.fileName);
+				code = code.replaceAll("__VIRTUAL_BUILD_ENTRY__?server", path.relative(path.dirname(importerPath), "dist/server/ssr.mjs")).replaceAll("__VIRTUAL_BUILD_ENTRY__?rsc", path.relative(path.dirname(importerPath), "dist/rsc/index.mjs"));
+				return { code };
+			}
+			return;
+		}
+	}
+];
+
+//#endregion
+//#region src/plugin/plugins/hmrPlugin.ts
+const styleFileRE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;
+const hmrPlugin = () => {
+	return {
+		name: "vike-rsc:hmr",
+		hotUpdate: {
+			order: "pre",
+			handler(ctx) {
+				const clientEnv = ctx.server.environments.client;
+				const cliendIds = new Set(Object.values(global.vikeReactRscGlobalState.clientReferences));
+				if (this.environment.name === "ssr") {
+					const withoutRscMods = ctx.modules.filter(({ id }) => {
+						return id && (cliendIds.has(id) || !global.vikeReactRscGlobalState.devServer?.environments.rsc.moduleGraph.getModuleById(id));
+					});
+					return withoutRscMods;
+				}
+				if (this.environment.name === "client") {
+					const withoutRscMods = ctx.modules.filter(({ id }) => {
+						return id && (cliendIds.has(id) || global.vikeReactRscGlobalState.isClientDependency(id) || styleFileRE.test(id) || !global.vikeReactRscGlobalState.devServer?.environments.rsc.moduleGraph.getModuleById(id));
+					});
+					return withoutRscMods;
+				}
+				if (this.environment.name === "rsc") {
+					const ids = ctx.modules.map((mod) => mod.id).filter((v) => v !== null);
+					const flattenedImporters = new Set(ctx.modules);
+					for (const mod of flattenedImporters) {
+						if (mod.id && cliendIds.has(mod.id)) break;
+						console.log(global.vikeReactRscGlobalState.excludedModuleMap, mod.url);
+						const excludedModule = Object.entries(global.vikeReactRscGlobalState.excludedModuleMap).find(([root, jsIds]) => jsIds.some((id) => id.split("?t=")[0] === mod.url))?.[0];
+						if (excludedModule) {
+							global.vikeReactRscGlobalState.pruneCssRegistry(excludedModule);
+							this.environment.moduleGraph.invalidateModule(mod);
+							const clientMod = clientEnv.moduleGraph.getModuleById(excludedModule);
+							const cssProxyModClient = clientEnv.moduleGraph.getModuleById(`\0virtual:css-proxy.css?id=${encodeURIComponent(excludedModule)}`);
+							clientEnv.moduleGraph.invalidateModule(clientMod);
+							clientEnv.moduleGraph.invalidateModule(cssProxyModClient);
+							clientEnv.reloadModule(cssProxyModClient);
+							break;
+						}
+						for (const importer of mod.importers) flattenedImporters.add(importer);
+					}
+					if (ids.length > 0) if (ids.some((id) => cliendIds.has(id))) return;
+					else ctx.server.environments.client.hot.send({
+						type: "custom",
+						event: "rsc:update",
+						data: { file: ctx.file }
+					});
+				}
+			}
+		}
+	};
+};
+
+//#endregion
+//#region src/plugin/index.ts
+global.vikeReactRscGlobalState ||= {
+	clientReferences: {},
+	serverReferences: {},
+	devServer: void 0,
+	disableUseClientPlugin: false,
+	getCssDependencies: async () => ({
+		cssIds: [],
+		jsIds: []
+	}),
+	pruneCssRegistry: () => {},
+	isClientDependency: () => false,
+	excludedModuleMap: {}
+};
+function vikeRscPlugin() {
+	return [
+		...configs,
+		...virtuals,
+		exposeDevServer,
+		vikeRscManifestPluginBuild(),
+		cssTrackerPlugin(),
+		clientDepTrackerPlugin(),
+		...useClientPlugin(),
+		...useServerPlugin(),
+		virtualNormalizeReferenceIdPlugin(),
+		...serverComponentExclusionPlugin(),
+		hmrPlugin(),
+		rscCore()
+	];
+}
+
+//#endregion
+//#region src/config.ts
+const config = {
+	name: "vike-react-rsc-rudder",
+	require: { vike: ">=0.4.182" },
+	onRenderHtml: "import:vike-react-rsc-rudder/__internal/integration/onRenderHtml:onRenderHtml",
+	onRenderClient: "import:vike-react-rsc-rudder/__internal/integration/onRenderClient:onRenderClient",
+	onBeforeRender: "import:vike-react-rsc-rudder/__internal/integration/onBeforeRender:onBeforeRender",
+	onPageTransitionStart: "import:vike-react-rsc-rudder/__internal/integration/onPageTransitionStart:onPageTransitionStart",
+	client: "import:vike-react-rsc-rudder/__internal/integration/client:default",
+	middleware: "import:vike-react-rsc-rudder/__internal/integration/rscMiddleware:default",
+	passToClient: ["rscPayloadString"],
+	clientRouting: true,
+	hydrationCanBeAborted: true,
+	meta: {
+		rsc: { env: {
+			server: true,
+			client: false
+		} },
+		onBeforeRender: { env: {
+			server: true,
+			client: false
+		} },
+		Head: {
+			env: { server: true },
+			cumulative: true
+		},
+		Wrapper: {
+			env: {
+				client: true,
+				server: true
+			},
+			cumulative: true
+		},
+		Layout: {
+			env: {
+				server: true,
+				client: true
+			},
+			cumulative: true
+		},
+		Loading: { env: {
+			server: true,
+			client: true
+		} }
+	},
+	vite6BuilderApp: true,
+	vite: { plugins: [vikeRscPlugin()] }
+};
+
+//#endregion
+export { config as default };