@fastkit/plugboy 1.3.0 → 1.4.1

package/README.md

@@ -191,9 +191,67 @@ value is shallow-merged over the project one, so it only needs to restate the
 keys it changes.
 
 Plugins may seed defaults here during workspace setup — the vanilla-extract
-plugin, for instance, owns `splitting` and `fileName` because its CSS merge
-depends on them. A configured value always wins over a plugin default, so check
-the plugin's documentation before overriding a key it manages.
+plugin, for instance, owns `splitting` and `fileName` so the emitted file matches
+the CSS export plugboy declares. A configured value always wins over a plugin
+default, so check the plugin's documentation before overriding a key it manages.
+
+#### CSS Optimization
+
+`optimizeCSS` applies plugboy's own postcss pass on top of whatever tsdown
+produced: duplicate `@layer` / `@media` blocks are merged, and the selectors
+listed in `combineRules` are combined into a single rule. Pass `false` to disable
+it.
+
+```typescript
+export default defineWorkspaceConfig({
+  optimizeCSS: {
+    combineRules: {
+      rules: [':root']
+    }
+  }
+});
+```
+
+It runs in `writeBundle`, on the stylesheets on disk, so it covers **every**
+stylesheet the build writes — including the ones tsdown's own CSS pipeline emits,
+which it does after every plugin has had its say.
+
+#### Preserved at the top of a stylesheet
+
+Two things tsdown's CSS pipeline would rewrite are restored afterwards, in this
+order, above every rule:
+
+1. **The authored `@layer` order.** lightningcss prunes a name from an
+   `@layer a, b, c;` statement once a block for it appears in the same
+   stylesheet. For a library that is wrong whenever the statement also orders
+   layers owned by *other* packages — the pruned layer's position then depends on
+   where its block happens to land relative to those. plugboy reads the statements
+   before the transform and re-emits them verbatim.
+2. **External `@import`s.** A bare package specifier (e.g.
+   `@import url('material-symbols/rounded.css') layer(...)`) stays external
+   instead of being inlined, so the consumer's bundler resolves it and the
+   imported package's own relative asset URLs keep working.
+
+Both are captured from every stylesheet in the module graph, whether its contents
+were authored or generated by a plugin — vanilla-extract emits its `@layer`
+statements into a virtual module, and those are covered too.
+
+#### One stylesheet per CSS entry
+
+Every entry with `css: true` gets a `./<entry>.css` export, and each of those files
+is guaranteed to exist and to be usable on its own.
+
+With several such entries the build emits one stylesheet per output *chunk*
+(`css.splitting`), which does not line up: CSS reached from more than one entry is
+moved into a shared chunk and emitted under a hashed name that no export points at,
+and an entry whose CSS comes only from there gets no stylesheet at all. plugboy
+rebuilds each entry's stylesheet from its own CSS plus the CSS of every chunk it
+imports, dependencies first, and drops the leftover per-chunk files. Shared CSS is
+duplicated into each entry that needs it, which is what makes a single
+`./<entry>.css` import complete.
+
+This is skipped when `css.inject` is on, since the JavaScript then imports the
+per-chunk stylesheets by name.
 
 ### defineProjectConfig
 

package/dist/cli.mjs

@@ -1,7 +1,7 @@
-import { i as getWorkspace, t as generateWorkspace } from "./workspace-CciZggrg.mjs";
+import { i as getWorkspace, t as generateWorkspace } from "./workspace-CniX_JDc.mjs";
 import { cac } from "cac";
 //#region package.json
-var version = "1.3.0";
+var version = "1.4.1";
 //#endregion
 //#region src/cli.ts
 async function main() {

package/dist/plugboy.mjs

@@ -1,2 +1,2 @@
-import { $ as resolveOptimizeCSSOptions, A as resolveRawExposeEntriesSettings, B as resolveBundledConfigOutputFile, C as findProjectPlugin, D as loadProjectConfig, E as isProjectPackageJson, F as getFilename, G as mergeChunkAddons, H as stripDanglingDTSSourceMaps, I as isFileNotFoundException, J as isPromise, K as mergeExternals, L as pathExists, M as findConfig, N as findFile, O as resolveUserProjectConfig, P as getDirname, Q as WORKSPACE_REQUIRED_FIELDS, R as rmrf, S as extractProjectPlugins, T as defineProjectConfig, U as exitHook, V as DANGLING_DTS_SOURCE_MAP_RE, W as collectExternalStringPrefixes, X as PROJECT_REQUIRED_FIELDS, Y as resolveListable, Z as TSDOWN_SYNC_OPTIONS, _ as loadWorkspaceConfig, a as syncWorkspacePackageFields, b as resolveUserWorkspaceConfig, c as Builder, d as getWorkspacePackageJson, et as mergeDTSSettingsList, f as Path, g as isWorkspacePackageJson, h as defineWorkspaceConfig, i as getWorkspace, it as createHooksDefaults, j as copyDirSync, k as exposeEntries, l as findWorkspacePackages, m as resolveUserHooks, n as PlugboyWorkspace, nt as normalizeDTSPreserveTypeTarget, o as PlugboyProject, p as buildHooks, q as mergeNoExternals, r as WORKSPACE_PACKAGE_SYNC_FIELDS, rt as normalizeDTSSettings, s as getProject, t as generateWorkspace, tt as normalizeDTSPreserveTypeSettings, u as getProjectPackageJson, v as resolveRawWorkspaceEntries, w as resolveUserPluginOption, x as definePlugin, y as resolveRawWorkspaceEntry, z as writeFileAtomic } from "./workspace-CciZggrg.mjs";
+import { $ as resolveOptimizeCSSOptions, A as resolveRawExposeEntriesSettings, B as resolveBundledConfigOutputFile, C as findProjectPlugin, D as loadProjectConfig, E as isProjectPackageJson, F as getFilename, G as mergeChunkAddons, H as stripDanglingDTSSourceMaps, I as isFileNotFoundException, J as isPromise, K as mergeExternals, L as pathExists, M as findConfig, N as findFile, O as resolveUserProjectConfig, P as getDirname, Q as WORKSPACE_REQUIRED_FIELDS, R as rmrf, S as extractProjectPlugins, T as defineProjectConfig, U as exitHook, V as DANGLING_DTS_SOURCE_MAP_RE, W as collectExternalStringPrefixes, X as PROJECT_REQUIRED_FIELDS, Y as resolveListable, Z as TSDOWN_SYNC_OPTIONS, _ as loadWorkspaceConfig, a as syncWorkspacePackageFields, b as resolveUserWorkspaceConfig, c as Builder, d as getWorkspacePackageJson, et as mergeDTSSettingsList, f as Path, g as isWorkspacePackageJson, h as defineWorkspaceConfig, i as getWorkspace, it as createHooksDefaults, j as copyDirSync, k as exposeEntries, l as findWorkspacePackages, m as resolveUserHooks, n as PlugboyWorkspace, nt as normalizeDTSPreserveTypeTarget, o as PlugboyProject, p as buildHooks, q as mergeNoExternals, r as WORKSPACE_PACKAGE_SYNC_FIELDS, rt as normalizeDTSSettings, s as getProject, t as generateWorkspace, tt as normalizeDTSPreserveTypeSettings, u as getProjectPackageJson, v as resolveRawWorkspaceEntries, w as resolveUserPluginOption, x as definePlugin, y as resolveRawWorkspaceEntry, z as writeFileAtomic } from "./workspace-CniX_JDc.mjs";
 export { Builder, DANGLING_DTS_SOURCE_MAP_RE, PROJECT_REQUIRED_FIELDS, Path, PlugboyProject, PlugboyWorkspace, TSDOWN_SYNC_OPTIONS, WORKSPACE_PACKAGE_SYNC_FIELDS, WORKSPACE_REQUIRED_FIELDS, buildHooks, collectExternalStringPrefixes, copyDirSync, createHooksDefaults, definePlugin, defineProjectConfig, defineWorkspaceConfig, exitHook, exposeEntries, extractProjectPlugins, findConfig, findFile, findProjectPlugin, findWorkspacePackages, generateWorkspace, getDirname, getFilename, getProject, getProjectPackageJson, getWorkspace, getWorkspacePackageJson, isFileNotFoundException, isProjectPackageJson, isPromise, isWorkspacePackageJson, loadProjectConfig, loadWorkspaceConfig, mergeChunkAddons, mergeDTSSettingsList, mergeExternals, mergeNoExternals, normalizeDTSPreserveTypeSettings, normalizeDTSPreserveTypeTarget, normalizeDTSSettings, pathExists, resolveBundledConfigOutputFile, resolveListable, resolveOptimizeCSSOptions, resolveRawExposeEntriesSettings, resolveRawWorkspaceEntries, resolveRawWorkspaceEntry, resolveUserHooks, resolveUserPluginOption, resolveUserProjectConfig, resolveUserWorkspaceConfig, rmrf, stripDanglingDTSSourceMaps, syncWorkspacePackageFields, writeFileAtomic };

package/dist/{workspace-CciZggrg.mjs → workspace-CniX_JDc.mjs}

@@ -1057,6 +1057,38 @@ async function getProject(searchDir, allowMissing, skipLoadConfig) {
 	});
 }
 //#endregion
+//#region src/workspace/stylesheets.ts
+/** `foo.mjs` -> `foo.css`, mirroring how `@tsdown/css` names a chunk's CSS. */
+function toCssFileName(jsFileName) {
+	return jsFileName.replace(/(?:\.module)?(\.[cm]?js)$/, ".css");
+}
+/** The stylesheets a package declares: `./<entry>.css` per `css: true` entry. */
+function declaredStylesheets(workspace) {
+	return new Set(workspace.exports.filter((exp) => exp.id.endsWith(".css")).map((exp) => path.posix.basename(exp.id)));
+}
+/**
+* Every stylesheet the build has written to `dir`, as file names.
+*
+* The bundle is not the whole story: `plugboy-assemble-entry-css` writes an
+* entry's stylesheet directly to disk when the build produced none for it, so a
+* `writeBundle` stage that only walked the bundle assets would skip exactly the
+* file that needed the most work. The declared exports fill that in — they are the
+* stylesheets the package publishes, so anything present under one of those names
+* belongs in the set.
+*/
+async function listEmittedStylesheets(workspace, dir, bundle) {
+	const names = /* @__PURE__ */ new Set();
+	for (const chunk of Object.values(bundle)) if (chunk.type === "asset" && chunk.fileName.endsWith(".css")) names.add(chunk.fileName);
+	await Promise.all([...declaredStylesheets(workspace)].map(async (name) => {
+		if (names.has(name)) return;
+		try {
+			await fs$1.access(path.join(dir, name));
+			names.add(name);
+		} catch {}
+	}));
+	return [...names];
+}
+//#endregion
 //#region src/postcss/plugin.ts
 async function getPostcss(options) {
 	const { layer, media, combineRules, cssnano } = options;
@@ -1077,77 +1109,211 @@ async function getPostcss(options) {
 const SOURCE_MAPPING_URL_COMMENT_RE = /\/\*# sourceMappingURL=.+? \*\//g;
 const allLayerDefRe = /(^|\n)@layer\s+([a-zA-Z\d\-_$. ,]+);/g;
 const layerDefTrimRe = /((^|\n)@layer\s+|;)/g;
-async function optimizeCSS(asset, options) {
+async function optimizeCSS(css, fileName, options) {
 	const postcss = await getPostcss(options);
-	function prepare(css) {
+	function prepare(source) {
 		return (() => {
-			const matched = css.match(allLayerDefRe);
+			const matched = source.match(allLayerDefRe);
 			if (!matched) return "";
 			const layerNames = [];
 			matched.forEach((row) => {
 				row.replace(layerDefTrimRe, "").split(",").forEach((chunk) => layerNames.push(chunk.trim()));
 			});
 			return `@layer ${Array.from(new Set(layerNames)).join(", ")};\n`;
-		})() + css.replace(allLayerDefRe, "");
+		})() + source.replace(allLayerDefRe, "");
 	}
-	const css = prepare(asset.source.toString());
-	asset.source = (await postcss.process(css, {
-		from: asset.fileName,
-		to: asset.fileName,
+	return (await postcss.process(prepare(css), {
+		from: fileName,
+		to: fileName,
 		map: { inline: false }
 	})).css.replace(SOURCE_MAPPING_URL_COMMENT_RE, "");
 }
+/**
+* Applies {@link PlugboyWorkspace.optimizeCSSOptions} to every stylesheet the
+* build writes.
+*
+* This runs in `writeBundle`, on the files on disk, rather than on the bundle
+* assets in `generateBundle` — because not every stylesheet exists as a bundle
+* asset by then. tsdown's own CSS pipeline emits from a *post* plugin, which
+* runs after every user plugin's `generateBundle`, so CSS that tsdown produces
+* (a plain `.css` / `.scss` import, or — since the vanilla-extract plugin routes
+* its `.css.ts` through tsdown — extracted CSS) used to skip these
+* optimizations entirely, while CSS a plugin emitted itself received them. By
+* `writeBundle` every producer has finished and the whole set is on disk.
+*
+* `preserve-css-imports` re-injects external `@import`s in its own
+* `writeBundle`; it is registered after this plugin, so it always sees the
+* optimized file.
+*/
 function OptimizeCSSPlugin(workspace) {
+	const processed = /* @__PURE__ */ new Set();
 	return {
 		name: "plugboy-optimize-css",
-		async generateBundle(_options, bundle) {
+		buildStart() {
+			processed.clear();
+		},
+		async writeBundle(options, bundle) {
 			const { optimizeCSSOptions } = workspace;
 			if (!optimizeCSSOptions) return;
+			const { dir } = options;
+			if (!dir) return;
+			const stylesheets = await listEmittedStylesheets(workspace, dir, bundle);
+			await Promise.all(stylesheets.map(async (fileName) => {
+				const filePath = path.join(dir, fileName);
+				if (processed.has(filePath)) return;
+				let css;
+				try {
+					css = await fs$1.readFile(filePath, "utf8");
+				} catch {
+					return;
+				}
+				processed.add(filePath);
+				const optimized = await optimizeCSS(css, fileName, optimizeCSSOptions);
+				if (optimized !== css) await fs$1.writeFile(filePath, optimized);
+			}));
+		}
+	};
+}
+//#endregion
+//#region src/workspace/plugins/assemble-entry-css.ts
+function createAssembleEntryCssPlugin(workspace) {
+	/** Chunk file name -> its identity and static imports, as of `generateBundle`. */
+	const graph = /* @__PURE__ */ new Map();
+	return definePlugin({
+		name: "plugboy-assemble-entry-css",
+		buildStart() {
+			graph.clear();
+		},
+		generateBundle(_options, bundle) {
 			for (const chunk of Object.values(bundle)) {
-				if (chunk.type !== "asset" || !chunk.fileName.endsWith(".css")) continue;
-				await optimizeCSS(chunk, optimizeCSSOptions);
+				if (chunk.type !== "chunk") continue;
+				graph.set(chunk.fileName, {
+					name: chunk.name,
+					isEntry: chunk.isEntry,
+					imports: [...chunk.imports]
+				});
 			}
+		},
+		async writeBundle(options, bundle) {
+			const { dir } = options;
+			if (!dir) return;
+			if (workspace.cssOptions?.inject) return;
+			const targets = declaredStylesheets(workspace);
+			if (!targets.size) return;
+			const emitted = new Set(Object.values(bundle).filter((chunk) => chunk.type === "asset" && chunk.fileName.endsWith(".css")).map((chunk) => chunk.fileName));
+			if (!emitted.size) return;
+			/** The stylesheet a chunk owns, if the build emitted one. */
+			const cssOf = (fileName) => {
+				const css = toCssFileName(fileName);
+				return css !== fileName && emitted.has(css) ? css : void 0;
+			};
+			/** Stylesheets an entry needs, dependencies first, each listed once. */
+			const collect = (entryFileName) => {
+				const visited = /* @__PURE__ */ new Set();
+				const ordered = [];
+				const walk = (fileName) => {
+					if (visited.has(fileName)) return;
+					visited.add(fileName);
+					const node = graph.get(fileName);
+					if (!node) return;
+					for (const imported of node.imports) walk(imported);
+					const css = cssOf(fileName);
+					if (css && !ordered.includes(css)) ordered.push(css);
+				};
+				walk(entryFileName);
+				return ordered;
+			};
+			const folded = /* @__PURE__ */ new Set();
+			await Promise.all([...graph].map(async ([fileName, node]) => {
+				if (!node.isEntry) return;
+				const target = `${node.name}.css`;
+				if (!targets.has(target)) return;
+				const sources = collect(fileName);
+				if (!sources.length) return;
+				sources.forEach((source) => folded.add(source));
+				if (sources.length === 1 && sources[0] === target) return;
+				const css = (await Promise.all(sources.map((source) => fs$1.readFile(path.join(dir, source), "utf8").catch(() => "")))).filter(Boolean).join("\n");
+				if (!css) return;
+				await fs$1.writeFile(path.join(dir, target), css);
+				folded.add(target);
+			}));
+			await Promise.all([...folded].filter((css) => !targets.has(css)).map((css) => fs$1.rm(path.join(dir, css), { force: true })));
 		}
-	};
+	});
 }
 //#endregion
 //#region src/workspace/plugins/raw-loader.ts
-const rawLoaderPlugin = {
-	name: "raw-loader",
-	async resolveId(id, importer, options) {
-		if (!id.endsWith("?raw")) return null;
-		const rawPath = id.slice(0, -4);
-		const resolved = await this.resolve(rawPath, importer, {
-			...options,
-			skipSelf: true
-		});
-		if (!resolved) return null;
-		return `\0raw:${resolved.id}`;
-	},
-	async load(id) {
-		if (!id.startsWith("\0raw:")) return null;
-		const realPath = id.slice(5);
-		const content = await fs$1.readFile(realPath, "utf-8");
-		return `export default ${JSON.stringify(content)};`;
-	}
-};
+/**
+* Plugin that inlines the contents of a `?raw` import.
+*
+* The virtual module id is kept **relative to the workspace** and turned back
+* into a path only inside `load`. rolldown normalizes an ordinary module id
+* against the project when it prints the `//#region <id>` comment that precedes
+* each module in the output, but a virtual id — anything starting with `\0` — is
+* printed verbatim. Building the id from the resolved absolute path therefore
+* published the build machine's directory layout:
+*
+* ```js
+* //#region \0raw:/home/runner/work/acme-ui/acme-ui/packages/core/src/logo.svg
+* ```
+*
+* A workspace-relative id makes the output independent of where the build ran,
+* which also keeps two machines' `dist` diffable.
+*/
+const PREFIX = "\0raw:";
+const SUFFIX = "?raw";
+function createRawLoaderPlugin(workspace) {
+	const root = workspace.dir.value;
+	return {
+		name: "raw-loader",
+		async resolveId(id, importer, options) {
+			if (!id.endsWith(SUFFIX)) return null;
+			const rawPath = id.slice(0, -4);
+			const resolved = await this.resolve(rawPath, importer, {
+				...options,
+				skipSelf: true
+			});
+			if (!resolved) return null;
+			return `${PREFIX}${path.relative(root, resolved.id).split(path.sep).join(path.posix.sep)}`;
+		},
+		async load(id) {
+			if (!id.startsWith(PREFIX)) return null;
+			const content = await fs$1.readFile(path.resolve(root, id.slice(5)), "utf-8");
+			return `export default ${JSON.stringify(content)};`;
+		}
+	};
+}
 //#endregion
 //#region src/workspace/plugins/preserve-css-imports.ts
 /**
-* Plugin to preserve external CSS `@import` statements.
+* Plugin to preserve what tsdown's CSS pipeline would rewrite away at the top of
+* a stylesheet: external `@import` statements and the authored `@layer` order.
 *
-* rolldown / tsdown's CSS pipeline (lightningcss) resolves and inlines every
-* `@import` it can. For bare package specifiers (e.g.
+* **External `@import`s.** rolldown / tsdown's CSS pipeline (lightningcss)
+* resolves and inlines every `@import` it can. For bare package specifiers (e.g.
 * `@import url('material-symbols/rounded.css') layer(...)`) that is wrong for a
 * library build: it bloats the output and rebases the imported package's own
 * relative asset URLs (fonts) against our `dist`, breaking them. Such imports
 * should stay external so the consumer's bundler resolves them.
 *
-* We can't intercept this in a `transform` hook — by then tsdown has already
-* inlined the imports. Instead we strip them in `load` (which runs before the
-* CSS transform), remember them, and re-emit them in `writeBundle`, after every
-* other CSS producer (including vanilla-extract's merge) has written the final
-* file to disk.
+* **Layer order.** lightningcss drops a name from an `@layer a, b, c;` statement
+* when a block for it follows in the same stylesheet, since the block establishes
+* the same order. That holds for a standalone document, but not for a library
+* stylesheet whose statement also orders layers belonging to *other* packages:
+* once the name is gone, its position is decided by wherever its block happens to
+* land relative to those, and the authored order is lost. `@fastkit/vui` declares
+* `@layer vui-normalize, vui-color-scheme, …, vui;`, and losing `vui-normalize`
+* from it promoted the reset layer above the packages it is supposed to lose to.
+*
+* Both are captured from a `transform` hook declared `order: 'pre'`, which runs
+* ahead of tsdown's CSS handling even though that is registered as a *pre plugin*
+* — hook order wins over plugin order. It is the only point that sees the CSS of
+* **every** stylesheet in the graph, including a virtual one another plugin
+* supplies from `load`: vanilla-extract generates its `@layer` statements into
+* such a module, so a `load`-based capture would miss exactly the case where the
+* generated statement is the only record of the intended order. The captured
+* values are re-emitted in `writeBundle`, after every CSS producer has written
+* its final file to disk.
 */
 /**
 * Matches a single `@import` statement, capturing the quote (group 1) and the
@@ -1165,47 +1331,133 @@ function isInternalImportSpecifier(spec) {
 }
 /** Matches a top-level `@layer <names>;` statement (declaration, not a block). */
 const LAYER_STATEMENT_RE = /@layer\s+([^{};]+);[ \t]*\n?/g;
-function createPreserveCssImportsPlugin() {
+/** Stylesheet ids, with any query (`?source=…`, `?inline`) still attached. */
+const STYLE_ID_RE = /\.(?:css|scss|sass|less|styl|stylus)(?:$|\?)/;
+/** The layer names a stylesheet declares, in the order it declares them. */
+function collectLayerNames(css) {
+	const names = [];
+	for (const [, group] of css.matchAll(LAYER_STATEMENT_RE)) for (const name of group.split(",")) {
+		const trimmed = name.trim();
+		if (trimmed && !names.includes(trimmed)) names.push(trimmed);
+	}
+	return names;
+}
+/**
+* Merge several declaration orders into one that contradicts none of them.
+*
+* Concatenating them and dropping repeats does not work, because a name's first
+* appearance is rarely where its order is decided: vanilla-extract re-declares a
+* layer at the top of *every* stylesheet that puts a rule in it, so a single
+* `@layer that-one;` from some component is seen before the module that declares
+* how all the layers relate — and once the component's name is in the list, the
+* declaring module's order is silently dropped for it.
+*
+* Each sequence is therefore read as a set of "must come before" constraints and
+* the result is a topological sort of them, preferring the earliest-seen name when
+* several are free. Earlier sequences win: a constraint that would contradict one
+* already recorded is skipped, so a stylesheet's own surviving statement — whose
+* order tsdown may have rewritten — can add names without reordering anything.
+*/
+function mergeLayerOrder(sequences) {
+	const nodes = [];
+	const next = /* @__PURE__ */ new Map();
+	const add = (name) => {
+		if (next.has(name)) return;
+		nodes.push(name);
+		next.set(name, /* @__PURE__ */ new Set());
+	};
+	/** Whether `to` already has to come after `from`. */
+	const precedes = (from, to) => {
+		const seen = /* @__PURE__ */ new Set();
+		const stack = [from];
+		while (stack.length) {
+			const current = stack.pop();
+			if (current === to) return true;
+			if (seen.has(current)) continue;
+			seen.add(current);
+			stack.push(...next.get(current) ?? []);
+		}
+		return false;
+	};
+	for (const sequence of sequences) {
+		sequence.forEach(add);
+		for (let i = 0; i + 1 < sequence.length; i++) {
+			const from = sequence[i];
+			const to = sequence[i + 1];
+			if (from === to || precedes(to, from)) continue;
+			next.get(from).add(to);
+		}
+	}
+	const incoming = new Map(nodes.map((name) => [name, 0]));
+	for (const [, targets] of next) for (const target of targets) incoming.set(target, (incoming.get(target) ?? 0) + 1);
+	const remaining = new Set(nodes);
+	const merged = [];
+	while (remaining.size) {
+		const name = nodes.find((it) => remaining.has(it) && incoming.get(it) === 0) ?? nodes.find((it) => remaining.has(it));
+		remaining.delete(name);
+		merged.push(name);
+		for (const target of next.get(name) ?? []) incoming.set(target, (incoming.get(target) ?? 1) - 1);
+	}
+	return merged;
+}
+function createPreserveCssImportsPlugin(workspace) {
 	const externalImports = [];
+	const layersByModule = /* @__PURE__ */ new Map();
+	const declaredLayers = [];
 	const processed = /* @__PURE__ */ new Set();
 	return definePlugin({
 		name: "preserve-css-imports",
 		buildStart() {
 			externalImports.length = 0;
+			layersByModule.clear();
+			declaredLayers.length = 0;
 			processed.clear();
 		},
-		async load(id) {
-			const file = id.split("?")[0];
-			if (!file.endsWith(".css")) return null;
-			let code;
-			try {
-				code = await fs$1.readFile(file, "utf8");
-			} catch {
-				return null;
+		transform: {
+			order: "pre",
+			filter: { id: STYLE_ID_RE },
+			handler(code, id) {
+				const file = id.split("?")[0];
+				if (!STYLE_ID_RE.test(file)) return null;
+				const names = collectLayerNames(code);
+				if (names.length) layersByModule.set(id, names);
+				if (!file.endsWith(".css") || !code.includes("@import")) return null;
+				let changed = false;
+				const stripped = code.replace(IMPORT_RE, (statement, _quote, spec) => {
+					if (isInternalImportSpecifier(spec)) return statement;
+					changed = true;
+					const normalized = statement.trim();
+					if (!externalImports.includes(normalized)) externalImports.push(normalized);
+					return "";
+				});
+				if (!changed) return null;
+				return {
+					code: stripped,
+					map: null
+				};
 			}
-			if (!code.includes("@import")) return null;
-			let changed = false;
-			const stripped = code.replace(IMPORT_RE, (statement, _quote, spec) => {
-				if (isInternalImportSpecifier(spec)) return statement;
-				changed = true;
-				const normalized = statement.trim();
-				if (!externalImports.includes(normalized)) externalImports.push(normalized);
-				return "";
-			});
-			if (!changed) return null;
-			return {
-				code: stripped,
-				map: null
-			};
+		},
+		generateBundle(_options, bundle) {
+			if (!layersByModule.size) return;
+			const sequences = [];
+			for (const chunk of Object.values(bundle)) {
+				if (chunk.type !== "chunk") continue;
+				for (const id of chunk.moduleIds) {
+					const names = layersByModule.get(id);
+					if (names) sequences.push(names);
+				}
+			}
+			declaredLayers.length = 0;
+			declaredLayers.push(...mergeLayerOrder(sequences));
 		},
 		async writeBundle(options, bundle) {
-			if (!externalImports.length) return;
+			if (!externalImports.length && !declaredLayers.length) return;
 			const { dir } = options;
 			if (!dir) return;
-			const importBlock = `${externalImports.join("\n")}\n`;
-			await Promise.all(Object.values(bundle).map(async (chunk) => {
-				if (chunk.type !== "asset" || !chunk.fileName.endsWith(".css")) return;
-				const filePath = path.join(dir, chunk.fileName);
+			const importBlock = externalImports.length ? `${externalImports.join("\n")}\n` : "";
+			const stylesheets = await listEmittedStylesheets(workspace, dir, bundle);
+			await Promise.all(stylesheets.map(async (fileName) => {
+				const filePath = path.join(dir, fileName);
 				if (processed.has(filePath)) return;
 				let css;
 				try {
@@ -1214,14 +1466,10 @@ function createPreserveCssImportsPlugin() {
 					return;
 				}
 				processed.add(filePath);
-				const layerNames = [];
-				for (const [, names] of css.matchAll(LAYER_STATEMENT_RE)) for (const name of names.split(",")) {
-					const trimmed = name.trim();
-					if (trimmed && !layerNames.includes(trimmed)) layerNames.push(trimmed);
-				}
+				const layerNames = mergeLayerOrder([declaredLayers, collectLayerNames(css)]);
 				const body = css.replace(LAYER_STATEMENT_RE, "");
-				const layerStatement = layerNames.length ? `@layer ${layerNames.join(", ")};\n` : "";
-				await fs$1.writeFile(filePath, `${layerStatement}${importBlock}${body}`);
+				const next = `${layerNames.length ? `@layer ${layerNames.join(", ")};\n` : ""}${importBlock}${body}`;
+				if (next !== css) await fs$1.writeFile(filePath, next);
 			}));
 		}
 	});
@@ -1392,10 +1640,11 @@ var PlugboyWorkspace = class {
 			createExternalImportsPlugin(this),
 			createSuppressDtsSourcemapWarningPlugin(),
 			...plugins,
+			createAssembleEntryCssPlugin(this),
 			OptimizeCSSPlugin(this),
 			WorkspaceEnvPlugin(this),
-			rawLoaderPlugin,
-			createPreserveCssImportsPlugin()
+			createRawLoaderPlugin(this),
+			createPreserveCssImportsPlugin(this)
 		];
 		this.hooks = hooks;
 		this.dts = dts;
@@ -1717,4 +1966,4 @@ export default defineWorkspaceConfig({
 //#endregion
 export { resolveOptimizeCSSOptions as $, resolveRawExposeEntriesSettings as A, resolveBundledConfigOutputFile as B, findProjectPlugin as C, loadProjectConfig as D, isProjectPackageJson as E, getFilename as F, mergeChunkAddons as G, stripDanglingDTSSourceMaps as H, isFileNotFoundException as I, isPromise as J, mergeExternals as K, pathExists as L, findConfig as M, findFile as N, resolveUserProjectConfig as O, getDirname as P, WORKSPACE_REQUIRED_FIELDS as Q, rmrf as R, extractProjectPlugins as S, defineProjectConfig as T, exitHook as U, DANGLING_DTS_SOURCE_MAP_RE as V, collectExternalStringPrefixes as W, PROJECT_REQUIRED_FIELDS as X, resolveListable as Y, TSDOWN_SYNC_OPTIONS as Z, loadWorkspaceConfig as _, syncWorkspacePackageFields as a, resolveUserWorkspaceConfig as b, Builder as c, getWorkspacePackageJson as d, mergeDTSSettingsList as et, Path as f, isWorkspacePackageJson as g, defineWorkspaceConfig as h, getWorkspace as i, createHooksDefaults as it, copyDirSync as j, exposeEntries as k, findWorkspacePackages as l, resolveUserHooks as m, PlugboyWorkspace as n, normalizeDTSPreserveTypeTarget as nt, PlugboyProject as o, buildHooks as p, mergeNoExternals as q, WORKSPACE_PACKAGE_SYNC_FIELDS as r, normalizeDTSSettings as rt, getProject as s, generateWorkspace as t, normalizeDTSPreserveTypeSettings as tt, getProjectPackageJson as u, resolveRawWorkspaceEntries as v, resolveUserPluginOption as w, definePlugin as x, resolveRawWorkspaceEntry as y, writeFileAtomic as z };
 
-//# sourceMappingURL=workspace-CciZggrg.mjs.map
+//# sourceMappingURL=workspace-CniX_JDc.mjs.map