@vitejs/plugin-rsc 0.5.32 → 0.5.34

package/dist/transforms/index.js

@@ -1,5 +1,5 @@
 import { i as tinyassert } from "../dist-uqdtSkzK.js";
-import { a as validateNonAsyncFunction, i as hasDirective, n as extractIdentifiers, r as extractNames, t as buildScopeTree } from "../scope-Do08R7C2.js";
+import { a as isDirective, i as hasDirective, n as extractIdentifiers, o as rejectNonAsyncFunction, r as extractNames, s as validateNonAsyncFunction, t as buildScopeTree } from "../scope-Bdx33sQv.js";
 import MagicString from "magic-string";
 import { walk } from "estree-walker";
 //#region src/transforms/hoist.ts
@@ -55,20 +55,41 @@ import { walk } from "estree-walker";
 *
 * In this second sketch, `__ENCODE__(...)` and `__DECODE__(...)` likewise
 * represent the expressions returned by those code-generation callbacks.
+*
+* With `hoistRuntime`, the runtime result becomes the module-level binding and
+* the moved function becomes its private implementation:
+*
+* ```js
+* function Component() {
+*   const x = 1
+*   const action = $$hoist_0_action.bind(null, x)
+* }
+* export const $$hoist_0_action = __RUNTIME__($$hoist_0_action$$impl)
+* async function $$hoist_0_action$$impl(x, y) {
+*   "use server"
+*   return x + y
+* }
+* ```
+*
+* `noExport` independently keeps `$$hoist_0_action` module-local when an
+* integration needs module-scope runtime initialization without an export.
 */
-function transformHoistInlineDirective(input, ast, { runtime, rejectNonAsyncFunction, ...options }) {
+function transformHoistInlineDirective(input, viteAst, { runtime, rejectNonAsyncFunction, ...options }) {
+	const ast = viteAst;
 	if (!input.endsWith("\n")) input += "\n";
 	const output = new MagicString(input);
 	const directive = typeof options.directive === "string" ? exactRegex(options.directive) : options.directive;
 	const scopeTree = buildScopeTree(ast);
 	const names = [];
+	const runtimeHoists = [];
 	walk(ast, { enter(node, parent) {
 		if ((node.type === "FunctionExpression" || node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression") && node.body.type === "BlockStatement") {
 			const match = matchDirective(node.body.body, directive)?.match;
 			if (!match) return;
+			const methodInfo = getMethodInfo(node, parent, match[0]);
 			if (!node.async && rejectNonAsyncFunction) throw Object.assign(/* @__PURE__ */ new Error(`"${directive}" doesn't allow non async function`), { pos: node.start });
 			const declName = node.type === "FunctionDeclaration" && node.id.name;
-			const originalName = declName || parent?.type === "VariableDeclarator" && parent.id.type === "Identifier" && parent.id.name || "anonymous_server_function";
+			const originalName = declName || methodInfo?.name || parent?.type === "VariableDeclarator" && parent.id.type === "Identifier" && parent.id.name || "anonymous_server_function";
 			const bindVars = getBindVars(node, scopeTree);
 			let newParams = [...bindVars.map((b) => b.root), ...node.params.map((n) => input.slice(n.start, n.end))].join(", ");
 			if (bindVars.length > 0 && options.decode) {
@@ -77,15 +98,27 @@ function transformHoistInlineDirective(input, ast, { runtime, rejectNonAsyncFunc
 			}
 			const newName = `$$hoist_${names.length}` + (originalName ? `_${originalName}` : "");
 			names.push(newName);
-			output.update(node.start, node.body.start, `\n;${options.noExport ? "" : "export "}${node.async ? "async " : ""}function${node.generator ? "*" : ""} ${newName}(${newParams}) `);
-			output.appendLeft(node.end, `;\n/* #__PURE__ */ Object.defineProperty(${newName}, "name", { value: ${JSON.stringify(originalName)} });\n`);
+			const implementationName = options.hoistRuntime ? `${newName}$$impl` : newName;
+			output.update(node.start, node.body.start, `\n;${options.noExport || options.hoistRuntime ? "" : "export "}${node.async ? "async " : ""}function${node.generator ? "*" : ""} ${implementationName}(${newParams}) `);
+			const runtimeCode = `/* #__PURE__ */ ${runtime(implementationName, newName, {
+				directiveMatch: match,
+				valueNode: node
+			})}`;
+			if (options.hoistRuntime) runtimeHoists.push(`${options.noExport ? "" : "export "}const ${newName} = ${runtimeCode};\n`);
+			output.appendLeft(node.end, `;\n/* #__PURE__ */ Object.defineProperty(${implementationName}, "name", { value: ${JSON.stringify(originalName)} });\n`);
 			output.move(node.start, node.end, input.length);
-			let newCode = `/* #__PURE__ */ ${runtime(newName, newName, { directiveMatch: match })}`;
+			let newCode = options.hoistRuntime ? newName : runtimeCode;
 			if (bindVars.length > 0) {
 				const bindArgs = options.encode ? options.encode("[" + bindVars.map((b) => b.expr).join(", ") + "]") : bindVars.map((b) => b.expr).join(", ");
 				newCode = `${newCode}.bind(null, ${bindArgs})`;
 			}
-			if (declName) {
+			if (methodInfo) {
+				const isStatic = methodInfo.node.type === "MethodDefinition";
+				const key = input.slice(methodInfo.node.key.start, methodInfo.node.key.end);
+				const propertyKey = !methodInfo.node.computed && methodInfo.node.key.type === "Identifier" ? `["${key}"]` : `[${key}]`;
+				output.update(methodInfo.node.start, node.start, `${isStatic ? "static " : ""}${propertyKey}${isStatic ? " = " : ": "}`);
+				if (isStatic) newCode += ";";
+			} else if (declName) {
 				newCode = `const ${declName} = ${newCode};`;
 				if (parent?.type === "ExportDefaultDeclaration") {
 					output.remove(parent.start, node.start);
@@ -95,22 +128,44 @@ function transformHoistInlineDirective(input, ast, { runtime, rejectNonAsyncFunc
 			output.appendLeft(node.start, newCode);
 		}
 	} });
+	if (runtimeHoists.length > 0) output.prependLeft(getRuntimeHoistPosition(ast), runtimeHoists.join(""));
 	return {
 		output,
 		names
 	};
 }
+function getMethodInfo(node, parent, directive) {
+	if (node.type !== "FunctionExpression") return;
+	let method;
+	if (parent?.type === "Property" && parent.value === node && (parent.method || parent.kind !== "init")) method = parent;
+	else if (parent?.type === "MethodDefinition") method = parent;
+	else return;
+	if (method.type === "MethodDefinition" && !method.static) throw Object.assign(/* @__PURE__ */ new Error(`It is not allowed to define inline ${JSON.stringify(directive)} class instance methods.`), { pos: method.start });
+	if (method.type === "MethodDefinition" && method.key.type === "PrivateIdentifier") throw Object.assign(/* @__PURE__ */ new Error(`It is not allowed to define inline ${JSON.stringify(directive)} private class methods.`), { pos: method.start });
+	if (method.type === "Property" && method.kind !== "init" || method.type === "MethodDefinition" && method.kind !== "method") throw Object.assign(/* @__PURE__ */ new Error(`It is not allowed to define inline ${JSON.stringify(directive)} getters or setters.`), { pos: method.start });
+	const keyName = !method.computed && method.key.type === "Identifier" ? method.key.name : void 0;
+	return {
+		node: method,
+		name: keyName
+	};
+}
+function getRuntimeHoistPosition(ast) {
+	for (const statement of ast.body) if (!isDirective(statement)) return statement.start;
+	return 0;
+}
 const exactRegex = (s) => new RegExp("^" + s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&") + "$");
 function matchDirective(body, directive) {
-	for (const stmt of body) if (stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string") {
-		const match = stmt.expression.value.match(directive);
+	for (const stmt of body) {
+		if (!isDirective(stmt)) return;
+		const match = stmt.directive.match(directive);
 		if (match) return {
 			match,
 			node: stmt.expression
 		};
 	}
 }
-function findDirectives(ast, directive) {
+function findDirectives(viteAst, directive) {
+	const ast = viteAst;
 	const directiveRE = exactRegex(directive);
 	const nodes = [];
 	walk(ast, { enter(node) {
@@ -209,128 +264,374 @@ function dedupeByPrefix(paths) {
 	return result;
 }
 //#endregion
+//#region src/transforms/module-export-scan.ts
+function scanModuleExports(viteAst) {
+	const ast = viteAst;
+	const groups = [];
+	for (const node of ast.body) if (node.type === "ExportNamedDeclaration") if (node.declaration) if (node.declaration.type === "VariableDeclaration") {
+		const declaration = node.declaration;
+		groups.push({
+			type: "variable-declaration",
+			node,
+			declaration,
+			declarators: declaration.declarations.map((declarator) => {
+				const isFunction = declarator.id.type === "Identifier" && declarator.init ? getIsFunction(declarator.init) : void 0;
+				return {
+					node: declarator,
+					exports: extractNames(declarator.id).map((name) => ({
+						localName: name,
+						exportName: name,
+						meta: {
+							declName: name,
+							isFunction,
+							valueNode: declarator.init ?? void 0
+						}
+					}))
+				};
+			})
+		});
+	} else {
+		tinyassert(node.declaration.id);
+		const name = node.declaration.id.name;
+		groups.push({
+			type: "declaration",
+			node,
+			declaration: node.declaration,
+			export: {
+				localName: name,
+				exportName: name,
+				meta: {
+					declName: name,
+					isFunction: getIsFunction(node.declaration),
+					valueNode: node.declaration
+				}
+			}
+		});
+	}
+	else groups.push({
+		type: "specifiers",
+		node,
+		exports: node.specifiers.map((specifier) => {
+			return {
+				node: specifier,
+				localName: specifier.local.type === "Identifier" ? specifier.local.name : "__unsupported_string_export__",
+				exportName: specifier.exported.type === "Identifier" ? specifier.exported.name : "__unsupported_string_export__",
+				meta: {}
+			};
+		})
+	});
+	else if (node.type === "ExportAllDeclaration") groups.push({
+		type: "export-all",
+		node
+	});
+	else if (node.type === "ExportDefaultDeclaration") {
+		let kind;
+		let localName;
+		let meta;
+		if ((node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") && node.declaration.id) {
+			kind = "named-declaration";
+			localName = node.declaration.id.name;
+			meta = {
+				declName: node.declaration.id.name,
+				isFunction: getIsFunction(node.declaration),
+				valueNode: node.declaration
+			};
+		} else if (node.declaration.type === "Identifier") {
+			kind = "identifier";
+			meta = {
+				defaultExportIdentifierName: node.declaration.name,
+				valueNode: node.declaration
+			};
+		} else {
+			kind = "other";
+			meta = {
+				isFunction: getIsFunction(node.declaration),
+				valueNode: node.declaration
+			};
+		}
+		groups.push({
+			type: "default",
+			kind,
+			node,
+			localName,
+			meta
+		});
+	}
+	return groups;
+}
+function getIsFunction(node) {
+	if (node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return true;
+	if (node.type === "ClassDeclaration" || node.type === "Literal" || node.type === "ObjectExpression" || node.type === "ArrayExpression" || node.type === "ClassExpression") return false;
+}
+//#endregion
+//#region src/transforms/module-export-effect.ts
+/**
+* Preserves source bindings and emits registration effects at module end.
+*
+* Conceptually:
+*
+* ```js
+* export async function action() {}
+* export default async () => {}
+* ```
+*
+* becomes:
+*
+* ```js
+* async function action() {}
+* const $$effect_default = async () => {}
+*
+* __GENERATE__(action, 'action')
+* export { action }
+* __GENERATE__($$effect_default, 'default')
+* export default $$effect_default
+* ```
+*
+* Here, `__GENERATE__(...)` represents the expression returned by the
+* `generate` callback for each `{ binding, exportName, meta }` context.
+* `references` returns those contexts in generation order, while
+* `referenceNames` returns only their export names.
+*
+* Effects emitted through declaration and default-export rewrites remain mapped
+* to their original export sites. Export-specifier effects are appended without
+* explicit mappings and rely on adjacent-source fallback. React captures the
+* `registerServerReference` caller as the reference source location.
+*
+* Generated bindings such as `$$effect_default` and `$$effect_import_*` are not
+* deconflicted from user bindings, consistent with the other transform helpers.
+*/
+function transformModuleExportEffect(input, viteAst, options) {
+	const output = new MagicString(input);
+	const filter = options.filter ?? (() => true);
+	const references = [];
+	function generate(context) {
+		references.push(context);
+		return `${options.generate(context)};`;
+	}
+	function replaceAndMove(start, end, destination, code) {
+		output.update(start, end, `\n${code}\n`);
+		if (end !== destination) output.move(start, end, destination);
+	}
+	for (const group of scanModuleExports(viteAst)) if (group.type === "declaration") {
+		const { localName: binding, exportName, meta } = group.export;
+		if (!filter(exportName, meta)) continue;
+		validateNonAsyncFunction(options, group.declaration);
+		replaceAndMove(group.node.start, group.declaration.start, input.length, `${generate({
+			binding,
+			exportName,
+			meta
+		})}\nexport { ${binding} };`);
+	} else if (group.type === "variable-declaration") {
+		const exportNames = [];
+		const effects = [];
+		for (const declarator of group.declarators) {
+			let validate = false;
+			for (const entry of declarator.exports) {
+				const { localName: binding, exportName, meta } = entry;
+				exportNames.push(exportName);
+				if (filter(exportName, meta)) {
+					validate = true;
+					effects.push(generate({
+						binding,
+						exportName,
+						meta
+					}));
+				}
+			}
+			if (validate) {
+				const init = declarator.node.init;
+				if (init) validateNonAsyncFunction(options, init);
+				else rejectNonAsyncFunction(options, declarator.node.start);
+			}
+		}
+		if (effects.length > 0) replaceAndMove(group.node.start, group.declaration.start, input.length, `${effects.join("\n")}\nexport { ${exportNames.join(", ")} };`);
+	} else if (group.type === "specifiers") for (const entry of group.exports) {
+		tinyassert(entry.node.local.type === "Identifier");
+		if (entry.node.exported.type !== "Identifier") throw Object.assign(/* @__PURE__ */ new Error("unsupported string literal export name"), { pos: entry.node.exported.start });
+		const { exportName, meta } = entry;
+		if (!filter(exportName, meta)) continue;
+		let binding = entry.localName;
+		if (group.node.source) {
+			binding = `$$effect_import_${exportName}`;
+			output.append(`\nimport { ${entry.localName} as ${binding} } from ${group.node.source.raw};`);
+		}
+		output.append(`\n${generate({
+			binding,
+			exportName,
+			meta
+		})}`);
+	}
+	else if (group.type === "export-all") {
+		if (options.exportAll !== "preserve") throw Object.assign(/* @__PURE__ */ new Error("unsupported ExportAllDeclaration"), { pos: group.node.start });
+	} else if (group.type === "default") {
+		const node = group.node;
+		const binding = group.localName ?? "$$effect_default";
+		const meta = group.meta;
+		if (!filter("default", meta)) continue;
+		validateNonAsyncFunction(options, node.declaration);
+		const effect = generate({
+			binding,
+			exportName: "default",
+			meta
+		});
+		if (group.kind === "identifier") {
+			const declaration = node.declaration;
+			const exportTokenEnd = node.start + 6;
+			output.update(exportTokenEnd, node.end, `const ${binding} = ${declaration.name};`);
+			replaceAndMove(node.start, exportTokenEnd, input.length, `${effect}\nexport default ${binding};`);
+		} else if (group.kind === "named-declaration") replaceAndMove(node.start, node.declaration.start, input.length, `${effect}\nexport default ${binding};`);
+		else {
+			const exportTokenEnd = node.start + 6;
+			output.update(exportTokenEnd, node.declaration.start, `const ${binding} = `);
+			replaceAndMove(node.start, exportTokenEnd, input.length, `${effect}\nexport default ${binding};`);
+		}
+	}
+	return {
+		output,
+		references,
+		referenceNames: references.map((reference) => reference.exportName)
+	};
+}
+//#endregion
 //#region src/transforms/wrap-export.ts
-function transformWrapExport(input, ast, options) {
+/**
+* Replaces selected module-local export bindings with runtime wrappers.
+*
+* Conceptually:
+*
+* ```js
+* export async function action() {}
+* export const loader = async () => {}
+* export default function Page() {}
+* ```
+*
+* becomes:
+*
+* ```js
+* async function action() {}
+* let loader = async () => {}
+* function Page() {}
+*
+* action = __WRAP__(action, 'action')
+* export { action }
+* loader = __WRAP__(loader, 'loader')
+* export { loader }
+* const $$wrap_Page = __WRAP__(Page, 'default')
+* export { $$wrap_Page as default }
+* ```
+*
+* Here, `__WRAP__(...)` represents the expression returned by `runtime`.
+* Unlike `transformModuleExportWrap`, direct local references observe the
+* wrapped value because the original binding itself is reassigned.
+*
+* Declaration rewrites are moved to the end of the module so each generated
+* runtime call retains the original export token's source mapping. Wrappers for
+* export specifiers and default exports are appended without explicit mappings.
+*
+* Generated `$$wrap_*` and `$$import_*` names are not deconflicted from user
+* bindings, consistent with the other transform helpers.
+*/
+function transformWrapExport(input, viteAst, options) {
 	const output = new MagicString(input);
 	const exportNames = [];
-	const toAppend = [];
+	const appendedCode = [];
 	const filter = options.filter ?? (() => true);
-	function wrapSimple(start, end, exports) {
-		const filteredExports = exports.map((item) => ({
-			...item,
-			shouldWrap: filter(item.name, item.meta)
-		}));
-		exportNames.push(...filteredExports.filter((item) => item.shouldWrap).map((item) => item.name));
-		const newCode = filteredExports.map((e) => [e.shouldWrap && `${e.name} = /* #__PURE__ */ ${options.runtime(e.name, e.name, e.meta)};\n`, `export { ${e.name} };\n`]).flat().filter(Boolean).join("");
+	/**
+	* Strips a direct export declaration and emits assignments and exports at
+	* module end. All bindings are re-exported, but only selected bindings are
+	* assigned runtime wrappers.
+	*
+	* The rewritten source range is moved so generated runtime calls borrow the
+	* original export site's mapping:
+	*
+	* ```js
+	* // input
+	* export async function action() {}
+	* ^^^^^^
+	*
+	* // output
+	* async function action() {}
+	* action = __WRAP__(action, 'action')  << maps to the `export` token
+	* export { action }                    <<
+	* ```
+	*/
+	function emitWrappedAssignments(start, end, exports, selectedExportNames) {
+		exportNames.push(...selectedExportNames);
+		const newCode = exports.map((e) => selectedExportNames.has(e.exportName) && `${e.localName} = /* #__PURE__ */ ${options.runtime(e.localName, e.exportName, e.meta)};\n`).filter(Boolean).join("") + `export { ${exports.map((e) => e.localName).join(", ")} };\n`;
 		output.update(start, end, newCode);
 		output.move(start, end, input.length);
 	}
-	function wrapExport(name, exportName, meta = {}) {
-		if (!filter(exportName, meta)) {
-			toAppend.push(`export { ${name} as ${exportName} }`);
-			return;
-		}
+	/**
+	* Emits a separate wrapper binding for exports that cannot reassign an
+	* existing direct declaration, such as export specifiers and defaults.
+	*
+	* ```js
+	* // existing source binding remains unchanged
+	* const local = init()
+	* export { local as renamed }  // caller removes the original export
+	*
+	* // appended code
+	* const $$wrap_local = __WRAP__(local, 'renamed')
+	* export { $$wrap_local as renamed }
+	* ```
+	*/
+	function emitWrappedBinding(name, exportName, meta = {}) {
 		exportNames.push(exportName);
-		toAppend.push(`const $$wrap_${name} = /* #__PURE__ */ ${options.runtime(name, exportName, meta)}`, `export { $$wrap_${name} as ${exportName} }`);
+		appendedCode.push(`const $$wrap_${name} = /* #__PURE__ */ ${options.runtime(name, exportName, meta)}`, `export { $$wrap_${name} as ${exportName} }`);
 	}
-	for (const node of ast.body) {
-		if (node.type === "ExportNamedDeclaration") if (node.declaration) if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
-			/**
-			* export function foo() {}
-			*/
-			const name = node.declaration.id.name;
-			const meta = {
-				isFunction: getIsFunction(node.declaration),
-				declName: name
-			};
-			if (filter(name, meta)) validateNonAsyncFunction(options, node.declaration);
-			wrapSimple(node.start, node.declaration.start, [{
-				name,
-				meta
-			}]);
-		} else if (node.declaration.type === "VariableDeclaration") {
-			/**
-			* export const foo = 1, bar = 2
-			*/
-			if (node.declaration.kind === "const") output.update(node.declaration.start, node.declaration.start + 5, "let");
-			const exports = [];
-			for (const decl of node.declaration.declarations) {
-				const isFunction = decl.id.type === "Identifier" && decl.init ? getIsFunction(decl.init) : void 0;
-				const declarationExports = extractNames(decl.id).map((name) => ({
-					name,
-					meta: {
-						isFunction,
-						declName: name
-					}
-				}));
-				exports.push(...declarationExports);
-				if (decl.init && declarationExports.some(({ name, meta }) => filter(name, meta))) validateNonAsyncFunction(options, decl.init);
-			}
-			wrapSimple(node.start, node.declaration.start, exports);
-		} else node.declaration;
-		else if (node.source) {
-			/**
-			* export { foo, bar as car } from './foo'
-			*/
-			output.remove(node.start, node.end);
-			for (const spec of node.specifiers) {
-				tinyassert(spec.local.type === "Identifier");
-				if (spec.exported.type !== "Identifier") throw Object.assign(/* @__PURE__ */ new Error("unsupported string literal export name"), { pos: spec.exported.start });
-				const name = spec.local.name;
-				toAppend.push(`import { ${name} as $$import_${name} } from ${node.source.raw}`);
-				wrapExport(`$$import_${name}`, spec.exported.name);
+	for (const group of scanModuleExports(viteAst)) if (group.type === "declaration") {
+		const entry = group.export;
+		if (!filter(entry.exportName, entry.meta)) continue;
+		validateNonAsyncFunction(options, group.declaration);
+		emitWrappedAssignments(group.node.start, group.declaration.start, [entry], /* @__PURE__ */ new Set([entry.exportName]));
+	} else if (group.type === "variable-declaration") {
+		const exports = group.declarators.flatMap((item) => item.exports);
+		const selectedExportNames = new Set(exports.filter((entry) => filter(entry.exportName, entry.meta)).map((entry) => entry.exportName));
+		if (selectedExportNames.size === 0) continue;
+		if (group.declaration.kind === "const") output.update(group.declaration.start, group.declaration.start + 5, "let");
+		for (const declarator of group.declarators) if (declarator.exports.some(({ exportName }) => selectedExportNames.has(exportName))) if (declarator.node.init) validateNonAsyncFunction(options, declarator.node.init);
+		else rejectNonAsyncFunction(options, declarator.node.start);
+		emitWrappedAssignments(group.node.start, group.declaration.start, exports, selectedExportNames);
+	} else if (group.type === "specifiers") {
+		const skippedExports = [];
+		let selected = false;
+		for (const entry of group.exports) {
+			tinyassert(entry.node.local.type === "Identifier");
+			if (entry.node.exported.type !== "Identifier") throw Object.assign(/* @__PURE__ */ new Error("unsupported string literal export name"), { pos: entry.node.exported.start });
+			if (!filter(entry.exportName, entry.meta)) {
+				skippedExports.push(entry.localName === entry.exportName ? entry.localName : `${entry.localName} as ${entry.exportName}`);
+				continue;
 			}
-		} else {
-			/**
-			* export { foo, bar as car }
-			*/
-			output.remove(node.start, node.end);
-			for (const spec of node.specifiers) {
-				tinyassert(spec.local.type === "Identifier");
-				if (spec.exported.type !== "Identifier") throw Object.assign(/* @__PURE__ */ new Error("unsupported string literal export name"), { pos: spec.exported.start });
-				wrapExport(spec.local.name, spec.exported.name);
+			selected = true;
+			let binding = entry.localName;
+			const source = group.node.source;
+			if (source) {
+				binding = `$$import_${entry.localName}`;
+				appendedCode.push(`import { ${entry.localName} as ${binding} } from ${source.raw}`);
 			}
+			emitWrappedBinding(binding, entry.exportName, entry.meta);
 		}
-		/**
-		* export * as ns from './foo'
-		* export * from './foo'
-		*/
-		if (node.type === "ExportAllDeclaration") {
-			if (!options.ignoreExportAllDeclaration) throw Object.assign(/* @__PURE__ */ new Error("unsupported ExportAllDeclaration"), { pos: node.start });
-		}
-		/**
-		* export default function foo() {}
-		* export default class Foo {}
-		* export default () => {}
-		*/
-		if (node.type === "ExportDefaultDeclaration") {
-			let localName;
-			let isFunction;
-			let declName;
-			let defaultExportIdentifierName;
-			if ((node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") && node.declaration.id) {
-				localName = node.declaration.id.name;
-				output.remove(node.start, node.declaration.start);
-				isFunction = getIsFunction(node.declaration);
-				declName = node.declaration.id.name;
-			} else {
-				localName = "$$default";
-				output.update(node.start, node.declaration.start, "const $$default = ");
-				if (node.declaration.type === "Identifier") defaultExportIdentifierName = node.declaration.name;
-				else isFunction = getIsFunction(node.declaration);
+		if (selected) {
+			output.remove(group.node.start, group.node.end);
+			if (skippedExports.length > 0) {
+				const source = group.node.source ? ` from ${group.node.source.raw}` : "";
+				appendedCode.push(`export { ${skippedExports.join(", ")} }${source}`);
 			}
-			const defaultMeta = {
-				isFunction,
-				declName,
-				defaultExportIdentifierName
-			};
-			if (filter("default", defaultMeta)) validateNonAsyncFunction(options, node.declaration);
-			wrapExport(localName, "default", defaultMeta);
 		}
+	} else if (group.type === "export-all") {
+		if (!options.ignoreExportAllDeclaration) throw Object.assign(/* @__PURE__ */ new Error("unsupported ExportAllDeclaration"), { pos: group.node.start });
+	} else if (group.type === "default") {
+		const meta = group.meta;
+		if (!filter("default", meta)) continue;
+		const localName = group.localName ?? "$$default";
+		if (group.kind === "named-declaration") output.remove(group.node.start, group.node.declaration.start);
+		else output.update(group.node.start, group.node.declaration.start, "const $$default = ");
+		validateNonAsyncFunction(options, group.node.declaration);
+		emitWrappedBinding(localName, "default", meta);
 	}
-	if (toAppend.length > 0) output.append([
+	if (appendedCode.length > 0) output.append([
 		"",
-		...toAppend,
+		...appendedCode,
 		""
 	].join(";\n"));
 	return {
@@ -338,90 +639,103 @@ function transformWrapExport(input, ast, options) {
 		output
 	};
 }
-function getIsFunction(node) {
-	if (node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return true;
-	if (node.type === "ClassDeclaration" || node.type === "Literal" || node.type === "ObjectExpression" || node.type === "ArrayExpression" || node.type === "ClassExpression") return false;
-}
 //#endregion
 //#region src/transforms/proxy-export.ts
 function transformDirectiveProxyExport(ast, options) {
 	if (!hasDirective(ast.body, options.directive)) return;
 	return transformProxyExport(ast, options);
 }
-function transformProxyExport(ast, options) {
+/**
+* Replaces selected exports with proxies created by `runtime` and removes the
+* original module implementation.
+*
+* Conceptually, with a filter that excludes `objectValue`:
+*
+* ```js
+* import { dependency } from './dep'
+* export async function action() {}
+* export const objectValue = {}
+* export { dependency as renamed }
+* export default async () => {}
+* ```
+*
+* becomes:
+*
+* ```js
+* export const action = __PROXY__('action')
+* export const renamed = __PROXY__('renamed')
+* export default __PROXY__('default')
+* ```
+*
+* Unlike `transformWrapExport`, this transform does not evaluate the original
+* exports. Unknown values are represented only by their export names, so the
+* caller must filter solely from the available static `ModuleExportMeta`.
+* `keep` is a specialized mode that retains non-export implementation code and
+* passes a single variable initializer to `runtime`.
+*/
+function transformProxyExport(viteAst, options) {
+	const ast = viteAst;
 	if (options.keep && typeof options.code !== "string") throw new Error("`keep` option requires `code`");
+	if (options.keep && options.filter) throw new Error("`filter` option is not supported with `keep`");
 	const output = new MagicString(options.code ?? " ".repeat(ast.end));
 	const exportNames = [];
+	const filter = options.filter ?? (() => true);
+	function removeNode(node) {
+		output.remove(node.start, node.end);
+	}
+	/** Replaces one complete export statement with the selected proxy exports. */
 	function createExport(node, names) {
 		exportNames.push(...names);
 		const newCode = names.map((name) => (name === "default" ? `export default` : `export const ${name} =`) + ` /* #__PURE__ */ ${options.runtime(name)};\n`).join("");
 		output.update(node.start, node.end, newCode);
 	}
-	for (const node of ast.body) {
-		if (node.type === "ExportNamedDeclaration") {
-			if (node.declaration) if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
-				/**
-				* export function foo() {}
-				*/
-				validateNonAsyncFunction(options, node.declaration);
-				createExport(node, [node.declaration.id.name]);
-			} else if (node.declaration.type === "VariableDeclaration") {
-				/**
-				* export const foo = 1, bar = 2
-				*/
-				for (const decl of node.declaration.declarations) if (decl.init) validateNonAsyncFunction(options, decl.init);
-				if (options.keep && options.code) {
-					if (node.declaration.declarations.length === 1) {
-						const decl = node.declaration.declarations[0];
-						if (decl.id.type === "Identifier" && decl.init) {
-							const name = decl.id.name;
-							const value = options.code.slice(decl.init.start, decl.init.end);
-							const newCode = `export const ${name} = /* #__PURE__ */ ${options.runtime(name, { value })};`;
-							output.update(node.start, node.end, newCode);
-							exportNames.push(name);
-							continue;
-						}
-					}
-				}
-				createExport(node, node.declaration.declarations.flatMap((decl) => extractNames(decl.id)));
-			} else node.declaration;
-			else {
-				/**
-				* export { foo, bar as car } from './foo'
-				* export { foo, bar as car }
-				*/
-				const names = [];
-				for (const spec of node.specifiers) {
-					if (spec.exported.type !== "Identifier") throw Object.assign(/* @__PURE__ */ new Error("unsupported string literal export name"), { pos: spec.exported.start });
-					names.push(spec.exported.name);
-				}
-				createExport(node, names);
+	const exportNodes = /* @__PURE__ */ new Set();
+	for (const group of scanModuleExports(viteAst)) {
+		const node = group.node;
+		exportNodes.add(node);
+		if (group.type === "declaration") {
+			const entry = group.export;
+			if (filter(entry.exportName, entry.meta)) {
+				validateNonAsyncFunction(options, group.declaration);
+				createExport(node, [entry.exportName]);
+			} else removeNode(node);
+		} else if (group.type === "variable-declaration") {
+			const selectedNames = [];
+			for (const declarator of group.declarators) {
+				const names = declarator.exports.filter((entry) => filter(entry.exportName, entry.meta)).map((entry) => entry.exportName);
+				if (declarator.node.init && (!options.filter || declarator.exports.length === 0 || names.length > 0)) validateNonAsyncFunction(options, declarator.node.init);
+				selectedNames.push(...names);
 			}
-			continue;
-		}
-		/**
-		* export * as ns from './foo'
-		* export * from './foo'
-		*/
-		if (node.type === "ExportAllDeclaration") {
-			if (node.exported?.type === "Identifier") {
-				createExport(node, [node.exported.name]);
-				continue;
+			if (options.keep && group.declaration.declarations.length === 1) {
+				const decl = group.declaration.declarations[0];
+				if (decl.id.type === "Identifier" && decl.init) {
+					const name = decl.id.name;
+					const value = options.code.slice(decl.init.start, decl.init.end);
+					const newCode = `export const ${name} = /* #__PURE__ */ ${options.runtime(name, { value })};`;
+					output.update(node.start, node.end, newCode);
+					exportNames.push(name);
+					continue;
+				}
 			}
-			if (!options.ignoreExportAllDeclaration) throw new Error("unsupported ExportAllDeclaration");
-		}
-		/**
-		* export default function foo() {}
-		* export default class Foo {}
-		* export default () => {}
-		*/
-		if (node.type === "ExportDefaultDeclaration") {
-			validateNonAsyncFunction(options, node.declaration);
+			createExport(node, selectedNames);
+		} else if (group.type === "specifiers") createExport(node, group.exports.filter((entry) => {
+			if (entry.node.exported.type !== "Identifier") throw Object.assign(/* @__PURE__ */ new Error("unsupported string literal export name"), { pos: entry.node.exported.start });
+			return filter(entry.exportName, entry.meta);
+		}).map((entry) => entry.exportName));
+		else if (group.type === "export-all") {
+			if (group.node.exported?.type === "Identifier") {
+				const name = group.node.exported.name;
+				if (filter(name, {})) createExport(node, [name]);
+				else removeNode(node);
+			} else if (!options.ignoreExportAllDeclaration) throw new Error("unsupported ExportAllDeclaration");
+			else if (!options.keep) removeNode(node);
+		} else if (group.type === "default") if (filter("default", group.meta)) {
+			validateNonAsyncFunction(options, group.node.declaration);
 			createExport(node, ["default"]);
-			continue;
-		}
-		if (options.keep) continue;
-		output.remove(node.start, node.end);
+		} else removeNode(node);
+	}
+	if (!options.keep) {
+		for (const node of ast.body) if (!exportNodes.has(node)) removeNode(node);
 	}
 	return {
 		exportNames,
@@ -432,10 +746,13 @@ function transformProxyExport(ast, options) {
 //#region src/transforms/server-action.ts
 function transformServerActionServer(input, ast, options) {
 	if (hasDirective(ast.body, "use server")) {
-		const result = transformWrapExport(input, ast, options);
+		const result = transformModuleExportEffect(input, ast, {
+			rejectNonAsyncFunction: options.rejectNonAsyncFunction,
+			generate: ({ binding, exportName }) => options.runtime(binding, exportName)
+		});
 		return {
 			...result,
-			referenceNames: result.exportNames
+			exportNames: result.referenceNames
 		};
 	}
 	const result = transformHoistInlineDirective(input, ast, {
@@ -450,7 +767,9 @@ function transformServerActionServer(input, ast, options) {
 //#endregion
 //#region src/transforms/expand-export-all.ts
 async function transformExpandExportAll(options) {
-	const { plans } = resolveStarExports(await scanModuleExports(options.ast, options.importer, options));
+	const ast = options.ast;
+	const context = options;
+	const { plans } = resolveStarExports(await scanModuleExports$1(ast, options.importer, context));
 	if (plans.length === 0) return;
 	const output = new MagicString(options.code);
 	for (const item of plans) {
@@ -459,7 +778,7 @@ async function transformExpandExportAll(options) {
 	}
 	return { code: output.toString() };
 }
-async function scanModuleExports(ast, importer, context, seen = /* @__PURE__ */ new Set()) {
+async function scanModuleExports$1(ast, importer, context, seen = /* @__PURE__ */ new Set()) {
 	const starSources = [];
 	const bareStars = ast.body.filter((n) => n.type === "ExportAllDeclaration" && !n.exported);
 	for (const node of bareStars) {
@@ -482,7 +801,7 @@ async function collectExportScan(resolvedId, context, seen) {
 		ambiguousNames: /* @__PURE__ */ new Set()
 	};
 	seen.add(resolvedId);
-	const scan = await scanModuleExports(await context.load(resolvedId), resolvedId, context, seen);
+	const scan = await scanModuleExports$1(await context.load(resolvedId), resolvedId, context, seen);
 	const resolved = resolveStarExports(scan);
 	return {
 		names: [...scan.explicitNames, ...resolved.plans.flatMap((item) => item.names)],
@@ -526,4 +845,4 @@ function resolveStarExports(scan) {
 	};
 }
 //#endregion
-export { extractIdentifiers, extractNames, findDirectives, hasDirective, transformDirectiveProxyExport, transformExpandExportAll, transformHoistInlineDirective, transformProxyExport, transformServerActionServer, transformWrapExport, validateNonAsyncFunction };
+export { extractIdentifiers, extractNames, findDirectives, hasDirective, isDirective, rejectNonAsyncFunction, scanModuleExports, transformDirectiveProxyExport, transformExpandExportAll, transformHoistInlineDirective, transformModuleExportEffect, transformProxyExport, transformServerActionServer, transformWrapExport, validateNonAsyncFunction };