vinext 1.1.0 → 1.2.1

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

@@ -1,6 +1,6 @@
-import { getAstName } from "./ast-utils.js";
+import { getAstName, parseProgram } from "./ast-utils.js";
 import { magicStringTransformResult } from "./transform-result.js";
-import { parseAst } from "vite";
+import { findAstBindingScope, walkAstScopes } from "./ast-scope.js";
 import MagicString from "magic-string";
 //#region src/plugins/strip-server-exports.ts
 const SERVER_EXPORTS = /* @__PURE__ */ new Set([
@@ -12,6 +12,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,70 +129,102 @@ 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;
 	let ast;
 	try {
-		ast = parseAst(code);
+		ast = parseProgram(code);
 	} catch {
 		return;
 	}
@@ -208,7 +242,7 @@ function stripServerExports(code) {
 	if (!hasServerExportCandidate(code) && !hasExportAllCandidate(code)) return null;
 	let ast;
 	try {
-		ast = parseAst(code);
+		ast = parseProgram(code);
 	} catch {
 		return null;
 	}
@@ -227,14 +261,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 +343,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 +490,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 +571,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 +589,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 +638,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 +665,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/styled-jsx.js

@@ -1,9 +1,8 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { SCRIPT_MODULE_ID_RE, walkAst } from "./ast-utils.js";
+import { SCRIPT_MODULE_ID_RE, parseProgram, walkAst } from "./ast-utils.js";
 import { NODE_MODULES_PATH_RE, stripViteModuleQuery } from "../utils/path.js";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
-import { parseAst } from "vite";
 //#region src/plugins/styled-jsx.ts
 const STYLED_JSX_IMPORT_RE = /^styled-jsx(?:\/.*)?$/;
 const STYLED_JSX_SOURCE_RE = /(?:<style\b|from\s+["']styled-jsx\/css["']|require\s*\(\s*["']styled-jsx\/css["']\s*\))/;
@@ -14,7 +13,7 @@ function hasStyledJsxTag(source, id) {
 	const lang = extension === ".ts" || extension === ".mts" || extension === ".cts" ? "ts" : "tsx";
 	let ast;
 	try {
-		ast = parseAst(source, { lang });
+		ast = parseProgram(source, { lang });
 	} catch {
 		return false;
 	}

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.d.ts

@@ -1,9 +1,28 @@
 import { Plugin } from "vite";
 //#region src/plugins/use-cache-callable.d.ts
+type RscTransforms = typeof import("@vitejs/plugin-rsc/transforms");
 type Options = {
   projectRoot: string;
   cacheRuntime: string;
   allowMissingRsc?: boolean;
 };
-export declare function createUseCacheCallablePlugin(options: Options): Promise<Plugin>;
-//#endregion
+type BrowserTransformOptions = {
+  environmentName: string;
+  reference: {
+    referenceKey: string;
+  };
+  secureExportName: (name: string) => string;
+  createReference: (referenceId: string, name: string) => string;
+};
+type BrowserTransformOutput = NonNullable<ReturnType<RscTransforms["transformDirectiveProxyExport"]>>;
+export type UseCacheCallableApi = {
+  /**
+   * Compile a browser Web Worker module like the client environment does,
+   * with the same reference ids, without claiming references.
+   */
+  transformWorkerModule(code: string, id: string, createReference: BrowserTransformOptions["createReference"]): Promise<BrowserTransformOutput["output"] | undefined>;
+};
+declare const PLUGIN_NAME = "vinext:server-function-directives";
+export declare function createUseCacheCallablePlugin(options: Options): Promise<Plugin<UseCacheCallableApi>>;
+//#endregion
+export { PLUGIN_NAME as USE_CACHE_PLUGIN_NAME };