vinext 1.0.0-beta.8 → 1.0.0

package/dist/plugins/og-harfbuzz.js

@@ -0,0 +1,260 @@
+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 { isFunctionNode } from "./ast-scope.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;
+}`;
+function createOgHarfbuzzPlugin() {
+	let callbackModuleDir;
+	let isBuild = false;
+	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 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);
+			}
+		}
+	};
+}
+//#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

package/dist/plugins/optimize-imports.js

@@ -1,11 +1,11 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { escapeRegExp } from "../utils/regex.js";
+import { collectBindingNames, getAstName } from "./ast-utils.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { VIRTUAL_MODULE_ID_RE } from "../utils/virtual-module.js";
-import { getAstName } from "./ast-utils.js";
 import { createRequire } from "node:module";
-import { parseAst } from "vite";
 import fsp from "node:fs/promises";
+import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/optimize-imports.ts
 /**
@@ -21,7 +21,8 @@ async function readFileSafe(filepath) {
 }
 /**
 * 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
 */
 const DEFAULT_OPTIMIZE_PACKAGES = [
@@ -43,6 +44,7 @@ const DEFAULT_OPTIMIZE_PACKAGES = [
 	"rxjs",
 	"@mui/material",
 	"@mui/icons-material",
+	"@chakra-ui/react",
 	"recharts",
 	"react-use",
 	"effect",
@@ -199,7 +201,8 @@ async function resolvePackageEntry(packageName, projectRoot, preferReactServer)
 		}
 		const entryField = pkgJson.module ?? pkgJson.main;
 		if (typeof entryField === "string") return path.resolve(pkgDir, entryField);
-		return toSlash(createRequire(path.join(projectRoot, "package.json")).resolve(packageName));
+		const req = createRequire(path.join(projectRoot, "package.json"));
+		return toSlash(req.resolve(packageName));
 	} catch {
 		return null;
 	}
@@ -246,20 +249,22 @@ async function buildExportMapFromFile(filePath, readFile, cache, visited, initia
 	function normalizeSource(source) {
 		return source.startsWith(".") ? path.join(fileDir, source) : source;
 	}
+	function declarationNames(node) {
+		const names = /* @__PURE__ */ new Set();
+		if (!node) return names;
+		if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") collectBindingNames(node.id, names);
+		else if (node.type === "VariableDeclaration") for (const declaration of node.declarations) collectBindingNames(declaration.id, names);
+		return names;
+	}
 	function recordLocalDeclaration(node) {
-		if (!node) return;
-		if (node.id?.name) {
-			localDeclarations.add(node.id.name);
-			return;
-		}
-		for (const declaration of node.declarations ?? []) if (declaration.id?.name) localDeclarations.add(declaration.id.name);
+		for (const name of declarationNames(node)) localDeclarations.add(name);
 	}
 	for (const node of ast.body) switch (node.type) {
 		case "ImportDeclaration": {
 			const rawSource = typeof node.source?.value === "string" ? node.source.value : null;
 			if (!rawSource) break;
 			const source = normalizeSource(rawSource);
-			for (const spec of node.specifiers ?? []) switch (spec.type) {
+			for (const spec of node.specifiers) switch (spec.type) {
 				case "ImportNamespaceSpecifier":
 					importBindings.set(spec.local.name, {
 						source,
@@ -267,22 +272,21 @@ async function buildExportMapFromFile(filePath, readFile, cache, visited, initia
 					});
 					break;
 				case "ImportSpecifier":
-					if (spec.imported) {
+					{
 						const name = getAstName(spec.imported);
-						if (name !== null) importBindings.set(spec.local.name, {
+						if (name === null) break;
+						importBindings.set(spec.local.name, {
 							source,
 							isNamespace: false,
 							originalName: name
 						});
 					}
 					break;
-				case "ImportDefaultSpecifier":
-					importBindings.set(spec.local.name, {
-						source,
-						isNamespace: false,
-						originalName: "default"
-					});
-					break;
+				case "ImportDefaultSpecifier": importBindings.set(spec.local.name, {
+					source,
+					isNamespace: false,
+					originalName: "default"
+				});
 			}
 			break;
 		}
@@ -291,9 +295,7 @@ async function buildExportMapFromFile(filePath, readFile, cache, visited, initia
 		case "VariableDeclaration":
 			recordLocalDeclaration(node);
 			break;
-		case "ExportNamedDeclaration":
-			recordLocalDeclaration(node.declaration);
-			break;
+		case "ExportNamedDeclaration": recordLocalDeclaration(node.declaration);
 	}
 	for (const node of ast.body) switch (node.type) {
 		case "ExportAllDeclaration": {
@@ -341,7 +343,7 @@ async function buildExportMapFromFile(filePath, readFile, cache, visited, initia
 			const rawSource = typeof node.source?.value === "string" ? node.source.value : null;
 			if (rawSource) {
 				const source = normalizeSource(rawSource);
-				for (const spec of node.specifiers ?? []) if (spec.exported) {
+				for (const spec of node.specifiers) {
 					const exported = getAstName(spec.exported);
 					const local = getAstName(spec.local);
 					if (exported !== null) exportMap.set(exported, {
@@ -350,8 +352,7 @@ async function buildExportMapFromFile(filePath, readFile, cache, visited, initia
 						originalName: local ?? void 0
 					});
 				}
-			} else if (node.specifiers && node.specifiers.length > 0) for (const spec of node.specifiers) {
-				if (!spec.exported) continue;
+			} else if (node.specifiers.length > 0) for (const spec of node.specifiers) {
 				const exported = getAstName(spec.exported);
 				const local = getAstName(spec.local);
 				if (exported === null || local === null) continue;
@@ -369,18 +370,11 @@ async function buildExportMapFromFile(filePath, readFile, cache, visited, initia
 			}
 			else if (node.declaration) {
 				const decl = node.declaration;
-				if (decl.id?.name) exportMap.set(decl.id.name, {
+				for (const name of declarationNames(decl)) exportMap.set(name, {
 					source: filePath,
 					isNamespace: false,
-					originalName: decl.id.name
+					originalName: name
 				});
-				else if (decl.declarations) {
-					for (const d of decl.declarations) if (d.id?.name) exportMap.set(d.id.name, {
-						source: filePath,
-						isNamespace: false,
-						originalName: d.id.name
-					});
-				}
 			}
 			break;
 		}
@@ -493,13 +487,9 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 					}
 					const specifiers = [];
 					let allResolved = true;
-					for (const spec of node.specifiers ?? []) {
+					for (const spec of node.specifiers) {
 						switch (spec.type) {
 							case "ImportSpecifier": {
-								if (!spec.imported) {
-									allResolved = false;
-									break;
-								}
 								const imported = getAstName(spec.imported);
 								if (imported === null) {
 									allResolved = false;
@@ -519,15 +509,13 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 								});
 								if (!exportMap.has("default")) allResolved = false;
 								break;
-							case "ImportNamespaceSpecifier":
-								allResolved = false;
-								break;
+							case "ImportNamespaceSpecifier": allResolved = false;
 						}
 						if (!allResolved) break;
 					}
 					if (!allResolved || specifiers.length === 0) {
 						if (allResolved === false) {
-							for (const spec of node.specifiers ?? []) if (spec.type === "ImportSpecifier" && spec.imported) {
+							for (const spec of node.specifiers) if (spec.type === "ImportSpecifier") {
 								const imported = getAstName(spec.imported);
 								if (imported !== null && !exportMap.has(imported)) {
 									console.debug(`[vinext:optimize-imports] skipping "${importSource}": could not resolve specifier "${imported}" in barrel export map`);

package/dist/plugins/pages-node-externals.d.ts

@@ -18,6 +18,5 @@ type PagesNodeExternalsOptions = {
  * Vite's graph: Node cannot import it as ESM, while Rolldown can bundle the
  * selected `import` export just like Turbopack.
  */
-declare function createPagesNodeExternalsPlugin(options: PagesNodeExternalsOptions): Plugin;
-//#endregion
-export { createPagesNodeExternalsPlugin };
+export declare function createPagesNodeExternalsPlugin(options: PagesNodeExternalsOptions): Plugin;
+//#endregion

package/dist/plugins/pages-node-externals.js

@@ -1,6 +1,6 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { SCRIPT_MODULE_ID_RE, mayContainDynamicImport, scriptParserLanguage, staticStringValue, walkAst } from "./ast-utils.js";
 import { canonicalizeFilePath, isPathInsideOrEqual, stripViteModuleQuery } from "../utils/path.js";
-import { SCRIPT_MODULE_ID_RE, isAstRecord, mayContainDynamicImport, scriptParserLanguage, staticStringValue, walkAst } from "./ast-utils.js";
 import { packageNameFromSpecifier } from "../utils/package-name.js";
 import { isServerEnvironment } from "./environment.js";
 import fs from "node:fs";
@@ -53,21 +53,16 @@ function moduleDependencySpecifiers(code, id) {
 	}
 	const specifiers = [];
 	const seen = /* @__PURE__ */ new Set();
-	const sourceSpecifier = (source) => {
-		if (!isAstRecord(source)) return null;
-		return staticStringValue(source);
-	};
 	const addStaticSource = (source) => {
-		const specifier = sourceSpecifier(source);
+		const specifier = staticStringValue(source);
 		if (specifier === null || seen.has(specifier)) return;
 		seen.add(specifier);
 		specifiers.push(specifier);
 	};
-	for (const statement of ast.body) {
-		if (!isAstRecord(statement)) continue;
-		if (statement.type === "ImportDeclaration" || statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") {
-			if (statement.importKind !== "type" && statement.exportKind !== "type") addStaticSource(statement.source);
-		}
+	for (const statement of ast.body) if (statement.type === "ImportDeclaration" || statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") {
+		if (statement.type === "ImportDeclaration" && statement.importKind === "type") continue;
+		if (statement.type !== "ImportDeclaration" && statement.exportKind === "type") continue;
+		addStaticSource(statement.source);
 	}
 	if (!mayContainDynamicImport(code)) return specifiers;
 	const visitDynamicImports = (node) => {

package/dist/plugins/postcss.d.ts

@@ -1,10 +1,15 @@
 //#region src/plugins/postcss.d.ts
+/**
+ * PostCSS config file names to search for, in priority order.
+ * Matches the same search order as postcss-load-config / lilconfig.
+ */
+export declare const POSTCSS_CONFIG_FILES: string[];
 /**
  * Module-level cache for resolvePostcssStringPlugins — avoids re-scanning per Vite environment.
  * Stores the Promise itself so concurrent calls (RSC/SSR/Client config() hooks firing in
  * parallel) all await the same in-flight scan rather than each starting their own.
  */
-declare const postcssCache: Map<string, Promise<{
+export declare const postcssCache: Map<string, Promise<{
   plugins: unknown[];
 } | undefined>>;
 /**
@@ -19,8 +24,7 @@ declare const postcssCache: Map<string, Promise<{
  * Returns the resolved PostCSS config object to inject into Vite's
  * `css.postcss`, or `undefined` if no resolution is needed.
  */
-declare function resolvePostcssStringPlugins(projectRoot: string): Promise<{
+export declare function resolvePostcssStringPlugins(projectRoot: string): Promise<{
   plugins: unknown[];
 } | undefined>;
-//#endregion
-export { postcssCache, resolvePostcssStringPlugins };
+//#endregion

package/dist/plugins/postcss.js

@@ -93,4 +93,4 @@ async function resolvePostcssStringPluginsUncached(projectRoot) {
 	}
 }
 //#endregion
-export { postcssCache, resolvePostcssStringPlugins };
+export { POSTCSS_CONFIG_FILES, postcssCache, resolvePostcssStringPlugins };

package/dist/plugins/remove-console.d.ts

@@ -15,6 +15,5 @@ type RemoveConsoleResult = {
  *
  * Returns `null` if no console calls are removed.
  */
-declare function removeConsoleCalls(code: string, config: RemoveConsoleConfig): RemoveConsoleResult | null;
-//#endregion
-export { removeConsoleCalls };
+export declare function removeConsoleCalls(code: string, config: RemoveConsoleConfig): RemoveConsoleResult | null;
+//#endregion

package/dist/plugins/remove-console.js

@@ -87,7 +87,6 @@ function removeConsoleCalls(code, config) {
 				checkBinding(argument);
 				break;
 			}
-			default: break;
 		}
 	}
 	/**

package/dist/plugins/require-condition-resolution.d.ts

@@ -1,6 +1,6 @@
 import { Plugin, createIdResolver } from "vite";
 //#region src/plugins/require-condition-resolution.d.ts
-declare function isConditionalRequireScriptModuleId(id: string): boolean;
+export declare function isConditionalRequireScriptModuleId(id: string): boolean;
 /**
  * Resolve literal package `require()` calls while Vite still knows they are
  * CommonJS references. `vite-plugin-commonjs` subsequently hoists each call
@@ -11,6 +11,5 @@ declare function isConditionalRequireScriptModuleId(id: string): boolean;
  */
 type IdResolverFactory = typeof createIdResolver;
 type CommonJsTransformFilter = (id: string) => boolean | undefined;
-declare function createRequireConditionResolutionPlugin(createResolver?: IdResolverFactory, commonjsTransformFilter?: CommonJsTransformFilter): Plugin;
-//#endregion
-export { createRequireConditionResolutionPlugin, isConditionalRequireScriptModuleId };
+export declare function createRequireConditionResolutionPlugin(createResolver?: IdResolverFactory, commonjsTransformFilter?: CommonJsTransformFilter): Plugin;
+//#endregion