@staticbolt/core 1.0.0-beta.32 → 1.0.0-beta.33

package/lib/plugins/index.mjs

@@ -1,10 +1,11 @@
 import { A as isTextAssetMetadata, B as checkJsonObject, C as isBinaryAssetMetadata, D as isScriptMetadata, E as isPackageMetadata, G as isTypeScriptScript, H as isEmptyElement, I as safeReadFileSync, K as TYPESCRIPT_TYPE, M as METADATA_TYPES, N as Resolver, O as isStyleMetadata, P as readJsonFile, R as valueOrError, S as filterStyleMetadata, T as isMarkdownMetadata, U as isJavaScript, V as isDynamic, X as splitHtmlLink, Y as isValidRelativePath, Z as DependencyTracker, _ as mergeMaps, b as printFmtError, c as downloadContent, d as hashContent, f as humanReadableBytes, h as isURL, j as isWebManifestMetadata, k as isSvgMetadata, l as escapeHtml, n as bytesToKB, q as isScriptType, s as cloneObject, w as isHtmlMetadata, x as filterScriptMetadata, y as PrintFormattedError, z as checkFileExists } from "../utilities-jK4uUZBV.mjs";
-import { _ as replaceExtension, a as basename, c as isAbsolute, d as join, f as normalize, g as relative, i as createLog, l as isPathMatch, m as parsePatterns, n as CUSTOM_ATTRIBUTES, o as dirname, p as parse$2, r as Log, s as extname, u as isSubpath, v as resolve } from "../common-D1QTZ8ra.mjs";
+import { _ as replaceExtension, a as basename, c as isAbsolute, d as join, f as normalize, g as relative, i as createLog, l as isPathMatch, m as parsePatterns, n as CUSTOM_ATTRIBUTES, o as dirname, p as parse$5, r as Log, s as extname, u as isSubpath, v as resolve } from "../common-D1QTZ8ra.mjs";
 import { _ as minifyHtml, a as formatStyle, c as minifyStylePass, d as minifyScript, f as minifyScriptPass, g as formatHtmlPass, h as formatHtml, i as minifySvgPass, l as formatScript, m as formatMarkdownPass, n as formatSvgPass, o as formatStylePass, p as formatMarkdown, r as minifySvg, s as minifyStyle, t as formatSvg, u as formatScriptPass, v as minifyHtmlPass, y as formatCode } from "../deferred-DTj91vEg.mjs";
 import { t as loadConfigFile } from "../load-config-CsbiJ01A.mjs";
 import { createRequire } from "node:module";
 import nodePath from "node:path";
 import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { ResolverFactory } from "oxc-resolver";
 import chalk from "chalk";
 import json5 from "json5";
 import _generator from "@babel/generator";
@@ -15,6 +16,10 @@ import { globSync } from "glob";
 import * as esbuild from "esbuild";
 import _traverse from "@babel/traverse";
 import * as t from "@babel/types";
+import { init, parse as parse$1 } from "cjs-module-lexer";
+import { init as init$1, parse as parse$2 } from "es-module-lexer";
+import * as babelParser from "@babel/parser";
+import { parse as parse$3 } from "@babel/parser";
 import postcssrc from "postcss-load-config";
 import * as babel from "@babel/core";
 import babelPresetEnv from "@babel/preset-env";
@@ -35,8 +40,7 @@ import remarkRehype from "remark-rehype";
 import remarkSmartypants from "remark-smartypants";
 import { unified } from "unified";
 import { visit } from "unist-util-visit";
-import { parse as parse$1 } from "yaml";
-import * as babelParser from "@babel/parser";
+import { parse as parse$4 } from "yaml";
 import fastifyStatic from "@fastify/static";
 import fastifyUrlData from "@fastify/url-data";
 import Fastify from "fastify";
@@ -137,7 +141,7 @@ function analyzeOutputPlugin(options = {}) {
 		"workbox-*.js"
 	];
 	const maxFileSize = options.maxFileSize ?? { ".js": 150 };
-	const isLogUnusedFiles = options.logUnusedFiles ?? true;
+	const isLogUnusedFiles = options.logUnusedFiles ?? false;
 	return {
 		name: "analyze-output",
 		async postBuild() {
@@ -158,21 +162,21 @@ function analyzeOutputPlugin(options = {}) {
 				root: this.outdir
 			});
 			const missingFiles = [...usedFiles.difference(availableFiles)].filter((file) => !isExcluded(file));
-			let missingFilesLog = chalk.bold("The following files are missing:");
-			for (const missing of missingFiles) missingFilesLog += "\n" + chalk.red("File not found: ") + chalk.yellow(relative(this.root, missing));
-			if (missingFiles.length > 0) this.log.error(missingFilesLog);
+			if (missingFiles.length > 0) {
+				const missingFilesLog = missingFiles.map((missing) => "\n" + chalk.red("File not found: ") + chalk.yellow(relative(this.root, missing)));
+				this.log.error(chalk.bold("The following files are missing:") + missingFilesLog.join(""));
+			}
 			const unusedFiles = availableFiles.difference(usedFiles);
 			const unusedFilesLog = [];
 			for (const unused of unusedFiles) {
-				if (extname(unused) === ".html") continue;
 				if (isExcluded(unused)) continue;
 				if (isRemoveUnused) unlinkSync(unused);
 				unusedFilesLog.push(chalk.yellow(join(basename(this.outdir), relative(this.outdir, unused))));
 			}
 			const logTitle = isRemoveUnused ? chalk.bold(chalk.red("Removed"), "(" + chalk.yellow(unusedFilesLog.length) + ")", "unused files from the output directory") : chalk.bold("Found", "(" + chalk.yellow(unusedFilesLog.length) + ")", "unused files");
 			if (unusedFilesLog.length > 0) this.log.warn(logTitle + (isLogUnusedFiles ? "\n" + unusedFilesLog.join("\n") : ""));
-			const sortedDirectories = globSync(this.outdir + "/**/*/").toSorted((a, b) => a.localeCompare(b));
-			for (const directory of sortedDirectories) {
+			const directories = globSync(this.outdir + "/**/*/");
+			for (const directory of directories) {
 				let currentPath = directory;
 				while (currentPath !== this.outdir) {
 					if (!(readdirSync(currentPath).length === 0)) break;
@@ -181,9 +185,8 @@ function analyzeOutputPlugin(options = {}) {
 				}
 			}
 			if (maxFileSize) {
-				const extensions = Object.keys(maxFileSize).map((extension) => extension.slice(1));
-				const patternExtensionPart = extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0];
-				const filesStat = globSync(`**/*.${patternExtensionPart}`, {
+				const patterns = Object.keys(maxFileSize).map((extension) => `**/*${extension}`);
+				const filesStat = globSync(patterns, {
 					ignore: exclude,
 					nodir: true,
 					cwd: this.outdir,
@@ -195,9 +198,9 @@ function analyzeOutputPlugin(options = {}) {
 				for (const file of sortedFiles) {
 					const maxSize = maxFileSize[extname(file.name)];
 					if (typeof maxSize !== "number") continue;
-					if (file.size === 0) continue;
-					if (bytesToKB(file.size ?? 0) <= maxSize) continue;
-					largeFilesLogs.push(chalk.yellow(file.relative()) + ` (${chalk.red.bold(humanReadableBytes(file.size ?? 0))} ${chalk.blue(">")} ${chalk.green(humanReadableBytes(maxSize * 1024))})`);
+					const size = file.size ?? 0;
+					if (bytesToKB(size) <= maxSize) continue;
+					largeFilesLogs.push(chalk.yellow(file.relative()) + ` (${chalk.red.bold(humanReadableBytes(size))} ${chalk.blue(">")} ${chalk.green(humanReadableBytes(maxSize * 1024))})`);
 				}
 				if (largeFilesLogs.length > 0) this.log.warn(chalk.bold("The following files may be large:\n") + largeFilesLogs.join("\n"));
 			}
@@ -206,38 +209,135 @@ function analyzeOutputPlugin(options = {}) {
 }
 
 //#endregion
-//#region src/plugins/bundle-packages/bundle-esbuild.ts
+//#region src/plugins/bundle-packages/shared/helpers.ts
+/** Appends to the array at `key`, creating it when absent. */
+function pushInto(map, key, value) {
+	const existing = map.get(key);
+	if (!existing) {
+		map.set(key, [value]);
+		return;
+	}
+	existing.push(value);
+}
+/**
+* Replaces `.js` with `_js` in the directory parts of a package path, so a package like `highlight.js` does not need a folder
+* with the same name as its own bundle.
+*
+* Example: `highlight.js/languages/javascript.js` -> `highlight_js/languages/javascript.js`
+*/
+function normalizePackageName(originalSource) {
+	const parts = originalSource.split("/");
+	if (parts.length <= 1) return originalSource;
+	const fileName = parts.pop();
+	return [...parts.map((part) => part.endsWith(".js") ? part.slice(0, -3) + "_js" : part), fileName].join("/");
+}
+/** Extensions a package name can already end in, which are replaced rather than appended to. */
+const JS_EXTENSIONS$1 = /* @__PURE__ */ new Set([
+	".js",
+	".mjs",
+	".cjs"
+]);
+/**
+* Gives a package name the `.js` its bundle is written under.
+*
+* Only a real JavaScript extension is replaced. Treating the last dot-segment of any name as one puts `lodash.debounce` and
+* `lodash.merge` in the same file, where the second overwrites the first and every import of the loser breaks.
+*/
+function withJsExtension(name) {
+	const lastSegment = name.slice(name.lastIndexOf("/") + 1);
+	const dot = lastSegment.lastIndexOf(".");
+	if (dot === -1 || !JS_EXTENSIONS$1.has(lastSegment.slice(dot))) return name + ".js";
+	return name.slice(0, name.length - (lastSegment.length - dot)) + ".js";
+}
+/** Where a package's bundle is written. Example: `react-dom/client` -> `packages/react-dom/client.js` */
+function calcPackageOutPath(packageName, packagesDirectory) {
+	return join(packagesDirectory, withJsExtension(normalizePackageName(packageName)));
+}
+/**
+* Output path for an asset shipped by a package, keeping its own extension.
+*
+* Example: `node_modules/highlight.js/styles/default.css` -> `packages/highlight_js/styles/default.css`
+*/
+function calcPackageAssetOutPath(nodeModulesPath, packagesDirectory) {
+	const markerIndex = nodeModulesPath.lastIndexOf("node_modules/");
+	const packagePath = markerIndex === -1 ? nodeModulesPath : nodeModulesPath.slice(markerIndex + 13);
+	return join(packagesDirectory, normalizePackageName(packagePath));
+}
+/** The part of a pattern before its wildcard, or nothing when it has none. */
+function wildcardBase(pattern) {
+	if (pattern.endsWith("/**")) return pattern.slice(0, -3);
+	if (pattern.endsWith("/*")) return pattern.slice(0, -2);
+}
+/** Whether a package answers to any of the patterns written on a chunk. */
+function matchesPackage(packageName, packages) {
+	for (const pattern of packages) {
+		if (pattern === packageName) return true;
+		const base = wildcardBase(pattern);
+		if (base === void 0) continue;
+		if (packageName === base || packageName.startsWith(base + "/")) return true;
+	}
+	return false;
+}
+/** Joins a package name with one of its entry points. Example: `packageJoin("react-dom", "./client") // => "react-dom/client"` */
+function packageJoin(name, subPackage) {
+	return nodePath.join(name, subPackage).replace(/\\/g, "/").replace(/\/$/, "");
+}
+/** The `node_modules` directory a package was installed into, or nothing with the reason it could not be found. */
+function getNodeModuleDirectory(packageName, root) {
+	try {
+		const entryPoint = createRequire(root.endsWith(nodePath.sep) ? root : root + nodePath.sep).resolve(packageName);
+		const parts = entryPoint.split(nodePath.sep);
+		const index = parts.lastIndexOf("node_modules");
+		if (index === -1) return { problem: `"${packageName}" resolves to "${entryPoint}", which is not inside a node_modules directory.` };
+		return { path: parts.slice(0, index + 1).join(nodePath.sep) };
+	} catch {
+		return { problem: `"${packageName}" could not be resolved from the project root.` };
+	}
+}
+/**
+* The path a `resolvePackage` entry points a package export at, if one covers it.
+*
+* An entry that cannot be honoured goes to `onProblem` rather than being printed, so it reaches the build's own reporting.
+*/
+function getCustomPackagePath(root, importPath, isProduction, resolvePackage, onProblem) {
+	const environment = isProduction ? "production" : "development";
+	for (const [packageName, exports] of Object.entries(resolvePackage)) for (const [entry, stringOrObject] of Object.entries(exports)) {
+		if (packageJoin(packageName, entry) !== importPath) continue;
+		const relativePath = typeof stringOrObject === "string" ? stringOrObject : stringOrObject[environment];
+		if (!relativePath) continue;
+		const directory = getNodeModuleDirectory(packageName, root);
+		if ("problem" in directory) {
+			onProblem(`The "resolvePackage" entry for "${importPath}" was skipped: ${directory.problem}`);
+			continue;
+		}
+		return join(directory.path, packageName, relativePath);
+	}
+}
+/** Whether a path reaches into `node_modules`. */
+function isNodeModulesPath(path) {
+	return /(^|\/)node_modules\//.test(path);
+}
+/** Directory of the package a `node_modules` path belongs to, `undefined` for paths outside `node_modules`. */
+function packageDirectory(path) {
+	return /^(.*?node_modules\/(?:@[^/]+\/)?[^/]+)(?:\/|$)/.exec(path)?.[1];
+}
+
+//#endregion
+//#region src/plugins/bundle-packages/build/bundle-esbuild.ts
 const bundleFunction$1 = valueOrError(esbuild.build);
+/** Bundles one generated entry into a single ES module, keeping the result in memory rather than writing it. */
 async function bundlePackage(options) {
-	const { resolveDir, packageName, outfile, onPackageResolve, production, minify, treeShaking } = options;
-	const plugins = [{
-		name: "esbuild-plugin-packages-resolver",
-		setup(build) {
-			build.onResolve({ filter: /* @__PURE__ */ new RegExp("^[^./].*") }, async (arguments_) => {
-				if (arguments_.path === packageName || arguments_.importer === "<stdin>") return;
-				return await onPackageResolve(arguments_.path, arguments_.importer);
-			});
-		}
-	}];
-	if (options.onFileResolve) plugins.push({
-		name: "esbuild-plugin-relative-imports-resolver",
-		setup(build) {
-			build.onResolve({ filter: /^\./ }, (arguments_) => {
-				return options.onFileResolve?.(arguments_.path, arguments_.importer);
-			});
-		}
-	});
+	const { contents, resolveDir, outfile, onPackageResolve, production } = options;
 	const [bundleResult, bundleError] = await bundleFunction$1({
-		stdin: options.contents ? {
-			contents: options.contents,
+		stdin: {
+			contents,
 			resolveDir
-		} : void 0,
-		entryPoints: options.entryPoint ? [options.entryPoint] : void 0,
+		},
 		outfile,
 		absWorkingDir: resolveDir,
 		bundle: true,
-		minify,
-		treeShaking,
+		minify: production,
+		treeShaking: production,
 		write: false,
 		legalComments: "none",
 		packages: "bundle",
@@ -246,106 +346,879 @@ async function bundlePackage(options) {
 		target: "es2022",
 		define: { "process.env.NODE_ENV": production ? "\"production\"" : "\"development\"" },
 		logLevel: "silent",
-		plugins
+		plugins: [{
+			name: "esbuild-plugin-packages-resolver",
+			setup(build) {
+				build.onResolve({ filter: /^[^./]/ }, (arguments_) => onPackageResolve(arguments_.path));
+			}
+		}]
 	});
 	if (bundleError) return [null, bundleError];
 	const outCode = bundleResult?.outputFiles?.[0]?.text;
-	if (typeof outCode !== "string") return [null, /* @__PURE__ */ new Error(`Failed to bundle the package "${packageName}"`)];
+	if (typeof outCode !== "string") return [null, /* @__PURE__ */ new Error(`esbuild produced no output for "${outfile}"`)];
 	return [outCode, null];
 }
 
 //#endregion
-//#region src/plugins/bundle-packages/collect-specifiers.ts
+//#region src/plugins/bundle-packages/shared/name-set.ts
+/** A set of export names, or all of them. Grows only. */
+var NameSet = class NameSet {
+	/** `undefined` means all names. */
+	#names;
+	constructor(names) {
+		this.#names = names;
+	}
+	static all() {
+		return new NameSet(void 0);
+	}
+	static of(names = []) {
+		return new NameSet(new Set(names));
+	}
+	get isAll() {
+		return this.#names === void 0;
+	}
+	has(name) {
+		return this.#names ? this.#names.has(name) : true;
+	}
+	list() {
+		return this.#names ? [...this.#names] : [];
+	}
+	clone() {
+		return this.#names ? NameSet.of(this.#names) : NameSet.all();
+	}
+	/**
+	* Adds another set's names.
+	*
+	* @returns Whether anything changed
+	*/
+	widen(other) {
+		if (this.isAll) return false;
+		if (other.isAll) {
+			this.#names = void 0;
+			return true;
+		}
+		const names = this.#names;
+		let isWidened = false;
+		for (const name of other.list()) {
+			if (names.has(name)) continue;
+			names.add(name);
+			isWidened = true;
+		}
+		return isWidened;
+	}
+	/** @returns A stable string, for cache keys */
+	key() {
+		if (!this.#names) return "*";
+		return [...this.#names].toSorted((a, b) => a.localeCompare(b)).join(",");
+	}
+};
+/**
+* Widens a map entry, inserting when absent.
+*
+* @returns Whether anything changed
+*/
+function didWidenEntry(map, key, names) {
+	const existing = map.get(key);
+	if (!existing) {
+		map.set(key, names.clone());
+		return true;
+	}
+	return existing.widen(names);
+}
+
+//#endregion
+//#region src/plugins/bundle-packages/plan/resolve-chunks.ts
+/** The packages named directly by a chunk, whichever form it takes. */
+function namedPackages(option) {
+	return Array.isArray(option) ? option : option.include;
+}
+/**
+* Works out which packages each chunk holds.
+*
+* For the object form the walk starts at `include` and follows what those packages need, leaving out three kinds of package:
+*
+* - Ones the project imports itself, which keep their own file so a page needing only them does not pull the chunk.
+* - Ones named in `exclude`.
+* - Ones only ever reached through `import()`, since folding those into a chunk ends their laziness.
+*
+* A `require` overrules all three, since the two packages cannot be in separate files at all. An `exclude` naming such a package
+* is refused rather than quietly producing a bundle that throws.
+*/
+function resolveChunks(chunks, discovered, seeds, index, groups) {
+	const chunkOf = /* @__PURE__ */ new Map();
+	const refused = [];
+	const unmatched = [];
+	const everyPackage = discovered.keys().toArray();
+	const assign = (specifier, chunkName) => {
+		if (!chunkOf.get(specifier)?.includes(chunkName)) pushInto(chunkOf, specifier, chunkName);
+	};
+	for (const [chunkName, option] of Object.entries(chunks)) {
+		const named = namedPackages(option);
+		const excluded = Array.isArray(option) ? [] : option.exclude ?? [];
+		const roots = everyPackage.filter((specifier) => matchesPackage(specifier, named));
+		for (const root of roots) assign(root, chunkName);
+		unmatched.push(...findUnmatched(chunkName, named, excluded, everyPackage));
+		if (Array.isArray(option)) continue;
+		const queue = [...roots];
+		const seen = new Set(roots);
+		while (queue.length > 0) {
+			const specifier = queue.shift();
+			const closure = index.closureOf(specifier, discovered.get(specifier) ?? NameSet.of());
+			if (!closure) continue;
+			for (const edge of closure.crossPackage) {
+				if (seen.has(edge.specifier)) continue;
+				if (!discovered.has(edge.specifier)) continue;
+				const isRequired = edge.kind === "require" || edge.isStar;
+				if (!isRequired && isLeftOut(edge.specifier, edge.isLazyOnly, named, excluded, seeds)) continue;
+				if (isRequired && matchesPackage(edge.specifier, excluded)) refused.push({
+					chunk: chunkName,
+					specifier: edge.specifier,
+					requiredBy: specifier
+				});
+				seen.add(edge.specifier);
+				assign(edge.specifier, chunkName);
+				queue.push(edge.specifier);
+			}
+		}
+	}
+	pullInWholeGroups(chunkOf, groups, assign);
+	const duplicated = [];
+	for (const [specifier, names] of chunkOf) {
+		if (names.length < 2) continue;
+		duplicated.push({
+			specifier,
+			chunks: [...names]
+		});
+	}
+	const clashes = [];
+	for (const name of Object.keys(chunks)) {
+		if (!discovered.has(name)) continue;
+		const members = chunkOf.entries().filter(([, chunkNames]) => chunkNames.includes(name)).toArray();
+		const hasItself = members.some(([specifier]) => specifier === name);
+		clashes.push({
+			name,
+			otherMembers: hasItself ? members.length - 1 : members.length
+		});
+	}
+	return {
+		chunkOf,
+		duplicated,
+		refused,
+		clashes,
+		unmatched,
+		pulled: findPulledIn(chunks, chunkOf, seeds)
+	};
+}
+/**
+* Finds packages the project imports that ended up in a chunk without being named by it.
+*
+* The walk skips those so a page wanting only that package does not download the whole chunk, but a `require` or an `export *`
+* overrules it and the package loses its own file — a page importing `shiki` then gets everything `expressive-code` brought.
+*/
+function findPulledIn(chunks, chunkOf, seeds) {
+	const byChunk = /* @__PURE__ */ new Map();
+	for (const [specifier, chunkNames] of chunkOf) {
+		if (!seeds.has(specifier)) continue;
+		for (const chunk of chunkNames) {
+			const option = chunks[chunk];
+			if (!option || Array.isArray(option)) continue;
+			if (matchesPackage(specifier, option.include)) continue;
+			pushInto(byChunk, chunk, specifier);
+		}
+	}
+	return byChunk.entries().map(([chunk, specifiers]) => ({
+		chunk,
+		specifiers: specifiers.toSorted((a, b) => a.localeCompare(b))
+	})).toArray();
+}
+/**
+* Finds patterns on a chunk that no package answers to.
+*
+* A misspelled name, an uninstalled package and an unused subpath all end in a silently empty chunk, so the pattern is reported
+* rather than the chunk.
+*/
+function findUnmatched(chunk, named, excluded, everyPackage) {
+	const found = [];
+	const hasNoMatch = (pattern) => everyPackage.every((specifier) => !matchesPackage(specifier, [pattern]));
+	for (const pattern of named) {
+		if (!hasNoMatch(pattern)) continue;
+		found.push({
+			chunk,
+			pattern,
+			isExclusion: false
+		});
+	}
+	for (const pattern of excluded) {
+		if (!hasNoMatch(pattern)) continue;
+		found.push({
+			chunk,
+			pattern,
+			isExclusion: true
+		});
+	}
+	return found;
+}
+/**
+* Adds the rest of a group to whichever chunk took one of its members.
+*
+* A group cannot be split across files at all, so taking one member into a chunk brings the rest with it.
+*/
+function pullInWholeGroups(chunkOf, groups, assign) {
+	for (const [specifier, chunkNames] of chunkOf) {
+		const group = groups.groupOf.get(specifier);
+		if (!group) continue;
+		const groupMembers = groups.membersOf.get(group) ?? [];
+		for (const member of groupMembers) for (const chunkName of chunkNames) assign(member, chunkName);
+	}
+}
+/** Whether a package the walk reached should be left out of the chunk. */
+function isLeftOut(specifier, isLazyOnly, named, excluded, seeds) {
+	if (matchesPackage(specifier, named)) return false;
+	if (matchesPackage(specifier, excluded)) return true;
+	if (seeds.has(specifier)) return true;
+	return isLazyOnly;
+}
+
+//#endregion
+//#region src/plugins/bundle-packages/plan/plan-units.ts
+/** Whether a file holds more than one package, in which case their default exports get renamed. */
+function isSharedUnit(unit) {
+	return unit.exports.size > 1;
+}
+/** Follows the imports of the project's packages to find every other package they reach, and what each must export. */
+function discoverPackages(seeds, index) {
+	const wanted = /* @__PURE__ */ new Map();
+	for (const [specifier, names] of seeds) didWidenEntry(wanted, specifier, names);
+	let isSettled = false;
+	while (!isSettled) {
+		isSettled = true;
+		for (const [specifier, names] of wanted) {
+			const closure = index.closureOf(specifier, names);
+			if (!closure) continue;
+			for (const edge of closure.crossPackage) if (didWidenEntry(wanted, edge.specifier, edge.names)) isSettled = false;
+		}
+	}
+	return wanted;
+}
+/**
+* Maps each package to the group it must be bundled with.
+*
+* Two edges cannot cross a file:
+*
+* - `require("x")`, which esbuild replaces with a stub that throws `Dynamic require of "x" is not supported`.
+* - `export * from "x"`, which cannot name what it forwards, so left external the forwarded names disappear.
+*
+* The group takes the name of its lowest member, so the output file name does not change with discovery order.
+*/
+function mustShareGroups(wanted, index) {
+	const parent = /* @__PURE__ */ new Map();
+	const find = (name) => {
+		let current = name;
+		while (parent.get(current) !== current) current = parent.get(current) ?? current;
+		return current;
+	};
+	const union = (a, b) => {
+		const rootA = find(a);
+		const rootB = find(b);
+		if (rootA === rootB) return;
+		if (rootA < rootB) {
+			parent.set(rootB, rootA);
+			return;
+		}
+		parent.set(rootA, rootB);
+	};
+	for (const name of wanted.keys()) parent.set(name, name);
+	for (const [name, names] of wanted) {
+		const closure = index.closureOf(name, names);
+		if (!closure) continue;
+		for (const edge of closure.crossPackage) {
+			if (!(edge.kind === "require" || edge.isStar) || !parent.has(edge.specifier)) continue;
+			union(name, edge.specifier);
+		}
+	}
+	const groupOf = /* @__PURE__ */ new Map();
+	const membersOf = /* @__PURE__ */ new Map();
+	for (const name of parent.keys()) {
+		const group = find(name);
+		groupOf.set(name, group);
+		pushInto(membersOf, group, name);
+	}
+	return {
+		groupOf,
+		membersOf
+	};
+}
+/**
+* Decides which output file each package goes in.
+*
+* A `chunks` entry wins. Otherwise packages that require each other share one file, and every other package gets its own.
+*
+* Only what the project itself imports is exported. A package pulled in by a file-mate needs no exports: esbuild bundles it
+* either way, and re-exporting it would collide with its file-mates: `version` from both `react` and `react-dom`.
+*/
+function planUnits(discovered, seeds, chunkOf, groups) {
+	const units = /* @__PURE__ */ new Map();
+	const place = (specifier, unitName) => {
+		let unit = units.get(unitName);
+		if (!unit) {
+			unit = {
+				name: unitName,
+				exports: /* @__PURE__ */ new Map()
+			};
+			units.set(unitName, unit);
+		}
+		const imported = seeds.get(specifier) ?? NameSet.of();
+		unit.exports.set(specifier, imported.clone());
+	};
+	for (const specifier of discovered.keys()) {
+		const chunkNames = chunkOf.get(specifier);
+		if (!chunkNames || chunkNames.length === 0) {
+			place(specifier, groups.groupOf.get(specifier) ?? specifier);
+			continue;
+		}
+		for (const chunkName of chunkNames) place(specifier, chunkName);
+	}
+	return units;
+}
+/**
+* Finds sets of packages that require each other but were spread over several files.
+*
+* Grouping is automatic, so only a `chunks` entry taking part of a group can cause this. Reported per group, not per edge, since
+* the whole group has to move together anyway.
+*/
+function validateUnits(units, groups) {
+	const unitOf = unitsBySpecifier(units);
+	const problems = [];
+	for (const [group, packages] of groups.membersOf) {
+		if (packages.length < 2) continue;
+		const spread = new Set(packages.flatMap((specifier) => unitOf.get(specifier) ?? []));
+		if (spread.size < 2) continue;
+		problems.push({
+			group,
+			members: packages.toSorted((a, b) => a.localeCompare(b)),
+			units: [...spread]
+		});
+	}
+	return problems;
+}
+/**
+* Finds packages that resolve to more than one copy.
+*
+* One output file per package name means only one copy ships and importers of the other silently get it instead. Shipping both
+* would need a second output path and per-importer resolution, so this only reports the conflict.
+*/
+function findVersionConflicts(units, discovered, index) {
+	const entriesBySpecifier = /* @__PURE__ */ new Map();
+	const record = (specifier, entry) => {
+		const existing = entriesBySpecifier.get(specifier) ?? /* @__PURE__ */ new Set();
+		existing.add(entry);
+		entriesBySpecifier.set(specifier, existing);
+	};
+	for (const unit of units.values()) for (const specifier of unit.exports.keys()) {
+		const closure = index.closureOf(specifier, discovered.get(specifier) ?? NameSet.of());
+		if (!closure) continue;
+		record(specifier, closure.entry);
+		for (const edge of closure.crossPackage) for (const entry of edge.entries) record(edge.specifier, entry);
+	}
+	const conflicts = [];
+	for (const [specifier, entries] of entriesBySpecifier) {
+		if (entries.size < 2) continue;
+		conflicts.push({
+			specifier,
+			entries: [...entries]
+		});
+	}
+	return conflicts;
+}
+/**
+* Adds the export names that other output files import.
+*
+* `react-dom.js` imports `useState` from `react.js`. Nothing in the project imported it, so `react.js` would not export it.
+*/
+function addCrossUnitNames(units, discovered, index) {
+	const unitOf = unitsBySpecifier(units);
+	for (const unit of units.values()) for (const specifier of unit.exports.keys()) {
+		const closure = index.closureOf(specifier, discovered.get(specifier) ?? NameSet.of());
+		if (!closure) continue;
+		for (const edge of closure.crossPackage) {
+			if (unit.exports.has(edge.specifier)) continue;
+			const dependencyUnits = unitOf.get(edge.specifier) ?? [];
+			for (const dependencyUnit of dependencyUnits) {
+				const target = units.get(dependencyUnit);
+				if (!target) continue;
+				didWidenEntry(target.exports, edge.specifier, edge.names);
+			}
+		}
+	}
+}
+/** Package name → every output file holding it. More than one means a chunk asked for its own copy. */
+function unitsBySpecifier(units) {
+	const unitOf = /* @__PURE__ */ new Map();
+	for (const unit of units.values()) for (const specifier of unit.exports.keys()) pushInto(unitOf, specifier, unit.name);
+	return unitOf;
+}
+/** Runs discovery, grouping, chunk resolution and the cross-file export pass, which are always used together. */
+function planLayout(seeds, chunks, index) {
+	const discovered = discoverPackages(seeds, index);
+	const groups = mustShareGroups(discovered, index);
+	const plan = resolveChunks(chunks, discovered, seeds, index, groups);
+	const units = planUnits(discovered, seeds, plan.chunkOf, groups);
+	addCrossUnitNames(units, discovered, index);
+	return {
+		units,
+		discovered,
+		plan,
+		groups
+	};
+}
+
+//#endregion
+//#region src/plugins/bundle-packages/build/package-exports.ts
+/** For a package no page imports, present only because a file-mate needs it. */
+const NOTHING_NEEDED = {
+	names: NameSet.of(),
+	hasDefault: false,
+	hasSideEffect: false
+};
+/**
+* Per file, not per package: packages in one file constrain each other. Two can own the same name, and two defaults cannot both
+* be called `default`.
+*/
+function exportsForUnit(unit, context) {
+	const isSharedFile = isSharedUnit(unit);
+	/** Name → the package in this file that claimed it. */
+	const taken = /* @__PURE__ */ new Map();
+	const members = [...unit.exports].toSorted(([a], [b]) => a.localeCompare(b));
+	const exports = [];
+	for (const [specifier, names] of members) {
+		const needed = context.neededByPackage.get(specifier) ?? NOTHING_NEEDED;
+		exports.push(exportsForPackage({
+			specifier,
+			names,
+			needed,
+			isSharedFile,
+			taken,
+			unit,
+			context
+		}));
+	}
+	return exports;
+}
+function exportsForPackage(turn) {
+	const { specifier, names, needed, isSharedFile, taken, unit, context } = turn;
+	const index = context.index;
+	const asked = mergeNeededExports(needed, names);
+	const wanted = expandNamesForCjs(specifier, asked.names, index);
+	const owned = ownedNames(specifier, index);
+	const named = [];
+	for (const name of wanted.list()) {
+		if (name === "default") continue;
+		const keptBy = taken.get(name);
+		if (keptBy !== void 0) {
+			if (!needed.names.isAll && needed.names.has(name)) context.onNameClash?.({
+				unit: unit.name,
+				name,
+				keptBy,
+				lostBy: specifier
+			});
+			continue;
+		}
+		if (owned && !owned.has(name)) continue;
+		taken.set(name, specifier);
+		named.push(name);
+	}
+	const hasStar = wanted.isAll;
+	const hasDefault = asked.hasDefault || hasStar && index.hasDefaultExport(specifier);
+	const result = {
+		specifier,
+		hasSideEffect: asked.hasSideEffect,
+		hasStar,
+		defaultAs: defaultNameFor(specifier, hasDefault, isSharedFile),
+		named
+	};
+	if (!result.hasStar && !result.defaultAs && result.named.length === 0 && !result.hasSideEffect) return {
+		...result,
+		hasStar: true,
+		defaultAs: defaultNameFor(specifier, index.hasDefaultExport(specifier), isSharedFile)
+	};
+	return result;
+}
+/** Collapses every import of a package into the set of names it must export. */
+function neededExports(specifiers) {
+	const names = NameSet.of();
+	let hasDefault = false;
+	let hasSideEffect = false;
+	for (const specifier of specifiers) {
+		if (specifier.type === "namespace" || specifier.type === "unknown") {
+			names.widen(NameSet.all());
+			continue;
+		}
+		if (specifier.type === "default") {
+			names.widen(NameSet.of(["default"]));
+			hasDefault = true;
+			continue;
+		}
+		if (specifier.type === "side-effect") {
+			hasSideEffect = true;
+			continue;
+		}
+		if (specifier.type !== "named") continue;
+		const wanted = specifier.kind === "export" ? specifier.publicName : specifier.name;
+		names.widen(NameSet.of([wanted]));
+	}
+	return {
+		names,
+		hasDefault,
+		hasSideEffect
+	};
+}
+/** Merges what this project imports with what other output files need. */
+function mergeNeededExports(needed, names) {
+	const wanted = names.clone();
+	wanted.widen(needed.names);
+	const isDefaultNamed = !names.isAll && names.has("default");
+	return {
+		names: wanted,
+		hasDefault: needed.hasDefault || isDefaultNamed,
+		hasSideEffect: needed.hasSideEffect
+	};
+}
+/**
+* `export *` carries nothing out of CommonJS, whose exports are assignments rather than syntax, so spell the names out.
+*
+* ES modules keep the star; spelling those out would include `export type` names that do not exist at runtime.
+*/
+function expandNamesForCjs(specifier, names, index) {
+	if (!names.isAll || index.formatOf(specifier) !== "cjs") return names;
+	const entry = index.resolveFrom(specifier, join(index.root, "package.json"));
+	if (!entry) return names;
+	return NameSet.of(index.exportsOf(entry));
+}
+/** @returns The names a package publishes, or nothing when they could not be read, since an empty list means the lexer failed */
+function ownedNames(specifier, index) {
+	const entry = index.resolveFrom(specifier, join(index.root, "package.json"));
+	if (!entry) return;
+	const owned = index.exportsOf(entry);
+	if (owned.length === 0) return;
+	return new Set(owned);
+}
+/** `pointReferencesAtUnits` renames the import sites to match, deriving the name the same way. */
+function defaultNameFor(specifier, hasDefault, isSharedFile) {
+	if (!hasDefault) return;
+	if (!isSharedFile) return "default";
+	return defaultExportAlias(specifier);
+}
+/** Keeps defaults apart when several packages share a file. */
+function defaultExportAlias(packageName) {
+	return "default_" + packageName.replace(/@|-|\/|\./g, "_");
+}
+/** Writes the entry esbuild bundles a file from, deciding nothing itself. */
+function printBarrel(exports) {
+	let contents = "";
+	for (const one of exports) {
+		const from = `from '${one.specifier}';`;
+		if (one.hasSideEffect) contents += `import '${one.specifier}';`;
+		if (one.hasStar) contents += `\nexport * ${from}`;
+		if (one.defaultAs) {
+			const as = one.defaultAs === "default" ? "default" : `default as ${one.defaultAs}`;
+			contents += `\nexport { ${as} } ${from}`;
+		}
+		if (one.named.length > 0) contents += `\nexport { ${one.named.join(", ")} } ${from}`;
+	}
+	return contents;
+}
+
+//#endregion
+//#region src/plugins/bundle-packages/build/build-unit.ts
+/**
+* Bundles one output file, skipping it when the entry has not changed.
+*
+* Compared on the entry itself rather than a summary of it, since a summary missing one input — the kind of import, say — leaves
+* a file built from an entry the pages no longer ask for.
+*/
+async function buildUnit(unit, context, report) {
+	const existingMetadata = this.findMetadata({
+		type: METADATA_TYPES.Package,
+		id: unit.name
+	});
+	const contents = printBarrel(exportsForUnit(unit, context));
+	if (!contents) return;
+	if (existingMetadata && context.builtEntries.get(unit.name) === contents) return;
+	const packageOutputPath = calcPackageOutPath(unit.name, context.packagesDirectory);
+	const packageMetadata = isPackageMetadata(existingMetadata) ? existingMetadata : newPackageMetadata(unit.name, packageOutputPath);
+	packageMetadata.directDependencies.clear();
+	const [bundledCode, bundleError] = await bundlePackage({
+		contents,
+		resolveDir: this.root,
+		outfile: packageOutputPath,
+		production: this.production,
+		onPackageResolve: (name) => resolveImport.call(this, name, unit, context, packageOutputPath, packageMetadata)
+	});
+	if (bundleError) {
+		report(`Failed to bundle package "${unit.name}"`, bundleError);
+		if (this.production) process.exitCode = 1;
+		return;
+	}
+	packageMetadata.code = bundledCode;
+	context.builtEntries.set(unit.name, contents);
+	if (!existingMetadata) this.addMetadata(packageMetadata);
+}
+/**
+* Decides what esbuild does with a bare import it met while bundling.
+*
+* A package belonging to another file is made external and pointed at it. One belonging to this file, or to none, is bundled in,
+* and only then can a `resolvePackage` entry say where it is read from.
+*/
+function resolveImport(importedPackageName, unit, context, packageOutputPath, packageMetadata) {
+	const onProblem = (message) => this.log.warn(message);
+	const owningUnits = context.unitOf.get(importedPackageName) ?? [];
+	const customPath = getCustomPackagePath(this.root, importedPackageName, this.production, context.resolvePackage, onProblem);
+	const owningUnit = owningUnits.includes(unit.name) ? unit.name : owningUnits[0];
+	if (!owningUnit || owningUnit === unit.name) {
+		if (!customPath) return;
+		return {
+			path: customPath,
+			external: false
+		};
+	}
+	const dependencyOutputPath = calcPackageOutPath(owningUnit, context.packagesDirectory);
+	packageMetadata.directDependencies.add(dependencyOutputPath);
+	return {
+		path: relative(dirname(packageOutputPath), dependencyOutputPath),
+		external: true
+	};
+}
+/** A fresh metadata record for an output file that has not been built before. */
+function newPackageMetadata(name, filePath) {
+	return {
+		type: METADATA_TYPES.Package,
+		packageName: name,
+		code: "",
+		filePath,
+		id: name,
+		directDependencies: /* @__PURE__ */ new Set()
+	};
+}
+
+//#endregion
+//#region src/plugins/bundle-packages/collect/narrow-namespace.ts
+/**
+* Records what a binding holding a whole package is used for: the whole namespace when nothing could be narrowed, only the names
+* actually read, or a side-effect import when the binding is never read.
+*
+* `import * as z from "zod"` and `const z = await import("zod")` both come here, so the static and dynamic forms stay in step.
+*/
+function recordNamespaceUse(path, localName, specifiers) {
+	const used = namesReadFrom(path, localName);
+	if (used.isAll) {
+		specifiers.push({ type: "namespace" });
+		return;
+	}
+	const names = used.list();
+	if (names.length === 0) {
+		specifiers.push({ type: "side-effect" });
+		return;
+	}
+	for (const name of names) {
+		if (name === "default") {
+			specifiers.push({
+				type: "default",
+				setDefaultName: renameDefaultReads(path, localName)
+			});
+			continue;
+		}
+		specifiers.push({
+			type: "named",
+			kind: "import",
+			name,
+			publicName: name
+		});
+	}
+}
+/**
+* The names read off a binding that holds a whole package.
+*
+* Narrowed by:
+*
+* - Reading a property: `z.string()`
+* - Destructuring: `const { string, object } = z;`
+* - Following an alias: `const zod = z;`
+*
+* Anything else gives back `NameSet.all()`: a runtime property name, a `...rest`, or the binding used as a value.
+*/
+function namesReadFrom(path, importName) {
+	const binding = path.scope.getBinding(importName);
+	if (!binding) return NameSet.all();
+	const names = NameSet.of();
+	for (const referencePath of binding.referencePaths) {
+		const parentPath = referencePath.parentPath;
+		if (!parentPath) continue;
+		const parentNode = parentPath.node;
+		if (t.isMemberExpression(parentNode) && t.isIdentifier(parentNode.property)) {
+			if (parentNode.computed) return NameSet.all();
+			names.widen(NameSet.of([parentNode.property.name]));
+			continue;
+		}
+		if (t.isVariableDeclarator(parentNode) && t.isIdentifier(parentNode.init)) {
+			const id = parentNode.id;
+			if (t.isObjectPattern(id)) {
+				if (id.properties.some((property) => t.isRestElement(property))) return NameSet.all();
+				for (const property of id.properties) {
+					if (!t.isObjectProperty(property) || !t.isIdentifier(property.key)) continue;
+					names.widen(NameSet.of([property.key.name]));
+				}
+				continue;
+			}
+			if (t.isIdentifier(id)) {
+				names.widen(namesReadFrom(parentPath.get("id"), id.name));
+				continue;
+			}
+		}
+		return NameSet.all();
+	}
+	return names;
+}
+/**
+* Renames every `binding.default` read, so a package sharing a file keeps the default alias it was given.
+*
+* The import stays as is: the binding is the whole namespace, only the one property moves.
+*/
+function renameDefaultReads(path, localName) {
+	return (newName) => {
+		const binding = path.scope.getBinding(localName);
+		if (!binding) return;
+		for (const referencePath of binding.referencePaths) {
+			const parentNode = referencePath.parentPath?.node;
+			if (!t.isMemberExpression(parentNode) || !t.isIdentifier(parentNode.property)) continue;
+			if (parentNode.property.name !== "default") continue;
+			parentNode.property = t.identifier(newName);
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/bundle-packages/collect/collect-specifiers.ts
 const traverse$1 = typeof _traverse === "function" ? _traverse : _traverse.default;
+const NODE_MODULES = "node_modules";
+/** Pairs the names an import takes with a `source` that reads and writes the AST node holding its path. */
+function sourceReference(read, write, specifiers) {
+	return {
+		get source() {
+			return read();
+		},
+		set source(newValue) {
+			write(newValue);
+		},
+		specifiers
+	};
+}
+/**
+* Whether any import in a file names a path inside `node_modules`.
+*
+* A plain node walk, with no paths or scope built, so it is cheap enough to run over every script before deciding whether the
+* full traversal is worth it. `resolveSource` has already rewritten package imports into `node_modules` paths, so a file whose
+* imports never name one cannot reach a package.
+*/
+function hasNodeModulesImport(node) {
+	if (!node || typeof node.type !== "string") return false;
+	let isFound = false;
+	t.traverseFast(node, (current) => {
+		if (importSourceOf(current)?.includes(NODE_MODULES)) isFound = true;
+	});
+	return isFound;
+}
+/** The literal path one node imports from, whatever form the import takes. */
+function importSourceOf(node) {
+	if (t.isImportDeclaration(node) || t.isExportAllDeclaration(node) || t.isExportNamedDeclaration(node)) return t.isStringLiteral(node.source) ? node.source.value : void 0;
+	return dynamicImportSource(node)?.value;
+}
+/** Every import in a file, with the names it takes and a writable `source` that rewrites its path. */
 function collectSpecifiersFromAst(ast) {
 	const result = [];
 	traverse$1(ast, {
 		ImportDeclaration(path) {
 			if (!t.isStringLiteral(path.node.source)) return;
-			if ((path.node.importKind ?? "value") === "type") return;
+			if (path.node.importKind === "type") return;
 			const source = path.node.source.value;
 			if (source.startsWith("node:")) return;
 			const specifiers = [];
 			collectImportDeclarationSpecifiers(path, specifiers);
-			result.push({
-				get source() {
-					return source;
-				},
-				set source(newValue) {
-					if (path.node) path.node.source = t.stringLiteral(newValue);
-				},
-				specifiers
-			});
+			const write = (newValue) => {
+				if (!path.node) return;
+				path.node.source = t.stringLiteral(newValue);
+			};
+			result.push(sourceReference(() => source, write, specifiers));
 		},
 		ExportAllDeclaration(path) {
 			if (!path.node.source.value) return;
-			if ((path.node.exportKind ?? "value") === "type") return;
+			if (path.node.exportKind === "type") return;
 			const specifiers = [];
 			collectExportAllDeclarationSpecifiers(path, specifiers);
-			result.push({
-				get source() {
-					return path.node.source.value;
-				},
-				set source(newValue) {
-					path.node.source = t.stringLiteral(newValue);
-				},
-				specifiers
-			});
+			const read = () => path.node.source.value;
+			const write = (newValue) => {
+				path.node.source = t.stringLiteral(newValue);
+			};
+			result.push(sourceReference(read, write, specifiers));
 		},
 		ExportNamedDeclaration(path) {
 			if (!t.isStringLiteral(path.node.source)) return;
-			if ((path.node.exportKind ?? "value") === "type") return;
+			if (path.node.exportKind === "type") return;
 			const source = path.node.source.value;
 			if (source.startsWith("node:")) return;
 			const specifiers = [];
 			collectExportNamedDeclarationSpecifiers(path, specifiers);
-			result.push({
-				get source() {
-					return source;
-				},
-				set source(newValue) {
-					path.node.source = t.stringLiteral(newValue);
-				},
-				specifiers
-			});
+			const write = (newValue) => {
+				path.node.source = t.stringLiteral(newValue);
+			};
+			result.push(sourceReference(() => source, write, specifiers));
 		},
 		CallExpression(path) {
-			if (!t.isImport(path.node.callee) || !t.isStringLiteral(path.node.arguments[0])) return;
-			const setSource = (newValue) => {
-				path.node.arguments[0] = t.stringLiteral(newValue);
-			};
-			const source = path.node.arguments[0].value;
-			if (source.startsWith("node:")) return;
-			const specifiers = [];
-			collectDynamicImportSpecifiers(path, specifiers);
-			result.push({
-				get source() {
-					return source;
-				},
-				set source(newValue) {
-					setSource(newValue);
-				},
-				specifiers
-			});
+			collectDynamicImport(path, result);
+		},
+		ImportExpression(path) {
+			collectDynamicImport(path, result);
 		}
 	});
 	return result;
 }
+/** The literal specifier of a dynamic import, for either node shape. */
+function dynamicImportSource(node) {
+	if (t.isImportExpression(node)) return t.isStringLiteral(node.source) ? node.source : void 0;
+	if (!t.isCallExpression(node) || !t.isImport(node.callee)) return;
+	const argument = node.arguments[0];
+	return t.isStringLiteral(argument) ? argument : void 0;
+}
+/** Records one `import()` along with how to rewrite its path. */
+function collectDynamicImport(path, result) {
+	const literal = dynamicImportSource(path.node);
+	if (!literal) return;
+	const source = literal.value;
+	if (source.startsWith("node:")) return;
+	const write = (newValue) => {
+		if (t.isImportExpression(path.node)) {
+			path.node.source = t.stringLiteral(newValue);
+			return;
+		}
+		path.node.arguments[0] = t.stringLiteral(newValue);
+	};
+	const specifiers = [];
+	collectDynamicImportSpecifiers(path, specifiers);
+	result.push(sourceReference(() => source, write, specifiers));
+}
+/** What one `import ... from "x"` takes. No names at all means a side-effect import. */
 function collectImportDeclarationSpecifiers(path, specifiers) {
 	const node = path.node;
 	if (!t.isStringLiteral(node.source) || node.importKind && node.importKind !== "value") return;
 	let hasFoundSpecifier = false;
-	for (let index = 0; index < node.specifiers.length; index++) {
-		const specifier = node.specifiers[index];
+	for (const specifier of node.specifiers) {
 		if (t.isImportDefaultSpecifier(specifier)) {
 			const setDefaultName = (newName) => {
-				const index = node.specifiers.indexOf(specifier);
-				if (index === -1) return;
-				node.specifiers[index] = t.importSpecifier(t.identifier(specifier.local.name), t.identifier(newName));
+				const at = node.specifiers.indexOf(specifier);
+				if (at === -1) return;
+				node.specifiers[at] = t.importSpecifier(t.identifier(specifier.local.name), t.identifier(newName));
 			};
 			specifiers.push({
 				type: "default",
-				name: specifier.local.name,
 				setDefaultName
 			});
 			hasFoundSpecifier = true;
@@ -364,60 +1237,30 @@ function collectImportDeclarationSpecifiers(path, specifiers) {
 			continue;
 		}
 		if (t.isImportNamespaceSpecifier(specifier)) {
-			const usedNames = collectUsedNames(path, specifier.local.name);
-			for (const name of usedNames) {
-				if (name === "default") {
-					const capturedLocalName = specifier.local.name;
-					const capturedPath = path;
-					const setDefaultName = (newName) => {
-						const binding = capturedPath.scope.getBinding(capturedLocalName);
-						if (!binding) return;
-						for (const referencePath of binding.referencePaths) {
-							const parentNode = referencePath.parentPath?.node;
-							if (t.isMemberExpression(parentNode) && t.isIdentifier(parentNode.property) && parentNode.property.name === "default") parentNode.property = t.identifier(newName);
-						}
-					};
-					specifiers.push({
-						type: "default",
-						name: capturedLocalName,
-						setDefaultName
-					});
-					hasFoundSpecifier = true;
-					continue;
-				}
-				specifiers.push({
-					type: "named",
-					kind: "import",
-					name,
-					publicName: name
-				});
-				hasFoundSpecifier = true;
-			}
+			recordNamespaceUse(path, specifier.local.name, specifiers);
+			hasFoundSpecifier = true;
 		}
 	}
 	if (!hasFoundSpecifier) specifiers.push({ type: "side-effect" });
 }
+/** `export * from "x"` can forward any name, so the whole package is taken. */
 function collectExportAllDeclarationSpecifiers(path, specifiers) {
 	if (!path.node.source.value || path.node.exportKind !== "value") return;
-	specifiers.push({
-		type: "namespace",
-		name: "*"
-	});
+	specifiers.push({ type: "namespace" });
 }
+/** What one `export { ... } from "x"` takes, using the names before any rename. */
 function collectExportNamedDeclarationSpecifiers(path, specifiers) {
 	const node = path.node;
 	if (!t.isStringLiteral(node.source) || node.exportKind !== "value") return;
-	for (let index = 0; index < node.specifiers.length; index++) {
-		const specifier = node.specifiers[index];
+	for (const specifier of node.specifiers) {
 		if (t.isExportDefaultSpecifier(specifier) && t.isIdentifier(specifier.exported)) {
 			const setDefaultName = (newName) => {
-				const index = node.specifiers.indexOf(specifier);
-				if (index === -1) return;
-				node.specifiers[index] = t.exportSpecifier(t.identifier(newName), t.identifier(specifier.exported.name));
+				const at = node.specifiers.indexOf(specifier);
+				if (at === -1) return;
+				node.specifiers[at] = t.exportSpecifier(t.identifier(newName), t.identifier(specifier.exported.name));
 			};
 			specifiers.push({
 				type: "default",
-				name: specifier.exported.name,
 				setDefaultName
 			});
 			continue;
@@ -432,15 +1275,11 @@ function collectExportNamedDeclarationSpecifiers(path, specifiers) {
 			});
 			continue;
 		}
-		if (t.isExportNamespaceSpecifier(specifier)) specifiers.push({
-			type: "namespace",
-			name: t.isIdentifier(specifier.exported) ? specifier.exported.name : specifier.exported.value
-		});
+		if (t.isExportNamespaceSpecifier(specifier)) specifiers.push({ type: "namespace" });
 	}
 }
 function collectDynamicImportSpecifiers(path, specifiers) {
-	if (!t.isImport(path.node.callee)) return;
-	if (!t.isStringLiteral(path.node.arguments[0])) {
+	if (!dynamicImportSource(path.node)) {
 		specifiers.push({ type: "unknown" });
 		return;
 	}
@@ -451,17 +1290,17 @@ function collectDynamicImportSpecifiers(path, specifiers) {
 	}
 	const parentNode = parentPath.parentPath?.node;
 	if (t.isMemberExpression(parentNode)) {
-		const property = parentNode.property;
-		const importedName = getNodeName(property);
-		if (!importedName) return;
+		const importedName = staticKey(parentNode.property, parentNode.computed);
+		if (!importedName) {
+			specifiers.push({ type: "unknown" });
+			return;
+		}
 		if (importedName === "default") {
-			const capturedMemberExpression = parentNode;
 			const setDefaultName = (newName) => {
-				capturedMemberExpression.property = t.identifier(newName);
+				parentNode.property = t.identifier(newName);
 			};
 			specifiers.push({
 				type: "default",
-				name: importedName,
 				setDefaultName
 			});
 			return;
@@ -475,322 +1314,769 @@ function collectDynamicImportSpecifiers(path, specifiers) {
 		return;
 	}
 	if (t.isVariableDeclarator(parentNode) && t.isObjectPattern(parentNode.id)) {
-		for (const property of parentNode.id.properties) {
-			if (!t.isObjectProperty(property)) continue;
-			const importedName = getNodeName(property.key);
-			if (!importedName) continue;
-			const localName = getNodeName(property.value);
-			if (importedName === "default") {
-				const setDefaultName = (newName) => {
-					property.key = t.identifier(newName);
-				};
-				specifiers.push({
-					type: "default",
-					name: localName ?? importedName,
-					setDefaultName
-				});
-				continue;
-			}
-			specifiers.push({
-				type: "named",
-				kind: "import",
-				name: importedName,
-				publicName: localName ?? importedName
-			});
-		}
+		collectDestructuredNames(parentNode.id, specifiers);
 		return;
 	}
 	if (t.isVariableDeclarator(parentNode) && t.isIdentifier(parentNode.id)) {
-		const usedNames = collectUsedNames(path, parentNode.id.name);
-		for (const name of usedNames) {
-			if (name === "default") {
-				const capturedId = parentNode.id;
-				const capturedPath = path;
-				const setDefaultName = (newName) => {
-					const binding = capturedPath.scope.getBinding(capturedId.name);
-					if (!binding) return;
-					for (const referencePath of binding.referencePaths) {
-						const pNode = referencePath.parentPath?.node;
-						if (t.isMemberExpression(pNode) && t.isIdentifier(pNode.property) && pNode.property.name === "default") pNode.property = t.identifier(newName);
-					}
-				};
-				specifiers.push({
-					type: "default",
-					name: parentNode.id.name,
-					setDefaultName
-				});
-				continue;
-			}
-			specifiers.push({
-				type: "named",
-				kind: "import",
-				name,
-				publicName: name
+		recordNamespaceUse(path, parentNode.id.name, specifiers);
+		return;
+	}
+	if (!parentNode || t.isExpressionStatement(parentNode)) {
+		specifiers.push({ type: "side-effect" });
+		return;
+	}
+	specifiers.push({ type: "unknown" });
+}
+/** What `const { a, b: c } = await import('path')` takes, or the whole package when a property cannot be named. */
+function collectDestructuredNames(pattern, specifiers) {
+	const found = [];
+	for (const property of pattern.properties) {
+		if (!t.isObjectProperty(property)) {
+			specifiers.push({ type: "unknown" });
+			return;
+		}
+		const importedName = staticKey(property.key, property.computed);
+		if (!importedName) {
+			specifiers.push({ type: "unknown" });
+			return;
+		}
+		const localName = t.isIdentifier(property.value) ? property.value.name : void 0;
+		if (importedName === "default") {
+			const setDefaultName = (newName) => {
+				property.key = t.identifier(newName);
+			};
+			found.push({
+				type: "default",
+				setDefaultName
 			});
+			continue;
 		}
-		return;
+		found.push({
+			type: "named",
+			kind: "import",
+			name: importedName,
+			publicName: localName ?? importedName
+		});
 	}
-	if (!parentNode || t.isExpressionStatement(parentNode)) specifiers.push({ type: "side-effect" });
+	specifiers.push(...found);
+}
+/** The name a property key stands for, or nothing when only the running program knows it. */
+function staticKey(node, isComputed) {
+	if (t.isStringLiteral(node)) return node.value;
+	if (isComputed) return null;
+	return getNodeName(node);
 }
+/** The name a node stands for, however it was written. */
+function getNodeName(node) {
+	if (t.isIdentifier(node)) return node.name;
+	if (t.isStringLiteral(node)) return node.value;
+	if (t.isPrivateName(node)) return node.id.name;
+	return null;
+}
+
+//#endregion
+//#region src/plugins/bundle-packages/collect/collect-references.ts
+/** The name of the package an import points into, or nothing if it stays inside the project. */
+function packageOfSource(source, fromFile, context) {
+	const sourceRootRelative = join(dirname(fromFile), source);
+	if (isNodeModulesPath(sourceRootRelative)) return context.pathPackageMap.get(join(context.root, sourceRootRelative));
+}
+/** Records what an import takes from a package, so the package's file exports it. */
+function recordSpecifiers(packageName, specifiers, context) {
+	const existing = context.specifiersByPackage.get(packageName) ?? [];
+	existing.push(...specifiers);
+	context.specifiersByPackage.set(packageName, existing);
+}
+/** Every package import in a script, standalone or inline in a script tag. */
+function collectScriptReferences(metadata, context) {
+	const references = [];
+	if (!isNodeModulesPath(metadata.filePath) && !hasNodeModulesImport(metadata.ast)) return references;
+	for (const sourceReference of collectSpecifiersFromAst(metadata.ast)) {
+		const packageName = packageOfSource(sourceReference.source, metadata.filePath, context);
+		if (!packageName) {
+			reportUntracedSource(sourceReference.source, metadata.filePath, context);
+			continue;
+		}
+		recordSpecifiers(packageName, sourceReference.specifiers, context);
+		references.push({
+			setSource: (source) => {
+				sourceReference.source = source;
+			},
+			fromFile: metadata.filePath,
+			packageName,
+			specifiers: sourceReference.specifiers
+		});
+	}
+	return references;
+}
+/** Every package import written as a `<script src>` tag, which only runs the package, so it counts as a side-effect import. */
+function collectScriptTagReferences(metadata, context) {
+	const references = [];
+	for (const scriptTag of metadata.ast.querySelectorAll("script[src]")) {
+		const source = scriptTag.getAttribute("src");
+		if (!source) continue;
+		if (!isScriptType(scriptTag.getAttribute("type"))) continue;
+		const packageName = packageOfSource(source, metadata.filePath, context);
+		if (!packageName) {
+			reportUntracedSource(source, metadata.filePath, context);
+			continue;
+		}
+		const specifiers = [{ type: "side-effect" }];
+		recordSpecifiers(packageName, specifiers, context);
+		references.push({
+			setSource: (newSource) => {
+				scriptTag.setAttribute("src", newSource);
+			},
+			fromFile: metadata.filePath,
+			packageName,
+			specifiers
+		});
+	}
+	return references;
+}
+/** The `href` of every stylesheet link, as sources that write back to the tag. */
+function styleLinkSources(metadata) {
+	return metadata.ast.querySelectorAll("link[rel=\"stylesheet\"], link[rel=\"preload\"][as=\"style\"]").map((styleLink) => ({
+		get source() {
+			return styleLink.getAttribute("href") ?? "";
+		},
+		set source(value) {
+			styleLink.setAttribute("href", value);
+		}
+	}));
+}
+/** Moves the files a package ships next to the package output and points the sources reaching into it at the new place. */
+async function rebasePackageAssets(fromFile, sources, packagesDirectory, assetByPath) {
+	for (const reference of sources) {
+		const [link, suffix] = splitHtmlLink(reference.source);
+		const sourceRootRelative = join(dirname(fromFile), link);
+		if (!isNodeModulesPath(sourceRootRelative)) continue;
+		const asset = assetByPath.get(join(this.root, sourceRootRelative));
+		if (!asset) continue;
+		const assetOutputPath = calcPackageAssetOutPath(sourceRootRelative, packagesDirectory);
+		if (asset.filePath !== assetOutputPath) {
+			await this.rebase(asset, join(this.root, assetOutputPath));
+			asset.filePath = assetOutputPath;
+		}
+		reference.source = relative(dirname(fromFile), assetOutputPath) + suffix;
+	}
+}
+/** Walks every file in the build and collects the imports that reach into `node_modules`. */
+async function collectReferences(context, packagesDirectory) {
+	const references = [];
+	/** Absolute path → the metadata holding it, so a stylesheet is found without scanning the whole list per link. */
+	const assetByPath = /* @__PURE__ */ new Map();
+	for (const item of this.metadataList) assetByPath.set(join(this.root, item.id), item);
+	for (const inputMetadata of this.metadataList) {
+		for (const { metadata } of filterScriptMetadata(inputMetadata)) references.push(...collectScriptReferences(metadata, context));
+		for (const { metadata } of filterStyleMetadata(inputMetadata)) {
+			const sources = await this.requestSources(metadata);
+			await rebasePackageAssets.call(this, metadata.filePath, sources, packagesDirectory, assetByPath);
+		}
+		if (!isHtmlMetadata(inputMetadata)) continue;
+		references.push(...collectScriptTagReferences(inputMetadata, context));
+		await rebasePackageAssets.call(this, inputMetadata.filePath, styleLinkSources(inputMetadata), packagesDirectory, assetByPath);
+	}
+	return references;
+}
+/** Points every import at the file its package ended up in, renaming defaults when a file holds several packages. */
+function pointReferencesAtUnits(references, units, unitOf, packagesDirectory) {
+	for (const reference of references) {
+		const unitName = unitOf.get(reference.packageName)?.[0] ?? reference.packageName;
+		const packageOutputPath = calcPackageOutPath(unitName, packagesDirectory);
+		reference.setSource(relative(dirname(reference.fromFile), packageOutputPath));
+		const unit = units.get(unitName);
+		if (!unit || !isSharedUnit(unit)) continue;
+		const alias = defaultExportAlias(reference.packageName);
+		for (const specifier of reference.specifiers) if (specifier.type === "default") specifier.setDefaultName(alias);
+	}
+}
+/** Reports an import into `node_modules` whose package could not be named, leaving it out of the bundles. */
+function reportUntracedSource(source, fromFile, context) {
+	const sourceRootRelative = join(dirname(fromFile), source);
+	if (isNodeModulesPath(sourceRootRelative)) context.reportUntraced(`Could not resolve a package name for "${source}" imported from "${fromFile}".\nThe import is left pointing into node_modules and will not be bundled.`);
+}
+
+//#endregion
+//#region src/plugins/bundle-packages/index/read-requires.ts
+const ENVIRONMENT_GUARD = "process.env.NODE_ENV";
 /**
-* Collects used names from a name space import. E.g., `import * as z from "zod"`\
-* Covers most cases when importing a package using a name space.
+* Collects the specifiers a CommonJS file requires, with dead branches removed.
 *
-* Covered cases:
+* Packages routinely ship an entry that switches on the build mode:
 *
-* - Direct member expression: `z.string()`
-* - Destructuring: `const { string, object } = z;`
-* - Following aliases: `const zod = z;`
-*
-* Ignored cases:
+* ```js
+* if (process.env.NODE_ENV !== "production") {
+*   module.exports = require("./cjs/react.development.js");
+* } else {
+*   module.exports = require("./cjs/react.production.js");
+* }
+* ```
 *
-* - Object destructuring with spread syntax: `const { string, ...rest } = z;`
+* Esbuild gets `process.env.NODE_ENV` as a define, so it keeps one branch and drops the other. Reading both would report requires
+* that never reach the output, grouping packages that do not need each other in that mode.
 */
-function collectUsedNames(path, importName) {
-	const usedNames = /* @__PURE__ */ new Set();
-	const binding = path.scope.getBinding(importName);
-	if (!binding) return usedNames;
-	for (const referencePath of binding.referencePaths) {
-		const parentPath = referencePath.parentPath;
-		if (!parentPath) continue;
-		const parentNode = parentPath.node;
-		if (t.isMemberExpression(parentNode) && t.isIdentifier(parentNode.property)) {
-			usedNames.add(parentNode.property.name);
+function readRequires(code, isProduction) {
+	if (!code.includes(ENVIRONMENT_GUARD)) return matchRequires(code);
+	const ast = tryParse(code);
+	if (!ast) return matchRequires(code);
+	const specifiers = [];
+	for (const node of ast.program.body) collectFromNode(node, isProduction ? "production" : "development", specifiers);
+	return specifiers;
+}
+/** Every `require("…")` in the source, without looking at what guards it. */
+function matchRequires(code) {
+	return Array.from(code.matchAll(/require\(\s*["']([^"']+)["']\s*\)/g), (match) => match[1]);
+}
+/** Parses CommonJS, which is a script rather than a module. */
+function tryParse(code) {
+	try {
+		return parse$3(code, {
+			sourceType: "script",
+			allowReturnOutsideFunction: true,
+			errorRecovery: true
+		});
+	} catch {
+		return null;
+	}
+}
+/** Walks one node, following only the branches that survive in this mode. */
+function collectFromNode(node, mode, specifiers) {
+	if (!node) return;
+	if (t.isCallExpression(node) && t.isIdentifier(node.callee, { name: "require" })) {
+		const argument = node.arguments[0];
+		if (t.isStringLiteral(argument)) specifiers.push(argument.value);
+	}
+	const taken = takenBranch(node, mode);
+	if (taken !== void 0) {
+		collectFromNode(taken, mode, specifiers);
+		return;
+	}
+	const keys = t.VISITOR_KEYS[node.type] ?? [];
+	for (const key of keys) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const element of value) if (t.isNode(element)) collectFromNode(element, mode, specifiers);
 			continue;
 		}
-		if (t.isVariableDeclarator(parentNode) && t.isIdentifier(parentNode.init)) {
-			const id = parentNode.id;
-			if (t.isObjectPattern(id)) {
-				for (const property of id.properties) {
-					if (t.isRestElement(property) || !t.isIdentifier(property.key)) continue;
-					usedNames.add(property.key.name);
-				}
-				continue;
-			}
-			if (t.isIdentifier(id)) {
-				const aliasUsed = collectUsedNames(parentPath.get("id"), id.name);
-				for (const n of aliasUsed) usedNames.add(n);
-			}
-		}
+		if (t.isNode(value)) collectFromNode(value, mode, specifiers);
 	}
-	return usedNames;
 }
-function getNodeName(node) {
-	if (t.isIdentifier(node)) return node.name;
-	if (t.isStringLiteral(node)) return node.value;
-	if (t.isPrivateName(node)) return node.id.name;
-	return null;
+/**
+* @returns The branch a mode check resolves to, `undefined` when the node is not a mode check or its answer is unknown, and
+*   `null` when it resolves to a branch that is not there, such as an `if` with no `else`
+*/
+function takenBranch(node, mode) {
+	if (!t.isIfStatement(node) && !t.isConditionalExpression(node)) return;
+	const result = evaluateEnvironmentTest(node.test, mode);
+	if (result === void 0) return;
+	return result ? node.consequent : node.alternate ?? null;
+}
+/** Evaluates a comparison between `process.env.NODE_ENV` and a string, or nothing if the test is anything else. */
+function evaluateEnvironmentTest(test, mode) {
+	if (!t.isBinaryExpression(test)) return;
+	if (![
+		"===",
+		"==",
+		"!==",
+		"!="
+	].includes(test.operator)) return;
+	const left = readComparisonSide(test.left);
+	const right = readComparisonSide(test.right);
+	if (!left || !right) return;
+	if (left.kind === right.kind) return;
+	const isEqual = (left.kind === "literal" ? left.value : right.value) === mode;
+	return test.operator.startsWith("!") ? !isEqual : isEqual;
+}
+/** Reads one side of a comparison as either the environment lookup or a string literal. */
+function readComparisonSide(node) {
+	if (t.isStringLiteral(node)) return {
+		kind: "literal",
+		value: node.value
+	};
+	if (isEnvironmentLookup(node)) return { kind: "environment" };
+}
+/** Whether a node is `process.env.NODE_ENV`. */
+function isEnvironmentLookup(node) {
+	if (!t.isMemberExpression(node) || !t.isIdentifier(node.property, { name: "NODE_ENV" })) return false;
+	const object = node.object;
+	if (!t.isMemberExpression(object) || !t.isIdentifier(object.property, { name: "env" })) return false;
+	return t.isIdentifier(object.object, { name: "process" });
 }
 
 //#endregion
-//#region src/plugins/bundle-packages/helpers.ts
+//#region src/plugins/bundle-packages/index/lex-module.ts
 /**
-* Some package names may include `.js` as part of their name (e.g., `highlight.js`).\
-* If we have a subpackage within such a package, we face a conflict:\
-* We cannot create a folder named `highlight.js` because a file with the same name (`highlight.js`) already exists.\
-* To resolve this, we replace `.js` with `_js` in the subpackage path only, avoiding conflicts.\
-* Example: `highlight.js/languages/javascript.js` -> `highlight_js/languages/javascript.js`
+* Reads one file into a record, without resolving anything or opening another file.
+*
+* A file with neither imports nor exports lexes as neither ESM nor CJS, and is treated as an ES module exporting nothing.
 */
-function normalizePackageName$1(originalSource) {
-	const parts = originalSource.split("/");
-	if (parts.length <= 1) return originalSource;
-	const outParts = [];
-	for (let index = 0; index < parts.length; index++) {
-		const part = parts[index];
-		if (index === parts.length - 1) {
-			outParts.push(part);
+function lexModule(file, code, mtimeMs, isProduction) {
+	const [imports, exports] = parse$2(code, file);
+	const isEsm = imports.length > 0 || exports.length > 0;
+	const record = {
+		file,
+		mtimeMs,
+		format: isEsm ? "esm" : "cjs",
+		reexportOf: /* @__PURE__ */ new Map(),
+		ownExports: [],
+		starSources: [],
+		edges: []
+	};
+	if (isEsm) {
+		readEsmRecord(record, code, imports, exports);
+		return record;
+	}
+	readCjsRecord(record, code, isProduction);
+	return record;
+}
+/** Fills a record from the ES module lexer's output. */
+function readEsmRecord(record, code, imports, exports) {
+	for (const exported of exports) {
+		const owner = imports.find((index) => index.n && exported.s >= index.ss && exported.e <= index.se);
+		if (!owner?.n) {
+			record.ownExports.push(exported.n);
+			continue;
+		}
+		const renames = reexportedNames(code.slice(owner.ss, owner.se));
+		record.reexportOf.set(exported.n, {
+			source: owner.n,
+			importedName: renames.get(exported.n)
+		});
+	}
+	for (const imported of imports) {
+		if (!imported.n) continue;
+		const statement = code.slice(imported.ss, imported.se);
+		if (/^export\s*\*/.test(statement)) {
+			record.starSources.push(imported.n);
 			continue;
 		}
-		outParts.push(part.replace(".js", "_js"));
+		if (/^export\s*\{/.test(statement)) continue;
+		const isDynamic = imported.d > -1;
+		record.edges.push({
+			specifier: imported.n,
+			kind: "import",
+			names: namesOfImport(statement),
+			isDynamic
+		});
 	}
-	return outParts.join("/");
 }
-function calcPackageOutPath(packageName, packagesDirectory) {
-	const normalizedPackageName = normalizePackageName$1(packageName);
-	const withJsExtension = replaceExtension(normalizedPackageName, ".js");
-	return join(packagesDirectory, withJsExtension);
+/** Fills a record from the CommonJS lexer's output, plus the `require()` calls that survive in this mode. */
+function readCjsRecord(record, code, isProduction) {
+	const parsed = tryParseCjs(code);
+	if (!parsed) {
+		record.format = "esm";
+		return;
+	}
+	const live = new Set(readRequires(code, isProduction));
+	record.ownExports.push(...parsed.exports);
+	for (const reexport of liveReexports(parsed.reexports, live)) record.reexportOf.set(reexport, {
+		source: reexport,
+		importedName: reexport
+	});
+	for (const specifier of live) record.edges.push({
+		specifier,
+		kind: "require",
+		names: void 0,
+		isDynamic: false
+	});
 }
 /**
-* Output path for an asset shipped by a package, keeping its own extension.
+* The re-export targets that survive in this mode.
 *
-* Example: `node_modules/highlight.js/styles/default.css` -> `packages/highlight_js/styles/default.css`
+* The lexer always reports the development branch of a mode check, so in production it names a file the build drops. The relative
+* requires that did survive are the real targets.
 */
-function calcPackageAssetOutPath(nodeModulesPath, packagesDirectory) {
-	const markerIndex = nodeModulesPath.lastIndexOf("node_modules/");
-	const packagePath = markerIndex === -1 ? nodeModulesPath : nodeModulesPath.slice(markerIndex + 13);
-	return join(packagesDirectory, normalizePackageName$1(packagePath));
-}
-function generateStdinString(specifiers, packageName) {
-	let isDefaultImport = false;
-	let newDefaultName;
-	let hasSideEffect = false;
-	let isNamespace = false;
-	const named = /* @__PURE__ */ new Set();
-	for (const specifier of specifiers) {
-		if (specifier.type === "default") {
-			isDefaultImport = true;
-			newDefaultName = specifier.newDefaultName;
-		}
-		if (specifier.type === "named" && specifier.kind === "import") named.add(specifier.name);
-		if (specifier.type === "named" && specifier.kind === "export") {
-			named.delete(specifier.name);
-			named.add(specifier.publicName);
-		}
-		if (specifier.type === "namespace") isNamespace = true;
-		else if (specifier.type === "side-effect") hasSideEffect = true;
+function liveReexports(reported, live) {
+	const kept = reported.filter((reexport) => live.has(reexport));
+	if (kept.length > 0) return kept;
+	if (reported.length === 0) return reported;
+	return live.values().filter((specifier) => specifier.startsWith(".")).toArray();
+}
+/** Runs the CommonJS lexer, which throws on ES module syntax. */
+function tryParseCjs(code) {
+	try {
+		return parse$1(code);
+	} catch {
+		return null;
 	}
-	let contents = "";
-	if (hasSideEffect) contents += `import '${packageName}';`;
-	if (isNamespace) contents += `\nexport * from '${packageName}';`;
-	if (isDefaultImport) contents += `\nexport { default${newDefaultName ? ` as ${newDefaultName}` : ""} } from '${packageName}';`;
-	if (named.size > 0 && !isNamespace) contents += `\nexport { ${Array.from(named).join(", ")} } from '${packageName}';`;
-	return contents;
 }
-function getChunkName(packageName, chunks) {
-	for (const [chunkName, packages] of Object.entries(chunks)) if (matchesPackage(packageName, packages)) return chunkName;
+/**
+* Exported name → the name asked of the source, read off one `export ... from` statement.
+*
+* An entry is absent when the whole namespace is taken, which `export * as ns from "x"` does and a brace list never does.
+*/
+function reexportedNames(statement) {
+	const renames = /* @__PURE__ */ new Map();
+	const braces = /\{([^}]*)\}/.exec(statement);
+	if (!braces) return renames;
+	const parts = braces[1].split(",");
+	for (const part of parts) {
+		const [imported, exported] = part.split(/\s+as\s+/).map((side) => side.trim().replaceAll(/^["']|["']$/g, ""));
+		if (imported) renames.set(exported || imported, imported);
+	}
+	return renames;
+}
+/** The names an import statement binds, or `undefined` for `import * as`, which binds no individual names. */
+function namesOfImport(statement) {
+	if (/import\s+\*\s+as/.test(statement)) return;
+	const names = [];
+	if (/^import\s+(?!\{)[A-Za-z_$][\w$]*/.test(statement)) names.push("default");
+	const braces = /\{([^}]*)\}/.exec(statement);
+	if (!braces) {
+		if (names.length === 0) return;
+		return names;
+	}
+	const parts = braces[1].split(",");
+	for (const part of parts) {
+		const name = part.trim().split(/\s+as\s+/, 1)[0].trim();
+		if (name) names.push(name);
+	}
+	return names;
 }
-function matchesPackage(packageName, packages) {
-	for (const pattern of packages) {
-		if (pattern === packageName) return true;
-		if (pattern.endsWith("/*")) {
-			const base = pattern.slice(0, -2);
-			if (packageName === base || packageName.startsWith(base + "/")) return true;
+
+//#endregion
+//#region src/plugins/bundle-packages/index/vendor-index.ts
+/**
+* Lexes the part of `node_modules` the project uses. No bundler runs. It answers:
+*
+* - Which files a specifier pulls in, narrowed to the names asked for.
+* - Which names a specifier exports, following `export *` and CommonJS re-export chains.
+* - Which of its imports go to another package, with their names, and which of those are `require` calls.
+*/
+var VendorIndex = class VendorIndex {
+	root;
+	#resolver;
+	#resolveCache = /* @__PURE__ */ new Map();
+	#modules = /* @__PURE__ */ new Map();
+	#closures = /* @__PURE__ */ new Map();
+	#isProduction;
+	constructor(root, isProduction) {
+		this.root = root;
+		this.#isProduction = isProduction;
+		this.#resolver = new ResolverFactory({
+			conditionNames: [
+				"browser",
+				"import",
+				"module",
+				"default",
+				isProduction ? "production" : "development"
+			],
+			mainFields: [
+				"browser",
+				"module",
+				"main"
+			],
+			extensions: [
+				".js",
+				".mjs",
+				".cjs",
+				".json"
+			],
+			symlinks: false
+		});
+	}
+	static async create(root, isProduction) {
+		await init$1;
+		await init();
+		return new VendorIndex(root, isProduction);
+	}
+	/** Resolves a specifier from `fromFile`. Handles relative paths, bare package names and `#subpath` imports. */
+	resolveFrom(specifier, fromFile) {
+		const directory = dirname(fromFile);
+		const key = directory + "\0" + specifier;
+		if (this.#resolveCache.has(key)) return this.#resolveCache.get(key);
+		let resolved;
+		try {
+			resolved = this.#resolver.sync(directory, specifier).path ?? void 0;
+		} catch {
+			resolved = void 0;
+		}
+		this.#resolveCache.set(key, resolved);
+		return resolved;
+	}
+	/** Lexes one file. Re-reads it only when its mtime changed. */
+	lex(file) {
+		const mtimeMs = statSync(file).mtimeMs;
+		const cached = this.#modules.get(file);
+		if (cached && cached.mtimeMs === mtimeMs) return cached;
+		const code = readFileSync(file, "utf8");
+		const record = lexModule(file, code, mtimeMs, this.#isProduction);
+		this.#modules.set(file, record);
+		return record;
+	}
+	/**
+	* Whether the module a specifier resolves to has a default export.
+	*
+	* `export *` does not carry a default, so a package taken whole needs its default re-exported by name or it comes out empty.
+	*/
+	hasDefaultExport(specifier, fromFile = join(this.root, "package.json")) {
+		const entry = this.resolveFrom(specifier, fromFile);
+		if (!entry) return false;
+		const record = this.lex(entry);
+		return record.ownExports.includes("default") || record.reexportOf.has("default");
+	}
+	/** The format of the file a specifier resolves to. */
+	formatOf(specifier, fromFile = join(this.root, "package.json")) {
+		const entry = this.resolveFrom(specifier, fromFile);
+		if (!entry) return;
+		return this.lex(entry).format;
+	}
+	/**
+	* Every name a file exports, following `export *` and CommonJS re-export chains.
+	*
+	* Use this for CommonJS only. In an ES module `export type { X }` and `export { X }` look identical to the lexer, so the list
+	* would include type names, and re-exporting one is a build error.
+	*/
+	exportsOf(file, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(file)) return [];
+		seen.add(file);
+		const record = this.lex(file);
+		const names = new Set(record.ownExports.filter((name) => name !== "__esModule"));
+		for (const [name, reexport] of record.reexportOf) {
+			if (!isPathReexport(name, reexport)) {
+				names.add(name);
+				continue;
+			}
+			const target = this.resolveFrom(reexport.source, file);
+			if (!target) continue;
+			for (const inner of this.exportsOf(target, seen)) names.add(inner);
 		}
-		if (pattern.endsWith("/**")) {
-			const base = pattern.slice(0, -2);
-			if (packageName === base || packageName.startsWith(base + "/")) return true;
+		for (const source of record.starSources) {
+			const target = this.resolveFrom(source, file);
+			if (!target) continue;
+			for (const inner of this.exportsOf(target, seen)) names.add(inner);
 		}
+		names.delete("default");
+		return [...names];
 	}
-	return false;
-}
-/** Join the package name with its entry point. Example: `join("react-dom", "./client") // => "react-dom/client` */
-function packageJoin(name, subPackage) {
-	return nodePath.join(name, subPackage).replace(/\\/g, "/").replace(/\/$/, "");
-}
-function getNodeModuleDirectory(packageName, root) {
-	try {
-		const entryPoint = createRequire(root.endsWith(nodePath.sep) ? root : root + nodePath.sep).resolve(packageName);
-		const parts = entryPoint.split(nodePath.sep);
-		const index = parts.lastIndexOf("node_modules");
-		if (index === -1) {
-			console.error(`node_modules not found in resolved path for "${packageName}": ${entryPoint}`);
-			return null;
+	/**
+	* Walks everything `specifier` needs to provide `names`, and collects the imports that leave its package.
+	*
+	* Asking for every name walks the whole package. Naming them follows only the re-export branches that lead to those names,
+	* which is the difference between reading 15 files of `lodash-es` and reading all 600.
+	*/
+	closureOf(specifier, names, fromFile = join(this.root, "package.json")) {
+		const cacheKey = fromFile + "\0" + specifier + "\0" + names.key();
+		if (this.#closures.has(cacheKey)) return this.#closures.get(cacheKey);
+		const closure = this.#walkClosure(specifier, names, fromFile);
+		this.#closures.set(cacheKey, closure);
+		return closure;
+	}
+	#walkClosure(specifier, names, fromFile) {
+		const entry = this.resolveFrom(specifier, fromFile);
+		if (!entry) return;
+		const visited = /* @__PURE__ */ new Set();
+		const crossPackage = /* @__PURE__ */ new Map();
+		const queue = [{
+			file: entry,
+			wanted: names
+		}];
+		while (queue.length > 0) {
+			const { file, wanted } = queue.shift();
+			const key = file + "\0" + wanted.key();
+			if (visited.has(key)) continue;
+			visited.add(key);
+			const record = this.lex(file);
+			for (const [source, wantedNames] of sourcesForNames(record, wanted)) {
+				const target = this.resolveFrom(source, file);
+				if (!target) continue;
+				if (isBareSpecifier(source)) mergeEdge(crossPackage, {
+					specifier: source,
+					kind: "import",
+					names: wantedNames,
+					entry: target,
+					isDynamic: false,
+					isStar: record.starSources.includes(source)
+				});
+				const forward = wantedNames.isAll ? NameSet.all() : NameSet.of([...wantedNames.list(), "default"]);
+				queue.push({
+					file: target,
+					wanted: forward
+				});
+			}
+			for (const edge of record.edges) {
+				const target = this.resolveFrom(edge.specifier, file);
+				if (!target) continue;
+				if (isBareSpecifier(edge.specifier)) {
+					const names = edge.names ? NameSet.of(edge.names) : NameSet.all();
+					mergeEdge(crossPackage, {
+						specifier: edge.specifier,
+						kind: edge.kind,
+						names,
+						entry: target,
+						isDynamic: edge.isDynamic,
+						isStar: false
+					});
+				}
+				queue.push({
+					file: target,
+					wanted: NameSet.all()
+				});
+			}
 		}
-		return parts.slice(0, index + 1).join(nodePath.sep);
-	} catch (error) {
-		console.error(`Failed to resolve package directory for "${packageName}":`, error);
-		return null;
+		return {
+			entry,
+			crossPackage: crossPackage.values().toArray()
+		};
+	}
+};
+/** The `export ... from "x"` branches that can lead to a wanted name → the names to look for in each. */
+function sourcesForNames(record, wanted) {
+	const sources = /* @__PURE__ */ new Map();
+	for (const [name, reexport] of record.reexportOf) {
+		if (!wanted.has(name) && !isPathReexport(name, reexport)) continue;
+		const asked = reexport.importedName === void 0 ? NameSet.all() : NameSet.of([reexport.importedName]);
+		didWidenEntry(sources, reexport.source, asked);
 	}
+	for (const source of record.starSources) sources.set(source, wanted);
+	return sources;
 }
-function getCustomPackagePath(root, importPath, isProduction, resolvePackage) {
-	const environment = isProduction ? "production" : "development";
-	for (const [packageName, exports] of Object.entries(resolvePackage)) for (const [entry, stringOrObject] of Object.entries(exports)) {
-		if (packageJoin(packageName, entry) !== importPath) continue;
-		const relativePath = typeof stringOrObject === "string" ? stringOrObject : stringOrObject[environment];
-		if (!relativePath) continue;
-		const nodeModulesDirectory = getNodeModuleDirectory(packageName, root);
-		if (!nodeModulesDirectory) {
-			console.error(`Skipping "${packageName}" — could not determine node_modules directory`);
-			continue;
-		}
-		return join(nodeModulesDirectory, packageName, relativePath);
+/**
+* Whether a re-export names a whole module rather than one of its exports.
+*
+* `module.exports = require("./cjs/react.production.js")` is reported by the CommonJS lexer as re-exporting the path itself, so
+* the names live in the target and this branch is always followed.
+*/
+function isPathReexport(name, reexport) {
+	return name === reexport.source && reexport.source.startsWith(".");
+}
+/** Merges an edge into the ones already found for the same specifier. */
+function mergeEdge(edges, found) {
+	const existing = edges.get(found.specifier);
+	if (!existing) {
+		edges.set(found.specifier, {
+			specifier: found.specifier,
+			kind: found.kind,
+			names: found.names.clone(),
+			entries: /* @__PURE__ */ new Set([found.entry]),
+			isLazyOnly: found.isDynamic,
+			isStar: found.isStar
+		});
+		return;
 	}
+	existing.entries.add(found.entry);
+	if (!found.isDynamic) existing.isLazyOnly = false;
+	if (found.isStar) existing.isStar = true;
+	if (found.kind === "require") existing.kind = "require";
+	existing.names.widen(found.names);
 }
-function isNodeModulesPath(path, root) {
-	return isPathMatch(path, {
-		include: ["**/node_modules/**"],
-		ignore: [],
-		root
-	});
+/**
+* Whether a specifier can land in a different output file than the one importing it.
+*
+* Only bare specifiers can; `./x` and `#internal` resolve inside their own package and travel with it. Same package is not the
+* same file though: `react/jsx-runtime` is a subpath with a file of its own, and its development build requires `react` back.
+*/
+function isBareSpecifier(specifier) {
+	return !specifier.startsWith(".") && !specifier.startsWith("#") && !specifier.startsWith("/");
 }
-/** Directory of the package a `node_modules` path belongs to, `undefined` for paths outside `node_modules`. */
-function packageDirectory(path) {
-	return /^(.*?node_modules\/(?:@[^/]+\/)?[^/]+)(?:\/|$)/.exec(path)?.[1];
+
+//#endregion
+//#region src/plugins/bundle-packages/shared/report-problems.ts
+/** `a, b` becomes `"a", "b"`. */
+function quoted(names, separator = ", ") {
+	return names.map((name) => `"${name}"`).join(separator);
 }
 /**
-* Returns a stable key for a specifier, ignoring publicName and function refs. Side-effects are keyed by type alone (only one per
-* source).
+* Reports a `chunks` grouping that split packages joined by a `require` or an `export *`.
+*
+* Grouping is automatic, so only a hand-written entry can cause this. One message per group, since the whole group has to move
+* together anyway.
 */
-function specifierKey(s) {
-	switch (s.type) {
-		case "default": return `default::${s.name}`;
-		case "namespace": return `namespace::${s.name}`;
-		case "named": return `named::${s.name}`;
-		case "unknown":
-		case "side-effect": return `side-effect`;
-	}
+function reportLayoutProblems(units, groups, report) {
+	for (const problem of validateUnits(units, groups)) {
+		const chunkName = problem.units.find((name) => !problem.members.includes(name)) ?? problem.group;
+		report(`These packages cannot be in separate files, but they were spread over ${quoted(problem.units)}. A "require" between them throws when the bundle runs, and an "export *" between them loses the names it forwards with no error at all.\nPut all of them in one chunk:\n  bundlePackagesPlugin({ chunks: { "${chunkName}": [${quoted(problem.members)}] } })`);
+	}
+}
+/** Warns about anything in `chunks` that could not be honoured as written. */
+function reportChunkPlan(plan, warn) {
+	for (const { chunk, pattern, isExclusion } of plan.unmatched) warn(`The chunk "${chunk}" ${isExclusion ? "excludes" : "asks for"} "${pattern}", which no package in this build answers to. Check the spelling, or that the package is installed and something imports it.`);
+	for (const clash of plan.clashes) warn(`The chunk "${clash.name}" is named after a package this build uses, so that package's own file is now the chunk and carries ${clash.otherMembers} other package(s) with it. Every page importing "${clash.name}" downloads all of them. Give the chunk a name no package has.`);
+	for (const { chunk, specifiers } of plan.pulled) warn(`${quoted(specifiers)} would each have had a file of their own, since this project imports them directly, but "${chunk}" holds packages they cannot be separated from and took them too. A page importing only one of them now downloads the whole chunk. Drop the chunk to get separate files back.`);
+	for (const refused of plan.refused) warn(`"${refused.chunk}" excludes "${refused.specifier}", but "${refused.requiredBy}" requires it at runtime and the two cannot be in separate files. It was kept in the chunk.`);
+	if (plan.duplicated.length === 0) return;
+	const names = quoted(plan.duplicated.map((duplicate) => duplicate.specifier));
+	warn(`The chunks ${quoted([...new Set(plan.duplicated.flatMap((duplicate) => duplicate.chunks))], " and ")} both pull in ${names}, so each is built into both files. Every import of them points at one of the two, which leaves the other carrying packages nothing loads. Name an overlapping package in one chunk only.`);
+}
+/**
+* One output file cannot export a name twice, so a page importing it from the losing package silently reads the other's value.
+*
+* Only a `chunks` entry can put two directly-imported packages in one file, so naming the chunk is the way out.
+*/
+function nameClashMessage(clash) {
+	return `"${clash.keptBy}" and "${clash.lostBy}" both export "${clash.name}" and share the output file "${clash.unit}", so only one of them can publish it. "${clash.keptBy}" keeps it, and every page importing "${clash.name}" from "${clash.lostBy}" silently reads "${clash.keptBy}"'s value instead. Put them in separate chunks.`;
 }
 /**
-* Diffs two specifier arrays and returns only the entries from `collected` that are not already present in `existing`.
+* Warns about a package `node_modules` holds more than one copy of.
 *
-* @param existing - The full current set of specifiers.
-* @param collected - Newly gathered specifiers to screen for novelty.
-* @returns Specifiers in `collected` that are absent from `existing`.
+* One output file per package name means only one copy ships. Only a deduped install or a version override can fix that.
 */
-function diffSpecifiers(existing, collected) {
-	const existingKeys = new Set(existing.map((element) => specifierKey(element)));
-	return collected.filter((s) => !existingKeys.has(specifierKey(s)));
+function reportVersionConflicts(root, units, discovered, index, warn) {
+	for (const conflict of findVersionConflicts(units, discovered, index)) {
+		const copies = conflict.entries.map((entry) => `  ${relative(root, entry)}`).join("\n");
+		warn(`"${conflict.specifier}" resolves to more than one copy, and only one of them can be bundled:\n${copies}\nWhichever importer wanted the other copy will get this one instead. Dedupe the install to be sure which.`);
+	}
 }
 
 //#endregion
 //#region src/plugins/bundle-packages/bundle-packages-plugin.ts
-function normalizePackageName(packageName) {
-	return "default_" + packageName.replace(/@|-|\/|\./g, "_");
-}
+const JS_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".mjs",
+	".cjs",
+	".jsx",
+	".ts",
+	".mts",
+	".cts",
+	".tsx"
+]);
 /**
-* Bundles every "node_modules" package imported anywhere in the project into its own file under "packagesDir" and rewrites the
-* imports to point at it. Specifiers are collected across the whole codebase first, so esbuild can tree-shake each package down
-* to what is actually used.
+* Bundles every `node_modules` package imported anywhere in the project into a file under `packagesDir`, and rewrites the imports
+* to point at it.
 *
 * Notes:
 *
-* - Runs in both modes; minification and tree-shaking are production-only.
-* - Bare imports in scripts and "<script src>" tags resolving into "node_modules" are both redirected; a script tag is counted as a
-*   side-effect import.
-* - A "<link rel=stylesheet>" shipped by a package is moved next to the package output, keeping its path inside the package. Other
-*   file types stay where they resolve, under "node_modules".
-* - Dots in the output path become underscores ("highlight.js" becomes "highlight_js"), so a package cannot collide with the file
-*   bundled from it.
-* - "chunks" merges packages into one file and renames their default imports to "default_<package>" so they share a module scope,
-*   which is what CommonJS packages need to work in the browser.
-* - A package first discovered while bundling another one is bundled right away, then re-bundled once its specifiers are known.
+* - Minification and tree-shaking are production-only.
+* - `<script src>` into `node_modules` is redirected too, and counts as a side-effect import.
+* - A stylesheet shipped by a package, linked from HTML or `@import`ed from CSS, is copied next to the package output, keeping its
+*   path inside the package.
+* - Dots in output paths become underscores (`highlight.js` → `highlight_js`) so a package cannot collide with its own bundle.
+* - Packages that `require` each other are bundled together.
 */
 function bundlePackagesPlugin(options = {}) {
-	const packagesOutputDirection = options.packagesDir ?? "./packages";
+	const packagesDirectory = options.packagesDir ?? "./packages";
 	const resolvePackage = options.resolvePackage ?? {};
 	const chunks = options.chunks ?? {};
-	/** Maps package names to a list of collected import specifiers (named, default, side-effect, etc.) from various source files. */
+	/** Package specifier → specifiers imported from it. */
 	const specifiersByPackage = /* @__PURE__ */ new Map();
-	/** Maps the absolute path of a package entry point to its original source name */
+	/** Resolved `node_modules` path → package specifier. */
 	const pathPackageMap = /* @__PURE__ */ new Map();
-	/** Maps a chunk name to the entry contents it was last bundled from, to tell a stale chunk from an up to date one. */
-	const chunkContents = /* @__PURE__ */ new Map();
-	const JS_EXTENSIONS = /* @__PURE__ */ new Set([
-		".js",
-		".mjs",
-		".cjs",
-		".jsx",
-		".ts",
-		".mts",
-		".cts",
-		".tsx"
-	]);
+	/** Output file → entry it was last built from. */
+	const builtEntries = /* @__PURE__ */ new Map();
+	/** Every package import found so far. */
+	const allReferences = [];
+	/** Warnings already printed. */
+	const reported = /* @__PURE__ */ new Set();
 	const printFormattedError = PrintFormattedError.create({ function: bundlePackagesPlugin });
+	let index;
 	return {
 		name: "bundle-packages",
+		async setup() {
+			index = await VendorIndex.create(this.root, this.production);
+		},
 		resolveSource(source, filePath) {
 			if (!isValidRelativePath(source)) return;
 			const [link] = splitHtmlLink(source);
 			const target = join(dirname(filePath), link);
-			if (isNodeModulesPath(target, this.root) && packageDirectory(target) !== packageDirectory(filePath)) return {
+			if (isNodeModulesPath(target) && packageDirectory(target) !== packageDirectory(filePath)) return {
 				source,
 				dependencyID: void 0
 			};
 			const resolveResult = this.resolver.resolve(source, filePath);
 			if (!resolveResult) return;
 			if (!isAbsolute(resolveResult.path)) return;
-			if (!resolveResult.isPackage) return;
-			if (!JS_EXTENSIONS.has(extname(resolveResult.path))) return;
+			if (!resolveResult.isPackage || !JS_EXTENSIONS.has(extname(resolveResult.path))) return;
 			if (!resolveResult.path.startsWith(this.root)) this.log.warn(`Resolved package "${resolveResult.path}" outside of the root directory.`);
 			pathPackageMap.set(resolveResult.path, source);
 			const absFileDirectory = join(this.root, dirname(filePath));
@@ -800,272 +2086,49 @@ function bundlePackagesPlugin(options = {}) {
 			};
 		},
 		async postTransform() {
-			const root = this.root;
-			for (const inputMetadata of this.metadataList) {
-				for (const { metadata } of filterScriptMetadata(inputMetadata)) {
-					const sources = collectSpecifiersFromAst(metadata.ast);
-					for (const sourceReference of sources) {
-						const source = sourceReference.source;
-						const sourceRootRelative = join(dirname(metadata.filePath), source);
-						if (!isNodeModulesPath(sourceRootRelative, root)) continue;
-						const packageName = pathPackageMap.get(join(root, sourceRootRelative));
-						if (!packageName) {
-							printFormattedError(`Could not resolve package name for path "${sourceRootRelative}"\nimported from "${metadata.filePath}").\nSkipping specifier collection for this import.`);
-							continue;
-						}
-						const chunkName = getChunkName(packageName, chunks);
-						const packageOutputPath = calcPackageOutPath(chunkName ?? packageName, packagesOutputDirection);
-						sourceReference.source = relative(dirname(metadata.filePath), packageOutputPath);
-						const existingSpecifiers = specifiersByPackage.get(packageName) ?? [];
-						specifiersByPackage.set(packageName, existingSpecifiers);
-						const specifiers = sourceReference.specifiers;
-						if (chunkName) {
-							const normalizedPackageName = normalizePackageName(packageName);
-							for (const specifier of specifiers) {
-								if (specifier.type === "default") {
-									specifier.setDefaultName(normalizedPackageName);
-									specifier.newDefaultName = normalizedPackageName;
-								}
-								existingSpecifiers.push(specifier);
-							}
-							continue;
-						}
-						existingSpecifiers.push(...specifiers);
-					}
-				}
-				if (isHtmlMetadata(inputMetadata)) {
-					const scriptTags = inputMetadata.ast.querySelectorAll("script[src]");
-					for (const scriptTag of scriptTags) {
-						const source = scriptTag.getAttribute("src");
-						if (!source) continue;
-						const scriptType = scriptTag.getAttribute("type");
-						if (!isScriptType(scriptType)) continue;
-						const sourceRootRelative = join(dirname(inputMetadata.filePath), source);
-						if (!isNodeModulesPath(sourceRootRelative, root)) continue;
-						const packageName = pathPackageMap.get(join(root, sourceRootRelative));
-						if (!packageName) {
-							printFormattedError(`Could not resolve package name for script src "${source}" (in "${inputMetadata.filePath}"). The script tag will not be included in the bundled packages.`);
-							continue;
-						}
-						const packageOutputPath = calcPackageOutPath(packageName, packagesOutputDirection);
-						const newSource = relative(dirname(inputMetadata.filePath), packageOutputPath);
-						scriptTag.setAttribute("src", newSource);
-						const existingSpecifiers = specifiersByPackage.get(packageName) ?? [];
-						existingSpecifiers.push({ type: "side-effect" });
-						specifiersByPackage.set(packageName, existingSpecifiers);
-					}
-					const styleLinks = inputMetadata.ast.querySelectorAll("link[rel=\"stylesheet\"], link[rel=\"preload\"][as=\"style\"]");
-					for (const styleLink of styleLinks) {
-						const source = styleLink.getAttribute("href");
-						if (!source) continue;
-						const sourceRootRelative = join(dirname(inputMetadata.filePath), source);
-						if (!isNodeModulesPath(sourceRootRelative, root)) continue;
-						const assetOutputPath = calcPackageAssetOutPath(sourceRootRelative, packagesOutputDirection);
-						const assetPath = join(root, sourceRootRelative);
-						const asset = this.metadataList.find((metadata) => join(root, metadata.id) === assetPath);
-						if (asset && asset.filePath !== assetOutputPath) {
-							await this.rebase(asset, join(root, assetOutputPath));
-							asset.filePath = assetOutputPath;
-						}
-						styleLink.setAttribute("href", relative(dirname(inputMetadata.filePath), assetOutputPath));
-					}
-				}
-			}
-			/**
-			* Tracks packages that need to be re-bundled. During bundling, we might detect that a package imports another package whose
-			* specifiers we have already collected. This means we need to recollect the specifiers from the discovered package and
-			* re-bundle the current package.
-			*/
-			const pendingReBundles = [];
-			for (const [chunkName, packages] of Object.entries(chunks)) {
-				if (packages.length === 0) continue;
-				let contents = "";
-				for (const [packageName, specifiers] of specifiersByPackage) {
-					if (specifiers.length === 0) continue;
-					if (!matchesPackage(packageName, packages)) continue;
-					contents += generateStdinString(specifiers, packageName);
-				}
-				if (!contents) continue;
-				const bundledChunk = this.findMetadata({
-					type: METADATA_TYPES.Package,
-					id: chunkName
-				});
-				if (bundledChunk && chunkContents.get(chunkName) === contents) continue;
-				const packageOutputPath = calcPackageOutPath(chunkName, packagesOutputDirection);
-				const packageMetadata = isPackageMetadata(bundledChunk) ? bundledChunk : {
-					type: METADATA_TYPES.Package,
-					packageName: chunkName,
-					code: "",
-					filePath: packageOutputPath,
-					id: chunkName,
-					directDependencies: /* @__PURE__ */ new Set()
-				};
-				packageMetadata.directDependencies.clear();
-				const [bundledCode, bundleError] = await bundlePackage({
-					contents,
-					resolveDir: this.root,
-					outfile: packageOutputPath,
-					packageName: chunkName,
-					minify: this.production,
-					production: this.production,
-					treeShaking: this.production,
-					onPackageResolve: (importedPackageName) => {
-						const packageChunkName = getChunkName(importedPackageName, chunks);
-						if (packageChunkName === chunkName) {
-							const customPath = getCustomPackagePath(this.root, importedPackageName, this.production, resolvePackage);
-							if (customPath) return {
-								path: customPath,
-								external: false
-							};
-							return;
-						}
-						const dependencyOutputPath = calcPackageOutPath(packageChunkName ?? importedPackageName, packagesOutputDirection);
-						packageMetadata.directDependencies.add(dependencyOutputPath);
-						pendingReBundles.push({
-							dependencyName: importedPackageName,
-							dependencyOutputPath,
-							importerName: chunkName,
-							importerOutputPath: packageOutputPath
-						});
-						if (!specifiersByPackage.has(importedPackageName)) specifiersByPackage.set(importedPackageName, [{ type: "unknown" }]);
-						return {
-							path: relative(dirname(packageOutputPath), dependencyOutputPath),
-							external: true
-						};
-					}
-				});
-				if (bundleError) {
-					printFormattedError(`Failed to bundle package "${chunkName}"`, bundleError);
-					continue;
-				}
-				packageMetadata.code = bundledCode;
-				chunkContents.set(chunkName, contents);
-				if (!bundledChunk) this.addMetadata(packageMetadata);
-			}
-			for (const [packageName, specifiers] of specifiersByPackage) {
-				if (specifiers.length === 0) continue;
-				if (this.findMetadata({
-					type: METADATA_TYPES.Package,
-					id: packageName
-				})) continue;
-				if (getChunkName(packageName, chunks)) continue;
-				const packageOutputPath = calcPackageOutPath(packageName, packagesOutputDirection);
-				const packageMetadata = {
-					type: METADATA_TYPES.Package,
-					packageName,
-					code: "",
-					filePath: packageOutputPath,
-					id: packageName,
-					directDependencies: /* @__PURE__ */ new Set()
-				};
-				let isLoadAsIs = !this.production;
-				for (const [index, specifier] of Array.from(specifiers).entries()) {
-					if (specifier.type !== "unknown") continue;
-					isLoadAsIs = true;
-					specifiers.splice(index, 1);
-				}
-				const contents = isLoadAsIs ? void 0 : generateStdinString(specifiers, packageName);
-				const [bundledCode, bundleError] = await bundlePackage({
-					contents,
-					entryPoint: isLoadAsIs ? packageName : void 0,
-					resolveDir: this.root,
-					outfile: packageOutputPath,
-					packageName,
-					minify: this.production,
-					production: this.production,
-					treeShaking: this.production,
-					onPackageResolve: (importedPackageName) => {
-						const packageOrChunkName = getChunkName(importedPackageName, chunks) ?? importedPackageName;
-						const dependencyOutputPath = calcPackageOutPath(packageOrChunkName, packagesOutputDirection);
-						packageMetadata.directDependencies.add(dependencyOutputPath);
-						pendingReBundles.push({
-							dependencyName: importedPackageName,
-							dependencyOutputPath,
-							importerName: packageName,
-							importerOutputPath: packageOutputPath
-						});
-						if (!specifiersByPackage.has(importedPackageName)) specifiersByPackage.set(importedPackageName, [{ type: "unknown" }]);
-						return {
-							path: relative(dirname(packageOutputPath), dependencyOutputPath),
-							external: true
-						};
-					}
-				});
-				if (bundleError) {
-					printFormattedError(`Failed to bundle package "${packageName}"`, bundleError);
-					continue;
-				}
-				packageMetadata.code = bundledCode;
-				this.addMetadata(packageMetadata);
-			}
-			if (!this.production) return;
-			for (const { dependencyOutputPath, dependencyName, importerName, importerOutputPath } of pendingReBundles) {
-				const packageToBundle = this.metadataList.find((m) => m.filePath === dependencyOutputPath);
-				if (!isPackageMetadata(packageToBundle)) {
-					printFormattedError(`Re-bundle failed: could not find bundled asset for "${dependencyOutputPath}".`, `The package "${dependencyName}" is not bundled.`);
-					continue;
-				}
-				const importerBundle = this.metadataList.find((m) => m.filePath === importerOutputPath);
-				if (!isPackageMetadata(importerBundle)) {
-					printFormattedError(`Re-bundle failed: could not find bundled asset for "${importerOutputPath}".`, `The package "${importerName}" is not bundled.`);
-					continue;
-				}
-				const importerScript = await this.load(importerBundle.filePath, {
-					code: importerBundle.code,
-					type: "js"
-				});
-				if (!isScriptMetadata(importerScript)) {
-					printFormattedError(`Re-bundle failed: could not parse asset "${importerOutputPath}" as a script.`, `The package "${importerName}" may be missing specifiers.`);
-					continue;
-				}
-				const sources = collectSpecifiersFromAst(importerScript.ast);
-				const collectedSpecifiers = [];
-				for (const sourceReference of sources) {
-					const source = sourceReference.source;
-					if (join(dirname(importerScript.filePath), source) === dependencyOutputPath) {
-						const specifiers = sourceReference.specifiers;
-						collectedSpecifiers.push(...specifiers);
-					}
-				}
-				if (collectedSpecifiers.length === 0) {
-					printFormattedError(`Re-bundle failed: could not find an import of "${dependencyOutputPath}" inside "${importerOutputPath}".`, `\nThe dependency "${dependencyName}" may be missing specifiers.`);
-					continue;
-				}
-				if (collectedSpecifiers.some((specifier) => specifier.type === "unknown")) {
-					this.log.warn(`Cannot tree-shake the package "${dependencyName}" correctly. The package "${importerName}" has dynamic imports with unresolved specifiers.`);
-					continue;
-				}
-				const allSpecifiers = specifiersByPackage.get(dependencyName) ?? [];
-				const newSpecifiers = diffSpecifiers(allSpecifiers, collectedSpecifiers);
-				if (newSpecifiers.length === 0) continue;
-				allSpecifiers.push(...newSpecifiers);
-				specifiersByPackage.set(dependencyName, allSpecifiers);
-				packageToBundle.directDependencies.clear();
-				const contents = generateStdinString(allSpecifiers, dependencyName);
-				const [reBundledCode, reBundleError] = await bundlePackage({
-					contents,
-					resolveDir: this.root,
-					outfile: dependencyOutputPath,
-					packageName: dependencyName,
-					production: this.production,
-					minify: true,
-					treeShaking: true,
-					onPackageResolve: (importedPackageName) => {
-						const packageOrChunkName = getChunkName(importedPackageName, chunks) ?? importedPackageName;
-						const dependencyOutputPath = calcPackageOutPath(packageOrChunkName, packagesOutputDirection);
-						packageToBundle.directDependencies.add(dependencyOutputPath);
-						return {
-							path: relative(dirname(packageToBundle.filePath), dependencyOutputPath),
-							external: true
-						};
-					}
-				});
-				if (reBundleError) {
-					printFormattedError(`Failed to re-bundle package "${dependencyName}"`, reBundleError);
-					continue;
-				}
-				packageToBundle.code = reBundledCode;
-			}
+			if (!index) return;
+			const collectContext = {
+				root: this.root,
+				pathPackageMap,
+				specifiersByPackage,
+				reportUntraced: printFormattedError
+			};
+			const references = await collectReferences.call(this, collectContext, packagesDirectory);
+			allReferences.push(...references);
+			if (specifiersByPackage.size === 0) return;
+			const neededByPackage = /* @__PURE__ */ new Map();
+			const seeds = /* @__PURE__ */ new Map();
+			for (const [specifier, specifiers] of specifiersByPackage) {
+				const needed = neededExports(specifiers);
+				neededByPackage.set(specifier, needed);
+				seeds.set(specifier, needed.names);
+			}
+			const { units, discovered, plan, groups } = planLayout(seeds, chunks, index);
+			const unitOf = unitsBySpecifier(units);
+			const warn = (message) => {
+				if (reported.has(message)) return;
+				reported.add(message);
+				this.log.warn(message);
+			};
+			const fail = (message) => {
+				if (reported.has(message)) return;
+				reported.add(message);
+				printFormattedError(message);
+			};
+			reportLayoutProblems(units, groups, fail);
+			reportChunkPlan(plan, warn);
+			reportVersionConflicts(this.root, units, discovered, index, warn);
+			pointReferencesAtUnits(allReferences, units, unitOf, packagesDirectory);
+			const buildContext = {
+				packagesDirectory,
+				unitOf,
+				neededByPackage,
+				onNameClash: (clash) => warn(nameClashMessage(clash)),
+				resolvePackage,
+				index,
+				builtEntries
+			};
+			for (const unit of units.values()) await buildUnit.call(this, unit, buildContext, printFormattedError);
 		}
 	};
 }
@@ -4169,25 +5232,28 @@ var StyleBundler = class {
 	* Bundles `metadata.ast` in place.
 	*
 	* @param bundleAbsolutePath Where the bundle ends up, which imported `url()` references are rebased onto.
+	* @param isExternal Marks a resolved import path as external: the `@import` is kept instead of inlined, at any depth.
 	*/
-	async bundle(metadata, bundleAbsolutePath) {
-		return await new BundleRun(this.#app, this.#loaded, bundleAbsolutePath).bundle(metadata);
+	async bundle(metadata, bundleAbsolutePath, isExternal) {
+		return await new BundleRun(this.#app, this.#loaded, bundleAbsolutePath, isExternal).bundle(metadata);
 	}
 };
 var BundleRun = class {
 	#app;
 	#loaded;
 	#bundleAbsolutePath;
+	#isExternal;
 	#entries = [];
 	#occurrences = [];
 	#diagnostics = [];
 	#reportedNodes = /* @__PURE__ */ new Set();
 	#charsetParams;
 	#hasKeptImports = false;
-	constructor(app, loaded, bundleAbsolutePath) {
+	constructor(app, loaded, bundleAbsolutePath, isExternal) {
 		this.#app = app;
 		this.#loaded = loaded;
 		this.#bundleAbsolutePath = bundleAbsolutePath;
+		this.#isExternal = isExternal;
 	}
 	async bundle(metadata) {
 		const absolutePath = join(this.#app.root, metadata.filePath);
@@ -4308,6 +5374,7 @@ var BundleRun = class {
 			this.#error(node, filePath, `Failed to resolve "${prelude.url}"`);
 			return keep;
 		}
+		if (this.#isExternal?.(absolutePath)) return keep;
 		if (ancestors.has(absolutePath)) return { action: "drop" };
 		const metadata = await this.#load(absolutePath);
 		if (!metadata) {
@@ -4472,95 +5539,183 @@ function keptImportPrelude(text, prelude, chain) {
 //#endregion
 //#region src/plugins/html-bundle-style/html-bundle-style-plugin.ts
 /**
-* Inlines the "@import" tree of a stylesheet, so the tag ends up self-contained. Opt-in per tag through the "bundle" attribute
-* (configurable via HtmlBundleStyleOptions) on a "<link rel=stylesheet>" or a "<style>" tag.
+* Inlines the "@import" tree of a stylesheet, so the tag ends up self-contained. Opt-in per tag through the "bundle" attribute on
+* a "<link rel=stylesheet>", a "<link rel=preload as=style>" or a "<style>" tag.
+*
+* Attributes (names configurable via HtmlBundleStyleOptions):
+*
+* - "bundle": bundle this tag.
+* - "bundle-out": output path for a link tag, resolved from the output directory, not from the HTML file.
+* - "bundle-externals" / "bundle-externals-exclude": semicolon-separated globs, override the plugin defaults for this tag.
 *
-* Bundling happens in place: a "<style>" tag gets the resolved CSS as its content, and a linked file is rewritten with its
-* imports inlined while "href" stays as it is.
+* A "<link>" is bundled to "{filename}.bundle.css" next to the original (or to "bundle-out") and "href" is rewritten to it; the
+* source file is never touched. A "<style>" tag gets the resolved CSS as its content, in place.
 *
 * Notes:
 *
-* - Production only. In development nothing runs and the "bundle" attribute is left on the tag.
-* - "<link rel=preload as=style>" is always bundled, with or without the attribute, since a preloaded stylesheet has to carry
-*   everything it needs.
-* - A linked stylesheet is bundled once even when several pages link to it; they share the same file.
+* - Bundling only runs in production; in dev the attributes are just stripped. They never reach the output either way.
+* - If the target output path is already bundled, the work is skipped and "href" is simply pointed at it.
 * - Imports resolve the way every other source does: relative paths, path aliases and packages, through the build's resolver.
 * - Imported files are pulled from the build (so transforms other plugins made are included) and only read from disk when they are
-*   not part of it. They stay in the output as separate files, now unreferenced. Their "url()" references are rebased onto the
-*   bundle's location.
+*   not part of it. They stay in the output as separate files. Their "url()" references are rebased onto the bundle's location.
+* - An import matching the externals globs is kept as an "@import" (hoisted, conditions folded in, path rebased) and the file it
+*   points at stays in the output.
 * - Conditions ("layer", "supports()", media) wrap the imported rules, a file imported twice under the same conditions is kept
 *   where it was imported last, as in a browser, and imports from other origins are hoisted to the top.
+* - Combining with html-inline-style: register this plugin first, so a tag carrying both attributes bundles first and the inlined
+*   content is the bundle.
 */
 function htmlBundleStylePlugin(options = {}) {
+	const defaultExternals = options.externals ?? [];
+	const defaultExternalsExclude = options.externalsExclude ?? [];
 	const bundleAttribute = options.bundleAttribute ?? "bundle";
-	const query = `link[rel="stylesheet"][${bundleAttribute}], link[rel="preload"][as="style"], style[${bundleAttribute}]`;
-	const alreadyBundledIds = /* @__PURE__ */ new Set();
+	const bundleOutAttribute = options.bundleOutAttribute ?? "bundle-out";
+	const externalsAttribute = options.externalsAttribute ?? "bundle-externals";
+	const externalsExcludeAttribute = options.externalsExcludeAttribute ?? "bundle-externals-exclude";
+	const query = `link[rel="stylesheet"][${bundleAttribute}], link[rel="preload"][as="style"][${bundleAttribute}], style[${bundleAttribute}]`;
+	/** Bundled `<style bundle>` tags by content, rebase target and externals, so a tag repeated through a layout is built once. */
+	const bundledStyleTags = /* @__PURE__ */ new Map();
+	const printFmtError = PrintFormattedError.create({ function: htmlBundleStylePlugin });
+	const report = (diagnostics) => {
+		for (const { level, message, node, filePath } of diagnostics) printFmtError(message, {
+			node,
+			filePath,
+			level
+		});
+	};
 	let bundler;
 	return {
 		name: "html-bundle-style",
-		setup() {
+		preTransform() {
+			bundledStyleTags.clear();
 			bundler = new StyleBundler(this);
 		},
 		async transform(metadata) {
-			if (!this.production) return;
 			if (!isHtmlMetadata(metadata)) return;
+			const filePath = metadata.filePath;
 			const elements = metadata.ast.querySelectorAll(query);
 			for (const node of elements) {
+				const bundleOutValue = node.getAttribute(bundleOutAttribute);
+				const bundleOut = bundleOutValue ? normalize(bundleOutValue.replace(/^\/+/, "")) : null;
+				const externalsAttributeValue = node.getAttribute(externalsAttribute);
+				const externalsExcludeAttributeValue = node.getAttribute(externalsExcludeAttribute);
 				node.removeAttribute(bundleAttribute);
-				const isLinkTag = node.tagName.toLowerCase() === "link";
-				const styleMetadata = (() => {
-					if (isLinkTag) {
-						const href = node.getAttribute("href");
-						if (!href) return;
-						const [link] = splitHtmlLink(href);
-						const source = join(dirname(metadata.filePath), link);
-						const getStyleMetadata = this.findMetadata({ filePath: source });
-						if (!isStyleMetadata(getStyleMetadata)) return;
-						return getStyleMetadata;
+				node.removeAttribute(bundleOutAttribute);
+				node.removeAttribute(externalsAttribute);
+				node.removeAttribute(externalsExcludeAttribute);
+				if (!this.production) continue;
+				const externals = parsePatterns(externalsAttributeValue) ?? defaultExternals;
+				const externalsIgnore = parsePatterns(externalsExcludeAttributeValue) ?? defaultExternalsExclude;
+				const isExternal = externals.length === 0 ? void 0 : (absolutePath) => isPathMatch(absolutePath, {
+					include: externals,
+					ignore: externalsIgnore,
+					root: this.root
+				});
+				if (node.tagName.toLowerCase() === "link") {
+					const href = node.getAttribute("href");
+					if (!href) {
+						printFmtError("The link tag does not have an \"href\" attribute", {
+							node,
+							filePath
+						});
+						continue;
 					}
-					const metadataID = node.getAttribute(CUSTOM_ATTRIBUTES.MetadataID);
-					if (!metadataID) return;
-					return metadata.stylesMetadataList.get(metadataID);
-				})();
-				if (!styleMetadata) {
-					printFmtError(`Could not find style metadata.`, {
-						function: htmlBundleStylePlugin,
+					const [link, suffix] = splitHtmlLink(href);
+					const sourcePath = join(dirname(filePath), link);
+					const outfile = bundleOut ?? replaceExtension(sourcePath, ".bundle.css");
+					if (this.findMetadata({ filePath: outfile })) {
+						this.log.debug(`The stylesheet "${sourcePath}" is already bundled in "${outfile}", skipping...`);
+						node.setAttribute("href", relative(dirname(filePath), outfile) + suffix);
+						continue;
+					}
+					const sourceMetadata = this.findMetadata({ filePath: sourcePath });
+					if (!isStyleMetadata(sourceMetadata)) {
+						printFmtError(`Could not find style metadata for "${href}".`, {
+							node,
+							filePath
+						});
+						continue;
+					}
+					const bundleAbsolutePath = join(this.root, outfile);
+					const clone = this.clone(sourceMetadata);
+					await this.rebase(clone, bundleAbsolutePath);
+					report(await bundler.bundle(clone, bundleAbsolutePath, isExternal));
+					const bundledMetadata = await this.load(outfile, {
+						code: await this.stringify(clone),
+						type: "css"
+					});
+					if (!isStyleMetadata(bundledMetadata)) {
+						printFmtError("Failed to load the bundled stylesheet", {
+							node,
+							filePath
+						});
+						continue;
+					}
+					this.addMetadata(bundledMetadata);
+					node.setAttribute("href", relative(dirname(filePath), outfile) + suffix);
+					continue;
+				}
+				const metadataID = node.getAttribute(CUSTOM_ATTRIBUTES.MetadataID);
+				const styleMetadata = metadataID ? metadata.stylesMetadataList.get(metadataID) : void 0;
+				if (!metadataID || !styleMetadata) {
+					printFmtError("Could not find style metadata.", {
 						node,
-						filePath: metadata.id
+						filePath
 					});
 					continue;
 				}
-				if (isLinkTag) {
-					if (alreadyBundledIds.has(styleMetadata.id)) continue;
-					alreadyBundledIds.add(styleMetadata.id);
-				}
-				const bundleAbsolutePath = join(this.root, isLinkTag ? styleMetadata.filePath : metadata.filePath);
-				const diagnostics = await bundler.bundle(styleMetadata, bundleAbsolutePath);
-				for (const { level, message, node: importNode, filePath } of diagnostics) printFmtError(message, {
-					function: htmlBundleStylePlugin,
-					node: importNode,
-					filePath,
-					level
-				});
+				const cacheKey = [
+					metadataID,
+					dirname(filePath),
+					externals.join(";"),
+					externalsIgnore.join(";")
+				].join("\0");
+				const cached = bundledStyleTags.get(cacheKey);
+				if (cached) {
+					metadata.stylesMetadataList.set(metadataID, this.clone(cached));
+					continue;
+				}
+				report(await bundler.bundle(styleMetadata, join(this.root, filePath), isExternal));
+				bundledStyleTags.set(cacheKey, styleMetadata);
 			}
 		},
 		lspHtmlData() {
-			const description = `Adds the \`${bundleAttribute}\` attribute, which inlines the stylesheet's \`@import\` tree at build time.`;
-			const attributes = [{
+			const description = `Adds the \`${bundleAttribute}\` attribute and its options, which inline the stylesheet's \`@import\` tree at build time.`;
+			const bundle = {
 				name: bundleAttribute,
 				description: "Enable style bundling.",
 				valueSet: "v"
-			}];
+			};
+			const externals = {
+				name: externalsAttribute,
+				description: `Glob patterns for imports to keep as external \`@import\`s instead of inlining them, matched against the resolved import path. (semicolon-separated)\n\nDefaults to "${defaultExternals.join(";")}".`
+			};
+			const externalsExclude = {
+				name: externalsExcludeAttribute,
+				description: `Glob patterns that exempt imports from being treated as external, even if they match \`${externalsAttribute}\`. (semicolon-separated)\n\nDefaults to "${defaultExternalsExclude.join(";")}".`
+			};
 			return {
 				version: 1.1,
 				tags: [{
 					name: "link",
 					description,
-					attributes
+					attributes: [
+						bundle,
+						{
+							name: bundleOutAttribute,
+							description: "Specify the output path for the bundled stylesheet relative to the output directory, regardless of the HTML file's location.\nDefaults to `{filename}.bundle.css` next to the original file."
+						},
+						externals,
+						externalsExclude
+					]
 				}, {
 					name: "style",
 					description,
-					attributes
+					attributes: [
+						bundle,
+						externals,
+						externalsExclude
+					]
 				}]
 			};
 		}
@@ -4913,6 +6068,8 @@ async function loadScriptMetadata(source, filePath) {
 * - A local file has to be part of the build already, otherwise its metadata is not found and nothing is inlined.
 * - The inlined copy is rebased onto the HTML file, so relative "url()" and "@import" paths keep resolving, and the original file
 *   stays in the output unless something removes it.
+* - Combining with html-bundle-style: register that plugin first, so a link carrying both attributes is bundled before it is
+*   inlined and the inlined content is the bundle.
 */
 function htmlInlineStylePlugin(options = {}) {
 	const inlineAttribute = options.inlineAttribute ?? "inline";
@@ -6307,7 +7464,7 @@ function isSelfReference(sourceAbsolute, filePathAbsolute) {
 function calculatePagePath(originalPath, pagesDirectory) {
 	if (extname(originalPath) === ".md") originalPath = replaceExtension(originalPath, ".html");
 	if (!isSubpath(pagesDirectory, dirname(originalPath))) return normalize(originalPath);
-	const fileName = parse$2(originalPath).name;
+	const fileName = parse$5(originalPath).name;
 	const extension = extname(originalPath);
 	let newPath = cutLeadingSubpath(originalPath, pagesDirectory);
 	if (extension && fileName !== "index") newPath = join(dirname(newPath), fileName, "index" + extension);
@@ -7327,7 +8484,7 @@ function coreMarkdownPlugin(options = {}) {
 			const frontmatter = {};
 			const firstNode = root.children[0];
 			if (firstNode?.type === "yaml") {
-				const parsed = parse$1(firstNode.value) ?? {};
+				const parsed = parse$4(firstNode.value) ?? {};
 				Object.assign(frontmatter, parsed);
 			}
 			return [{