@qzsy/vinext 0.1.7

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

@@ -0,0 +1,285 @@
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+//#region src/plugins/og-asset-ownership.ts
+const realpathNative = promisify(fs.realpath.native);
+function isPathInside(root, target) {
+	const relative = path.relative(root, target);
+	return relative === "" || !path.isAbsolute(relative) && !relative.startsWith(`..${path.sep}`) && relative !== "..";
+}
+async function findPackageRoot(moduleDir, expectedPackageName) {
+	let currentDir = moduleDir;
+	while (true) {
+		try {
+			const packageJsonPath = path.join(currentDir, "package.json");
+			if ((await fs.promises.stat(packageJsonPath)).isFile()) {
+				const manifest = JSON.parse(await fs.promises.readFile(packageJsonPath, "utf8"));
+				return expectedPackageName === void 0 || manifest.name === expectedPackageName ? currentDir : null;
+			}
+		} catch {}
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function getPackageNameFromSpecifier(specifier) {
+	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("\0") || specifier.startsWith("#")) return null;
+	const segments = specifier.split("/");
+	if (specifier.startsWith("@")) return segments.length >= 2 ? `${segments[0]}/${segments[1]}` : null;
+	return segments[0] || null;
+}
+function getAliasedPackageName(value) {
+	if (typeof value !== "string") return null;
+	return value.match(/^(?:npm:|workspace:)(@[^/]+\/[^@]+|[^@*~^]+)(?:@|$)/)?.[1] ?? null;
+}
+function aliasMatches(find, source) {
+	if (typeof find === "string") return source === find || source.startsWith(`${find}/`);
+	find.lastIndex = 0;
+	return find.test(source);
+}
+function applyAlias(find, replacement, source) {
+	if (typeof find === "string") return replacement + source.slice(find.length);
+	find.lastIndex = 0;
+	return source.replace(find, replacement);
+}
+function getNodeModulesPackageRoot(logicalProjectRoot, logicalModulePath) {
+	const isProjectPath = isPathInside(logicalProjectRoot, logicalModulePath);
+	const parsedPath = path.parse(logicalModulePath);
+	const baseRoot = isProjectPath ? logicalProjectRoot : parsedPath.root;
+	const segments = (isProjectPath ? path.relative(logicalProjectRoot, logicalModulePath) : logicalModulePath.slice(parsedPath.root.length)).split(path.sep);
+	const nodeModulesIndex = segments.lastIndexOf("node_modules");
+	if (nodeModulesIndex === -1) return null;
+	const packageSegment = segments[nodeModulesIndex + 1];
+	if (!packageSegment) return null;
+	const packageSegmentCount = packageSegment.startsWith("@") ? 2 : 1;
+	if (segments.length <= nodeModulesIndex + packageSegmentCount) return null;
+	if (packageSegmentCount === 2 && !segments[nodeModulesIndex + 2]) return null;
+	return path.join(baseRoot, ...segments.slice(0, nodeModulesIndex + 1 + packageSegmentCount));
+}
+async function readPackageName(packageRoot) {
+	try {
+		const manifest = JSON.parse(await fs.promises.readFile(path.join(packageRoot, "package.json"), "utf8"));
+		return typeof manifest.name === "string" ? manifest.name : null;
+	} catch {
+		return null;
+	}
+}
+async function packageOwnsAliasFile(packageRoot, packageName, aliasFile) {
+	try {
+		const manifest = JSON.parse(await fs.promises.readFile(path.join(packageRoot, "package.json"), "utf8"));
+		if (packageName !== null && manifest.name === packageName) return true;
+		return [
+			"main",
+			"module",
+			"source",
+			"browser"
+		].some((field) => typeof manifest[field] === "string" && path.resolve(packageRoot, manifest[field]) === aliasFile);
+	} catch {
+		return false;
+	}
+}
+async function packageOwnsAliasDirectory(packageRoot, packageName, aliasDirectory) {
+	if (aliasDirectory === packageRoot) return true;
+	try {
+		const manifest = JSON.parse(await fs.promises.readFile(path.join(packageRoot, "package.json"), "utf8"));
+		if (packageName !== null && manifest.name === packageName) return true;
+		return [
+			"main",
+			"module",
+			"source",
+			"browser"
+		].some((field) => typeof manifest[field] === "string" && isPathInside(aliasDirectory, path.resolve(packageRoot, manifest[field])));
+	} catch {
+		return false;
+	}
+}
+var OgAssetOwnership = class {
+	projectRoot = process.cwd();
+	linkedPackageRoots = /* @__PURE__ */ new Set();
+	dependencyPackageNames = /* @__PURE__ */ new Map();
+	stringAliasesByFirstCharacter = /* @__PURE__ */ new Map();
+	regularExpressionAliases = [];
+	configuredAliases = [];
+	configure(projectRoot, aliases) {
+		this.projectRoot = path.resolve(projectRoot);
+		this.dependencyPackageNames.clear();
+		try {
+			const manifest = JSON.parse(fs.readFileSync(path.join(this.projectRoot, "package.json"), "utf8"));
+			for (const field of [
+				"dependencies",
+				"devDependencies",
+				"optionalDependencies",
+				"peerDependencies"
+			]) {
+				const dependencies = manifest[field];
+				if (dependencies === null || typeof dependencies !== "object") continue;
+				for (const [packageName, value] of Object.entries(dependencies)) this.dependencyPackageNames.set(packageName, getAliasedPackageName(value) ?? packageName);
+			}
+		} catch {}
+		this.stringAliasesByFirstCharacter.clear();
+		this.regularExpressionAliases = [];
+		this.configuredAliases = [];
+		for (const [index, alias] of aliases.entries()) {
+			const indexedAlias = {
+				...alias,
+				index
+			};
+			this.configuredAliases.push(indexedAlias);
+			if (typeof alias.find === "string") {
+				const firstCharacter = alias.find[0];
+				if (firstCharacter === void 0) continue;
+				const matchingAliases = this.stringAliasesByFirstCharacter.get(firstCharacter) ?? [];
+				matchingAliases.push(indexedAlias);
+				this.stringAliasesByFirstCharacter.set(firstCharacter, matchingAliases);
+			} else this.regularExpressionAliases.push(indexedAlias);
+		}
+	}
+	reset() {
+		this.linkedPackageRoots.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 = getPackageNameFromSpecifier(source);
+		const expectedPackageName = this.getExpectedPackageName(source);
+		if (configuredAlias === void 0 && expectedPackageName === void 0) return;
+		let realResolvedPath;
+		try {
+			realResolvedPath = await realpathNative(path.resolve(resolvedId.split("?")[0]));
+		} catch {
+			return;
+		}
+		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);
+	}
+	async resolveModuleBoundary(moduleId) {
+		const modulePath = path.resolve(moduleId.split("?")[0]);
+		let realProjectRoot;
+		let realModulePath;
+		try {
+			[realProjectRoot, realModulePath] = await Promise.all([realpathNative(this.projectRoot), realpathNative(modulePath)]);
+		} catch {
+			try {
+				realProjectRoot = await realpathNative(this.projectRoot);
+				const realModuleDir = await realpathNative(path.dirname(modulePath));
+				realModulePath = path.join(realModuleDir, path.basename(modulePath));
+			} catch {
+				return null;
+			}
+		}
+		const moduleDir = path.dirname(realModulePath);
+		const logicalPackageRoot = getNodeModulesPackageRoot(this.projectRoot, modulePath);
+		if (logicalPackageRoot !== null) {
+			let realPackageRoot;
+			try {
+				realPackageRoot = await realpathNative(logicalPackageRoot);
+			} catch {
+				return null;
+			}
+			if (isPathInside(realPackageRoot, realModulePath)) return {
+				assetRoot: realPackageRoot,
+				moduleDir
+			};
+			const declaredPackageName = await readPackageName(logicalPackageRoot);
+			if (declaredPackageName === null) return null;
+			const logicalModuleRelativePath = path.relative(logicalPackageRoot, modulePath);
+			if (path.isAbsolute(logicalModuleRelativePath) || logicalModuleRelativePath === ".." || logicalModuleRelativePath.startsWith(`..${path.sep}`)) return null;
+			const canonicalPackageRoot = await findPackageRoot(moduleDir, declaredPackageName);
+			if (canonicalPackageRoot === null) return null;
+			if (path.relative(canonicalPackageRoot, realModulePath) !== logicalModuleRelativePath) return null;
+			return {
+				assetRoot: canonicalPackageRoot,
+				moduleDir
+			};
+		}
+		if (isPathInside(realProjectRoot, realModulePath)) return {
+			assetRoot: realProjectRoot,
+			moduleDir
+		};
+		const linkedPackageRoot = [...this.linkedPackageRoots].filter((root) => isPathInside(root, realModulePath)).sort((a, b) => b.length - a.length)[0];
+		if (linkedPackageRoot !== void 0) return {
+			assetRoot: linkedPackageRoot,
+			moduleDir
+		};
+		const configuredAliasRoot = await this.resolveConfiguredAliasRoot(realModulePath);
+		return configuredAliasRoot === null ? null : {
+			assetRoot: configuredAliasRoot,
+			moduleDir
+		};
+	}
+	async resolveContainedAsset(assetRoot, assetPath) {
+		try {
+			const realPath = await realpathNative(assetPath);
+			return isPathInside(assetRoot, realPath) ? realPath : null;
+		} catch {
+			return null;
+		}
+	}
+	findAlias(source) {
+		return [...this.stringAliasesByFirstCharacter.get(source[0] ?? "") ?? [], ...this.regularExpressionAliases].filter((alias) => aliasMatches(alias.find, source)).sort((a, b) => a.index - b.index)[0];
+	}
+	getExpectedPackageName(source) {
+		const packageName = getPackageNameFromSpecifier(source);
+		return packageName === null ? void 0 : this.dependencyPackageNames.get(packageName);
+	}
+	async resolveAliasPackageRoot(alias, source, sourcePackageName, realResolvedPath) {
+		const aliasTarget = applyAlias(alias.find, alias.replacement, source);
+		if (!path.isAbsolute(aliasTarget)) return null;
+		try {
+			const realAliasTarget = await realpathNative(aliasTarget);
+			const aliasTargetStat = await fs.promises.stat(realAliasTarget);
+			const hasCapture = alias.find instanceof RegExp && alias.replacement.includes("$");
+			let configuredDirectory = null;
+			if (!hasCapture) {
+				const realReplacement = await realpathNative(alias.replacement);
+				if ((await fs.promises.stat(realReplacement)).isDirectory()) configuredDirectory = realReplacement;
+			}
+			if (configuredDirectory !== null || aliasTargetStat.isDirectory()) {
+				const aliasBoundary = configuredDirectory ?? realAliasTarget;
+				const packageRoot = await findPackageRoot(path.dirname(realResolvedPath));
+				if (packageRoot === null || !isPathInside(aliasBoundary, packageRoot) || !isPathInside(packageRoot, realResolvedPath)) return null;
+				return packageRoot;
+			}
+			const packageRoot = await findPackageRoot(path.dirname(realResolvedPath));
+			if (packageRoot === null || !await packageOwnsAliasFile(packageRoot, sourcePackageName, realAliasTarget) || !isPathInside(packageRoot, realResolvedPath)) return null;
+			return packageRoot;
+		} catch {
+			return null;
+		}
+	}
+	async resolveConfiguredAliasRoot(realModulePath) {
+		const packageRoot = await findPackageRoot(path.dirname(realModulePath));
+		if (packageRoot === null || !isPathInside(packageRoot, realModulePath)) return null;
+		for (const alias of this.configuredAliases) {
+			if (!path.isAbsolute(alias.replacement)) continue;
+			const packageName = typeof alias.find === "string" ? getPackageNameFromSpecifier(alias.find) : null;
+			if (alias.replacement.indexOf("$") !== -1) {
+				const packageManifestName = await readPackageName(packageRoot);
+				if (packageManifestName === null || !aliasMatches(alias.find, packageManifestName)) continue;
+				const aliasTarget = applyAlias(alias.find, alias.replacement, packageManifestName);
+				if (!path.isAbsolute(aliasTarget)) continue;
+				try {
+					const realAliasTarget = await realpathNative(aliasTarget);
+					const aliasTargetStat = await fs.promises.stat(realAliasTarget);
+					if (aliasTargetStat.isDirectory() && isPathInside(realAliasTarget, realModulePath) || aliasTargetStat.isFile() && realAliasTarget === realModulePath) return packageRoot;
+				} catch {}
+				continue;
+			}
+			try {
+				const realReplacement = await realpathNative(alias.replacement);
+				if ((await fs.promises.stat(realReplacement)).isDirectory()) {
+					if (isPathInside(packageRoot, realReplacement) && isPathInside(realReplacement, realModulePath) && await packageOwnsAliasDirectory(packageRoot, packageName, realReplacement)) return packageRoot;
+					continue;
+				}
+				if (realReplacement === realModulePath && await packageOwnsAliasFile(packageRoot, packageName, realReplacement)) return packageRoot;
+			} catch {}
+		}
+		return null;
+	}
+};
+//#endregion
+export { OgAssetOwnership };

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

@@ -0,0 +1,50 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/og-assets.d.ts
+/**
+ * Create the `vinext:og-inline-fetch-assets` Vite plugin.
+ *
+ * Inlines binary assets that are runtime-fetched via
+ * `fetch(new URL("./asset", import.meta.url))` or read via
+ * `readFileSync(fileURLToPath(new URL("./asset", import.meta.url)))`.
+ * Both patterns are rewritten to inline base64 literals so the code works
+ * correctly inside Cloudflare Workers where `import.meta.url` is not a
+ * valid file URL.
+ */
+declare function createOgInlineFetchAssetsPlugin(): Plugin;
+/**
+ * Copy a single root copy of each requested WASM asset from `sourceDir` into
+ * `outDir`, skipping any asset whose source is missing or whose destination
+ * already exists.
+ *
+ * Extracted as a pure, dependency-injected helper so it can be unit-tested
+ * against a temp source directory without depending on the real @vercel/og
+ * install (whose `yoga.wasm` is only materialized as a side effect of the
+ * `vinext:og-font-patch` transform during a build).
+ */
+declare function copyMissingOgWasm(opts: {
+  outDir: string;
+  sourceDir: string;
+  assets: readonly string[];
+}): void;
+/**
+ * Create the `vinext:og-assets` Vite plugin.
+ *
+ * Ensures each @vercel/og WASM module (resvg.wasm, yoga.wasm) ships exactly once
+ * in the RSC output, with every loader strategy resolving to that single file:
+ *
+ *   1. `generateBundle` (post): if the bundler already emitted the WASM as a
+ *      hashed asset (from the `import("./x.wasm?module")` path), rewrite the
+ *      Node.js fallback reference `new URL("./x.wasm", import.meta.url)` in each
+ *      chunk to point at that emitted asset (a sibling under `_next/static/`).
+ *      This deduplicates without copying a second root file.
+ *   2. `writeBundle` (post): for any referenced WASM that was NOT emitted as an
+ *      asset (e.g. a build that inlined or skipped it), copy a single root copy
+ *      from @vercel/og's dist so the Node.js disk-read fallback still works.
+ *
+ * The decision keys off "did the bundler emit this asset?", never the deploy
+ * target — so it helps Node/self-hosted builds as well as Cloudflare Workers.
+ */
+declare function createOgAssetsPlugin(): Plugin;
+//#endregion
+export { copyMissingOgWasm, createOgAssetsPlugin, createOgInlineFetchAssetsPlugin };

package/dist/plugins/og-assets.js

@@ -0,0 +1,229 @@
+import { OgAssetOwnership } from "./og-asset-ownership.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import MagicString from "magic-string";
+//#region src/plugins/og-assets.ts
+/**
+* Create the `vinext:og-inline-fetch-assets` Vite plugin.
+*
+* Inlines binary assets that are runtime-fetched via
+* `fetch(new URL("./asset", import.meta.url))` or read via
+* `readFileSync(fileURLToPath(new URL("./asset", import.meta.url)))`.
+* Both patterns are rewritten to inline base64 literals so the code works
+* correctly inside Cloudflare Workers where `import.meta.url` is not a
+* valid file URL.
+*/
+function createOgInlineFetchAssetsPlugin() {
+	const cache = /* @__PURE__ */ new Map();
+	const ownership = new OgAssetOwnership();
+	let isBuild = false;
+	return {
+		name: "vinext:og-inline-fetch-assets",
+		enforce: "pre",
+		configResolved(config) {
+			isBuild = config.command === "build";
+			ownership.configure(config.root, config.resolve.alias);
+		},
+		buildStart() {
+			if (isBuild) cache.clear();
+			ownership.reset();
+		},
+		async resolveId(source, importer, options) {
+			if (!ownership.shouldTrackImport(source)) return null;
+			const resolved = await this.resolve(source, importer, {
+				...options,
+				skipSelf: true
+			});
+			if (resolved === null || resolved.external) return null;
+			await ownership.recordResolvedImport(source, resolved.id);
+			return null;
+		},
+		transform: {
+			filter: { code: "import.meta.url" },
+			async handler(code, id) {
+				const useCache = isBuild;
+				const boundary = await ownership.resolveModuleBoundary(id);
+				if (boundary === null) return null;
+				const { assetRoot, moduleDir } = boundary;
+				const s = new MagicString(code);
+				let didReplace = false;
+				const readAsBase64 = async (absPath) => {
+					const realPath = await ownership.resolveContainedAsset(assetRoot, absPath);
+					if (realPath === null) return null;
+					const cached = useCache ? cache.get(realPath) : void 0;
+					if (cached !== void 0) return cached;
+					try {
+						const b64 = (await fs.promises.readFile(realPath)).toString("base64");
+						if (useCache) cache.set(realPath, b64);
+						return b64;
+					} catch {
+						return null;
+					}
+				};
+				if (code.includes("fetch(")) for (const match of code.matchAll(/fetch\(\s*new URL\(\s*(["'])(\.[^"']+)\1\s*,\s*import\.meta\.url\s*\)\s*\)(?:\.then\(\s*(?:function\s*\([^)]*\)|\([^)]*\)\s*=>)\s*\{?\s*return\s+[^.]+\.arrayBuffer\(\)\s*;?\s*\}?\s*,?\s*\)|\.then\(\s*\([^)]*\)\s*=>\s*[^.]+\.arrayBuffer\(\)\s*,?\s*\))/g)) {
+					const fullMatch = match[0];
+					const relPath = match[2];
+					const fileBase64 = await readAsBase64(path.resolve(moduleDir, relPath));
+					if (fileBase64 === null) continue;
+					const inlined = [
+						`(function(){`,
+						`var b=${JSON.stringify(fileBase64)};`,
+						`var r=atob(b);`,
+						`var a=new Uint8Array(r.length);`,
+						`for(var i=0;i<r.length;i++)a[i]=r.charCodeAt(i);`,
+						`return Promise.resolve(a.buffer);`,
+						`})()`
+					].join("");
+					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 (fileBase64 === null) continue;
+					const inlined = `Buffer.from(${JSON.stringify(fileBase64)},"base64")`;
+					s.overwrite(match.index, match.index + fullMatch.length, inlined);
+					didReplace = true;
+				}
+				if (!didReplace) return null;
+				return {
+					code: s.toString(),
+					map: s.generateMap({ hires: "boundary" })
+				};
+			}
+		}
+	};
+}
+const OG_WASM_ASSETS = ["resvg.wasm", "yoga.wasm"];
+/**
+* Find an emitted WASM asset in the output bundle whose name corresponds to the
+* given base file (e.g. base `resvg.wasm` matches the emitted `resvg-HASH.wasm`).
+*
+* The bundler emits the `import("./resvg.wasm?module")` dynamic import as a
+* hashed asset. When it exists, both loader strategies can point at the same
+* physical file — no second copy needed.
+*
+* @returns the emitted asset's `fileName` (relative to outDir), or null.
+*/
+function findEmittedWasmAsset(bundle, baseName) {
+	const stem = baseName.replace(/\.wasm$/, "");
+	const re = new RegExp(`^${stem}(?:-[\\w-]+)?\\.wasm$`);
+	for (const output of Object.values(bundle)) {
+		if (output.type !== "asset") continue;
+		if (re.test(path.posix.basename(output.fileName))) return output.fileName;
+	}
+	return null;
+}
+/**
+* Build the regex that matches the Node.js fallback reference
+* `new URL("./<base>", import.meta.url)` for a given WASM base name.
+*
+* Handles all three quote styles ("'`) because the minifier may rewrite the
+* string literal (commonly to a template literal) by the time the chunk code
+* is available in generateBundle.
+*/
+function fallbackUrlRegex(baseName) {
+	const escaped = baseName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(String.raw`new URL\(\s*(["'\`])\.\/${escaped}\1\s*,\s*import\.meta\.url\s*\)`, "g");
+}
+/**
+* Copy a single root copy of each requested WASM asset from `sourceDir` into
+* `outDir`, skipping any asset whose source is missing or whose destination
+* already exists.
+*
+* Extracted as a pure, dependency-injected helper so it can be unit-tested
+* against a temp source directory without depending on the real @vercel/og
+* install (whose `yoga.wasm` is only materialized as a side effect of the
+* `vinext:og-font-patch` transform during a build).
+*/
+function copyMissingOgWasm(opts) {
+	for (const asset of opts.assets) {
+		const src = path.join(opts.sourceDir, asset);
+		const dest = path.join(opts.outDir, asset);
+		if (fs.existsSync(src) && !fs.existsSync(dest)) fs.copyFileSync(src, dest);
+	}
+}
+/**
+* Create the `vinext:og-assets` Vite plugin.
+*
+* Ensures each @vercel/og WASM module (resvg.wasm, yoga.wasm) ships exactly once
+* in the RSC output, with every loader strategy resolving to that single file:
+*
+*   1. `generateBundle` (post): if the bundler already emitted the WASM as a
+*      hashed asset (from the `import("./x.wasm?module")` path), rewrite the
+*      Node.js fallback reference `new URL("./x.wasm", import.meta.url)` in each
+*      chunk to point at that emitted asset (a sibling under `_next/static/`).
+*      This deduplicates without copying a second root file.
+*   2. `writeBundle` (post): for any referenced WASM that was NOT emitted as an
+*      asset (e.g. a build that inlined or skipped it), copy a single root copy
+*      from @vercel/og's dist so the Node.js disk-read fallback still works.
+*
+* The decision keys off "did the bundler emit this asset?", never the deploy
+* target — so it helps Node/self-hosted builds as well as Cloudflare Workers.
+*/
+function createOgAssetsPlugin() {
+	let dedupedBases = /* @__PURE__ */ new Set();
+	return {
+		name: "vinext:og-assets",
+		apply: "build",
+		enforce: "post",
+		generateBundle: {
+			order: "post",
+			handler(_options, bundle) {
+				if (this.environment?.name !== "rsc") return;
+				dedupedBases = /* @__PURE__ */ new Set();
+				const chunks = Object.values(bundle).filter((o) => o.type === "chunk");
+				for (const base of OG_WASM_ASSETS) {
+					if (!chunks.some((c) => c.code.includes(base))) continue;
+					const emitted = findEmittedWasmAsset(bundle, base);
+					if (!emitted) continue;
+					for (const chunk of chunks) {
+						const re = fallbackUrlRegex(base);
+						const chunkDir = path.posix.dirname(chunk.fileName);
+						const rel = path.posix.relative(chunkDir, emitted);
+						const ref = rel.startsWith(".") ? rel : `./${rel}`;
+						const s = new MagicString(chunk.code);
+						let edited = false;
+						for (const m of chunk.code.matchAll(re)) {
+							const quote = m[1];
+							const start = m.index;
+							s.overwrite(start, start + m[0].length, `new URL(${quote}${ref}${quote}, import.meta.url)`);
+							edited = true;
+						}
+						if (!edited) continue;
+						chunk.code = s.toString();
+						if (chunk.map) chunk.map = s.generateMap({
+							hires: "boundary",
+							source: chunk.fileName
+						});
+					}
+					dedupedBases.add(base);
+				}
+			}
+		},
+		writeBundle: {
+			sequential: true,
+			order: "post",
+			async handler(options, bundle) {
+				if (this.environment?.name !== "rsc") return;
+				const outDir = options.dir;
+				if (!outDir) return;
+				const chunkCode = Object.values(bundle).map((output) => output.type === "chunk" ? output.code : "").join("\n");
+				const referencedAssets = OG_WASM_ASSETS.filter((asset) => chunkCode.includes(asset) && !dedupedBases.has(asset));
+				if (referencedAssets.length === 0) return;
+				try {
+					const ogPkgPath = createRequire(import.meta.url).resolve("@vercel/og/package.json");
+					copyMissingOgWasm({
+						outDir,
+						sourceDir: path.join(path.dirname(ogPkgPath), "dist"),
+						assets: referencedAssets
+					});
+				} catch {}
+			}
+		}
+	};
+}
+//#endregion
+export { copyMissingOgWasm, createOgAssetsPlugin, createOgInlineFetchAssetsPlugin };

package/dist/plugins/optimize-imports.d.ts

@@ -0,0 +1,42 @@
+import { ResolvedNextConfig } from "../config/next-config.js";
+import { Plugin } from "vite";
+
+//#region src/plugins/optimize-imports.d.ts
+type BarrelExportEntry = {
+  source: string;
+  isNamespace: boolean;
+  originalName?: string;
+};
+type BarrelExportMap = Map<string, BarrelExportEntry>;
+/**
+ * Packages whose barrel imports are automatically optimized.
+ * Matches Next.js's built-in optimizePackageImports defaults plus radix-ui.
+ * @see https://github.com/vercel/next.js/blob/9c31bbdaa/packages/next/src/server/config.ts#L1301
+ */
+declare const DEFAULT_OPTIMIZE_PACKAGES: string[];
+declare function createOptimizedImportSourceMatcher(packages: Iterable<string>): (code: string) => boolean;
+/**
+ * Build a map of exported names → source sub-module for a barrel package.
+ *
+ * Parses the barrel entry file AST and extracts the export map.
+ * Handles: `export * as X from`, `export { A } from`, `import * as X; export { X }`,
+ * and `export * from "./sub"` (recursively resolves wildcard re-exports).
+ *
+ * Returns null if `entryPath` is empty, the file cannot be read, or the file
+ * has a parse error. Returns an empty map if the file is valid but exports
+ * nothing.
+ *
+ * @param entryPath - Pre-resolved absolute path to the barrel entry file (the
+ *   caller owns entry resolution + its caching), or null when it could not be
+ *   resolved.
+ */
+declare function buildBarrelExportMap(entryPath: string | null, readFile: (filepath: string) => Promise<string | null>, cache?: Map<string, BarrelExportMap>): Promise<BarrelExportMap | null>;
+/**
+ * Creates the vinext:optimize-imports Vite plugin.
+ *
+ * @param nextConfig - Resolved Next.js config (may be undefined before config hook runs).
+ * @param getRoot - Returns the current project root (set by the vinext:config hook).
+ */
+declare function createOptimizeImportsPlugin(getNextConfig: () => ResolvedNextConfig | undefined, getRoot: () => string): Plugin;
+//#endregion
+export { DEFAULT_OPTIMIZE_PACKAGES, buildBarrelExportMap, createOptimizeImportsPlugin, createOptimizedImportSourceMatcher };