vinext 1.0.0-beta.9 → 1.0.1

package/dist/plugins/og-assets.js

@@ -1,5 +1,6 @@
 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";
 import fs from "node:fs";
@@ -79,22 +80,68 @@ 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 OG_WASM_ASSETS = ["resvg.wasm", "yoga.wasm"];
+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",
+	"hb.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`).
@@ -105,15 +152,20 @@ const OG_WASM_ASSETS = ["resvg.wasm", "yoga.wasm"];
 *
 * @returns the emitted asset's `fileName` (relative to outDir), or null.
 */
-function findEmittedWasmAsset(bundle, baseName) {
+function findEmittedWasmAsset(bundle, baseName, expectedSource) {
 	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.basename(output.fileName))) return output.fileName;
+		if (!re.test(path.basename(output.fileName))) continue;
+		if (expectedSource && !isSameBytes(output.source, expectedSource)) continue;
+		return output.fileName;
 	}
 	return null;
 }
+function isSameBytes(source, expected) {
+	return source instanceof Uint8Array && Buffer.from(source).equals(expected);
+}
 /**
 * Build the regex that matches the Node.js fallback reference
 * `new URL("./<base>", import.meta.url)` for a given WASM base name.
@@ -162,7 +214,7 @@ function copyMissingOgWasm(opts) {
 * target — so it helps Node/self-hosted builds as well as Cloudflare Workers.
 */
 function createOgAssetsPlugin() {
-	let dedupedBases = /* @__PURE__ */ new Set();
+	const dedupedBasesByEnvironment = /* @__PURE__ */ new Map();
 	return {
 		name: "vinext:og-assets",
 		apply: "build",
@@ -170,17 +222,18 @@ function createOgAssetsPlugin() {
 		generateBundle: {
 			order: "post",
 			handler(_options, bundle) {
-				if (this.environment?.name !== "rsc") return;
-				dedupedBases = /* @__PURE__ */ new Set();
+				const envName = this.environment?.name;
+				if (envName !== "rsc" && envName !== "ssr") return;
+				const dedupedBases = /* @__PURE__ */ new Set();
+				dedupedBasesByEnvironment.set(envName, dedupedBases);
 				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;
+					const emitted = findEmittedWasmAsset(bundle, base, base === "hb.wasm" ? fs.readFileSync(resolveHarfbuzzWasmPath(createRequire(import.meta.url).resolve("@vercel/og"))) : void 0);
 					for (const chunk of chunks) {
 						const re = fallbackUrlRegex(base);
 						const chunkDir = path.dirname(chunk.fileName);
-						const rel = path.relative(chunkDir, emitted);
+						const rel = path.relative(chunkDir, emitted ?? base);
 						const ref = rel.startsWith(".") ? rel : `./${rel}`;
 						const s = new MagicString(chunk.code);
 						let edited = false;
@@ -197,7 +250,7 @@ function createOgAssetsPlugin() {
 							source: chunk.fileName
 						});
 					}
-					dedupedBases.add(base);
+					if (emitted) dedupedBases.add(base);
 				}
 			}
 		},
@@ -205,18 +258,26 @@ function createOgAssetsPlugin() {
 			sequential: true,
 			order: "post",
 			async handler(options, bundle) {
-				if (this.environment?.name !== "rsc") return;
+				const envName = this.environment?.name;
+				if (envName !== "rsc" && envName !== "ssr") 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));
+				const dedupedBases = dedupedBasesByEnvironment.get(envName);
+				dedupedBasesByEnvironment.delete(envName);
+				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
+						assets: referencedAssets.filter((asset) => asset !== "hb.wasm")
+					});
+					if (referencedAssets.includes("hb.wasm")) copyMissingOgWasm({
+						outDir,
+						sourceDir: path.dirname(resolveHarfbuzzWasmPath(ogPkgPath)),
+						assets: ["hb.wasm"]
 					});
 				} catch {}
 			}
@@ -224,4 +285,4 @@ function createOgAssetsPlugin() {
 	};
 }
 //#endregion
-export { copyMissingOgWasm, createOgAssetsPlugin, createOgInlineFetchAssetsPlugin };
+export { copyMissingOgWasm, createOgAssetsPlugin, createOgInlineFetchAssetsPlugin, matchReadFileSyncAssetUrls };

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

@@ -0,0 +1,24 @@
+import { Plugin } from "vite";
+//#region src/plugins/og-harfbuzz.d.ts
+/**
+ * Resolve the `hb.wasm` binary that matches the glue inlined in @vercel/og.
+ * @vercel/og and satori pin exact versions, so resolving through
+ * @vercel/og → satori → harfbuzzjs yields the build the bundle was made from.
+ */
+export declare function resolveHarfbuzzWasmPath(ogEntry: string): string;
+/**
+ * Read every function type in a WASM binary as an Emscripten signature (result
+ * letter, or `v` for none, then parameters). Any callback HarfBuzz calls
+ * through its function table must have one of these types, so adapters for
+ * all of them cover every callback the glue can register.
+ */
+export declare function readWasmFunctionSignatures(wasm: Uint8Array): string[];
+/**
+ * Build the module Emscripten's `convertJsFunctionToWasm` compiles for a
+ * signature: it imports a JavaScript function as `e.f` and re-exports it as
+ * `f`. Every section in it is shorter than 128 bytes, so each length and count
+ * is a single LEB128 byte.
+ */
+export declare function createHarfbuzzCallbackWasm(signature: string): Uint8Array<ArrayBuffer>;
+export declare function createOgHarfbuzzPlugin(): Plugin;
+//#endregion

package/dist/plugins/og-harfbuzz.js

@@ -0,0 +1,271 @@
+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, 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";
+import MagicString from "magic-string";
+//#region src/plugins/og-harfbuzz.ts
+/**
+* vinext:og-harfbuzz — load @vercel/og's bundled HarfBuzz under vinext.
+*
+* @vercel/og 1.x inlines harfbuzzjs's Emscripten glue into both entry bundles.
+* Unmodified, that glue cannot start:
+*
+*   - Node ESM: its Node branch calls esbuild's `__require("fs")` and reads
+*     `__dirname`, neither of which exists in an ES module.
+*   - workerd: it reads `self.location.href`, takes the Node branch under
+*     `nodejs_compat`, and fetches `hb.wasm` from a relative URL. Workers also
+*     forbid compiling WASM from bytes, which Emscripten does for every
+*     JavaScript callback it adds to the WASM function table.
+*
+* The transform locates the HarfBuzz factory by syntax (the function that
+* names `"hb.wasm"` and reads Emscripten's `instantiateWasm` hook) and, inside
+* it only:
+*
+*   1. sets every `ENVIRONMENT_IS_*` flag to `false`, so no host branch runs;
+*   2. replaces `instantiateWasm` reads with a vinext loader that instantiates
+*      `hb.wasm` synchronously (a `?module` import on workerd, a disk read on
+*      Node), so a bad binary rejects initialization instead of hanging it;
+*   3. on workerd, serves callback modules from precompiled adapters instead
+*      of `new WebAssembly.Module(bytes)`.
+*
+* Whitespace, esbuild's renames and harfbuzzjs's wrapper code can change
+* freely. If a patch site is missing, the build fails with an explicit error
+* instead of shipping an OG route that breaks at runtime.
+*/
+const HARFBUZZ_WASM = "hb.wasm";
+const VALUE_TYPES = {
+	i: 127,
+	j: 126,
+	f: 125,
+	d: 124
+};
+const VALUE_TYPE_LETTERS = new Map(Object.entries(VALUE_TYPES).map(([k, v]) => [v, k]));
+/**
+* Resolve the `hb.wasm` binary that matches the glue inlined in @vercel/og.
+* @vercel/og and satori pin exact versions, so resolving through
+* @vercel/og → satori → harfbuzzjs yields the build the bundle was made from.
+*/
+function resolveHarfbuzzWasmPath(ogEntry) {
+	const satoriEntry = createRequire(ogEntry).resolve("satori");
+	return toSlash(createRequire(satoriEntry).resolve(`harfbuzzjs/${HARFBUZZ_WASM}`));
+}
+/**
+* Read every function type in a WASM binary as an Emscripten signature (result
+* letter, or `v` for none, then parameters). Any callback HarfBuzz calls
+* through its function table must have one of these types, so adapters for
+* all of them cover every callback the glue can register.
+*/
+function readWasmFunctionSignatures(wasm) {
+	let offset = 8;
+	const readU32 = () => {
+		let result = 0;
+		for (let shift = 0;; shift += 7) {
+			const byte = wasm[offset++];
+			result |= (byte & 127) << shift;
+			if (!(byte & 128)) return result >>> 0;
+		}
+	};
+	const readTypes = () => {
+		let letters = "";
+		for (let count = readU32(); count > 0; count--) {
+			const letter = VALUE_TYPE_LETTERS.get(wasm[offset++]);
+			letters = letter && letters !== null ? letters + letter : null;
+		}
+		return letters;
+	};
+	const signatures = /* @__PURE__ */ new Set();
+	while (offset < wasm.length) {
+		const sectionId = wasm[offset++];
+		const sectionEnd = readU32() + offset;
+		if (sectionId === 1) for (let count = readU32(); count > 0; count--) {
+			offset++;
+			const params = readTypes();
+			const results = readTypes();
+			if (params !== null && results !== null && results.length <= 1) signatures.add((results || "v") + params);
+		}
+		offset = sectionEnd;
+	}
+	return [...signatures];
+}
+/**
+* Build the module Emscripten's `convertJsFunctionToWasm` compiles for a
+* signature: it imports a JavaScript function as `e.f` and re-exports it as
+* `f`. Every section in it is shorter than 128 bytes, so each length and count
+* is a single LEB128 byte.
+*/
+function createHarfbuzzCallbackWasm(signature) {
+	const typeCode = (letter) => {
+		const code = VALUE_TYPES[letter];
+		if (code === void 0) throw new Error(`[vinext] Invalid WASM callback signature: ${signature}`);
+		return code;
+	};
+	const [result, ...params] = signature;
+	const results = result === "v" ? [] : [typeCode(result)];
+	const functionType = [
+		96,
+		params.length,
+		...params.map(typeCode),
+		results.length,
+		...results
+	];
+	if (functionType.length > 64) throw new Error(`[vinext] WASM callback signature too long: ${signature}`);
+	const section = (id, contents) => [
+		id,
+		contents.length,
+		...contents
+	];
+	return Uint8Array.from([
+		0,
+		97,
+		115,
+		109,
+		1,
+		0,
+		0,
+		0,
+		...section(1, [1, ...functionType]),
+		...section(2, [
+			1,
+			1,
+			101,
+			1,
+			102,
+			0,
+			0
+		]),
+		...section(7, [
+			1,
+			1,
+			102,
+			0,
+			0
+		])
+	]);
+}
+/** Write each callback adapter once and return its path by signature. */
+function writeHarfbuzzCallbackModules(harfbuzzWasm, outDir) {
+	fs.mkdirSync(outDir, { recursive: true });
+	const modules = /* @__PURE__ */ new Map();
+	for (const signature of readWasmFunctionSignatures(fs.readFileSync(harfbuzzWasm))) {
+		const filePath = path.join(outDir, `harfbuzz-callback-${signature}.wasm`);
+		if (!fs.existsSync(filePath)) {
+			const tempPath = `${filePath}.${process.pid}.tmp`;
+			fs.writeFileSync(tempPath, createHarfbuzzCallbackWasm(signature));
+			fs.renameSync(tempPath, filePath);
+		}
+		modules.set(signature, filePath);
+	}
+	return modules;
+}
+const contains = (outer, inner) => outer.start <= inner.start && inner.end <= outer.end;
+/**
+* Find the HarfBuzz factory — the innermost function that both names
+* `"hb.wasm"` and reads `instantiateWasm` — and the patch sites inside it.
+* Scoping edits to that function keeps yoga's own Emscripten module, which
+* also reads `instantiateWasm`, untouched.
+*/
+function findHarfbuzzPatchSites(program) {
+	const functionStack = [];
+	const wasmNameScopes = [];
+	const instantiateWasmMembers = [];
+	const environmentFlags = [];
+	const moduleCompilations = [];
+	const visit = (node) => {
+		const isFunction = isFunctionNode(node);
+		if (isFunction) functionStack.push(node);
+		if (staticStringValue(node) === HARFBUZZ_WASM) wasmNameScopes.push([...functionStack]);
+		else if (node.type === "MemberExpression" && getAstName(node.property) === "instantiateWasm") instantiateWasmMembers.push(node);
+		else if (node.type === "VariableDeclarator" && node.id.type === "Identifier" && node.id.name.startsWith("ENVIRONMENT_IS_") && node.init) environmentFlags.push({
+			declarator: node,
+			init: node.init
+		});
+		else if (node.type === "NewExpression" && node.callee.type === "MemberExpression" && getAstName(node.callee.object) === "WebAssembly" && getAstName(node.callee.property) === "Module" && functionStack.length > 0) moduleCompilations.push({
+			node,
+			enclosingFunction: functionStack[functionStack.length - 1]
+		});
+		forEachAstChild(node, visit);
+		if (isFunction) functionStack.pop();
+	};
+	visit(program);
+	const factories = /* @__PURE__ */ new Set();
+	for (const scopes of wasmNameScopes) {
+		const factory = [...scopes].reverse().find((scope) => instantiateWasmMembers.some((member) => contains(scope, member)));
+		if (factory) factories.add(factory);
+	}
+	if (factories.size !== 1) return `expected one function that names "${HARFBUZZ_WASM}" and reads instantiateWasm, found ${factories.size}`;
+	const [factory] = factories;
+	const flags = environmentFlags.filter(({ declarator }) => contains(factory, declarator));
+	if (!flags.some(({ declarator }) => getAstName(declarator.id) === "ENVIRONMENT_IS_NODE")) return "the factory does not declare ENVIRONMENT_IS_NODE";
+	return {
+		instantiateWasmReads: instantiateWasmMembers.filter((member) => contains(factory, member)),
+		environmentFlags: flags.map(({ init }) => init),
+		moduleCompilations: moduleCompilations.filter(({ node }) => contains(factory, node))
+	};
+}
+const INSTANTIATE_WASM = `function __vi_hb_instantiateWasm(imports, receiveInstance) {
+  var instance = new WebAssembly.Instance(__vi_hb_module(), imports);
+  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",
+		configResolved(config) {
+			callbackModuleDir = path.join(toSlash(config.root), ".vinext", "og-assets");
+			isBuild = config.command === "build";
+		},
+		transform: {
+			filter: {
+				id: /[\\/]@vercel[\\/]og[\\/]dist[\\/]index\.(?:edge|node)\.js(?:\?.*)?$/,
+				code: /["'`]hb\.wasm["'`]/
+			},
+			handler(code, id) {
+				const patch = () => patchHarfbuzzBundle(code, id, isBuild, callbackModuleDir, (message) => this.error(message));
+				return omitUnusedBuildSourcemap(this.environment, isBuild ? cached(id, code, callbackModuleDir, patch) : patch());
+			}
+		}
+	};
+}
+//#endregion
+export { createHarfbuzzCallbackWasm, createOgHarfbuzzPlugin, readWasmFunctionSignatures, resolveHarfbuzzWasmPath };

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

@@ -9,11 +9,12 @@ type BarrelExportEntry = {
 type BarrelExportMap = Map<string, BarrelExportEntry>;
 /**
  * Packages whose barrel imports are automatically optimized.
- * Matches Next.js's built-in optimizePackageImports defaults plus radix-ui.
+ * Matches Next.js's built-in optimizePackageImports defaults plus vinext-specific
+ * compatibility entries for radix-ui and @chakra-ui/react.
  * @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;
+export declare const DEFAULT_OPTIMIZE_PACKAGES: string[];
+export declare function createOptimizedImportSourceMatcher(packages: Iterable<string>): (code: string) => boolean;
 /**
  * Build a map of exported names → source sub-module for a barrel package.
  *
@@ -29,13 +30,12 @@ declare function createOptimizedImportSourceMatcher(packages: Iterable<string>):
  *   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>;
+export 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 };
+export declare function createOptimizeImportsPlugin(getNextConfig: () => ResolvedNextConfig | undefined, getRoot: () => string): Plugin;
+//#endregion