@vitejs/plugin-rsc 0.5.21 → 0.5.23

package/dist/transforms/index.js

@@ -1,3 +1,367 @@
-import { a as hasDirective, c as transformHoistInlineDirective, i as getExportNames, n as transformDirectiveProxyExport, o as transformWrapExport, r as transformProxyExport, s as findDirectives, t as transformServerActionServer } from "../server-action-JkEy-6yW.js";
-
-export { findDirectives, getExportNames, hasDirective, transformDirectiveProxyExport, transformHoistInlineDirective, transformProxyExport, transformServerActionServer, transformWrapExport };
+import { i as tinyassert } from "../dist-rz-Bnebz.js";
+import { a as hasDirective, i as getExportNames, n as extractIdentifiers, o as validateNonAsyncFunction, r as extractNames, t as buildScopeTree } from "../scope-DKCDtt0O.js";
+import MagicString from "magic-string";
+import { walk } from "estree-walker";
+//#region src/transforms/hoist.ts
+function transformHoistInlineDirective(input, ast, { runtime, rejectNonAsyncFunction, ...options }) {
+	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 = [];
+	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;
+			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 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) {
+				newParams = ["$$hoist_encoded", ...node.params.map((n) => input.slice(n.start, n.end))].join(", ");
+				output.appendLeft(node.body.body[0].start, `const [${bindVars.map((b) => b.root).join(",")}] = ${options.decode("$$hoist_encoded")};\n`);
+			}
+			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 ${newName}(${newParams}) `);
+			output.appendLeft(node.end, `;\n/* #__PURE__ */ Object.defineProperty(${newName}, "name", { value: ${JSON.stringify(originalName)} });\n`);
+			output.move(node.start, node.end, input.length);
+			let newCode = `/* #__PURE__ */ ${runtime(newName, newName, { directiveMatch: match })}`;
+			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) {
+				newCode = `const ${declName} = ${newCode};`;
+				if (parent?.type === "ExportDefaultDeclaration") {
+					output.remove(parent.start, node.start);
+					newCode = `${newCode}\nexport default ${declName};`;
+				}
+			}
+			output.appendLeft(node.start, newCode);
+		}
+	} });
+	return {
+		output,
+		names
+	};
+}
+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);
+		if (match) return {
+			match,
+			node: stmt.expression
+		};
+	}
+}
+function findDirectives(ast, directive) {
+	const directiveRE = exactRegex(directive);
+	const nodes = [];
+	walk(ast, { enter(node) {
+		if (node.type === "Program" || node.type === "BlockStatement") {
+			const match = matchDirective(node.body, directiveRE);
+			if (match) nodes.push(match.node);
+		}
+	} });
+	return nodes;
+}
+function getBindVars(fn, scopeTree) {
+	const fnScope = scopeTree.nodeScope.get(fn);
+	const ancestorScopes = fnScope.getAncestorScopes();
+	const bindReferences = (scopeTree.scopeToReferences.get(fnScope) ?? []).filter((id) => {
+		const scope = scopeTree.referenceToDeclaredScope.get(id);
+		return scope && scope !== scopeTree.moduleScope && ancestorScopes.has(scope);
+	});
+	const accessMap = {};
+	for (const id of bindReferences) {
+		const name = id.name;
+		const node = scopeTree.referenceToNode.get(id);
+		if (node.type === "Identifier") {
+			accessMap[name] = { kind: "bare" };
+			continue;
+		}
+		accessMap[name] ??= {
+			kind: "paths",
+			paths: []
+		};
+		const entry = accessMap[name];
+		if (entry.kind === "paths") {
+			const path = memberExpressionToPath(node);
+			if (!entry.paths.some((existing) => existing.key === path.key)) entry.paths.push(path);
+		}
+	}
+	const result = [];
+	for (const [root, entry] of Object.entries(accessMap)) {
+		if (entry.kind === "bare") {
+			result.push({
+				root,
+				expr: root
+			});
+			continue;
+		}
+		result.push({
+			root,
+			expr: synthesizePartialObject(root, entry.paths)
+		});
+	}
+	return result;
+}
+function memberExpressionToPath(node) {
+	const segments = [];
+	let current = node;
+	while (current.type === "MemberExpression") {
+		tinyassert(current.property.type === "Identifier");
+		segments.unshift(current.property.name);
+		tinyassert(current.object.type === "Identifier" || current.object.type === "MemberExpression");
+		current = current.object;
+	}
+	return {
+		key: segments.join("."),
+		segments
+	};
+}
+function synthesizePartialObject(root, bindPaths) {
+	const trie = /* @__PURE__ */ new Map();
+	const paths = dedupeByPrefix(bindPaths.map((p) => p.segments));
+	for (const path of paths) {
+		let node = trie;
+		for (let i = 0; i < path.length; i++) {
+			const segment = path[i];
+			let child = node.get(segment);
+			if (!child) {
+				child = /* @__PURE__ */ new Map();
+				node.set(segment, child);
+			}
+			node = child;
+		}
+	}
+	function serialize(node, segments) {
+		if (node.size === 0) return root + segments.map((segment) => `.${segment}`).join("");
+		const entries = [];
+		for (const [key, child] of node) {
+			const safeKey = key === "__proto__" ? `["__proto__"]` : key;
+			entries.push(`${safeKey}: ${serialize(child, [...segments, key])}`);
+		}
+		return `{ ${entries.join(", ")} }`;
+	}
+	return serialize(trie, []);
+}
+function dedupeByPrefix(paths) {
+	const sorted = [...paths].sort((a, b) => a.length - b.length);
+	const result = [];
+	for (const path of sorted) if (!result.some((existingPath) => existingPath.every((segment, i) => segment === path[i]))) result.push(path);
+	return result;
+}
+//#endregion
+//#region src/transforms/wrap-export.ts
+function transformWrapExport(input, ast, options) {
+	const output = new MagicString(input);
+	const exportNames = [];
+	const toAppend = [];
+	const filter = options.filter ?? (() => true);
+	function wrapSimple(start, end, exports) {
+		exportNames.push(...exports.map((e) => e.name));
+		const newCode = exports.map((e) => [filter(e.name, e.meta) && `${e.name} = /* #__PURE__ */ ${options.runtime(e.name, e.name, e.meta)};\n`, `export { ${e.name} };\n`]).flat().filter(Boolean).join("");
+		output.update(start, end, newCode);
+		output.move(start, end, input.length);
+	}
+	function wrapExport(name, exportName, meta = {}) {
+		exportNames.push(exportName);
+		if (!filter(exportName, meta)) {
+			toAppend.push(`export { ${name} as ${exportName} }`);
+			return;
+		}
+		toAppend.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() {}
+			*/
+			validateNonAsyncFunction(options, node.declaration);
+			const name = node.declaration.id.name;
+			wrapSimple(node.start, node.declaration.start, [{
+				name,
+				meta: {
+					isFunction: true,
+					declName: 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 (node.declaration.kind === "const") output.update(node.declaration.start, node.declaration.start + 5, "let");
+			const names = node.declaration.declarations.flatMap((decl) => extractNames(decl.id));
+			let isFunction = false;
+			if (node.declaration.declarations.length === 1) {
+				const decl = node.declaration.declarations[0];
+				isFunction = decl.id.type === "Identifier" && (decl.init?.type === "ArrowFunctionExpression" || decl.init?.type === "FunctionExpression");
+			}
+			wrapSimple(node.start, node.declaration.start, names.map((name) => ({
+				name,
+				meta: {
+					isFunction,
+					declName: name
+				}
+			})));
+		} 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");
+				tinyassert(spec.exported.type === "Identifier");
+				const name = spec.local.name;
+				toAppend.push(`import { ${name} as $$import_${name} } from ${node.source.raw}`);
+				wrapExport(`$$import_${name}`, spec.exported.name);
+			}
+		} else {
+			/**
+			* export { foo, bar as car }
+			*/
+			output.remove(node.start, node.end);
+			for (const spec of node.specifiers) {
+				tinyassert(spec.local.type === "Identifier");
+				tinyassert(spec.exported.type === "Identifier");
+				wrapExport(spec.local.name, spec.exported.name);
+			}
+		}
+		/**
+		* export * from './foo'
+		*/
+		if (!options.ignoreExportAllDeclaration && node.type === "ExportAllDeclaration") 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") {
+			validateNonAsyncFunction(options, node.declaration);
+			let localName;
+			let isFunction = false;
+			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 = node.declaration.type === "FunctionDeclaration";
+				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;
+			}
+			wrapExport(localName, "default", {
+				isFunction,
+				declName,
+				defaultExportIdentifierName
+			});
+		}
+	}
+	if (toAppend.length > 0) output.append([
+		"",
+		...toAppend,
+		""
+	].join(";\n"));
+	return {
+		exportNames,
+		output
+	};
+}
+//#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) {
+	if (options.keep && typeof options.code !== "string") throw new Error("`keep` option requires `code`");
+	const output = new MagicString(options.code ?? " ".repeat(ast.end));
+	const exportNames = [];
+	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) {
+					tinyassert(spec.exported.type === "Identifier");
+					names.push(spec.exported.name);
+				}
+				createExport(node, names);
+			}
+			continue;
+		}
+		/**
+		* export * from './foo'
+		*/
+		if (!options.ignoreExportAllDeclaration && node.type === "ExportAllDeclaration") 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, ["default"]);
+			continue;
+		}
+		if (options.keep) continue;
+		output.remove(node.start, node.end);
+	}
+	return {
+		exportNames,
+		output
+	};
+}
+//#endregion
+//#region src/transforms/server-action.ts
+function transformServerActionServer(input, ast, options) {
+	if (hasDirective(ast.body, "use server")) return transformWrapExport(input, ast, options);
+	return transformHoistInlineDirective(input, ast, {
+		...options,
+		directive: "use server"
+	});
+}
+//#endregion
+export { extractIdentifiers, extractNames, findDirectives, getExportNames, hasDirective, transformDirectiveProxyExport, transformHoistInlineDirective, transformProxyExport, transformServerActionServer, transformWrapExport, validateNonAsyncFunction };

package/dist/utils/encryption-runtime.js

@@ -1,8 +1,7 @@
-import { r as once } from "../dist-yW9-EeG1.js";
-import { a as fromBase64, i as encryptBuffer, n as concatArrayStream, r as decryptBuffer, t as arrayToStream } from "../encryption-utils-Bk5eKdu6.js";
+import { r as once } from "../dist-rz-Bnebz.js";
+import { a as fromBase64, i as encryptBuffer, n as concatArrayStream, r as decryptBuffer, t as arrayToStream } from "../encryption-utils-BblioYEx.js";
 import { createFromReadableStream, renderToReadableStream } from "../react/rsc.js";
 import encryptionKeySource from "virtual:vite-rsc/encryption-key";
-
 //#region src/utils/encryption-runtime.ts
 async function encryptActionBoundArgs(originalValue) {
 	return encryptBuffer(await concatArrayStream(renderToReadableStream(originalValue)), await getEncryptionKey());
@@ -15,6 +14,5 @@ const getEncryptionKey = /* @__PURE__ */ once(async () => {
 	const resolved = await encryptionKeySource();
 	return await crypto.subtle.importKey("raw", fromBase64(resolved), { name: "AES-GCM" }, true, ["encrypt", "decrypt"]);
 });
-
 //#endregion
-export { decryptActionBoundArgs, encryptActionBoundArgs };
+export { decryptActionBoundArgs, encryptActionBoundArgs };

package/dist/utils/rpc.js

@@ -1,5 +1,4 @@
 import { decode, encode } from "turbo-stream";
-
 //#region src/utils/rpc.ts
 const decodePlugins = [(type, ...rest) => {
 	switch (type) {
@@ -86,6 +85,5 @@ function createRpcClient(options) {
 		return (...args) => callRpc(p, args);
 	} });
 }
-
 //#endregion
-export { createRpcClient, createRpcServer };
+export { createRpcClient, createRpcServer };

package/dist/vendor/react-server-dom/cjs/react-server-dom-webpack-client.browser.development.js

@@ -4901,10 +4901,10 @@
       return hook.checkDCE ? !0 : !1;
     })({
       bundleType: 1,
-      version: "19.2.4",
+      version: "19.2.5",
       rendererPackageName: "react-server-dom-webpack",
       currentDispatcherRef: ReactSharedInternals,
-      reconcilerVersion: "19.2.4",
+      reconcilerVersion: "19.2.5",
       getCurrentComponentInfo: function () {
         return currentOwnerInDEV;
       }

package/dist/vendor/react-server-dom/cjs/react-server-dom-webpack-server.browser.development.js

@@ -4394,23 +4394,20 @@
     function createMap(response, model) {
       if (!isArrayImpl(model)) throw Error("Invalid Map initializer.");
       if (!0 === model.$$consumed) throw Error("Already initialized Map.");
-      response = new Map(model);
       model.$$consumed = !0;
-      return response;
+      return new Map(model);
     }
     function createSet(response, model) {
       if (!isArrayImpl(model)) throw Error("Invalid Set initializer.");
       if (!0 === model.$$consumed) throw Error("Already initialized Set.");
-      response = new Set(model);
       model.$$consumed = !0;
-      return response;
+      return new Set(model);
     }
     function extractIterator(response, model) {
       if (!isArrayImpl(model)) throw Error("Invalid Iterator initializer.");
       if (!0 === model.$$consumed) throw Error("Already initialized Iterator.");
-      response = model[Symbol.iterator]();
       model.$$consumed = !0;
-      return response;
+      return model[Symbol.iterator]();
     }
     function createModel(response, model, parentObject, key) {
       return "then" === key && "function" === typeof model ? null : model;

package/dist/vendor/react-server-dom/cjs/react-server-dom-webpack-server.browser.production.js

@@ -2807,23 +2807,20 @@ function getOutlinedModel(
 function createMap(response, model) {
   if (!isArrayImpl(model)) throw Error("Invalid Map initializer.");
   if (!0 === model.$$consumed) throw Error("Already initialized Map.");
-  response = new Map(model);
   model.$$consumed = !0;
-  return response;
+  return new Map(model);
 }
 function createSet(response, model) {
   if (!isArrayImpl(model)) throw Error("Invalid Set initializer.");
   if (!0 === model.$$consumed) throw Error("Already initialized Set.");
-  response = new Set(model);
   model.$$consumed = !0;
-  return response;
+  return new Set(model);
 }
 function extractIterator(response, model) {
   if (!isArrayImpl(model)) throw Error("Invalid Iterator initializer.");
   if (!0 === model.$$consumed) throw Error("Already initialized Iterator.");
-  response = model[Symbol.iterator]();
   model.$$consumed = !0;
-  return response;
+  return model[Symbol.iterator]();
 }
 function createModel(response, model, parentObject, key) {
   return "then" === key && "function" === typeof model ? null : model;

package/dist/vendor/react-server-dom/cjs/react-server-dom-webpack-server.edge.development.js

@@ -4465,23 +4465,20 @@
     function createMap(response, model) {
       if (!isArrayImpl(model)) throw Error("Invalid Map initializer.");
       if (!0 === model.$$consumed) throw Error("Already initialized Map.");
-      response = new Map(model);
       model.$$consumed = !0;
-      return response;
+      return new Map(model);
     }
     function createSet(response, model) {
       if (!isArrayImpl(model)) throw Error("Invalid Set initializer.");
       if (!0 === model.$$consumed) throw Error("Already initialized Set.");
-      response = new Set(model);
       model.$$consumed = !0;
-      return response;
+      return new Set(model);
     }
     function extractIterator(response, model) {
       if (!isArrayImpl(model)) throw Error("Invalid Iterator initializer.");
       if (!0 === model.$$consumed) throw Error("Already initialized Iterator.");
-      response = model[Symbol.iterator]();
       model.$$consumed = !0;
-      return response;
+      return model[Symbol.iterator]();
     }
     function createModel(response, model, parentObject, key) {
       return "then" === key && "function" === typeof model ? null : model;

package/dist/vendor/react-server-dom/cjs/react-server-dom-webpack-server.edge.production.js

@@ -2803,23 +2803,20 @@ function getOutlinedModel(
 function createMap(response, model) {
   if (!isArrayImpl(model)) throw Error("Invalid Map initializer.");
   if (!0 === model.$$consumed) throw Error("Already initialized Map.");
-  response = new Map(model);
   model.$$consumed = !0;
-  return response;
+  return new Map(model);
 }
 function createSet(response, model) {
   if (!isArrayImpl(model)) throw Error("Invalid Set initializer.");
   if (!0 === model.$$consumed) throw Error("Already initialized Set.");
-  response = new Set(model);
   model.$$consumed = !0;
-  return response;
+  return new Set(model);
 }
 function extractIterator(response, model) {
   if (!isArrayImpl(model)) throw Error("Invalid Iterator initializer.");
   if (!0 === model.$$consumed) throw Error("Already initialized Iterator.");
-  response = model[Symbol.iterator]();
   model.$$consumed = !0;
-  return response;
+  return model[Symbol.iterator]();
 }
 function createModel(response, model, parentObject, key) {
   return "then" === key && "function" === typeof model ? null : model;

package/dist/vendor/react-server-dom/cjs/react-server-dom-webpack-server.node.development.js

@@ -4868,23 +4868,20 @@
     function createMap(response, model) {
       if (!isArrayImpl(model)) throw Error("Invalid Map initializer.");
       if (!0 === model.$$consumed) throw Error("Already initialized Map.");
-      response = new Map(model);
       model.$$consumed = !0;
-      return response;
+      return new Map(model);
     }
     function createSet(response, model) {
       if (!isArrayImpl(model)) throw Error("Invalid Set initializer.");
       if (!0 === model.$$consumed) throw Error("Already initialized Set.");
-      response = new Set(model);
       model.$$consumed = !0;
-      return response;
+      return new Set(model);
     }
     function extractIterator(response, model) {
       if (!isArrayImpl(model)) throw Error("Invalid Iterator initializer.");
       if (!0 === model.$$consumed) throw Error("Already initialized Iterator.");
-      response = model[Symbol.iterator]();
       model.$$consumed = !0;
-      return response;
+      return model[Symbol.iterator]();
     }
     function createModel(response, model, parentObject, key) {
       return "then" === key && "function" === typeof model ? null : model;

package/dist/vendor/react-server-dom/cjs/react-server-dom-webpack-server.node.production.js

@@ -2832,23 +2832,20 @@ function getOutlinedModel(
 function createMap(response, model) {
   if (!isArrayImpl(model)) throw Error("Invalid Map initializer.");
   if (!0 === model.$$consumed) throw Error("Already initialized Map.");
-  response = new Map(model);
   model.$$consumed = !0;
-  return response;
+  return new Map(model);
 }
 function createSet(response, model) {
   if (!isArrayImpl(model)) throw Error("Invalid Set initializer.");
   if (!0 === model.$$consumed) throw Error("Already initialized Set.");
-  response = new Set(model);
   model.$$consumed = !0;
-  return response;
+  return new Set(model);
 }
 function extractIterator(response, model) {
   if (!isArrayImpl(model)) throw Error("Invalid Iterator initializer.");
   if (!0 === model.$$consumed) throw Error("Already initialized Iterator.");
-  response = model[Symbol.iterator]();
   model.$$consumed = !0;
-  return response;
+  return model[Symbol.iterator]();
 }
 function createModel(response, model, parentObject, key) {
   return "then" === key && "function" === typeof model ? null : model;

package/dist/vendor/react-server-dom/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-server-dom-webpack",
   "description": "React Server Components bindings for DOM using Webpack. This is intended to be integrated into meta-frameworks. It is not intended to be imported directly.",
-  "version": "19.2.4",
+  "version": "19.2.5",
   "keywords": [
     "react"
   ],
@@ -84,8 +84,8 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
     "webpack": "^5.59.0"
   },
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitejs/plugin-rsc",
-  "version": "0.5.21",
+  "version": "0.5.23",
   "description": "React Server Components (RSC) support for Vite.",
   "keywords": [
     "react",
@@ -39,33 +39,32 @@
     "prepack": "tsdown"
   },
   "dependencies": {
-    "@rolldown/pluginutils": "1.0.0-rc.5",
+    "@rolldown/pluginutils": "1.0.0-rc.13",
     "es-module-lexer": "^2.0.0",
     "estree-walker": "^3.0.3",
     "magic-string": "^0.30.21",
-    "periscopic": "^4.0.2",
-    "srvx": "^0.11.7",
+    "srvx": "^0.11.15",
     "strip-literal": "^3.1.0",
-    "turbo-stream": "^3.1.0",
-    "vitefu": "^1.1.1"
+    "turbo-stream": "^3.2.0",
+    "vitefu": "^1.1.3"
   },
   "devDependencies": {
     "@hiogawa/utils": "^1.7.0",
-    "@playwright/test": "^1.58.2",
+    "@playwright/test": "^1.59.1",
     "@tsconfig/strictest": "^2.0.8",
     "@types/estree": "^1.0.8",
-    "@types/node": "^24.10.13",
+    "@types/node": "^24.12.2",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "workspace:*",
     "@vitejs/test-dep-cjs-and-esm": "./test-dep/cjs-and-esm",
     "@vitejs/test-dep-cjs-falsy-primitive": "./test-dep/cjs-falsy-primitive",
     "picocolors": "^1.1.1",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
-    "react-server-dom-webpack": "^19.2.4",
-    "tinyexec": "^1.0.2",
-    "tsdown": "^0.20.3"
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "react-server-dom-webpack": "^19.2.5",
+    "tinyexec": "^1.0.4",
+    "tsdown": "^0.21.7"
   },
   "peerDependencies": {
     "react": "*",