vinext 1.0.0 → 1.0.1

package/dist/plugins/ignore-dynamic-requests.js

@@ -1,6 +1,6 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, collectBindingNames, forEachAstChild, isIdentifierNamed, mayContainDynamicImport, scriptParserLanguage, stringLiteralValue, unwrapExpression } from "./ast-utils.js";
-import { magicStringTransformResult } from "./transform-result.js";
+import { magicStringTransformResult, omitUnusedBuildSourcemap } from "./transform-result.js";
 import { stripViteModuleQuery } from "../utils/path.js";
 import { collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, hasAstBinding, isFunctionNode } from "./ast-scope.js";
 import { createTransformCache } from "./transform-cache.js";
@@ -12,6 +12,16 @@ const DYNAMIC_REQUEST_ERROR = "Cannot find module as expression is too dynamic";
 const REQUIRE_PRESCAN = /(?:\brequire\b|(?:r|\\u(?:0072|\{0*72\}))(?:e|\\u(?:0065|\{0*65\}))(?:q|\\u(?:0071|\{0*71\}))(?:u|\\u(?:0075|\{0*75\}))(?:i|\\u(?:0069|\{0*69\}))(?:r|\\u(?:0072|\{0*72\}))(?:e|\\u(?:0065|\{0*65\})))/i;
 const DYNAMIC_REQUEST_PRESCAN = new RegExp(String.raw`(?:${REQUIRE_PRESCAN.source}|${DYNAMIC_IMPORT_PRESCAN.source})`, "i");
 const MAX_CONSTANT_BINDING_DEPTH = 1500;
+const REQUIRE_OR_IMPORT_OCCURRENCE = new RegExp(String.raw`${REQUIRE_PRESCAN.source}|\bimport\b`, "gi");
+const IDENTIFIER_CHAR = /[\w$]/;
+const LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
+const WHITESPACE_CHAR = /\s/;
+const UNCHANGED_STRING_ARGUMENT = String.raw`\s*\(\s*(?:"(?!\/")[^"\\\r\n]*"|'(?!\/')[^'\\\r\n]*')\s*`;
+const UNCHANGED_REQUIRE_CALL = new RegExp(String.raw`${UNCHANGED_STRING_ARGUMENT}\)`, "y");
+const UNCHANGED_IMPORT_CALL = new RegExp(String.raw`${UNCHANGED_STRING_ARGUMENT}[,)]`, "y");
+const POSSIBLE_REQUIRE_CALLEE_FOLLOWER = /\s*(?:[(/<]|--!?>|\?\.|!(?!=)|as\b|satisfies\b)/y;
+const CLOSING_PAREN_FOLLOWER = /\s*\)/y;
+const POSSIBLE_IMPORT_EXPRESSION_FOLLOWER = /\s*(?:[(/<]|--!?>|\.(?!\s*meta\b))/y;
 const VINEXT_SOURCE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const PLUGIN_RSC_PATH = /[\\/]node_modules[\\/](?:\.pnpm[\\/][^/\\]+[\\/]node_modules[\\/])?@vitejs[\\/]plugin-rsc[\\/]/;
 function stringFromCharCodeValue(value, scope) {
@@ -355,8 +365,48 @@ function dynamicRequireReplacement() {
 function dynamicImportReplacement() {
 	return `Promise.resolve().then(() => { const error = new Error(${JSON.stringify(DYNAMIC_REQUEST_ERROR)}); error.code = "MODULE_NOT_FOUND"; throw error; })`;
 }
+function matchesAt(pattern, code, index) {
+	pattern.lastIndex = index;
+	return pattern.test(code);
+}
+function mayBeWrappedCallee(code, start) {
+	let index = start - 1;
+	while (index >= 0 && WHITESPACE_CHAR.test(code[index])) {
+		if (LINE_TERMINATOR.test(code[index])) return true;
+		index--;
+	}
+	return index < 0 || code[index] === "(" || code[index] === ">" || code[index] === "/";
+}
+/**
+* Cheap, conservative check run before parsing: whether any `require` or
+* `import` occurrence could be a request this transform rewrites. Occurrences
+* that are part of a longer identifier, member properties, static imports,
+* non-callee positions (`typeof require`, `require,`), and calls with a
+* single-line string literal argument other than "/" are left unchanged, so a
+* module containing only those is skipped. Anything else, including escaped
+* identifiers, falls through to the AST pass.
+*/
+function mayContainVeryDynamicRequest(code) {
+	REQUIRE_OR_IMPORT_OCCURRENCE.lastIndex = 0;
+	for (let match; match = REQUIRE_OR_IMPORT_OCCURRENCE.exec(code);) {
+		const text = match[0];
+		const start = match.index;
+		const end = start + text.length;
+		if (text.includes("\\")) return true;
+		if (text !== "require" && text !== "import") continue;
+		if (IDENTIFIER_CHAR.test(code[start - 1] ?? "") || IDENTIFIER_CHAR.test(code[end] ?? "")) continue;
+		if (code[start - 1] === "." && code[start - 2] !== ".") continue;
+		if (text === "import") {
+			if (matchesAt(POSSIBLE_IMPORT_EXPRESSION_FOLLOWER, code, end) && !matchesAt(UNCHANGED_IMPORT_CALL, code, end)) return true;
+		} else if (matchesAt(POSSIBLE_REQUIRE_CALLEE_FOLLOWER, code, end)) {
+			if (!matchesAt(UNCHANGED_REQUIRE_CALL, code, end)) return true;
+		} else if (matchesAt(CLOSING_PAREN_FOLLOWER, code, end) && mayBeWrappedCallee(code, start)) return true;
+	}
+	return false;
+}
 function transformVeryDynamicRequests(code, id) {
 	if (!REQUIRE_PRESCAN.test(code) && !mayContainDynamicImport(code)) return null;
+	if (!mayContainVeryDynamicRequest(code)) return null;
 	const lang = scriptParserLanguage(id) ?? "js";
 	let ast;
 	try {
@@ -486,7 +536,7 @@ function createIgnoreDynamicRequestsPlugin(getTranspiledPackages = () => []) {
 				if (!shouldTransformVeryDynamicRequests(this.environment, cleanId, getTranspiledPackages())) return null;
 				const absoluteId = path.resolve(cleanId);
 				if (absoluteId === VINEXT_SOURCE_ROOT || absoluteId.startsWith(`${VINEXT_SOURCE_ROOT}/`) || PLUGIN_RSC_PATH.test(absoluteId)) return null;
-				return cached(id, code, void 0, () => transformVeryDynamicRequests(code, id));
+				return omitUnusedBuildSourcemap(this.environment, cached(id, code, void 0, () => transformVeryDynamicRequests(code, id)));
 			}
 		}
 	};
@@ -498,5 +548,6 @@ function shouldTransformVeryDynamicRequests(environment, id, transpiledPackages)
 	return !transpiledPackages.some((packageName) => normalizedId.includes(`/node_modules/${packageName}/`));
 }
 const _transformVeryDynamicRequests = transformVeryDynamicRequests;
+const _mayContainVeryDynamicRequest = mayContainVeryDynamicRequest;
 //#endregion
-export { _transformVeryDynamicRequests, createIgnoreDynamicRequestsPlugin };
+export { _mayContainVeryDynamicRequest, _transformVeryDynamicRequests, createIgnoreDynamicRequestsPlugin };

package/dist/plugins/import-meta-url.js

@@ -1,6 +1,6 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { SCRIPT_MODULE_ID_RE, collectBindingNames, forEachAstChild, isIdentifierNamed, scriptParserLanguage } from "./ast-utils.js";
-import { magicStringTransformResult } from "./transform-result.js";
+import { magicStringTransformResult, omitUnusedBuildSourcemap } from "./transform-result.js";
 import { canonicalizeFilePath, isPathInsideOrEqual, stripViteModuleQuery } from "../utils/path.js";
 import { VIRTUAL_MODULE_ID_RE } from "../utils/virtual-module.js";
 import fs from "node:fs";
@@ -80,11 +80,11 @@ function createImportMetaUrlPlugin(options) {
 						if (dependency) {
 							const importMetaUrlReplacement = mayContainImportMetaUrl(code) ? this.environment.mode === "dev" ? JSON.stringify(pathToFileURL(dependency.canonicalId).href) : emittedModuleIdentity.importMetaUrlInitializer : void 0;
 							const cjsGlobalInitializers = dependency.isCommonJs && mayContainServerCjsGlobal(code) ? this.environment.mode === "dev" ? sourcePathCjsGlobalInitializers(dependency.canonicalId) : emittedModuleIdentity.cjsGlobalInitializers : void 0;
-							if (importMetaUrlReplacement !== void 0 || cjsGlobalInitializers) return rewriteModuleIdentity(code, {
+							if (importMetaUrlReplacement !== void 0 || cjsGlobalInitializers) return omitUnusedBuildSourcemap(this.environment, rewriteModuleIdentity(code, {
 								id: dependency.canonicalId,
 								importMetaUrlReplacement,
 								cjsGlobalInitializers
-							});
+							}));
 						}
 					}
 					if (isNodeModulesId(cleanId)) return null;
@@ -106,10 +106,10 @@ function createImportMetaUrlPlugin(options) {
 						setBoundedCacheEntry(transformCache, id, entry, MAX_TRANSFORM_CACHE_ENTRIES);
 					}
 					const cached = entry.results.get(transformKind);
-					if (cached) return cached.value;
+					if (cached) return omitUnusedBuildSourcemap(this.environment, cached.value);
 					const value = rewriteCanonicalSourceIdentity(code, canonicalId, paths, environment, this.environment.mode === "build" && mayContainServerCjsGlobal(code) ? emittedModuleIdentity.cjsGlobalInitializers : sourcePathCjsGlobalInitializers(canonicalId));
 					entry.results.set(transformKind, { value });
-					return value;
+					return omitUnusedBuildSourcemap(this.environment, value);
 				}
 			},
 			renderChunk: {
@@ -117,7 +117,7 @@ function createImportMetaUrlPlugin(options) {
 				handler(code, chunk, outputOptions) {
 					if (this.environment?.config.consumer !== "server" || outputOptions.format !== "es") return null;
 					const emittedFileName = resolveEmittedModuleFileName(this.environment?.name, chunk.fileName);
-					return finalizeEmittedModuleIdentity(code, emittedModuleIdentity.replacements, emittedFileName);
+					return omitUnusedBuildSourcemap(this.environment, finalizeEmittedModuleIdentity(code, emittedModuleIdentity.replacements, emittedFileName));
 				}
 			}
 		},

package/dist/plugins/og-asset-ownership.d.ts

@@ -11,6 +11,7 @@ export declare class OgAssetOwnership {
   private readonly stringAliasesByFirstCharacter;
   private regularExpressionAliases;
   private configuredAliases;
+  private readonly resolvedImportPackageRoots;
   configure(projectRoot: string, aliases: readonly Alias[]): void;
   reset(): void;
   shouldTrackImport(source: string): boolean;
@@ -19,6 +20,7 @@ export declare class OgAssetOwnership {
   resolveContainedAsset(assetRoot: string, assetPath: string): Promise<string | null>;
   private findAlias;
   private getExpectedPackageName;
+  private findResolvedImportPackageRoot;
   private resolveAliasPackageRoot;
   private resolveConfiguredAliasRoot;
 }

package/dist/plugins/og-asset-ownership.js

@@ -93,8 +93,10 @@ var OgAssetOwnership = class {
 	stringAliasesByFirstCharacter = /* @__PURE__ */ new Map();
 	regularExpressionAliases = [];
 	configuredAliases = [];
+	resolvedImportPackageRoots = /* @__PURE__ */ new Map();
 	configure(projectRoot, aliases) {
 		this.projectRoot = path.resolve(projectRoot);
+		this.resolvedImportPackageRoots.clear();
 		this.dependencyPackageNames.clear();
 		try {
 			const manifest = JSON.parse(fs.readFileSync(path.join(this.projectRoot, "package.json"), "utf8"));
@@ -129,25 +131,20 @@ var OgAssetOwnership = class {
 	}
 	reset() {
 		this.linkedPackageRoots.clear();
+		this.resolvedImportPackageRoots.clear();
 	}
 	shouldTrackImport(source) {
 		return this.findAlias(source) !== void 0 || this.getExpectedPackageName(source) !== void 0;
 	}
 	async recordResolvedImport(source, resolvedId) {
-		const configuredAlias = this.findAlias(source);
-		const sourcePackageName = packageNameFromSpecifier(source);
-		const expectedPackageName = this.getExpectedPackageName(source);
-		if (configuredAlias === void 0 && expectedPackageName === void 0) return;
-		let realResolvedPath;
-		try {
-			realResolvedPath = await realpathNative(path.resolve(stripViteModuleQuery(resolvedId)));
-		} catch {
-			return;
+		const key = `${source}\0${resolvedId}`;
+		let packageRoot = this.resolvedImportPackageRoots.get(key);
+		if (packageRoot === void 0) {
+			packageRoot = this.findResolvedImportPackageRoot(source, resolvedId);
+			this.resolvedImportPackageRoots.set(key, packageRoot);
 		}
-		let packageRoot;
-		if (configuredAlias !== void 0) packageRoot = await this.resolveAliasPackageRoot(configuredAlias, source, sourcePackageName, realResolvedPath);
-		else packageRoot = await findPackageRoot(path.dirname(realResolvedPath), expectedPackageName);
-		if (packageRoot !== null) this.linkedPackageRoots.add(packageRoot);
+		const root = await packageRoot;
+		if (root !== null) this.linkedPackageRoots.add(root);
 	}
 	async resolveModuleBoundary(moduleId) {
 		const modulePath = path.resolve(stripViteModuleQuery(moduleId));
@@ -219,6 +216,20 @@ var OgAssetOwnership = class {
 		const packageName = packageNameFromSpecifier(source);
 		return packageName === null ? void 0 : this.dependencyPackageNames.get(packageName);
 	}
+	async findResolvedImportPackageRoot(source, resolvedId) {
+		const configuredAlias = this.findAlias(source);
+		const sourcePackageName = packageNameFromSpecifier(source);
+		const expectedPackageName = this.getExpectedPackageName(source);
+		if (configuredAlias === void 0 && expectedPackageName === void 0) return null;
+		let realResolvedPath;
+		try {
+			realResolvedPath = await realpathNative(path.resolve(stripViteModuleQuery(resolvedId)));
+		} catch {
+			return null;
+		}
+		if (configuredAlias !== void 0) return this.resolveAliasPackageRoot(configuredAlias, source, sourcePackageName, realResolvedPath);
+		return findPackageRoot(path.dirname(realResolvedPath), expectedPackageName);
+	}
 	async resolveAliasPackageRoot(alias, source, sourcePackageName, realResolvedPath) {
 		const aliasTarget = applyAlias(alias.find, alias.replacement, source);
 		if (!path.isAbsolute(aliasTarget)) return null;

package/dist/plugins/og-assets.d.ts

@@ -11,6 +11,24 @@ import { Plugin } from "vite";
  * valid file URL.
  */
 export declare function createOgInlineFetchAssetsPlugin(): Plugin;
+type ReadFileSyncAssetUrlMatch = {
+  start: number;
+  end: number;
+  relPath: string;
+};
+/**
+ * Find every `<identifier>.readFileSync(fileURLToPath(new URL("./file", import.meta.url)))`
+ * call in `code`.
+ *
+ * Returns the same matches, in the same order, as `code.matchAll()` with
+ * `/[a-zA-Z_$][a-zA-Z0-9_$]*` followed by `READ_FILE_SYNC_ASSET_URL_TAIL_RE` as a
+ * global regex. That regex retries the identifier prefix at every identifier
+ * character of the module, which is slow on large bundles such as typescript.js.
+ * A match's identifier always ends right at a `.readFileSync(` occurrence, so
+ * candidates are found with `indexOf` and the identifier is recovered by
+ * scanning backwards.
+ */
+export declare function matchReadFileSyncAssetUrls(code: string): ReadFileSyncAssetUrlMatch[];
 /**
  * Copy a single root copy of each requested WASM asset from `sourceDir` into
  * `outDir`, skipping any asset whose source is missing or whose destination

package/dist/plugins/og-assets.js

@@ -1,5 +1,5 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { magicStringTransformResult } from "./transform-result.js";
+import { magicStringTransformResult, omitUnusedBuildSourcemap } from "./transform-result.js";
 import { resolveHarfbuzzWasmPath } from "./og-harfbuzz.js";
 import { OgAssetOwnership } from "./og-asset-ownership.js";
 import { createRequire } from "node:module";
@@ -80,21 +80,63 @@ function createOgInlineFetchAssetsPlugin() {
 					s.overwrite(match.index, match.index + fullMatch.length, inlined);
 					didReplace = true;
 				}
-				if (code.includes("readFileSync(")) for (const match of code.matchAll(/[a-zA-Z_$][a-zA-Z0-9_$]*\.readFileSync\(\s*(?:[a-zA-Z_$][a-zA-Z0-9_$]*\.)?fileURLToPath\(\s*new URL\(\s*(["'])(\.[^"']+)\1\s*,\s*import\.meta\.url\s*\)\s*\)\s*\)/g)) {
-					const fullMatch = match[0];
-					const relPath = match[2];
-					const fileBase64 = await readAsBase64(path.resolve(moduleDir, relPath));
+				if (code.includes("readFileSync(")) for (const match of matchReadFileSyncAssetUrls(code)) {
+					const fileBase64 = await readAsBase64(path.resolve(moduleDir, match.relPath));
 					if (fileBase64 === null) continue;
 					const inlined = `Buffer.from(${JSON.stringify(fileBase64)},"base64")`;
-					s.overwrite(match.index, match.index + fullMatch.length, inlined);
+					s.overwrite(match.start, match.end, inlined);
 					didReplace = true;
 				}
 				if (!didReplace) return null;
-				return magicStringTransformResult(s);
+				return omitUnusedBuildSourcemap(this.environment, magicStringTransformResult(s));
 			}
 		}
 	};
 }
+const READ_FILE_SYNC_ASSET_URL_TAIL_RE = /\.readFileSync\(\s*(?:[a-zA-Z_$][a-zA-Z0-9_$]*\.)?fileURLToPath\(\s*new URL\(\s*(["'])(\.[^"']+)\1\s*,\s*import\.meta\.url\s*\)\s*\)\s*\)/y;
+/**
+* Find every `<identifier>.readFileSync(fileURLToPath(new URL("./file", import.meta.url)))`
+* call in `code`.
+*
+* Returns the same matches, in the same order, as `code.matchAll()` with
+* `/[a-zA-Z_$][a-zA-Z0-9_$]*` followed by `READ_FILE_SYNC_ASSET_URL_TAIL_RE` as a
+* global regex. That regex retries the identifier prefix at every identifier
+* character of the module, which is slow on large bundles such as typescript.js.
+* A match's identifier always ends right at a `.readFileSync(` occurrence, so
+* candidates are found with `indexOf` and the identifier is recovered by
+* scanning backwards.
+*/
+function matchReadFileSyncAssetUrls(code) {
+	const matches = [];
+	let searchFrom = 0;
+	let dot = code.indexOf(".readFileSync(");
+	while (dot !== -1) {
+		let start = dot;
+		while (start > searchFrom && isAsciiIdentifierPart(code.charCodeAt(start - 1))) start--;
+		while (start < dot && !isAsciiIdentifierStart(code.charCodeAt(start))) start++;
+		if (start < dot) {
+			READ_FILE_SYNC_ASSET_URL_TAIL_RE.lastIndex = dot;
+			const tail = READ_FILE_SYNC_ASSET_URL_TAIL_RE.exec(code);
+			if (tail !== null) {
+				const end = dot + tail[0].length;
+				matches.push({
+					start,
+					end,
+					relPath: tail[2]
+				});
+				searchFrom = end;
+			}
+		}
+		dot = code.indexOf(".readFileSync(", Math.max(dot + 1, searchFrom));
+	}
+	return matches;
+}
+function isAsciiIdentifierStart(charCode) {
+	return charCode >= 97 && charCode <= 122 || charCode >= 65 && charCode <= 90 || charCode === 95 || charCode === 36;
+}
+function isAsciiIdentifierPart(charCode) {
+	return isAsciiIdentifierStart(charCode) || charCode >= 48 && charCode <= 57;
+}
 const OG_WASM_ASSETS = [
 	"resvg.wasm",
 	"yoga.wasm",
@@ -243,4 +285,4 @@ function createOgAssetsPlugin() {
 	};
 }
 //#endregion
-export { copyMissingOgWasm, createOgAssetsPlugin, createOgInlineFetchAssetsPlugin };
+export { copyMissingOgWasm, createOgAssetsPlugin, createOgInlineFetchAssetsPlugin, matchReadFileSyncAssetUrls };

package/dist/plugins/og-harfbuzz.js

@@ -1,7 +1,8 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { forEachAstChild, getAstName, staticStringValue } from "./ast-utils.js";
-import { magicStringTransformResult } from "./transform-result.js";
+import { magicStringTransformResult, omitUnusedBuildSourcemap } from "./transform-result.js";
 import { isFunctionNode } from "./ast-scope.js";
+import { createTransformCache } from "./transform-cache.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import { parseAst } from "vite";
@@ -210,9 +211,43 @@ const INSTANTIATE_WASM = `function __vi_hb_instantiateWasm(imports, receiveInsta
   receiveInstance(instance);
   return instance.exports;
 }`;
+/**
+* Patch one @vercel/og entry bundle. The result depends only on the bundle
+* source, its id, the command and the callback module directory; callback
+* modules are written once and reused by later calls.
+*/
+function patchHarfbuzzBundle(code, id, isBuild, callbackModuleDir, error) {
+	const ogEntry = toSlash(id.split("?", 1)[0]);
+	const isWorkerd = ogEntry.endsWith("/index.edge.js");
+	const fail = (reason) => error(`[vinext] Unsupported @vercel/og HarfBuzz bundle in ${ogEntry}: ${reason}. vinext must be updated to support this @vercel/og version.`);
+	const sites = findHarfbuzzPatchSites(parseAst(code, { lang: "js" }));
+	if (typeof sites === "string") return fail(sites);
+	const output = new MagicString(code);
+	for (const flag of sites.environmentFlags) output.overwrite(flag.start, flag.end, "false");
+	for (const member of sites.instantiateWasmReads) output.overwrite(member.start, member.end, "__vi_hb_instantiateWasm");
+	const harfbuzzWasm = resolveHarfbuzzWasmPath(ogEntry);
+	const preamble = [];
+	if (isWorkerd) {
+		if (sites.moduleCompilations.length === 0) return fail("no callback module compilation (new WebAssembly.Module) was found");
+		for (const { node, enclosingFunction } of sites.moduleCompilations) {
+			const signature = isFunctionNode(enclosingFunction) ? enclosingFunction.params[1] : void 0;
+			if (signature?.type !== "Identifier") return fail("the callback compiler does not take a (func, sig) signature");
+			output.prependLeft(node.start, `(__vi_hb_callbacks[${signature.name}.replace(/p/g, "i")] || `);
+			output.appendRight(node.end, ")");
+		}
+		const callbacks = [...writeHarfbuzzCallbackModules(harfbuzzWasm, callbackModuleDir)];
+		preamble.push(`import __vi_hb_wasm from ${JSON.stringify(`${harfbuzzWasm}?module`)};`, ...callbacks.map(([, file], index) => `import __vi_hb_callback_${index} from ${JSON.stringify(`${file}?module`)};`), `var __vi_hb_callbacks = { ${callbacks.map(([signature], index) => `${signature}: __vi_hb_callback_${index}`).join(", ")} };`, "function __vi_hb_module() { return __vi_hb_wasm; }");
+	} else {
+		const location = isBuild ? `new URL("./${HARFBUZZ_WASM}", import.meta.url)` : JSON.stringify(harfbuzzWasm);
+		preamble.push(`import { readFileSync as __vi_hb_readFileSync } from "node:fs";`, `function __vi_hb_module() { return new WebAssembly.Module(__vi_hb_readFileSync(${location})); }`);
+	}
+	output.prepend(`${preamble.join("\n")}\n${INSTANTIATE_WASM}\n`);
+	return magicStringTransformResult(output);
+}
 function createOgHarfbuzzPlugin() {
 	let callbackModuleDir;
 	let isBuild = false;
+	const cached = createTransformCache();
 	return {
 		name: "vinext:og-harfbuzz",
 		enforce: "pre",
@@ -226,32 +261,8 @@ function createOgHarfbuzzPlugin() {
 				code: /["'`]hb\.wasm["'`]/
 			},
 			handler(code, id) {
-				const ogEntry = toSlash(id.split("?", 1)[0]);
-				const isWorkerd = ogEntry.endsWith("/index.edge.js");
-				const fail = (reason) => this.error(`[vinext] Unsupported @vercel/og HarfBuzz bundle in ${ogEntry}: ${reason}. vinext must be updated to support this @vercel/og version.`);
-				const sites = findHarfbuzzPatchSites(parseAst(code, { lang: "js" }));
-				if (typeof sites === "string") return fail(sites);
-				const output = new MagicString(code);
-				for (const flag of sites.environmentFlags) output.overwrite(flag.start, flag.end, "false");
-				for (const member of sites.instantiateWasmReads) output.overwrite(member.start, member.end, "__vi_hb_instantiateWasm");
-				const harfbuzzWasm = resolveHarfbuzzWasmPath(ogEntry);
-				const preamble = [];
-				if (isWorkerd) {
-					if (sites.moduleCompilations.length === 0) return fail("no callback module compilation (new WebAssembly.Module) was found");
-					for (const { node, enclosingFunction } of sites.moduleCompilations) {
-						const signature = isFunctionNode(enclosingFunction) ? enclosingFunction.params[1] : void 0;
-						if (signature?.type !== "Identifier") return fail("the callback compiler does not take a (func, sig) signature");
-						output.prependLeft(node.start, `(__vi_hb_callbacks[${signature.name}.replace(/p/g, "i")] || `);
-						output.appendRight(node.end, ")");
-					}
-					const callbacks = [...writeHarfbuzzCallbackModules(harfbuzzWasm, callbackModuleDir)];
-					preamble.push(`import __vi_hb_wasm from ${JSON.stringify(`${harfbuzzWasm}?module`)};`, ...callbacks.map(([, file], index) => `import __vi_hb_callback_${index} from ${JSON.stringify(`${file}?module`)};`), `var __vi_hb_callbacks = { ${callbacks.map(([signature], index) => `${signature}: __vi_hb_callback_${index}`).join(", ")} };`, "function __vi_hb_module() { return __vi_hb_wasm; }");
-				} else {
-					const location = isBuild ? `new URL("./${HARFBUZZ_WASM}", import.meta.url)` : JSON.stringify(harfbuzzWasm);
-					preamble.push(`import { readFileSync as __vi_hb_readFileSync } from "node:fs";`, `function __vi_hb_module() { return new WebAssembly.Module(__vi_hb_readFileSync(${location})); }`);
-				}
-				output.prepend(`${preamble.join("\n")}\n${INSTANTIATE_WASM}\n`);
-				return magicStringTransformResult(output);
+				const patch = () => patchHarfbuzzBundle(code, id, isBuild, callbackModuleDir, (message) => this.error(message));
+				return omitUnusedBuildSourcemap(this.environment, isBuild ? cached(id, code, callbackModuleDir, patch) : patch());
 			}
 		}
 	};

package/dist/plugins/optimize-imports.js

@@ -108,7 +108,8 @@ function createOptimizedImportSourceMatcher(packages) {
 	const pattern = [...packages].map(escapeRegExp).join("|");
 	if (!pattern) return () => false;
 	const importFromPattern = new RegExp(String.raw`(?:^|[;}\n\r])\s*import(?!\s*\()(?:(?!\bfrom\b)[\s\S])*?\bfrom\s*["'](?:${pattern})["']`, "m");
-	return (code) => code.includes("import") && code.includes("from") && importFromPattern.test(code);
+	const quotedSourcePattern = new RegExp(String.raw`["'](?:${pattern})["']`);
+	return (code) => code.includes("import") && code.includes("from") && quotedSourcePattern.test(code) && importFromPattern.test(code);
 }
 /**
 * Resolve a package.json exports value to a string entry path.

package/dist/plugins/require-context.d.ts

@@ -1,4 +1,5 @@
 import { Plugin } from "vite";
 //#region src/plugins/require-context.d.ts
 export declare function createRequireContextPlugin(): Plugin;
+export declare function _mayContainRequireContextCall(code: string): boolean;
 //#endregion

package/dist/plugins/require-context.js

@@ -51,7 +51,34 @@ function createRequireContextPlugin() {
 		}
 	};
 }
+const CONTEXT_CALL_SPACE = String.raw`[\s\u0085\u200b]`;
+const LINE_TERMINATOR = String.raw`[\n\r\u2028\u2029]`;
+const CONTEXT_PROPERTY = String.raw`(?:c|\\u(?:0063|\{0*63\}))(?:o|\\u(?:006f|\{0*6f\}))(?:n|\\u(?:006e|\{0*6e\}))(?:t|\\u(?:0074|\{0*74\}))(?:e|\\u(?:0065|\{0*65\}))(?:x|\\u(?:0078|\{0*78\}))(?:t|\\u(?:0074|\{0*74\}))`;
+const CONTEXT_MEMBER_PREFIX = String.raw`(?:\.|\*\/|(?:\/\/|<!--|-->)[^\n\r\u2028\u2029]*${LINE_TERMINATOR})${CONTEXT_CALL_SPACE}*`;
+const COMMENT_OPENER = String.raw`\/[*/]|<!--|-->`;
+/**
+* Cheap pre-parse gate for {@link transformRequireContext}. The transform only
+* rewrites a `.context` member call whose first argument is a string literal,
+* so the source must contain `.`, `context`, then — after optional closing
+* parens of a `(require.context)` callee and an optional `?.` — a `(` followed
+* by optional opening parens and a quote. TypeScript type arguments
+* (`context<T>(...)`) are not scanned: any `<` after `context` keeps the parse.
+*
+* The transform filter admits every module that mentions both `require` and
+* `.context` (React, TypeScript, ...), and parsing multi-MB dependencies that
+* can never contain a matching call dominated this plugin's cost. The gate
+* errs toward over-matching: a false positive costs one redundant parse,
+* whereas a false negative would silently skip a real `require.context` call.
+* Comments therefore count as a match instead of being scanned, and the match
+* starts at `context` and looks back for the `.`. Every repetition then covers
+* only whitespace and parens next to one `context`, so the scan stays linear.
+*/
+const REQUIRE_CONTEXT_CALL_PRESCAN = new RegExp(String.raw`${CONTEXT_PROPERTY}(?<=${CONTEXT_MEMBER_PREFIX}${CONTEXT_PROPERTY})(?:${CONTEXT_CALL_SPACE}|\))*(?:\?\.${CONTEXT_CALL_SPACE}*)?(?:<|${COMMENT_OPENER}|\((?:${CONTEXT_CALL_SPACE}|\()*(?:["']|${COMMENT_OPENER}))`, "i");
+function _mayContainRequireContextCall(code) {
+	return REQUIRE_CONTEXT_CALL_PRESCAN.test(code);
+}
 async function transformRequireContext(code, id) {
+	if (!REQUIRE_CONTEXT_CALL_PRESCAN.test(code)) return null;
 	const lang = scriptParserLanguage(id);
 	let ast;
 	try {
@@ -261,4 +288,4 @@ function stripTrailingSlash(value) {
 	return value.endsWith("/") ? value.slice(0, -1) : value;
 }
 //#endregion
-export { createRequireContextPlugin };
+export { _mayContainRequireContextCall, createRequireContextPlugin };

package/dist/plugins/scan-build-css.d.ts

@@ -0,0 +1,12 @@
+import { Plugin } from "vite";
+//#region src/plugins/scan-build-css.d.ts
+/**
+ * @vitejs/plugin-rsc discovers client and server references with two
+ * write-less scan builds whose output is discarded, and its `rsc:scan-strip`
+ * plugin reduces every module to its import specifiers. A stylesheet cannot
+ * contribute a JavaScript import, yet without this plugin every stylesheet in
+ * the app still ran through PostCSS/Tailwind/Sass in both scans. Empty their
+ * source during those scans only; real builds and dev are unchanged.
+ */
+export declare function createScanBuildCssPlugin(): Plugin;
+//#endregion

package/dist/plugins/scan-build-css.js

@@ -0,0 +1,39 @@
+//#region src/plugins/scan-build-css.ts
+const CSS_LANGS_RE = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const SPECIAL_QUERY_RE = /[?&](?:worker|sharedworker|raw|url)\b/;
+const VIRTUAL_MODULE_RE = /^\0/;
+/**
+* @vitejs/plugin-rsc discovers client and server references with two
+* write-less scan builds whose output is discarded, and its `rsc:scan-strip`
+* plugin reduces every module to its import specifiers. A stylesheet cannot
+* contribute a JavaScript import, yet without this plugin every stylesheet in
+* the app still ran through PostCSS/Tailwind/Sass in both scans. Empty their
+* source during those scans only; real builds and dev are unchanged.
+*/
+function createScanBuildCssPlugin() {
+	let rscApi;
+	return {
+		name: "vinext:scan-build-css",
+		enforce: "pre",
+		apply: "build",
+		configResolved(config) {
+			rscApi = config.plugins.find((plugin) => plugin.name === "rsc:minimal")?.api;
+		},
+		transform: {
+			order: "pre",
+			filter: { id: {
+				include: CSS_LANGS_RE,
+				exclude: [SPECIAL_QUERY_RE, VIRTUAL_MODULE_RE]
+			} },
+			handler() {
+				if (!rscApi?.manager.isScanBuild || this.environment.config.build.write !== false) return null;
+				return {
+					code: "",
+					map: null
+				};
+			}
+		}
+	};
+}
+//#endregion
+export { createScanBuildCssPlugin };

package/dist/plugins/strip-server-exports.d.ts

@@ -1,6 +1,8 @@
 import MagicString from "magic-string";
 //#region src/plugins/strip-server-exports.d.ts
 export declare function hasServerExportCandidate(code: string): boolean;
+/** Transform prefilter; must admit every module `hasExportAllCandidate` accepts */
+export declare const EXPORT_ALL_CANDIDATE_FILTER: RegExp;
 export declare function hasExportAllCandidate(code: string): boolean;
 export declare function validatePageExports(code: string): void;
 type StripServerExportsResult = {

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

@@ -18,6 +18,8 @@ function hasServerExportCandidate(code) {
 	for (const name of SERVER_EXPORTS) if (code.includes(name)) return true;
 	return false;
 }
+/** Transform prefilter; must admit every module `hasExportAllCandidate` accepts */
+const EXPORT_ALL_CANDIDATE_FILTER = /\bexport\s*[*/]/;
 function hasExportAllCandidate(code) {
 	let searchFrom = 0;
 	while (searchFrom < code.length) {
@@ -510,4 +512,4 @@ function stripServerExports(code) {
 	return magicStringTransformResult(string);
 }
 //#endregion
-export { hasExportAllCandidate, hasServerExportCandidate, stripServerExports, validatePageExports };
+export { EXPORT_ALL_CANDIDATE_FILTER, hasExportAllCandidate, hasServerExportCandidate, stripServerExports, validatePageExports };

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

@@ -4,6 +4,24 @@ export type MagicStringTransformResult = {
   code: string;
   map: ReturnType<MagicString["generateMap"]>;
 };
+type SourcemapEnvironment = {
+  mode?: string;
+  config?: {
+    build?: {
+      sourcemap?: boolean | "inline" | "hidden";
+    };
+  };
+};
 /** Build the standard code + sourcemap result returned by source transforms. */
 export declare function magicStringTransformResult(output: MagicString, options?: Parameters<MagicString["generateMap"]>[0]): MagicStringTransformResult;
+/**
+ * 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): {
+  code: string;
+  map: MagicStringTransformResult["map"] | null;
+} | null;
 //#endregion

package/dist/plugins/transform-result.js

@@ -1,10 +1,31 @@
 //#region src/plugins/transform-result.ts
 /** Build the standard code + sourcemap result returned by source transforms. */
 function magicStringTransformResult(output, options = { hires: "boundary" }) {
+	let source = output;
+	let map;
 	return {
 		code: output.toString(),
-		map: output.generateMap(options)
+		get map() {
+			if (source) {
+				map = source.generateMap(options);
+				source = void 0;
+			}
+			return map;
+		}
+	};
+}
+/**
+* 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.
+*/
+function omitUnusedBuildSourcemap(environment, result) {
+	if (!result || environment?.mode !== "build" || environment.config?.build?.sourcemap !== false) return result;
+	return {
+		code: result.code,
+		map: null
 	};
 }
 //#endregion
-export { magicStringTransformResult };
+export { magicStringTransformResult, omitUnusedBuildSourcemap };

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

@@ -6,6 +6,11 @@ export type ConsumerEnvironmentReplacements = {
   typeofWindow?: WindowType;
   processBrowser?: boolean;
   pruneUnreachableImports?: boolean;
+  /**
+   * Return null without walking the AST when folding cannot change the module's
+   * scanned imports. Only valid for import-scan builds.
+   */
+  onlyIfScannedImportsChange?: boolean;
 };
 type EnvironmentLike = {
   config: {
@@ -13,6 +18,11 @@ type EnvironmentLike = {
   };
 };
 export declare function getTypeofWindowReplacement(environment: EnvironmentLike): WindowType;
+/**
+ * Cheap pre-parse gate for import-scan builds. Over-inclusive by design; the
+ * 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;
 //#endregion