vinext 1.0.1 → 1.2.0

package/dist/plugins/strip-server-exports.js

@@ -1,5 +1,6 @@
 import { getAstName } from "./ast-utils.js";
 import { magicStringTransformResult } from "./transform-result.js";
+import { findAstBindingScope, walkAstScopes } from "./ast-scope.js";
 import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/strip-server-exports.ts
@@ -12,6 +13,8 @@ const SERVER_EXPORTS = /* @__PURE__ */ new Set([
 	"unstable_getStaticProps",
 	"unstable_getStaticPaths"
 ]);
+const UNUSED_LOOP_TARGET = "({ x: 0 }).x";
+const CATCH_BOUND_NAME = "\0catch-bound";
 const SERVER_PROPS_SSG_CONFLICT = "You can not use getStaticProps or getStaticPaths with getServerSideProps. To use SSG, please remove getServerSideProps";
 const EXPORT_ALL_IN_PAGE_ERROR = "Using `export * from '...'` in a page is disallowed. Please use `export { default } from '...'` instead.\nRead more: https://nextjs.org/docs/messages/export-all-in-page";
 function hasServerExportCandidate(code) {
@@ -127,64 +130,96 @@ function renderExportDeclaration(code, statement, removed) {
 	if (kept.length === 0) return "";
 	return `export { ${kept.map((specifier) => code.slice(specifier.start, specifier.end)).join(", ")} }${statement.source ? ` from ${code.slice(statement.source.start, statement.end)}` : ";"}`;
 }
-function renderBindingPattern(code, pattern, removedNames) {
+/**
+* Render a binding or assignment pattern without the removed names. `slice`
+* copies kept subexpressions (defaults, computed keys) so callers can apply
+* edits nested inside them.
+*/
+function renderBindingPattern(slice, pattern, removedNames) {
 	if (pattern.type === "Identifier") return removedNames.has(pattern.name) ? null : pattern.name;
+	if (pattern.type === "MemberExpression") {
+		const root = assignmentTargetIdentifiers(pattern)[0];
+		return root && removedNames.has(root.name) ? null : slice(pattern.start, pattern.end);
+	}
 	if (pattern.type === "RestElement") {
-		const argument = renderBindingPattern(code, pattern.argument, removedNames);
+		const argument = renderBindingPattern(slice, pattern.argument, removedNames);
 		return argument ? `...${argument}` : null;
 	}
 	if (pattern.type === "AssignmentPattern") {
-		const left = renderBindingPattern(code, pattern.left, removedNames);
-		return left ? `${left} = ${code.slice(pattern.right.start, pattern.right.end)}` : null;
+		const left = renderBindingPattern(slice, pattern.left, removedNames);
+		return left ? `${left} = ${slice(pattern.right.start, pattern.right.end)}` : null;
 	}
 	if (pattern.type === "ObjectPattern") {
 		const properties = pattern.properties.flatMap((property) => {
 			if (property.type === "RestElement") {
-				const rendered = renderBindingPattern(code, property, removedNames);
+				const rendered = renderBindingPattern(slice, property, removedNames);
 				return rendered ? [rendered] : [];
 			}
-			const value = renderBindingPattern(code, property.value, removedNames);
+			const value = renderBindingPattern(slice, property.value, removedNames);
 			if (!value) return [];
 			if (property.shorthand && property.value.type === "Identifier") return [value];
-			const key = code.slice(property.key.start, property.key.end);
+			const key = slice(property.key.start, property.key.end);
 			return [`${property.computed ? `[${key}]` : key}: ${value}`];
 		});
 		return properties.length > 0 ? `{ ${properties.join(", ")} }` : null;
 	}
 	if (pattern.type === "ArrayPattern") {
-		const elements = pattern.elements.map((element) => element ? renderBindingPattern(code, element, removedNames) : null);
+		const elements = pattern.elements.map((element) => element ? renderBindingPattern(slice, element, removedNames) : null);
 		while (elements.length > 0 && elements.at(-1) === null) elements.pop();
 		return elements.length > 0 ? `[${elements.map((element) => element ?? "").join(", ")}]` : null;
 	}
-	return code.slice(pattern.start, pattern.end);
+	return slice(pattern.start, pattern.end);
 }
-function assignmentRootName(node) {
-	if (node.type === "Identifier") return node.name;
-	if (node.type === "MemberExpression") return assignmentRootName(node.object);
+/** Edits pointing a loop head's removed targets at `UNUSED_LOOP_TARGET`. */
+function throwawayTargetEdits(pattern, removedNames) {
+	if (pattern.type === "Identifier" || pattern.type === "MemberExpression") {
+		const root = assignmentTargetIdentifiers(pattern)[0];
+		return root && removedNames.has(root.name) ? [{
+			start: pattern.start,
+			end: pattern.end,
+			replacement: UNUSED_LOOP_TARGET
+		}] : [];
+	}
+	if (pattern.type === "RestElement") return throwawayTargetEdits(pattern.argument, removedNames);
+	if (pattern.type === "AssignmentPattern") return throwawayTargetEdits(pattern.left, removedNames);
+	if (pattern.type === "ArrayPattern") return pattern.elements.flatMap((element) => element ? throwawayTargetEdits(element, removedNames) : []);
+	if (pattern.type === "ObjectPattern") return pattern.properties.flatMap((property) => {
+		if (property.type === "RestElement") return throwawayTargetEdits(property, removedNames);
+		const edits = throwawayTargetEdits(property.value, removedNames);
+		if (!property.shorthand) return edits;
+		return edits.map((edit) => ({
+			...edit,
+			replacement: `${property.key.name}: ${UNUSED_LOOP_TARGET}`
+		}));
+	});
+	return [];
 }
-function assignmentBindingNames(node) {
-	if (node.type === "ArrayPattern" || node.type === "ObjectPattern") return bindingNames(node);
-	const rootName = assignmentRootName(node);
-	return rootName ? [rootName] : [];
+/** Pattern parts `renderBindingPattern` drops, including their defaults and keys. */
+function prunedPatternParts(pattern, removedNames) {
+	const isPruned = (part) => renderBindingPattern((start, end) => "".padEnd(end - start), part, removedNames) === null;
+	if (isPruned(pattern)) return [pattern];
+	if (pattern.type === "AssignmentPattern") return prunedPatternParts(pattern.left, removedNames);
+	if (pattern.type === "RestElement") return prunedPatternParts(pattern.argument, removedNames);
+	if (pattern.type === "ArrayPattern") return pattern.elements.flatMap((element) => element ? prunedPatternParts(element, removedNames) : []);
+	if (pattern.type === "ObjectPattern") return pattern.properties.flatMap((property) => {
+		if (property.type === "RestElement") return prunedPatternParts(property, removedNames);
+		return isPruned(property.value) ? [property] : prunedPatternParts(property.value, removedNames);
+	});
+	return [];
 }
-function isAssignmentTargetIdentifier(node, left) {
-	if (left.type === "Identifier") return node.start === left.start;
-	if (left.type === "ArrayPattern" || left.type === "ObjectPattern") return bindingIdentifiers(left).some((identifier) => identifier.start === node.start);
-	if (left.type === "MemberExpression") {
-		let object = left.object;
-		while (object.type === "MemberExpression") object = object.object;
-		return object.type === "Identifier" && object.start === node.start;
-	}
-	return false;
+/** Identifiers an assignment target writes: pattern bindings and member roots. */
+function assignmentTargetIdentifiers(node) {
+	if (!node) return [];
+	if (node.type === "Identifier") return [node];
+	if (node.type === "MemberExpression") return assignmentTargetIdentifiers(node.object);
+	if (node.type === "RestElement") return assignmentTargetIdentifiers(node.argument);
+	if (node.type === "AssignmentPattern") return assignmentTargetIdentifiers(node.left);
+	if (node.type === "ArrayPattern") return node.elements.flatMap((element) => assignmentTargetIdentifiers(element));
+	if (node.type === "ObjectPattern") return node.properties.flatMap((property) => assignmentTargetIdentifiers(property.type === "RestElement" ? property.argument : property.value));
+	return [];
 }
-function findLexicalScope(ancestors) {
-	return [...ancestors].reverse().find((ancestor) => [
-		"BlockStatement",
-		"SwitchStatement",
-		"ForStatement",
-		"ForInStatement",
-		"ForOfStatement"
-	].includes(ancestor.type));
+function isAssignmentTargetIdentifier(node, left) {
+	return assignmentTargetIdentifiers(left).some((identifier) => identifier.start === node.start);
 }
 function validatePageExports(code) {
 	if (!hasExportAllCandidate(code)) return;
@@ -227,14 +262,41 @@ function stripServerExports(code) {
 	const forcedBindings = /* @__PURE__ */ new Set();
 	const candidateBindings = /* @__PURE__ */ new Set();
 	const bindings = /* @__PURE__ */ new Map();
+	const redeclarations = [];
+	const loopHeadDeclarations = /* @__PURE__ */ new Set();
+	const catchBoundNames = /* @__PURE__ */ new Map();
+	const iterationHeadDeclarators = /* @__PURE__ */ new Set();
+	const removedNamesFor = (declarator) => {
+		const catchBound = catchBoundNames.get(declarator);
+		const iterationHead = iterationHeadDeclarators.has(declarator);
+		if (!catchBound && !iterationHead) return deadBindings;
+		return new Set([...deadBindings].filter((name) => !catchBound?.has(name) && (!iterationHead || forcedBindings.has(name) || candidateBindings.has(name))));
+	};
+	const iterationHeadDeclarations = /* @__PURE__ */ new Set();
+	const declarationsOf = (name) => {
+		const binding = bindings.get(name);
+		return [...binding ? [binding] : [], ...redeclarations.filter((redeclaration) => redeclaration.name === name)];
+	};
+	const renderEdit = (edit) => typeof edit.replacement === "function" ? edit.replacement() : edit.replacement;
+	const renderRange = (start, end) => {
+		const nested = [...new Map(edits.filter((edit) => edit.start >= start && edit.end <= end).map((edit) => [`${edit.start}:${edit.end}`, edit])).values()].sort((left, right) => left.start - right.start || right.end - left.end);
+		let rendered = "";
+		let cursor = start;
+		for (const edit of nested) {
+			if (edit.start < cursor) continue;
+			rendered += code.slice(cursor, edit.start) + renderEdit(edit);
+			cursor = edit.end;
+		}
+		return rendered + code.slice(cursor, end);
+	};
 	const bindingPositions = /* @__PURE__ */ new Set();
 	const references = /* @__PURE__ */ new Map();
-	const shadowRanges = /* @__PURE__ */ new Map();
+	const memberTargetReads = /* @__PURE__ */ new Map();
 	const exportSpecifierRemovals = /* @__PURE__ */ new Map();
 	const variableRemovals = /* @__PURE__ */ new Map();
 	const importRemovals = /* @__PURE__ */ new Map();
-	const assignmentStatements = [];
-	const removedAssignments = /* @__PURE__ */ new Set();
+	const assignments = [];
+	const rewrittenAssignments = /* @__PURE__ */ new Map();
 	for (const statement of statements) {
 		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
 		if (declaration?.type === "FunctionDeclaration" && declaration.id) {
@@ -282,48 +344,89 @@ function stripServerExports(code) {
 				declaredNames: [name]
 			});
 		}
-		else if (statement.type === "ExpressionStatement") {
-			const expression = statement.expression;
-			if (expression.type === "AssignmentExpression") {
-				const left = expression.left;
-				const names = assignmentBindingNames(left);
-				if (names.length > 0) assignmentStatements.push({
-					statement,
-					left,
-					bindingNames: names
-				});
-			}
-		}
 	}
-	const addShadowRange = (name, range) => {
-		if (!range || range.type === "Program") return;
-		const ranges = shadowRanges.get(name) ?? [];
-		ranges.push(range);
-		shadowRanges.set(name, ranges);
-	};
+	const localIdentifiers = /* @__PURE__ */ new Set();
+	walkAstScopes(ast, (node, scope) => {
+		if (node.type !== "Identifier") return;
+		if (findAstBindingScope(scope, node.name)?.parent) localIdentifiers.add(node.start);
+	});
+	const isLocal = (identifier) => localIdentifiers.has(identifier.start);
 	walkAstWithAncestors(ast.body, (node, parent, ancestors = []) => {
-		if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-			for (const parameter of node.params) for (const name of bindingNames(parameter)) addShadowRange(name, node);
-			if (node.type === "FunctionDeclaration" && node.id) addShadowRange(node.id.name, findLexicalScope(ancestors));
-			else if (node.type === "FunctionExpression" && node.id) addShadowRange(node.id.name, node);
-		} else if (node.type === "ClassDeclaration" && node.id) addShadowRange(node.id.name, findLexicalScope(ancestors));
-		else if (node.type === "ClassExpression" && node.id) addShadowRange(node.id.name, node);
-		else if (node.type === "CatchClause" && node.param) for (const name of bindingNames(node.param)) addShadowRange(name, node.body);
-		else if (node.type === "VariableDeclarator" && parent?.type === "VariableDeclaration") {
-			const scope = parent.kind === "var" ? [...ancestors].reverse().find((ancestor) => [
+		if (node.type === "VariableDeclarator" && parent?.type === "VariableDeclaration") {
+			const varScope = parent.kind === "var" ? [...ancestors].reverse().find((ancestor) => [
 				"FunctionDeclaration",
 				"FunctionExpression",
-				"ArrowFunctionExpression"
-			].includes(ancestor.type)) : findLexicalScope(ancestors);
-			for (const name of bindingNames(node.id)) addShadowRange(name, scope);
+				"ArrowFunctionExpression",
+				"StaticBlock"
+			].includes(ancestor.type)) : void 0;
+			const owner = ancestors.at(-2);
+			if (parent.kind === "var" && !varScope && owner && owner.type !== "ExportNamedDeclaration") {
+				if (owner.init === parent || owner.left === parent) loopHeadDeclarations.add(parent);
+				if (owner.left === parent) {
+					iterationHeadDeclarations.add(parent);
+					iterationHeadDeclarators.add(node);
+				}
+				const identifiers = bindingIdentifiers(node.id);
+				for (const identifier of identifiers) bindingPositions.add(identifier.start);
+				const catchBound = new Set(identifiers.filter((identifier) => isLocal(identifier)).map((identifier) => identifier.name));
+				if (catchBound.size > 0) catchBoundNames.set(node, catchBound);
+				const declaredNames = identifiers.map((identifier) => catchBound.has(identifier.name) ? CATCH_BOUND_NAME : identifier.name);
+				for (const identifier of identifiers) {
+					const name = identifier.name;
+					if (catchBound.has(name)) continue;
+					const binding = {
+						name,
+						node,
+						parent,
+						kind: "variable",
+						implementation: iterationHeadDeclarators.has(node) ? identifier : node.init ?? node,
+						declaredNames
+					};
+					if (bindings.has(name)) redeclarations.push(binding);
+					else bindings.set(name, binding);
+				}
+			}
 		}
 	});
 	walkAstWithAncestors(ast.body, (node, parent, ancestors = []) => {
+		if (node.type === "AssignmentExpression") {
+			const names = assignmentTargetIdentifiers(node.left).filter((identifier) => !isLocal(identifier)).map((identifier) => identifier.name);
+			if (names.length > 0) {
+				const statement = parent?.type === "ExpressionStatement" && parent.expression === node ? parent : void 0;
+				assignments.push({
+					expression: node,
+					statement,
+					topLevel: statement !== void 0 && ancestors.length === 1,
+					bindingNames: names
+				});
+			}
+			return;
+		}
+		if (node.type === "ForInStatement" || node.type === "ForOfStatement") {
+			const left = node.left;
+			const names = (left.type === "VariableDeclaration" ? bindingIdentifiers(left.declarations[0]?.id) : assignmentTargetIdentifiers(left)).filter((identifier) => !isLocal(identifier)).map((identifier) => identifier.name);
+			if (names.length > 0) assignments.push({
+				expression: node,
+				statement: node,
+				topLevel: ancestors.length === 0,
+				bindingNames: names,
+				loop: true
+			});
+			return;
+		}
 		if (!isReferenceIdentifier(node, parent)) return;
 		if (bindingPositions.has(node.start)) return;
-		if (isInsideRanges(node.start, shadowRanges.get(node.name) ?? [])) return;
-		const assignment = [...ancestors].reverse().find((ancestor) => ancestor.type === "AssignmentExpression");
-		if (assignment && isAssignmentTargetIdentifier(node, assignment.left)) return;
+		if (isLocal(node)) return;
+		const writer = [...ancestors].reverse().find((ancestor) => ancestor.type === "AssignmentExpression" || (ancestor.type === "ForInStatement" || ancestor.type === "ForOfStatement") && node.start >= ancestor.left.start && node.end <= ancestor.left.end);
+		if (writer && isAssignmentTargetIdentifier(node, writer.left)) {
+			const left = writer.left;
+			if (node !== left && !bindingIdentifiers(left).some((target) => target.start === node.start) && !(writer.type === "AssignmentExpression" && left.type === "MemberExpression")) {
+				const positions = memberTargetReads.get(node.name) ?? [];
+				positions.push(node.start);
+				memberTargetReads.set(node.name, positions);
+			}
+			return;
+		}
 		const positions = references.get(node.name) ?? [];
 		positions.push(node.start);
 		references.set(node.name, positions);
@@ -388,26 +491,76 @@ function stripServerExports(code) {
 	let changed = true;
 	while (changed) {
 		changed = false;
-		for (const { statement, left, bindingNames: names } of assignmentStatements) {
+		for (const { expression, statement, topLevel, bindingNames: names, loop } of assignments) {
 			const removableNames = new Set(names.filter((name) => forcedBindings.has(name) || deadBindings.has(name)));
 			if (removableNames.size === 0) continue;
-			if (removedAssignments.has(statement)) continue;
-			const expression = statement.expression;
-			const renderedLeft = left.type === "ArrayPattern" || left.type === "ObjectPattern" ? renderBindingPattern(code, left, removableNames) : null;
-			removedAssignments.add(statement);
+			if ((rewrittenAssignments.get(expression) ?? 0) >= removableNames.size) continue;
+			rewrittenAssignments.set(expression, removableNames.size);
+			if (loop) {
+				const head = expression.left;
+				const pattern = head.type === "VariableDeclaration" ? head.declarations[0].id : head;
+				if (![...removableNames].some((name) => forcedBindings.has(name) || candidateBindings.has(name))) {
+					if (head.type !== "VariableDeclaration") edits.push(...throwawayTargetEdits(head, removableNames));
+					continue;
+				}
+				const prunedNames = head.type === "VariableDeclaration" ? new Set([...removableNames].filter((name) => forcedBindings.has(name) || candidateBindings.has(name))) : removableNames;
+				if (renderBindingPattern((start, end) => code.slice(start, end), pattern, prunedNames)) {
+					for (const part of prunedPatternParts(pattern, prunedNames)) if (addDeadRange(part)) changed = true;
+					if (head.type !== "VariableDeclaration") edits.push({
+						start: head.start,
+						end: head.end,
+						replacement: () => renderBindingPattern(renderRange, head, removableNames)
+					});
+					continue;
+				}
+				edits.push({
+					start: expression.start,
+					end: expression.end,
+					replacement: topLevel ? "" : ";"
+				});
+				if (addDeadRange(expression)) changed = true;
+				continue;
+			}
+			const left = expression.left;
+			const renderedLeft = left.type === "ArrayPattern" || left.type === "ObjectPattern" ? renderBindingPattern((start, end) => code.slice(start, end), left, removableNames) : null;
+			const right = expression.right;
+			const renderRight = () => renderRange(right.start, right.end);
+			const target = statement ?? expression;
+			if (renderedLeft) {
+				for (const part of prunedPatternParts(left, removableNames)) if (addDeadRange(part)) changed = true;
+				edits.push({
+					start: target.start,
+					end: target.end,
+					replacement: () => {
+						const assignment = `${renderBindingPattern(renderRange, left, removableNames)} ${expression.operator} ${renderRight()}`;
+						if (!statement) return `(${assignment})`;
+						return left.type === "ObjectPattern" ? `(${assignment});` : `${assignment};`;
+					}
+				});
+				continue;
+			}
+			if (!statement && ![...removableNames].some((name) => forcedBindings.has(name) || candidateBindings.has(name))) {
+				edits.push({
+					start: target.start,
+					end: target.end,
+					replacement: () => `(${renderRight()})`
+				});
+				continue;
+			}
 			edits.push({
-				start: statement.start,
-				end: statement.end,
-				replacement: renderedLeft ? `${left.type === "ObjectPattern" ? `(${renderedLeft} ${expression.operator} ${code.slice(expression.right.start, expression.right.end)})` : `${renderedLeft} ${expression.operator} ${code.slice(expression.right.start, expression.right.end)}`};` : ""
+				start: target.start,
+				end: target.end,
+				replacement: statement ? topLevel ? "" : ";" : "void 0"
 			});
-			if (!renderedLeft && addDeadRange(statement)) changed = true;
+			if (addDeadRange(target)) changed = true;
 		}
 		const removableBindings = /* @__PURE__ */ new Set();
 		for (const [name] of bindings) if (forcedBindings.has(name) || candidateBindings.has(name) || (references.get(name) ?? []).some((position) => isInsideRanges(position, deadRanges))) removableBindings.add(name);
+		const removableImplementations = (names, { shared }) => [...names].flatMap((name) => declarationsOf(name).filter((binding) => shared || binding.declaredNames.every((declared) => names.has(declared))).map((binding) => binding.implementation));
 		let closureChanged = true;
 		while (closureChanged) {
 			closureChanged = false;
-			const implementations = [...removableBindings].map((name) => bindings.get(name)?.implementation).filter((implementation) => Boolean(implementation));
+			const implementations = removableImplementations(removableBindings, { shared: true });
 			for (const [name] of bindings) {
 				if (removableBindings.has(name)) continue;
 				if ((references.get(name) ?? []).some((position) => isInsideRanges(position, implementations))) {
@@ -419,10 +572,11 @@ function stripServerExports(code) {
 		let pruneChanged = true;
 		while (pruneChanged) {
 			pruneChanged = false;
-			const implementations = [...removableBindings].map((name) => bindings.get(name)?.implementation).filter((implementation) => Boolean(implementation));
+			const implementations = removableImplementations(removableBindings, { shared: false });
 			for (const name of removableBindings) {
 				if (forcedBindings.has(name)) continue;
-				if ((references.get(name) ?? []).some((position) => !isInsideRanges(position, deadRanges) && !isInsideRanges(position, implementations))) {
+				const isLive = (position) => !isInsideRanges(position, deadRanges) && !isInsideRanges(position, implementations);
+				if ((references.get(name) ?? []).some(isLive) || !candidateBindings.has(name) && (memberTargetReads.get(name) ?? []).some(isLive)) {
 					removableBindings.delete(name);
 					pruneChanged = true;
 				}
@@ -436,15 +590,18 @@ function stripServerExports(code) {
 			changed = true;
 			if (binding.kind === "function" || binding.kind === "class") addDeadRange(binding.implementation);
 		}
-		for (const binding of new Set(bindings.values())) {
+		for (const binding of /* @__PURE__ */ new Set([...bindings.values(), ...redeclarations])) {
 			if (binding.kind !== "variable") continue;
-			if (!binding.declaredNames.every((name) => deadBindings.has(name))) continue;
+			const removedNames = removedNamesFor(binding.node);
+			if (!binding.declaredNames.every((name) => removedNames.has(name))) {
+				for (const part of prunedPatternParts(binding.node.id, removedNames)) if (addDeadRange(part)) changed = true;
+				continue;
+			}
 			if (addDeadRange(binding.implementation)) changed = true;
 		}
 	}
-	for (const name of deadBindings) {
-		const binding = bindings.get(name);
-		if (!binding) continue;
+	for (const binding of [...deadBindings].flatMap(declarationsOf)) {
+		const name = binding.name;
 		if (forcedBindings.has(name)) {
 			if ((binding.kind === "function" || binding.kind === "class") && binding.parent.type !== "ExportNamedDeclaration") edits.push({
 				start: binding.node.start,
@@ -482,17 +639,24 @@ function stripServerExports(code) {
 		replacement: renderExportDeclaration(code, statement, removed)
 	});
 	for (const [declaration, removed] of variableRemovals) {
-		const rendered = declaration.declarations.flatMap((declarator) => {
-			if (!removed.has(declarator)) return [code.slice(declarator.start, declarator.end)];
-			const pattern = renderBindingPattern(code, declarator.id, deadBindings);
-			if (!pattern) return [];
-			return [`${pattern}${declarator.init ? ` = ${code.slice(declarator.init.start, declarator.init.end)}` : ""}`];
-		});
 		const exportStatement = statements.find((statement) => statement.type === "ExportNamedDeclaration" && statement.declaration === declaration);
 		edits.push({
 			start: exportStatement?.start ?? declaration.start,
 			end: declaration.end,
-			replacement: rendered.length > 0 ? `${exportStatement ? "export " : ""}${declaration.kind} ${rendered.join(", ")};` : ""
+			replacement: () => {
+				const rendered = declaration.declarations.flatMap((declarator) => {
+					if (!removed.has(declarator)) return [renderRange(declarator.start, declarator.end)];
+					const pattern = renderBindingPattern(renderRange, declarator.id, removedNamesFor(declarator));
+					if (!pattern) return [];
+					return [`${pattern}${declarator.init ? ` = ${renderRange(declarator.init.start, declarator.init.end)}` : ""}`];
+				});
+				if (rendered.length > 0) {
+					const terminator = loopHeadDeclarations.has(declaration) ? "" : ";";
+					return `${exportStatement ? "export " : ""}${declaration.kind} ${rendered.join(", ")}${terminator}`;
+				}
+				if (iterationHeadDeclarations.has(declaration)) return UNUSED_LOOP_TARGET;
+				return exportStatement || statements.includes(declaration) || loopHeadDeclarations.has(declaration) ? "" : ";";
+			}
 		});
 	}
 	for (const [statement, removed] of importRemovals) edits.push({
@@ -502,12 +666,12 @@ function stripServerExports(code) {
 	});
 	if (edits.length === 0) return null;
 	const string = new MagicString(code);
-	const uniqueEdits = [...new Map(edits.map((edit) => [`${edit.start}:${edit.end}`, edit])).values()].sort((left, right) => right.start - left.start || right.end - left.end);
-	let lastStart = Number.POSITIVE_INFINITY;
+	const uniqueEdits = [...new Map(edits.map((edit) => [`${edit.start}:${edit.end}`, edit])).values()].sort((left, right) => left.start - right.start || right.end - left.end);
+	let lastEnd = Number.NEGATIVE_INFINITY;
 	for (const edit of uniqueEdits) {
-		if (edit.end > lastStart) continue;
-		string.overwrite(edit.start, edit.end, edit.replacement);
-		lastStart = edit.start;
+		if (edit.start < lastEnd) continue;
+		string.overwrite(edit.start, edit.end, renderEdit(edit));
+		lastEnd = edit.end;
 	}
 	return magicStringTransformResult(string);
 }

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

@@ -1,8 +1,12 @@
 import MagicString from "magic-string";
 //#region src/plugins/transform-result.d.ts
-export type MagicStringTransformResult = {
+export type MagicStringTransformResult<TMap = ReturnType<MagicString["generateMap"]>> = {
   code: string;
-  map: ReturnType<MagicString["generateMap"]>;
+  map: TMap;
+};
+type MagicStringOutput<TMap> = {
+  toString(): string;
+  generateMap(options: Parameters<MagicString["generateMap"]>[0]): TMap;
 };
 type SourcemapEnvironment = {
   mode?: string;
@@ -13,15 +17,15 @@ type SourcemapEnvironment = {
   };
 };
 /** Build the standard code + sourcemap result returned by source transforms. */
-export declare function magicStringTransformResult(output: MagicString, options?: Parameters<MagicString["generateMap"]>[0]): MagicStringTransformResult;
+export declare function magicStringTransformResult<TMap = ReturnType<MagicString["generateMap"]>>(output: MagicStringOutput<TMap>, options?: Parameters<MagicString["generateMap"]>[0]): MagicStringTransformResult<TMap>;
 /**
  * Drop the sourcemap from a transform result when the build environment
  * discards it, mirroring Vite's own transforms
  * (`config.build.sourcemap ? s.generateMap(...) : null`). Dev and builds with
  * sourcemaps enabled keep the result unchanged.
  */
-export declare function omitUnusedBuildSourcemap(environment: SourcemapEnvironment | undefined, result: MagicStringTransformResult | null): {
+export declare function omitUnusedBuildSourcemap<TMap = ReturnType<MagicString["generateMap"]>>(environment: SourcemapEnvironment | undefined, result: MagicStringTransformResult<TMap> | null): {
   code: string;
-  map: MagicStringTransformResult["map"] | null;
+  map: TMap | null;
 } | null;
 //#endregion

package/dist/plugins/transitive-externals.js

@@ -1,7 +1,7 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { canonicalizeFilePath, stripViteModuleQuery } from "../utils/path.js";
-import { BARE_PACKAGE_SPECIFIER_RE, packageNameFromSpecifier } from "../utils/package-name.js";
 import { isServerEnvironment } from "./environment.js";
+import { BARE_PACKAGE_SPECIFIER_RE, packageNameFromSpecifier } from "../utils/package-name.js";
 import { createRequire } from "node:module";
 import { createIdResolver } from "vite";
 //#region src/plugins/transitive-externals.ts

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

@@ -23,6 +23,6 @@ export declare function getTypeofWindowReplacement(environment: EnvironmentLike)
  * parser's module record in {@link moduleRecordHasScannedFoldTargets} is exact.
  */
 export declare function mayFoldChangeScannedImports(code: string): boolean;
-export declare function replaceTypeofWindow(code: string, replacement: WindowType, id?: string): MagicStringTransformResult | null;
-export declare function replaceConsumerEnvironmentConditions(code: string, replacements: ConsumerEnvironmentReplacements, id?: string): MagicStringTransformResult | null;
+export declare function replaceTypeofWindow(code: string, replacement: WindowType, id?: string): MagicStringTransformResult<import("magic-string").SourceMap> | null;
+export declare function replaceConsumerEnvironmentConditions(code: string, replacements: ConsumerEnvironmentReplacements, id?: string): MagicStringTransformResult<import("magic-string").SourceMap> | null;
 //#endregion

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

@@ -72,9 +72,11 @@ function getFunctionDirectiveExportNames(transforms, ast, directive) {
 }
 function getCacheWrapperOptions(meta) {
 	const argumentCount = getArgumentCount(meta);
+	const captureCount = "bindVars" in meta ? meta.bindVars.length : 0;
 	return {
 		acceptsSecondArgument: acceptsSecondArgument(meta),
-		...argumentCount === void 0 ? {} : { argumentCount }
+		...argumentCount === void 0 ? {} : { argumentCount },
+		...captureCount === 0 ? {} : { captureCount }
 	};
 }
 async function createUseCacheCallablePlugin(options) {
@@ -190,7 +192,11 @@ async function createUseCacheCallablePlugin(options) {
 					hoistRuntime: true,
 					noExport: true,
 					runtime: (value, name, meta) => runtime(value, name, matchUseCacheDirective(meta.directiveMatch[0]), meta),
-					encode: (value) => `$$cacheRuntime.encryptCacheCaptures(${value})`,
+					encode: (value, name) => {
+						if (name === void 0) throw new Error("vinext: inline \"use cache\" functions require @vitejs/plugin-rsc 0.5.37 or newer.");
+						const referenceId = `${reference.referenceKey}#${secureExportName(name)}`;
+						return `$$cacheRuntime.encryptCacheCaptures(${JSON.stringify(referenceId)}, ${value})`;
+					},
 					decode: (value) => value
 				});
 				if (!result.output.hasChanged()) {

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

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

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

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