@menapo/vicss 0.0.0-stage → 1.1.0

package/dist/vite.js

@@ -0,0 +1,2264 @@
+import { $ as isPaletteAtom, Ct as isArbitrary, Dt as mergeIdOf, G as minLengthOf, H as createNamer, J as placeholdersIn, K as minLengthWarning, U as hasPlaceholders, Y as renameClasses, _t as VicssError, bt as compareStrings, d as printSheet, k as layerStatement, l as printAtoms, n as chainSelectors, q as placeholder, s as outerLayers, t as baseTokens, u as printBase } from "./print-B_mn7wBu.js";
+import { S as originalLines, _ as isSfc, d as FRAMEWORKS, f as SFC_SCRIPT_ID, h as extractScripts, i as poolSize, l as resolveFile, m as detectFramework, o as compile, p as configuredJsxSource, r as configShape, s as createParseCache, t as CompilePool, u as resolvesAlike, x as SourceEdits } from "./pool-F3qb30Fy.js";
+import { C as createLocator, u as baseAtoms } from "./theme-zBcr5DHi.js";
+import { C as CompileCache, D as generateTypes, E as readHash, O as createManifest, S as report, T as hashCode, _ as critical, a as ScanConflict, b as hashesJson, c as scan, d as libraryOf, f as loadLibraries, g as SheetCache, h as withLibraries, i as writeIfChanged, k as codeFrame, l as escapeRegExp, m as renameCustomProperties, n as snapshotRoot, o as estimateStyled, p as ownPackageName, r as typesFile, s as listFiles, t as snapshotFile, u as findLibraries, v as criticalPage, w as compiledOf, y as criticalSettings } from "./types-file-D6Iu4kzv.js";
+import { r as snapshotText } from "./snapshot-DAJ8FLU4.js";
+import { n as loadSystem, t as CONFIG_FILES } from "./config-loader-1kWS0cRU.js";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { gzipSync } from "node:zlib";
+import { createIdResolver, isFileLoadingAllowed, normalizePath, parseSync } from "vite";
+//#region src/core/literals.ts
+/**
+* Literal declarations (the plugin's `api.literals()`, email PLAN D4): each
+* atom with its tokens resolved to the values they stand for, for a renderer
+* that cannot read custom properties. Mail clients drop `var()` and cascade
+* layers, so `@menapo/email` inlines these instead of linking the sheet.
+*/
+const VAR = /var\((--[\w-]+)\)/g;
+const SCHEMES = /* @__PURE__ */ new Set(["dark", "light"]);
+function tokenIndex(system) {
+	const index = /* @__PURE__ */ new Map();
+	for (const table of system.tokens.values()) for (const token of table.values()) index.set(token.cssVar, token);
+	return index;
+}
+/** `value` with every token's `var()` replaced by its value in `mode` (its base value without one). */
+function resolve(value, index, mode) {
+	return value.replace(VAR, (match, name) => {
+		const token = index.get(name);
+		if (!token) return match;
+		return resolve((mode && token.modes?.[mode]) ?? token.value, index, mode);
+	});
+}
+/**
+* Every class of `atoms` and of the flattened bases in `rules`, by identity,
+* with its declarations in literal form. A flattened base is one class with
+* many declarations; an atom is one with one.
+*/
+function literalsOf(atoms, rules, system) {
+	const index = tokenIndex(system);
+	const modes = [...system.modes].filter((mode) => system.conditions.get(mode)?.scope);
+	const literal = (atom) => {
+		const value = resolve(atom.value, index);
+		const switched = {};
+		let any = false;
+		for (const mode of modes) {
+			const there = resolve(atom.value, index, mode);
+			if (there !== value) {
+				switched[mode] = there;
+				any = true;
+			}
+		}
+		const conditions = atom.chain.filter((name) => !SCHEMES.has(name));
+		return {
+			property: atom.property,
+			value,
+			tier: atom.tier,
+			chain: atom.chain,
+			rules: chainSelectors(conditions, "&", system),
+			...any && { modes: switched }
+		};
+	};
+	const out = /* @__PURE__ */ new Map();
+	for (const atom of atoms) if (!out.has(atom.className)) out.set(atom.className, [literal(atom)]);
+	for (const rule of rules) if (rule.kind === "base" && rule.atoms) out.set(rule.id, rule.atoms.map(literal));
+	return out;
+}
+const STRINGS = /(["'`])((?:\\.|(?!\1)[^\\\n])*)\1/g;
+/** The classes of `known` that string literals in `code` name (dev code writes classes as they are). */
+function classesIn(code, known) {
+	const found = /* @__PURE__ */ new Set();
+	for (const match of code.matchAll(STRINGS)) for (const word of match[2].split(/\s+/)) if (known.has(word)) found.add(word);
+	return [...found];
+}
+//#endregion
+//#region src/vite/css.ts
+/**
+* The CSS modules the plugin serves (PLAN §5.10, D13, D14) and the ids they
+* live under. None exists on disk; `load` builds each from compiled atoms
+* and rules.
+* The ids end in `.css` and sit under the root, so Vite's CSS pipeline, HMR
+* and framework CSS collection treat them as ordinary stylesheets.
+*/
+const BASE_SPECIFIER = "virtual:vicss/base.css";
+const SHEET_SPECIFIER = "virtual:vicss/sheet.css";
+const MODULE_SUFFIX = ".vicss.css";
+/** `root` is Vite's root with forward slashes. */
+function cssIds(root) {
+	return {
+		base: path.posix.join(root, "@vicss/base.css"),
+		sheet: path.posix.join(root, "@vicss/sheet.css"),
+		tokens: path.posix.join(root, "@vicss/tokens.css"),
+		libraries: path.posix.join(root, "@vicss/lib/")
+	};
+}
+function splitQuery(id) {
+	const at = id.search(/[?#]/);
+	return at === -1 ? [id, ""] : [id.slice(0, at), id.slice(at)];
+}
+/**
+* `./Button.tsx.vicss.css`: what a styled module imports in dev. A framework
+* file's script sub-module (`Card.astro?astro&type=script…`) imports its
+* file's, which holds the styles of every module of the file.
+*/
+function moduleCssSpecifier(id) {
+	return `./${path.posix.basename(splitQuery(id)[0])}${MODULE_SUFFIX}`;
+}
+const join = (...parts) => parts.filter(Boolean).join("\n");
+/**
+* Dev `base.css` (PLAN §5.10, D14): everything but the atoms. Every token,
+* so a token edit never waits for a module to use it; the layer statement
+* over every atom compiled so far; the rules of every module compiled so far
+* (themes after the root tokens, module keyframes after the config's); and
+* the config's reset, fonts, keyframes and global CSS. Its `<style>` comes
+* before any module's, and the browser orders layers by their first
+* declaration in document order, so updating it re-orders the sub-layers of
+* modules added later.
+*/
+function devBaseCss(registry, options, libraries = []) {
+	return printBase({
+		...options,
+		atoms: [
+			...registry.layerAtoms(),
+			...registry.paletteAtoms(),
+			...libraries.flatMap((library) => library.atoms)
+		],
+		rules: [...registry.rules(), ...libraries.flatMap((library) => library.rules)],
+		referenced: registry.paletteKeys(),
+		tokens: "all"
+	});
+}
+/** `virtual:vicss/lib/<n>.css`, the dev CSS of the library at index `n`. */
+const LIBRARY_SPECIFIER = "virtual:vicss/lib/";
+function librarySpecifier(index) {
+	return `${LIBRARY_SPECIFIER}${index}.css`;
+}
+/**
+* Dev CSS of one module: its atom rules and flattened recipe bases, in the
+* sub-layers `base.css` declares; its other rules print in `base.css`.
+*/
+function moduleCss(styles, system, names) {
+	return printAtoms(styles.atoms, system, styles.rules, names);
+}
+/**
+* The build's sheet and, in an SPA, its tokens file. Both depend only on the
+* scan and the config, so every environment and build order prints the same
+* bytes. Tokens are the used ones: those atoms, rules, `token()` calls,
+* `globalCss` and config keyframes read (D13). Flattened recipe bases are
+* code, like atoms: they print in the sheet, never in the tokens file.
+*/
+function buildCss(scan, options, tokensFile) {
+	const { system, layers } = options;
+	const input = {
+		...options,
+		atoms: scan.atoms,
+		rules: scan.rules,
+		tokens: "used",
+		referenced: scan.tokens
+	};
+	const tokenKeys = new Set(baseTokens(input).map((token) => `${token.scale}:${token.path}`));
+	if (!tokensFile) return {
+		sheet: printSheet(input),
+		tokens: void 0,
+		tokenKeys
+	};
+	return {
+		sheet: join(layers ? outerLayers(layers) : "", layerStatement(scan.atoms, system, scan.rules), printAtoms(scan.atoms, system, scan.rules, options.names)),
+		tokens: printBase(input),
+		tokenKeys
+	};
+}
+//#endregion
+//#region src/vite/attributes.ts
+/**
+* What every compiled component and JSX module gets for `class=` and
+* `style=` (PLAN §5.16), whether it imports vicss or not: a style it
+* receives may come from anywhere.
+*
+* - Vue's `normalizeClass` and Svelte's `clsx` read an object as a map from
+*   class to condition, so `class={card}` would write the merge ids. The
+*   compiled component's calls go through `__vxClassWith`, which passes a
+*   compiled style as its class string (runtime/style.ts), and the calls
+*   that normalise a props object's `class` (spreads, a root element's
+*   attributes) through `__vxPropsWith` and `__vxEffectWith`.
+* - In dev, a `style=` value the compiler could not write as an inline
+*   style goes through `__vxStyleCheck`, which fails on a compiled style
+*   and names the fix (runtime/dev.ts): in JSX attributes and template
+*   literals here, in Vue's, Svelte's and Astro's style setters through
+*   `__vxStyleWith`.
+*/
+const RUNTIME = "@menapo/vicss";
+/** Vue's and Svelte's class calls, and in dev the style setters of all three compilers. */
+function rewriteComponent(code, id, options) {
+	const edits = new SourceEdits(code);
+	const helpers = /* @__PURE__ */ new Set();
+	const consts = [];
+	let n = 0;
+	const src = JSON.stringify(options.src);
+	const named = /import\s*\{([^}]*)\}\s*from\s*(["'])([^"']+)\2;?/g;
+	const WRAPS = {
+		normalizeClass: (local) => `__vxClassWith(${local})`,
+		ssrRenderClass: (local) => `__vxClassWith(${local})`,
+		mergeProps: (local) => `__vxPropsWith(${local})`,
+		normalizeProps: (local) => `__vxPropsWith(${local})`,
+		ssrRenderAttrs: (local) => `__vxPropsWith(${local})`,
+		normalizeStyle: (local) => options.dev ? `__vxStyleWith(${local}, 0, ${src})` : void 0,
+		ssrRenderStyle: (local) => options.dev ? `__vxStyleWith(${local}, 0, ${src})` : void 0,
+		addAttribute: (local) => options.dev ? `__vxStyleWith(${local}, 0, ${src}, "style")` : void 0
+	};
+	const SOURCES = /^(?:vue|vue\/server-renderer|@vue\/server-renderer|astro\/(?:runtime\/server(?:\/index\.js)?|compiler-runtime))$/;
+	for (const match of code.matchAll(named)) {
+		if (!SOURCES.test(match[3])) continue;
+		const listStart = match.index + match[0].indexOf("{") + 1;
+		for (const spec of match[1].matchAll(/(\w+)(?:\s+as\s+([\w$]+))?/g)) {
+			const wrap = WRAPS[spec[1]];
+			const local = spec[2] ?? spec[1];
+			const inner = `__vxOwn${++n}`;
+			const text = wrap?.(inner);
+			if (!text) continue;
+			edits.overwrite(listStart + spec.index, listStart + spec.index + spec[0].length, `${spec[1]} as ${inner}`);
+			for (const helper of text.match(/__vx(?:ClassWith|StyleWith|PropsWith)/g)) helpers.add(helper);
+			consts.push({
+				at: match.index + match[0].length,
+				text: `const ${local} = ${text};`
+			});
+		}
+	}
+	for (const match of code.matchAll(/import\s*\*\s*as\s+([\w$]+)\s+from\s*(["'])svelte\/internal\/(client|server)\2;?/g)) {
+		const ns = match[1];
+		const calls = {
+			clsx: "__vxClassWith",
+			attribute_effect: "__vxEffectWith",
+			attributes: "__vxPropsWith",
+			set_style: options.dev ? "__vxStyleWith" : void 0,
+			attr_style: options.dev ? "__vxStyleWith" : void 0
+		};
+		for (const [name, helper] of Object.entries(calls)) {
+			if (!helper) continue;
+			const pattern = new RegExp(`(?<![\\w$.])${ns.replace(/\$/g, "\\$")}\\.${name}(?=\\s*\\()`, "g");
+			const local = `__vx_${name}`;
+			let used = false;
+			for (const call of code.matchAll(pattern)) {
+				edits.overwrite(call.index, call.index + call[0].length, local);
+				used = true;
+			}
+			if (!used) continue;
+			helpers.add(helper);
+			const at = name === "set_style" ? `, 1, ${src}` : name === "attr_style" ? `, 0, ${src}` : "";
+			consts.push({
+				at: match.index + match[0].length,
+				text: `const ${local} = ${helper}(${ns}.${name}${at});`
+			});
+		}
+	}
+	if (consts.length === 0) return null;
+	for (const { at, text } of consts) edits.insert(at, `\n${text}`);
+	edits.prepend(`import { ${[...helpers].join(", ")} } from "${RUNTIME}";\n`);
+	const file = id.replace(/[?#].*$/, "");
+	return {
+		code: edits.toString(),
+		map: edits.generateMap({
+			source: file,
+			file,
+			includeContent: true,
+			hires: true
+		})
+	};
+}
+/** Values whose type is plainly not a compiled style: no check. */
+const PLAIN = /* @__PURE__ */ new Set([
+	"ObjectExpression",
+	"Literal",
+	"TemplateLiteral",
+	"ArrowFunctionExpression",
+	"FunctionExpression"
+]);
+/**
+* Dev: `style={x}` in JSX, and `style=${x}` in a template literal, where
+* `x` is anything the compiler left: checked when it renders.
+*/
+function checkStyles(code, id, src) {
+	const file = id.replace(/[?#].*$/, "");
+	const lang = /\.([cm]?[jt]sx?)$/.exec(file)?.[1]?.replace(/^[cm]/, "");
+	let program;
+	try {
+		const parsed = parseSync(file, code, {
+			lang: lang ?? "js",
+			sourceType: "module"
+		});
+		if (parsed.errors.length > 0) return null;
+		program = parsed.program;
+	} catch {
+		return null;
+	}
+	const values = [];
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const item of node) visit(item);
+			return;
+		}
+		const current = node;
+		if (typeof current.type !== "string") return;
+		if (current.type === "JSXAttribute" && current.name.type === "JSXIdentifier" && current.name.name === "style" && current.value?.type === "JSXExpressionContainer" && current.value.expression.type !== "JSXEmptyExpression" && !PLAIN.has(current.value.expression.type)) values.push(current.value.expression);
+		else if (current.type === "TemplateLiteral") current.quasis.forEach((quasi, i) => {
+			const expression = current.expressions[i];
+			if (expression && /\sstyle="?$/.test(quasi.value.raw) && !PLAIN.has(expression.type)) values.push(expression);
+		});
+		for (const key in current) if (key !== "parent" && key !== "range") visit(current[key]);
+	};
+	visit(program);
+	if (values.length === 0) return null;
+	const edits = new SourceEdits(code, { keepLines: true });
+	const locate = createLocator(code);
+	for (const value of values) {
+		const at = JSON.stringify(`${src}:${locate(value.start).line}`);
+		edits.insert(value.start, "__vxStyleCheck(");
+		edits.insert(value.end, `, ${at})`);
+	}
+	const first = program.body.find((node) => !(node.type === "ExpressionStatement" && typeof node.directive === "string"));
+	edits.insert(first?.start ?? 0, `import { __vxStyleCheck } from "${RUNTIME}"; `);
+	return {
+		code: edits.toString(),
+		map: edits.generateMap({
+			source: file,
+			file,
+			includeContent: true,
+			hires: true
+		})
+	};
+}
+//#endregion
+//#region src/vite/html.ts
+/**
+* The SPA tokens file (PLAN D13). Tokens change on a theme-only deploy and
+* atoms do not; kept out of every chunk's `importedCss`, they rename no JS
+* file through `augmentChunkHash` (report 06 §7.1). Only HTML that Vite
+* builds can link it, so it exists only when the client build has an HTML
+* entry, and only when Vite splits CSS per chunk: with one CSS file for the
+* whole app, no JS names CSS at all.
+*/
+/** The CSS entry's name: Vite emits its CSS as `assets/vicss-tokens-[hash].css`. */
+const TOKENS_CHUNK_NAME = "vicss-tokens";
+/**
+* Whether the client build has an HTML entry, read from the config so that
+* every environment agrees: it decides what the sheet holds. Mirrors how
+* Vite picks a build's input.
+*/
+function hasHtmlEntry(config) {
+	const client = config.environments.client;
+	if (!client || client.build.lib) return false;
+	const input = client.build.rolldownOptions?.input ?? client.input;
+	if (input === void 0) return existsSync(path.join(config.root, "index.html"));
+	return (typeof input === "string" ? [input] : Object.values(input)).some((entry) => entry.endsWith(".html"));
+}
+/**
+* `<link rel="stylesheet">` first in `<head>`, so its layer statement comes
+* first. Its URL is built the way Vite builds its own links in the same page
+* (`renderBuiltUrl`, then the base, relative when the base is), and it is
+* `crossorigin` like them, so a CDN setup serves both alike.
+*/
+function tokensLink(config, fileName, hostId) {
+	const link = (href) => ({
+		tag: "link",
+		attrs: {
+			rel: "stylesheet",
+			crossorigin: true,
+			href
+		},
+		injectTo: "head-prepend"
+	});
+	const rendered = config.experimental.renderBuiltUrl?.(fileName, {
+		hostId,
+		hostType: "html",
+		type: "asset",
+		ssr: false
+	});
+	if (typeof rendered === "string") return link(rendered);
+	if (!(rendered?.relative ?? (config.base === "" || config.base === "./"))) return link(`${config.base}${fileName}`);
+	const href = path.posix.join(path.posix.relative(path.posix.dirname(hostId), ""), fileName);
+	return link(href.startsWith(".") ? href : `./${href}`);
+}
+//#endregion
+//#region src/vite/registry.ts
+/**
+* What each compiled module contributes to the CSS, shared by every
+* environment: one source compiles to the same atoms for the client, SSR and
+* any other consumer, so keeping one copy also keeps their CSS identical.
+*/
+/** Whether a module contributes CSS, and so imports it. */
+function isStyled(styles) {
+	return styles.atoms.length > 0 || styles.tokens.length > 0 || styles.rules.length > 0;
+}
+/** Entries counted by key, so one leaves only when the last module holding it does. */
+var Counted = class {
+	#entries = /* @__PURE__ */ new Map();
+	/** Returns the keys that were not held before. */
+	add(values, keyOf) {
+		const added = [];
+		for (const value of values) {
+			const key = keyOf(value);
+			const entry = this.#entries.get(key);
+			if (entry) entry.count++;
+			else {
+				this.#entries.set(key, {
+					value,
+					count: 1
+				});
+				added.push(key);
+			}
+		}
+		return added;
+	}
+	/** Returns the keys that lost their last holder. */
+	remove(values, keyOf) {
+		const gone = [];
+		for (const value of values) {
+			const key = keyOf(value);
+			const entry = this.#entries.get(key);
+			if (!entry || --entry.count > 0) continue;
+			this.#entries.delete(key);
+			gone.push(key);
+		}
+		return gone;
+	}
+	has(key) {
+		return this.#entries.has(key);
+	}
+	values() {
+		return [...this.#entries.values()].map((entry) => entry.value);
+	}
+	clear() {
+		this.#entries.clear();
+	}
+};
+var Registry = class {
+	#modules = /* @__PURE__ */ new Map();
+	/**
+	* Module ids by file: a framework file can be several modules (Astro's
+	* `?astro&type=script` scripts next to its component), which share the
+	* file's one dev CSS module.
+	*/
+	#files = /* @__PURE__ */ new Map();
+	#dependants = /* @__PURE__ */ new Map();
+	/**
+	* What each compiled module that styles nothing read: `sx(row)` folds a
+	* marker's class, a module may inline a constant into a string. It must
+	* compile again when one of those files changes, as styled modules do.
+	*/
+	#reads = /* @__PURE__ */ new Map();
+	/**
+	* One atom per sub-layer (chain and tier). The layer statement depends only
+	* on which sub-layers exist, so it changes exactly when a key appears or
+	* goes, and one atom per key is enough to print it.
+	*/
+	#subLayers = new Counted();
+	/** Rules by id: a theme folded into several modules prints once. */
+	#rules = new Counted();
+	/**
+	* `colorPalette` atoms and the palette keys styles read (`palette.600`):
+	* `base.css` prints the palettes' rules from them (core/palettes.ts).
+	*/
+	#palettes = new Counted();
+	#paletteKeys = new Counted();
+	/**
+	* Flattened recipe bases by id, and one of their atoms per chain. They
+	* print in the modules' CSS, so `base.css` depends only on the chains'
+	* flattened sub-layers, as on the atoms' sub-layers: an edited base is a
+	* new class over the same chains, which leaves it alone.
+	*/
+	#bases = new Counted();
+	#flatLayers = new Counted();
+	get(id) {
+		return this.#modules.get(id);
+	}
+	has(id) {
+		return this.#modules.has(id);
+	}
+	ids() {
+		return [...this.#modules.keys()];
+	}
+	/** The styles of every module of `file` (an id without its query), merged. */
+	ofFile(file) {
+		const styles = [...this.#files.get(file) ?? []].flatMap((id) => this.#modules.get(id) ?? []);
+		if (styles.length <= 1) return styles[0];
+		return {
+			atoms: [...new Map(styles.flatMap((s) => s.atoms).map((a) => [a.className, a])).values()].sort((a, b) => compareStrings(a.className, b.className)),
+			tokens: styles.flatMap((s) => s.tokens),
+			rules: styles.flatMap((s) => s.rules),
+			dependencies: [...new Set(styles.flatMap((s) => s.dependencies))]
+		};
+	}
+	/**
+	* Returns whether `base.css` changed: a sub-layer, and so the layer
+	* statement, or a rule appeared or went.
+	*/
+	set(id, styles) {
+		const removed = this.#remove(id);
+		this.#modules.set(id, styles);
+		const file = fileOf(id);
+		let ids = this.#files.get(file);
+		if (!ids) this.#files.set(file, ids = /* @__PURE__ */ new Set());
+		ids.add(id);
+		this.#depend(id, styles.dependencies);
+		this.#bases.add(styles.rules.filter(isBase), ruleId);
+		const added = [
+			...this.#subLayers.add(styles.atoms, subLayer).map((key) => `l:${key}`),
+			...this.#rules.add(styles.rules.filter(prints), ruleId).map((key) => `r:${key}`),
+			...this.#flatLayers.add(flatAtoms(styles.rules), flatLayer).map((key) => `f:${key}`),
+			...this.#palettes.add(styles.atoms.filter(isPaletteAtom), className).map((key) => `p:${key}`),
+			...this.#paletteKeys.add(paletteRefs(styles), refId).map((key) => `k:${key}`)
+		];
+		return removed.some((key) => !this.#holds(key)) || added.some((key) => !removed.includes(key));
+	}
+	/** Returns whether `base.css` changed. */
+	delete(id) {
+		return this.#remove(id).length > 0;
+	}
+	/**
+	* A compiled module that styles nothing: not registered, but a module
+	* that read `dependencies`, so `dependantsOf` lists it. Returns whether
+	* `base.css` changed (it styled something before).
+	*/
+	unstyled(id, dependencies) {
+		const changed = this.delete(id);
+		this.#depend(id, dependencies);
+		return changed;
+	}
+	clear() {
+		this.#modules.clear();
+		this.#files.clear();
+		this.#dependants.clear();
+		this.#reads.clear();
+		this.#subLayers.clear();
+		this.#rules.clear();
+		this.#palettes.clear();
+		this.#paletteKeys.clear();
+		this.#bases.clear();
+		this.#flatLayers.clear();
+	}
+	/** Modules, styled or not, that read constants from `file`. */
+	dependantsOf(file) {
+		return [...this.#dependants.get(file) ?? []];
+	}
+	/** One atom per sub-layer in use: what the layer statement is printed from. */
+	layerAtoms() {
+		return this.#subLayers.values();
+	}
+	/** Every registered module's rules, one per id: flattened bases declare their sub-layers. */
+	rules() {
+		return [...this.#rules.values(), ...this.#bases.values()];
+	}
+	/** Every `colorPalette` atom of the registered modules. */
+	paletteAtoms() {
+		return this.#palettes.values();
+	}
+	/** The palette keys the registered modules read, as token references. */
+	paletteKeys() {
+		return this.#paletteKeys.values();
+	}
+	/** Records that `id` read `dependencies`, replacing what it read before. */
+	#depend(id, dependencies) {
+		for (const dep of this.#reads.get(id) ?? []) {
+			const set = this.#dependants.get(dep);
+			set?.delete(id);
+			if (set?.size === 0) this.#dependants.delete(dep);
+		}
+		if (dependencies.length === 0) this.#reads.delete(id);
+		else this.#reads.set(id, dependencies);
+		for (const dep of dependencies) {
+			let set = this.#dependants.get(dep);
+			if (!set) this.#dependants.set(dep, set = /* @__PURE__ */ new Set());
+			set.add(id);
+		}
+	}
+	#holds(key) {
+		const id = key.slice(2);
+		switch (key[0]) {
+			case "l": return this.#subLayers.has(id);
+			case "r": return this.#rules.has(id);
+			case "f": return this.#flatLayers.has(id);
+			case "p": return this.#palettes.has(id);
+			default: return this.#paletteKeys.has(id);
+		}
+	}
+	/**
+	* Returns the sub-layers (`l:`), rules (`r:`), flattened sub-layers (`f:`),
+	* palette atoms (`p:`) and palette keys (`k:`) that lost their last holder.
+	*/
+	#remove(id) {
+		const old = this.#modules.get(id);
+		if (!old) return [];
+		this.#modules.delete(id);
+		const ids = this.#files.get(fileOf(id));
+		ids?.delete(id);
+		if (ids?.size === 0) this.#files.delete(fileOf(id));
+		this.#depend(id, []);
+		this.#bases.remove(old.rules.filter(isBase), ruleId);
+		return [
+			...this.#subLayers.remove(old.atoms, subLayer).map((key) => `l:${key}`),
+			...this.#rules.remove(old.rules.filter(prints), ruleId).map((key) => `r:${key}`),
+			...this.#flatLayers.remove(flatAtoms(old.rules), flatLayer).map((key) => `f:${key}`),
+			...this.#palettes.remove(old.atoms.filter(isPaletteAtom), className).map((key) => `p:${key}`),
+			...this.#paletteKeys.remove(paletteRefs(old), refId).map((key) => `k:${key}`)
+		];
+	}
+};
+/** The palette keys a module's styles read: colour tokens of the `palette` group. */
+function paletteRefs(styles) {
+	const refs = [
+		...styles.atoms.flatMap((atom) => atom.tokens),
+		...styles.rules.flatMap((rule) => rule.tokens),
+		...styles.tokens
+	];
+	const unique = /* @__PURE__ */ new Map();
+	for (const ref of refs) if (ref.scale === "colors" && (ref.path === "palette" || ref.path.startsWith("palette."))) unique.set(ref.path, ref);
+	return [...unique.values()];
+}
+const subLayer = (atom) => `${atom.chain.join(" ")}|${atom.tier}`;
+const className = (atom) => atom.className;
+const refId = (ref) => ref.path;
+const flatLayer = (atom) => atom.chain.join(" ");
+const isBase = (rule) => rule.kind === "base";
+/** What `base.css` prints: themes and keyframes. */
+const prints = (rule) => !isBase(rule);
+const flatAtoms = (rules) => rules.flatMap((rule) => isBase(rule) ? rule.atoms ?? [] : []);
+/** A module id without its query: the file its dev CSS module is named after. */
+const fileOf = (id) => id.replace(/[?#].*$/, "");
+const ruleId = (rule) => rule.id;
+//#endregion
+//#region src/vite/plugin.ts
+/**
+* The Vite plugin (PLAN §5.10, M2). One `pre` transform compiles styled
+* modules on their source; dev serves one CSS module per styled module plus
+* a shared `base.css` (D14); a build pre-scans `include` and serves one sheet
+* (D5), plus a tokens file in SPAs (D13).
+*/
+const RUNTIME_PACKAGE = "@menapo/vicss";
+/** What a library build writes into its `outDir` (PLAN §5.13). */
+const MANIFEST_FILE = "vicss.json";
+const LIBRARY_SHEET_FILE = "vicss.css";
+const SCRIPT_ID = /\.[cm]?[jt]sx?$/;
+/** The calls `vicss:attributes` rewrites: a module with none is left alone. */
+const COMPONENT_CALLS = [
+	"normalizeClass",
+	"ssrRenderClass",
+	"mergeProps",
+	"normalizeProps",
+	"ssrRenderAttrs",
+	"clsx",
+	"attribute_effect",
+	"attributes",
+	"normalizeStyle",
+	"ssrRenderStyle",
+	"set_style",
+	"attr_style",
+	"addAttribute"
+];
+/** Declaration files: never styled, and the generated `vicss.d.ts` names the runtime. */
+const DECLARATION_ID = /\.d\.[cm]?ts$/;
+/**
+* PLAN §6: a warning above this share of hashed atoms (values outside the
+* scales, and long or unusual literals), as a design system erodes.
+*/
+const HASHED_BUDGET = .1;
+const CSS_ID = /(?:^virtual:vicss\/(?:base|sheet|lib\/\d+)\.css|\/@vicss\/(?:base|sheet|tokens|lib\/\d+)\.css|\.vicss\.css)(?:[?#]|$)/;
+/** Modules compiled at once outside a transform (HMR, a config edit). */
+const BATCH = 16;
+function vicss(options = {}) {
+	let state;
+	let server;
+	const registry = new Registry();
+	const cache = new CompileCache();
+	/** Dev: ids the transform rewrote, invalidated when the config changes. */
+	const transformed = /* @__PURE__ */ new Set();
+	/**
+	* Dev: what each framework file's scripts style, as the pre-scan reads
+	* them, by file and the hash of its source.
+	*/
+	const scriptStyles = /* @__PURE__ */ new Map();
+	/**
+	* Build: one scan per config, shared by every environment of one build.
+	* A build is the configs one `vite build` or builder resolves, all before
+	* any environment starts; a config resolved after that starts a new one.
+	*/
+	const scans = /* @__PURE__ */ new Map();
+	let session = newSession();
+	/** The CSS each scan's result prints with the libraries, its atom count and its classes. */
+	const sheets = /* @__PURE__ */ new WeakMap();
+	/** Each scan's classes in literal form, for `api.literals()`. */
+	const literalTables = /* @__PURE__ */ new WeakMap();
+	/** A scan whose sheet failed to print (a library's atoms conflict with the app's). */
+	const sheetErrors = /* @__PURE__ */ new WeakMap();
+	/** Scan failures a hook has reported (`sheetFor`). */
+	const reportedFailures = /* @__PURE__ */ new WeakSet();
+	const reported = /* @__PURE__ */ new WeakSet();
+	/**
+	* What the scan (build) or an HMR pass (dev) compiled, by id, so the
+	* transform of an unchanged module reuses it instead of compiling every
+	* module twice. Build entries go when the build ends; dev entries when
+	* their transform takes them.
+	*/
+	const kept = /* @__PURE__ */ new Map();
+	let diskCache;
+	/** Build: the CSS files of the chunk that holds the sheet, per environment. */
+	const sheetFiles = /* @__PURE__ */ new WeakMap();
+	/**
+	* Build: resolutions per environment, by importer directory, shared by
+	* the scan and the transforms: most modules import the same few modules.
+	*/
+	const buildResolutions = /* @__PURE__ */ new WeakMap();
+	/** The SPA tokens file, per client build, with the config that links it. */
+	const tokenAssets = /* @__PURE__ */ new Map();
+	/**
+	* Dev: resolutions per environment, kept until a file is added or removed.
+	* While the watcher handles a change, every async call (Vite's native
+	* resolver included) waits behind it for ~50 ms; the requests of an
+	* edited module were all resolved when it was first served.
+	*/
+	const resolutions = /* @__PURE__ */ new Map();
+	/** One recompile per file change, shared by the environments' `hotUpdate` calls. */
+	const changes = /* @__PURE__ */ new Map();
+	/**
+	* Dev and build watch mode: files a config load read before it failed (a
+	* token file it could not parse), watched too so fixing one reloads the
+	* config.
+	*/
+	let failedReads = /* @__PURE__ */ new Set();
+	/**
+	* Build watch mode: a file the config read changed, so the next build
+	* loads the config again. A rebuild runs no `configResolved`.
+	*/
+	let configChanged = false;
+	/** Build: `scan.json` writes in progress, which the build's end waits for. */
+	const cacheWrites = [];
+	/**
+	* Build: scan threads started while the config loads (pool.ts), for the
+	* scan to take; closed if it does not.
+	*/
+	let spawned;
+	/** Settles when the current dev server closes. */
+	let closing = new Promise(() => {});
+	/** Dev: settles once the modules registered before a config edit compiled again. */
+	let rebuilt = Promise.resolve();
+	const sources = [RUNTIME_PACKAGE];
+	const ready = () => {
+		if (!state) throw new Error("vicss: the plugin was used before Vite resolved its config");
+		return state;
+	};
+	const layers = options.layers;
+	/**
+	* The config with the installed libraries it must cover (an app's), their
+	* manifests watched like the config's files. Throws VicssError when a
+	* library uses a token or condition the config lacks.
+	*/
+	function checkLibraries(s, loaded) {
+		const libraries = s.library ? [] : loadLibraries(s.root, loaded.system);
+		const files = libraries.flatMap((library) => library.files);
+		return {
+			...loaded,
+			watch: [.../* @__PURE__ */ new Set([...loaded.watch, ...files])],
+			configFiles: loaded.watch,
+			libraries
+		};
+	}
+	function setSystem(s, loaded) {
+		s.loaded = loaded;
+		s.compile = {
+			system: loaded.system,
+			importSources: loaded.system.config.importSources ?? [],
+			parsed: createParseCache(),
+			sourceMap: s.dev || Object.values(s.config.environments).some((env) => env.build.sourcemap),
+			dev: s.devSource,
+			placeholders: !s.dev,
+			keepLines: s.dev,
+			root: s.root,
+			package: s.pkg,
+			frameworks: s.frameworks
+		};
+		const warned = /* @__PURE__ */ new Set();
+		const options = loaded.system.classNames;
+		s.print = {
+			system: loaded.system,
+			layers,
+			warn(message) {
+				if (warned.has(message)) return;
+				warned.add(message);
+				s.config.logger.warn(`vicss: ${message}`);
+			},
+			...s.dev && { names: createNamer([], {
+				prefix: options.prefix,
+				minLength: minLengthOf(options, false)
+			}, loaded.libraries.map((library) => ({
+				library: library.name,
+				names: library.classes
+			})), true) }
+		};
+		const short = minLengthWarning(options);
+		if (short) s.config.logger.warn(`vicss: ${short}`);
+		setConfigHash(s);
+		sources.splice(0, sources.length, .../* @__PURE__ */ new Set([RUNTIME_PACKAGE, ...s.compile.importSources]));
+		const dirs = loaded.libraries.flatMap((library) => library.dirs);
+		libraryDirs.splice(0, libraryDirs.length, ...dirs.length > 0 ? dirs.map((dir) => new RegExp(`^${escapeRegExp(dir)}/`)) : [NOTHING]);
+		writeTypes(s);
+	}
+	/**
+	* The generated `vicss.d.ts`, for the config just loaded (PLAN §5.11),
+	* with the framework of the project's plain modules, so `sx()`'s result
+	* type follows the shape the compiler gives them (§5.12); and next to it
+	* the lint snapshot, so the editor's lint rules see the config the server
+	* just loaded.
+	*/
+	function writeTypes(s) {
+		if (options.types === false) return;
+		const types = typesFile(s.root, options.types?.output);
+		const outputs = [[types, () => generateTypes(s.loaded.system, { framework: s.frameworks.scripts })], [snapshotFile(types), () => snapshotText(s.loaded.system, { root: snapshotRoot(snapshotFile(types), s.root) })]];
+		for (const [file, text] of outputs) try {
+			if (writeIfChanged(file, text())) s.config.logger.info(`vicss: wrote ${path.relative(s.root, file) || file}`);
+		} catch (error) {
+			s.config.logger.warn(`vicss: could not write ${file}: ${String(error)}`);
+		}
+	}
+	/**
+	* The part of a cache key that stands for the config. The system's hash
+	* covers a function only by its source, so the files that define the
+	* config count too (a constant a utility closes over), and so do the
+	* token files it read, though their data is in the hash already. A
+	* function from an installed package (a preset's utility) is defined in a
+	* file Vite leaves to Node, which no list names: the lockfile stands for
+	* every such file, as for Vite's dependency optimizer, so an upgrade
+	* scans afresh. When no module on disk defines the config and a function
+	* could hide a change, `scan.json` is not used: token files hold no
+	* functions. The libraries' manifests do not count: no module's compile
+	* reads them, and the sheet prints them after the scan.
+	*/
+	function setConfigHash(s) {
+		const defining = typeof options.config === "object" ? [s.config.configFile, ...s.config.configFileDependencies].flatMap((f) => f ? [normalizePath(f)] : []) : s.loaded.configFiles;
+		const functions = hasFunction(s.loaded.system.config);
+		const contents = [.../* @__PURE__ */ new Set([
+			...defining,
+			...s.loaded.configFiles,
+			...functions ? lockfiles(s.root) : []
+		])].map((file) => `${file}\0${readHash(file) ?? ""}`).join("\0");
+		const { scripts, jsxImportSource } = s.frameworks;
+		s.configHash = hashCode(`${s.loaded.system.hash}\0${s.compile.sourceMap}\0${s.compile.placeholders}\0${scripts}\0${jsxImportSource ?? ""}\0${s.pkg}\0${contents}`);
+		s.diskCache = defining.length > 0 || !functions;
+	}
+	async function reloadConfig(dev) {
+		const s = ready();
+		let loaded;
+		const reads = /* @__PURE__ */ new Set();
+		try {
+			loaded = checkLibraries(s, await loadSystem(s.root, options.config, (m) => s.config.logger.info(m), reads));
+			failedReads = /* @__PURE__ */ new Set();
+		} catch (error) {
+			failedReads = new Set([...reads].map(normalizePath));
+			dev.watcher.add([...failedReads]);
+			const failure = loadFailure(error, s.root, options.config);
+			const err = failure instanceof Error ? failure : new Error(String(failure));
+			const message = error instanceof VicssError ? err.message : `vicss: ${err.message}`;
+			s.config.logger.error(message, {
+				error: err,
+				timestamp: true
+			});
+			dev.environments.client?.hot.send({
+				type: "error",
+				err: {
+					message,
+					stack: err.stack ?? "",
+					plugin: "vicss"
+				}
+			});
+			return;
+		}
+		const before = sources.join("\n");
+		const styled = registry.ids();
+		const stale = [
+			...[...transformed].map(fileOf),
+			...styled.map((id) => fileOf(id) + MODULE_SUFFIX),
+			s.ids.base,
+			...s.loaded.libraries.map((_, i) => `${s.ids.libraries}${i}.css`)
+		];
+		setSystem(s, loaded);
+		registry.clear();
+		cache.clear();
+		kept.clear();
+		scans.clear();
+		transformed.clear();
+		scriptStyles.clear();
+		resolutions.clear();
+		dev.watcher.add([...loaded.watch]);
+		const client = dev.environments.client;
+		const resolve = memoize(resolutions, "client", envResolver(s, client));
+		const recompiled = inBatches(styled, async (id) => registry.has(id) ? void 0 : recompile(id, void 0, resolve));
+		rebuilt = recompiled;
+		const everything = sources.join("\n") !== before;
+		for (const env of Object.values(dev.environments)) {
+			const graph = env.moduleGraph;
+			if (everything) graph.invalidateAll();
+			else for (const file of stale) for (const mod of graph.getModulesByFile(file) ?? []) graph.invalidateModule(mod);
+			env.hot.send({
+				type: "full-reload",
+				path: "*"
+			});
+		}
+		await recompiled;
+	}
+	/**
+	* Build watch mode: the config again, before the rebuild that a change to
+	* one of its files started. A config that fails stays marked, so every
+	* rebuild reports it until it loads.
+	*/
+	async function reloadBuildConfig(ctx, s) {
+		const reads = /* @__PURE__ */ new Set();
+		let loaded;
+		try {
+			loaded = checkLibraries(s, await loadSystem(s.root, options.config, (m) => s.config.logger.info(m), reads));
+		} catch (error) {
+			failedReads = new Set([...reads].map(normalizePath));
+			for (const file of [...s.loaded.watch, ...failedReads]) ctx.addWatchFile(file);
+			fail(ctx, error, {});
+		}
+		configChanged = false;
+		failedReads = /* @__PURE__ */ new Set();
+		setSystem(s, loaded);
+		cache.clear();
+		diskCache = void 0;
+		scans.clear();
+		kept.clear();
+	}
+	/** A hook context's resolver, through the dev server's memo. */
+	function devResolver(ctx) {
+		return memoize(resolutions, ctx.environment.name, contextResolver(ready(), ctx));
+	}
+	/** A hook context's resolver, through its build environment's memo. */
+	function buildResolver(ctx) {
+		let resolved = buildResolutions.get(ctx.environment);
+		if (!resolved) buildResolutions.set(ctx.environment, resolved = /* @__PURE__ */ new Map());
+		return memoize(resolved, "", contextResolver(ready(), ctx));
+	}
+	let refresh;
+	/**
+	* A module compiled after `base.css` was served brought new sub-layers.
+	* Stale copies go at once, so the next request prints the new statement;
+	* the browser's copy is replaced on the next tick, after a burst of
+	* transforms (a lazy route's modules) has settled.
+	*/
+	function baseChanged() {
+		if (!server) return;
+		const base = ready().ids.base;
+		for (const env of Object.values(server.environments)) for (const mod of env.moduleGraph.getModulesByFile(base) ?? []) env.moduleGraph.invalidateModule(mod);
+		refresh ??= setTimeout(() => {
+			refresh = void 0;
+			const client = server?.environments.client;
+			for (const mod of client?.moduleGraph.getModulesByFile(base) ?? []) client.reloadModule(mod);
+		}, 30).unref();
+	}
+	/**
+	* A transform compiled other atoms than the registry held, after the
+	* module's CSS was served from them: two saves a few ms apart that the
+	* watcher reported once, or an HMR compile of a half-written file. The
+	* served copies go, and the browser's is replaced.
+	*/
+	function cssChanged(id) {
+		for (const env of Object.values(server?.environments ?? {})) for (const mod of env.moduleGraph.getModulesByFile(fileOf(id) + ".vicss.css") ?? []) {
+			if (!mod.transformResult) continue;
+			env.moduleGraph.invalidateModule(mod);
+			if (env === server?.environments.client) env.reloadModule(mod);
+		}
+	}
+	/** Returns whether `base.css` changed. */
+	function register(id, styles) {
+		return isStyled(styles) ? registry.set(id, styles) : registry.unstyled(id, styles.dependencies);
+	}
+	/**
+	* Compiles `id` again outside its transform, from `code` or the file, and
+	* keeps the result for that transform. Returns whether the layer statement
+	* changed, or undefined when the module does not compile: its own
+	* transform runs again and reports why. The file is read synchronously:
+	* the first async read after a change waits behind the watcher for
+	* 15–85 ms (report 06 §6.2).
+	*/
+	async function recompile(id, code, resolve) {
+		if (isSfc(id)) return void 0;
+		try {
+			const source = code ?? readFileSync(id, "utf8");
+			const result = compile(ready().compile, id, source, resolve);
+			kept.set(id, {
+				code: source,
+				result
+			});
+			return register(id, await result);
+		} catch {
+			return;
+		}
+	}
+	async function applyChange(file, type, read, resolve) {
+		const styled = [];
+		let base = false;
+		if (SCRIPT_ID.test(file) && !file.includes("/node_modules/")) {
+			if (type === "delete") {
+				kept.delete(file);
+				base = registry.delete(file);
+			} else {
+				const code = await read();
+				if (registry.has(file) || sources.some((source) => code.includes(source))) {
+					const changed = await recompile(file, code, resolve);
+					if (changed !== void 0) {
+						base ||= changed;
+						styled.push(file);
+					}
+				}
+			}
+		}
+		const dependants = registry.dependantsOf(file).filter((id) => id !== file);
+		const changed = await inBatches(dependants, (id) => recompile(id, void 0, resolve));
+		for (const [i, id] of dependants.entries()) {
+			const layersChanged = changed[i];
+			if (layersChanged === void 0) continue;
+			base ||= layersChanged;
+			styled.push(id);
+		}
+		return {
+			styled,
+			dependants,
+			base
+		};
+	}
+	/** The build's scan, started by the first environment that needs it. */
+	function scanned(ctx) {
+		return startScan(ctx).result;
+	}
+	function startScan(ctx) {
+		const s = ready();
+		const key = s.configHash;
+		const running = scans.get(key);
+		if (running) return running;
+		let allQueued;
+		const queued = new Promise((resolve) => allQueued = resolve);
+		const cacheFile = s.diskCache && path.join(s.config.cacheDir, "vicss", "scan.json");
+		const resolve = buildResolver(ctx);
+		const resolveId = (source, importer) => resolveFile(resolve, source, importer);
+		const setup = workerSetup(s);
+		const promise = (async () => {
+			if (cacheFile) await (diskCache ??= cache.read(cacheFile, s.root));
+			const result = await scan({
+				root: s.root,
+				system: s.loaded.system,
+				configHash: key,
+				importSources: s.compile.importSources,
+				cache,
+				resolve: resolveId,
+				compile: (id, code, script) => compile(s.compile, id, code, resolve, script),
+				queued(id, code, result, prioritize) {
+					kept.set(id, {
+						code: hashCode(code),
+						result,
+						prioritize
+					});
+				},
+				allQueued,
+				cached(id, code, entry) {
+					kept.set(id, {
+						code: hashCode(code),
+						result: Promise.resolve(compiledOf(entry, id, code))
+					});
+				},
+				pool: setup ? (jobs) => {
+					const pool = spawned ?? CompilePool.spawn(poolSize(jobs));
+					spawned = void 0;
+					return pool?.use({
+						setup,
+						resolve: resolveId,
+						warn: (message) => s.config.logger.warn(`vicss: ${message}`)
+					});
+				} : void 0
+			});
+			if (cacheFile) {
+				const write = async () => {
+					await new Promise((resolve) => setImmediate(resolve));
+					try {
+						await cache.write(cacheFile, s.root, result.files);
+					} catch (error) {
+						s.config.logger.warn(`vicss: could not write ${cacheFile}: ${String(error)}`);
+					}
+				};
+				cacheWrites.push(write());
+			}
+			return result;
+		})();
+		promise.then(allQueued, allQueued);
+		const unused = () => {
+			spawned?.close();
+			spawned = void 0;
+		};
+		promise.then(unused, unused);
+		const run = {
+			queued,
+			result: promise
+		};
+		scans.set(key, run);
+		return run;
+	}
+	function sheetOf(result) {
+		return printed(result).css;
+	}
+	function printed(result) {
+		let sheet = sheets.get(result);
+		if (!sheet) {
+			const s = ready();
+			const failed = sheetErrors.get(result);
+			if (failed) throw failed.error;
+			try {
+				const all = withLibraries(result, s.loaded.libraries, s.loaded.system);
+				const options = s.loaded.system.classNames;
+				const names = createNamer(identitiesOf(all, result.names), {
+					prefix: options.prefix,
+					minLength: minLengthOf(options, s.library)
+				}, s.loaded.libraries.map((library) => ({
+					library: library.name,
+					names: library.classes
+				})), readableBuild(options));
+				sheet = {
+					css: buildCss(all, {
+						...s.print,
+						names
+					}, s.tokensFile),
+					atoms: all.atoms.length,
+					bases: all.rules.filter((rule) => rule.kind === "base").length,
+					names,
+					identities: identitiesOf(result, result.names).filter((identity) => !identity.startsWith("!"))
+				};
+			} catch (error) {
+				sheetErrors.set(result, { error });
+				throw error;
+			}
+			sheets.set(result, sheet);
+		}
+		return sheet;
+	}
+	/**
+	* The build's scan and the CSS it prints, or their failure as this hook's
+	* error. Every hook that waits for a failed scan sees the same error: the
+	* first reports it, with its code frame, and the others get `undefined`
+	* and go on quietly, so the build fails once.
+	*/
+	async function sheetFor(ctx) {
+		try {
+			const scan = await scanned(ctx);
+			const { css, names } = printed(scan);
+			return {
+				scan,
+				css,
+				names
+			};
+		} catch (error) {
+			if (typeof error === "object" && error !== null) {
+				if (reportedFailures.has(error)) return void 0;
+				reportedFailures.add(error);
+			}
+			fail(ctx, error, { id: error instanceof ScanConflict ? error.id : void 0 });
+		}
+	}
+	/**
+	* The build's one summary line (spec P12), with the sizes of the files
+	* written, or else of the sheet vicss printed.
+	*/
+	function summarize(result, files) {
+		if (reported.has(result)) return;
+		reported.add(result);
+		const kb = (n) => `${(n / 1e3).toFixed(2)} kB`;
+		const size = (text) => `${kb(Buffer.byteLength(text))} │ gzip: ${kb(gzipSync(text).length)}`;
+		const sizes = files ? files.map(([name, text]) => `${name} ${size(text)}`) : [`sheet ${size(sheetOf(result).sheet)} (unminified)`];
+		const { logger } = ready().config;
+		const own = new Set(result.atoms.map((atom) => atom.className));
+		const every = [...result.atoms, ...baseAtoms(result.rules).filter((atom) => !own.has(atom.className))];
+		const hashed = every.filter(isArbitrary).length;
+		const share = every.length === 0 ? 0 : hashed / every.length;
+		const percent = `${(share * 100).toFixed(1)} %`;
+		const { atoms, bases } = printed(result);
+		const flat = bases === 0 ? "" : `, ${bases} flattened base${bases === 1 ? "" : "s"}`;
+		logger.info(`vicss: ${atoms} atoms${flat}, ${result.files.length} files scanned; ${result.arbitrary} values outside the scales, ${hashed} hashed atoms (${percent}); ${sizes.join(", ")}`);
+		if (share > HASHED_BUDGET) logger.warn(`vicss: ${percent} of the atoms (${hashed} of ${every.length}) get hashed class names (\`~…\`): values outside the scales and long or unusual literals; the budget is ${HASHED_BUDGET * 100} %. \`vicss check\` lists them by file.`);
+	}
+	/**
+	* Compiles a module (a script, or a framework file's compiled output),
+	* registers its styles (dev) or checks them against the sheet (build), and
+	* imports their CSS.
+	*/
+	async function transformStyled(ctx, code, id) {
+		if (id.includes("/node_modules/") || !sources.some((source) => code.includes(source))) return null;
+		const s = ready();
+		if (!s.dev) await startScan(ctx).queued;
+		const reused = kept.get(id);
+		let result;
+		/** Whether the scan compiled it, so its atoms, rules and tokens are the sheet's. */
+		let fromScan = false;
+		try {
+			const resolve = s.dev ? devResolver(ctx) : buildResolver(ctx);
+			if (reused && reused.code === (s.dev ? code : hashCode(code))) {
+				if (s.dev) kept.delete(id);
+				reused.prioritize?.();
+				const earlier = await reused.result.catch(async (error) => {
+					if (!await sheetFor(ctx)) return void 0;
+					throw error;
+				});
+				if (!earlier) return null;
+				const file = (source, importer) => resolveFile(resolve, source, importer);
+				if (s.dev || await resolvesAlike(earlier.resolutions, file)) {
+					result = earlier;
+					fromScan = !s.dev;
+				}
+			}
+			const lines = s.compile.dev && isSfc(id) ? mappedLines(ctx, id) : void 0;
+			result ??= await compile(s.compile, id, code, resolve, void 0, lines);
+		} catch (error) {
+			if (isSfc(id) && error instanceof VicssError && !(error instanceof ScanConflict)) {
+				await failInComponent(ctx, s, id, error);
+				return null;
+			}
+			fail(ctx, error, error instanceof ScanConflict ? { id: error.id } : {
+				id,
+				code
+			});
+		}
+		for (const message of result.warnings) ctx.warn(message);
+		for (const dep of result.dependencies) ctx.addWatchFile(dep);
+		const styled = isStyled(result);
+		if (s.dev) {
+			if (styled && isSfc(id)) await checkTemplate(ctx, s, id, result);
+			const before = registry.get(id);
+			if (register(id, result)) baseChanged();
+			if (before && before !== result && !sameCss(before, result)) cssChanged(id);
+			if (!result.changed) return null;
+			transformed.add(id);
+		} else {
+			if (!result.changed) return null;
+			if (styled && !fromScan) {
+				const sheet = await sheetFor(ctx);
+				if (!sheet) return null;
+				checkSheet(ctx, sheet.scan, sheet.css.tokenKeys, result, id, s.root);
+			}
+		}
+		let out = result.code;
+		if (styled) out += cssImports(s, id);
+		return {
+			code: out,
+			map: result.map
+		};
+	}
+	/**
+	* A framework file's compiled output did not compile. Its location is in
+	* code the author never wrote (the virtual script module in a build), so
+	* the error is reported against the component. A build's scan compiled
+	* the file's scripts, and a failure there is the build's one error, which
+	* the first hook to see it reports (`sheetFor`): this returns quietly
+	* once another has. In dev the scripts compile again, as `checkTemplate`
+	* compiles them, and their error is reported at its place in the file.
+	* What fails only in the compiled output (a style in the template) is
+	* located through the framework's source map, by line.
+	*/
+	async function failInComponent(ctx, s, id, error) {
+		if (!s.dev && !await sheetFor(ctx)) return;
+		const file = fileOf(id);
+		const source = readSource(file);
+		if (source === void 0) fail(ctx, error, { id });
+		if (s.dev) {
+			const resolve = devResolver(ctx);
+			try {
+				await Promise.all(extractScripts(file, source).map(({ code: text, ...script }) => compile(s.compile, file, text, resolve, script)));
+			} catch (own) {
+				fail(ctx, own, {
+					id: file,
+					code: source
+				});
+			}
+		}
+		const line = error.loc && mappedLines(ctx, id)?.(error.loc.line, error.loc.column);
+		if (line === void 0) fail(ctx, error, { id });
+		const hint = error.hint === void 0 ? {} : { hint: error.hint };
+		fail(ctx, new VicssError(error.code, error.message, {
+			...hint,
+			loc: {
+				file,
+				line,
+				column: 0
+			}
+		}), {
+			id: file,
+			code: source
+		});
+	}
+	/**
+	* Dev: a style written in a framework file's template works here, yet the
+	* build's pre-scan reads only the file's scripts, and its safety net fails
+	* the build (§5.4). It fails now, with the build's hint.
+	*/
+	async function checkTemplate(ctx, s, id, result) {
+		const file = fileOf(id);
+		let code;
+		try {
+			code = readFileSync(file, "utf8");
+		} catch {
+			return;
+		}
+		const hash = hashCode(code);
+		let scripts = scriptStyles.get(file);
+		if (scripts?.hash !== hash) {
+			const resolve = devResolver(ctx);
+			let parts;
+			try {
+				parts = await Promise.all(extractScripts(file, code).map(({ code: text, ...script }) => compile(s.compile, file, text, resolve, script)));
+			} catch {
+				return;
+			}
+			scripts = {
+				hash,
+				styles: mergeStyles(parts)
+			};
+			scriptStyles.set(file, scripts);
+		}
+		const classes = new Set(scripts.styles.atoms.map((atom) => atom.className));
+		const ids = new Set(scripts.styles.rules.map((rule) => rule.id));
+		const rel = path.relative(s.root, file) || file;
+		const own = result.own ?? {
+			classes: result.atoms.map((a) => a.className),
+			rules: result.rules.map((r) => r.id)
+		};
+		const atom = own.classes.find((name) => !classes.has(name));
+		const rule = own.rules.find((ruleId) => !ids.has(ruleId));
+		const [errorCode, what] = atom ? ["MISSING_ATOM", `the class \`${atom}\``] : rule ? ["MISSING_RULE", `the rule \`${rule}\``] : [];
+		if (errorCode) ctx.error({
+			code: errorCode,
+			id,
+			message: `vicss(${errorCode}): ${rel} uses ${what} outside its scripts: ${TEMPLATE_HINT}`
+		});
+	}
+	/**
+	* What a styled module imports: in dev, `base.css`, the installed
+	* libraries' CSS and its own, in that order (a CSS module's imports run
+	* before it, so a library's sub-layers would come before the statement
+	* if `base.css` imported them); the sheet in an app build; nothing in a
+	* library build, whose consumers print its manifest or link `vicss.css`.
+	*/
+	function cssImports(s, id) {
+		if (s.dev) return `\n${[
+			BASE_SPECIFIER,
+			...s.loaded.libraries.map((_, i) => librarySpecifier(i)),
+			moduleCssSpecifier(id)
+		].map((specifier) => `import "${specifier}";`).join("\n")}\n`;
+		return s.library ? "" : `\nimport "${SHEET_SPECIFIER}";\n`;
+	}
+	/**
+	* What a module of an installed library imports (PLAN §5.13): its classes
+	* are the sheet's, so wherever the app renders its components, alone or
+	* with no styles of its own, the sheet comes with them. In dev, `base.css`
+	* and the libraries' CSS.
+	*/
+	function libraryImports(s, library) {
+		if (!s.dev) return `\nimport "${SHEET_SPECIFIER}";\n`;
+		let code = `\n${[BASE_SPECIFIER, ...s.loaded.libraries.map((_, i) => librarySpecifier(i))].map((specifier) => `import "${specifier}";`).join("\n")}\n`;
+		const bases = (library?.rules ?? []).filter((rule) => rule.kind === "base");
+		if (bases.length > 0) {
+			const shipped = (identity) => library.classes[identity] ?? identity;
+			const atoms = Object.fromEntries(bases.map((rule) => [shipped(rule.id), Object.fromEntries((rule.atoms ?? []).map((atom) => [mergeIdOf(atom.className), shipped(atom.className)]))]));
+			code += `import { __vxFlatBases } from "${RUNTIME_PACKAGE}";\nObject.assign(__vxFlatBases, ${JSON.stringify(atoms)});\n`;
+		}
+		return code;
+	}
+	const transformFilter = {
+		id: SCRIPT_ID,
+		code: sources
+	};
+	const frameworkFilter = {
+		id: SFC_SCRIPT_ID,
+		code: sources
+	};
+	/** Build: the installed libraries' directories, filled once they load. */
+	const libraryDirs = [];
+	const libraryFilter = { id: libraryDirs };
+	const main = {
+		name: "vicss",
+		enforce: "pre",
+		sharedDuringBuild: true,
+		api: {
+			options,
+			/**
+			* The app's whole stylesheet as one string, for a renderer outside the
+			* browser (`@menapo/og` hands it to takumi, og PLAN D3): in a build,
+			* what the scan prints, so it needs the hook's context; in dev, the
+			* base and every compiled module's atoms, as the dev server serves them.
+			*/
+			async stylesheet(ctx) {
+				const s = ready();
+				if (s.dev) return [
+					devBaseCss(registry, s.print, s.loaded.libraries),
+					...s.loaded.libraries.map((library) => moduleCss(library, s.loaded.system, s.print.names)),
+					...registry.ids().map((id) => moduleCss(registry.get(id), s.loaded.system, s.print.names))
+				].join("\n");
+				if (!ctx) throw new Error("vicss: api.stylesheet() needs a plugin hook's context in a build.");
+				const printed = await sheetFor(ctx);
+				return [printed?.css.tokens ?? "", printed?.css.sheet ?? ""].join("\n");
+			},
+			/**
+			* The literal declarations (core/literals.ts) of the classes `code`, a
+			* module as this plugin's transform left it, names: for a renderer
+			* that cannot read custom properties (`@menapo/email` inlines them,
+			* email PLAN D4). Keyed as the code writes each class, so a key written
+			* back into the module is named with the module's own classes: a build
+			* writes placeholders that `renderChunk` names, dev the class itself.
+			* A build needs a hook's context, as `stylesheet()` does.
+			*/
+			async literals(code, ctx) {
+				const s = ready();
+				const out = {};
+				if (s.dev) {
+					const table = literalsOf([...s.loaded.libraries.flatMap((library) => library.atoms), ...registry.ids().flatMap((id) => registry.get(id).atoms)], [...s.loaded.libraries.flatMap((library) => library.rules), ...registry.rules()], s.loaded.system);
+					const byName = /* @__PURE__ */ new Map();
+					for (const [identity, list] of table) byName.set(s.print.names.name(identity), list);
+					for (const name of classesIn(code, new Set(byName.keys()))) out[name] = byName.get(name);
+					return out;
+				}
+				if (!ctx) throw new Error("vicss: api.literals() needs a plugin hook's context in a build.");
+				const sheet = await sheetFor(ctx);
+				if (!sheet) return out;
+				let table = literalTables.get(sheet.scan);
+				if (!table) {
+					const all = withLibraries(sheet.scan, s.loaded.libraries, s.loaded.system);
+					table = literalsOf(all.atoms, all.rules, s.loaded.system);
+					literalTables.set(sheet.scan, table);
+				}
+				for (const identity of placeholdersIn(code)) {
+					const list = table.get(identity);
+					if (list) out[placeholder(identity)] = list;
+				}
+				return out;
+			}
+		},
+		async configResolved(config) {
+			if (state && !state.dev && config.command === "build" && !session.started) {
+				session.configs++;
+				return;
+			}
+			if (layers) outerLayers(layers);
+			const dev = config.command === "serve";
+			if (dev && config.experimental.bundledDev) config.logger.warn("vicss: experimental.bundledDev is not supported yet; CSS updates may arrive late or not at all");
+			const html = hasHtmlEntry(config);
+			const split = config.environments.client?.build.cssCodeSplit !== false;
+			if (!dev && options.tokensFile === true && !html) config.logger.warn("vicss: tokensFile: true needs an HTML entry in the client build to link the file; the tokens stay at the start of the sheet");
+			else if (!dev && options.tokensFile === true && !split) config.logger.warn("vicss: tokensFile: true needs build.cssCodeSplit; with one CSS file for the app, the tokens stay at the start of the sheet");
+			const root = normalizePath(config.root);
+			spawned?.close();
+			spawned = void 0;
+			if (!dev && !existsSync(path.join(config.cacheDir, "vicss", "scan.json"))) {
+				const files = await listFiles(root);
+				const estimate = files.length > 200 ? estimateStyled(files, [RUNTIME_PACKAGE]) : 0;
+				if (estimate > 200) spawned = CompilePool.spawn(poolSize(estimate));
+			}
+			const critical = criticalSettings(options.critical);
+			if (critical && !dev && config.build?.lib) config.logger.warn("vicss: critical needs pages, and a library build has none; it does nothing here");
+			else if (critical && !dev && !html) config.logger.info("vicss: critical: this build emits no HTML page; once your framework has written its pages, run `vicss critical <outDir>`");
+			if (options.framework !== void 0 && !FRAMEWORKS.includes(options.framework)) throw new Error(`vicss: framework must be one of ${FRAMEWORKS.join(", ")}; got ${JSON.stringify(options.framework)}`);
+			const s = {
+				config,
+				root,
+				ids: cssIds(root),
+				dev,
+				devSource: dev && !isTestRunner(config),
+				loaded: void 0,
+				compile: void 0,
+				print: void 0,
+				tokensFile: options.tokensFile !== false && html && split,
+				library: !dev && Boolean(config.build?.lib),
+				configHash: "",
+				diskCache: false,
+				frameworks: {
+					scripts: options.framework ?? detectFramework(root) ?? "vanilla",
+					jsxImportSource: configuredJsxSource(config, root)
+				},
+				pkg: ownPackageName(root)
+			};
+			let loaded;
+			try {
+				loaded = checkLibraries(s, await loadSystem(root, options.config, (m) => config.logger.info(m)));
+			} catch (error) {
+				throw loadFailure(error, root, options.config);
+			}
+			setSystem(s, loaded);
+			for (const filter of [transformFilter, frameworkFilter]) if (s.dev) delete filter.code;
+			else filter.code = sources;
+			if (s.dev) delete libraryFilter.id;
+			else libraryFilter.id = libraryDirs;
+			if (state) {
+				registry.clear();
+				cache.clear();
+				diskCache = void 0;
+				scans.clear();
+				kept.clear();
+				transformed.clear();
+				scriptStyles.clear();
+				changes.clear();
+				resolutions.clear();
+			}
+			session = newSession();
+			state = s;
+		},
+		configureServer(dev) {
+			server = dev;
+			const s = ready();
+			let release;
+			closing = new Promise((resolve) => release = resolve);
+			const client = dev.environments.client;
+			if (client) {
+				const close = client.close.bind(client);
+				client.close = () => {
+					release();
+					return close();
+				};
+			}
+			const forget = () => resolutions.clear();
+			for (const event of [
+				"add",
+				"unlink",
+				"addDir",
+				"unlinkDir"
+			]) dev.watcher.on(event, forget);
+			dev.watcher.on("change", (file) => {
+				if (/(?:^|[/\\])(?:package|[jt]sconfig[^/\\]*)\.json$/.test(file)) forget();
+			});
+			const candidates = options.config ? [] : CONFIG_FILES.map((name) => normalizePath(path.join(s.root, name)));
+			dev.watcher.add([...s.loaded.watch, ...candidates]);
+			let reloading = Promise.resolve();
+			let queued = false;
+			const onChange = (file) => {
+				const id = normalizePath(file);
+				const watched = ready().loaded.watch.includes(id) || candidates.includes(id) || failedReads.has(id);
+				if (queued || !watched) return;
+				queued = true;
+				reloading = reloading.then(() => {
+					queued = false;
+					return reloadConfig(dev).catch((error) => {
+						ready().config.logger.error(`vicss: ${String(error)}`, { timestamp: true });
+					});
+				});
+			};
+			dev.watcher.on("change", onChange);
+			dev.watcher.on("add", onChange);
+			dev.watcher.on("unlink", onChange);
+		},
+		async buildStart() {
+			const s = ready();
+			if (s.dev) return;
+			session.started = true;
+			if (this.meta.watchMode) {
+				if (configChanged) await reloadBuildConfig(this, s);
+				for (const file of [...s.loaded.watch, ...failedReads]) this.addWatchFile(file);
+			}
+			buildResolutions.delete(this.environment);
+			const run = startScan(this);
+			if (this.meta.watchMode) {
+				await run.result.catch(() => {});
+				const sheet = await sheetFor(this);
+				for (const file of sheet?.scan.files ?? []) this.addWatchFile(file);
+			}
+			if (s.tokensFile && this.environment.config.consumer === "client") {
+				this.emitFile({
+					type: "chunk",
+					id: s.ids.tokens,
+					name: TOKENS_CHUNK_NAME
+				});
+				tokenAssets.set(this.environment, { config: this.environment.config });
+			}
+		},
+		watchChange(id) {
+			scans.clear();
+			kept.clear();
+			const file = normalizePath(id);
+			if (state && !state.dev && (state.loaded.watch.includes(file) || failedReads.has(file))) configChanged = true;
+		},
+		resolveId: {
+			filter: { id: CSS_ID },
+			handler(source, importer) {
+				const s = ready();
+				const [file, query] = splitQuery(source);
+				if (file === "virtual:vicss/base.css" || file === "/@vicss/base.css" || file === s.ids.base) return s.dev ? s.ids.base + query : null;
+				if (file === "virtual:vicss/sheet.css" || file === "/@vicss/sheet.css" || file === s.ids.sheet) return s.dev ? null : s.ids.sheet + query;
+				if (file === "/@vicss/tokens.css" || file === s.ids.tokens) return s.dev || !s.tokensFile ? null : s.ids.tokens + query;
+				const library = /(?:^virtual:vicss\/lib\/|\/@vicss\/lib\/)(\d+)\.css$/.exec(file);
+				if (library) return s.dev ? `${s.ids.libraries}${library[1]}.css${query}` : null;
+				if (!s.dev || !file.endsWith(".vicss.css")) return null;
+				return moduleCssId(s.root, file, importer) + query;
+			}
+		},
+		load: {
+			filter: { id: CSS_ID },
+			async handler(id) {
+				const s = ready();
+				const [file] = splitQuery(id);
+				if (file === s.ids.sheet && !s.dev) return (await sheetFor(this))?.css.sheet ?? "";
+				if (file === s.ids.tokens && !s.dev) return (await sheetFor(this))?.css.tokens ?? "";
+				if (!s.dev) return null;
+				if (file.startsWith(s.ids.libraries)) {
+					const library = s.loaded.libraries[Number(file.slice(s.ids.libraries.length, -4))];
+					return library ? moduleCss(library, s.loaded.system, s.print.names) : "";
+				}
+				if (file === s.ids.base) {
+					const env = this.environment;
+					if (env.mode === "dev" && env.config.consumer === "client") await Promise.race([env.waitForRequestsIdle(id), closing]);
+					await rebuilt;
+					try {
+						return devBaseCss(registry, s.print, s.loaded.libraries);
+					} catch (error) {
+						return fail(this, error, { id });
+					}
+				}
+				if (!file.endsWith(".vicss.css")) return null;
+				const source = file.slice(0, -10);
+				let styles = registry.ofFile(source);
+				if (!styles) {
+					if (!(SCRIPT_ID.test(source) || isSfc(source)) || source.includes("/node_modules/") || !isFileLoadingAllowed(s.config, source)) return "";
+					let code;
+					try {
+						code = await readFile(source, "utf8");
+					} catch {
+						return "";
+					}
+					let result;
+					try {
+						const resolve = devResolver(this);
+						result = isSfc(source) ? mergeStyles(await Promise.all(extractScripts(source, code).map(({ code: script, ...options }) => compile(s.compile, source, script, resolve, options)))) : await compile(s.compile, source, code, resolve);
+					} catch (error) {
+						fail(this, error, {
+							id: source,
+							code
+						});
+					}
+					for (const dep of result.dependencies) this.addWatchFile(dep);
+					if (register(source, result)) baseChanged();
+					styles = result;
+				}
+				this.addWatchFile(source);
+				return moduleCss(styles, s.loaded.system, s.print.names);
+			}
+		},
+		transform: {
+			order: "pre",
+			filter: transformFilter,
+			handler(code, id) {
+				if (isSfc(id)) return null;
+				return transformStyled(this, code, id);
+			}
+		},
+		async hotUpdate(ctx) {
+			const s = ready();
+			const file = normalizePath(ctx.file);
+			if (!s.dev || s.loaded.watch.includes(file) || DECLARATION_ID.test(file)) return;
+			const key = `${ctx.timestamp}:${file}`;
+			let change = changes.get(key);
+			if (!change) {
+				for (const [k, c] of changes) if (c.at < ctx.timestamp - 1e4) changes.delete(k);
+				const read = () => readFileSync(file, "utf8") || ctx.read();
+				const resolve = memoize(resolutions, this.environment.name, envResolver(s, this.environment));
+				const done = applyChange(file, ctx.type, read, resolve);
+				changes.set(key, change = {
+					at: ctx.timestamp,
+					done
+				});
+			}
+			const { styled, dependants, base } = await change.done;
+			if (styled.length === 0 && dependants.length === 0 && !base) return;
+			const graph = this.environment.moduleGraph;
+			const updates = new Set(ctx.modules);
+			const files = [
+				...dependants.map(fileOf),
+				...styled.map((id) => fileOf(id) + MODULE_SUFFIX),
+				...base ? [s.ids.base] : []
+			];
+			for (const updated of files) for (const mod of graph.getModulesByFile(updated) ?? []) {
+				graph.invalidateModule(mod, /* @__PURE__ */ new Set(), ctx.timestamp, true);
+				updates.add(mod);
+			}
+			return [...updates];
+		},
+		/**
+		* Compiled code names classes by placeholder (core/names.ts): the
+		* build's scan knows every class by now, the sheet's load having waited
+		* for it, so each chunk gets the names the sheet prints (PLAN D31).
+		*/
+		async renderChunk(code, chunk) {
+			if (state?.dev !== false || !hasPlaceholders(code)) return null;
+			const sheet = await sheetFor(this);
+			if (!sheet) return null;
+			const edits = new SourceEdits(code);
+			for (const { start, end, text } of renameClasses(code, (identity) => sheet.names.name(identity))) edits.overwrite(start, end, text);
+			const file = chunk.fileName;
+			return {
+				code: edits.toString(),
+				map: this.environment.config.build.sourcemap ? edits.generateMap({
+					source: file,
+					file,
+					hires: true
+				}) : null
+			};
+		},
+		async generateBundle(_options, bundle) {
+			if (state?.dev !== false) return;
+			if (state.library && this.environment.config.build?.lib) {
+				const s = state;
+				const sheet = await sheetFor(this);
+				if (!sheet) return;
+				const result = sheet.scan;
+				const classes = Object.fromEntries(printed(result).identities.map((identity) => [identity, sheet.names.name(identity)]));
+				const manifest = createManifest(result, s.loaded.system, s.pkg, classes);
+				this.emitFile({
+					type: "asset",
+					fileName: MANIFEST_FILE,
+					source: `${JSON.stringify(manifest, null, 2)}\n`
+				});
+				this.emitFile({
+					type: "asset",
+					fileName: LIBRARY_SHEET_FILE,
+					source: buildCss(result, {
+						...s.print,
+						names: sheet.names
+					}, false).sheet
+				});
+			}
+			const names = [];
+			const tokens = tokenAssets.get(this.environment);
+			for (const chunk of Object.values(bundle)) {
+				if (chunk.type !== "chunk") continue;
+				const css = [...chunk.viteMetadata?.importedCss ?? []];
+				if (chunk.moduleIds.includes(state.ids.sheet)) names.push(...css);
+				if (tokens && chunk.facadeModuleId === state.ids.tokens) tokens.fileName = css[0];
+			}
+			sheetFiles.set(this.environment, names);
+		},
+		writeBundle(_options, bundle) {
+			const names = [...sheetFiles.get(this.environment) ?? []];
+			const tokens = tokenAssets.get(this.environment)?.fileName;
+			if (!session.scan || names.length === 0) return;
+			if (tokens) names.push(tokens);
+			const files = names.flatMap((name) => {
+				const asset = bundle[name];
+				return asset?.type === "asset" ? [[name, asset.source]] : [];
+			});
+			if (files.length === names.length) summarize(session.scan, files);
+		},
+		async buildEnd(error) {
+			if (error) session.failed = true;
+			if (error || state?.dev !== false) return;
+			session.failed = true;
+			const sheet = await sheetFor(this);
+			if (!sheet) return;
+			session.failed = false;
+			session.scan = sheet.scan;
+		},
+		async closeBundle() {
+			const s = state;
+			if (!s || s.dev || ++session.closed < Math.max(1, session.configs - 1)) return;
+			await Promise.all(cacheWrites.splice(0));
+			kept.clear();
+			if (s.diskCache) {
+				cache.clear();
+				diskCache = void 0;
+			}
+			s.compile = {
+				...s.compile,
+				parsed: createParseCache()
+			};
+			if (session.scan && !session.failed) summarize(session.scan);
+		}
+	};
+	/**
+	* `.vue`, `.svelte` and `.astro` modules once their framework's plugin has
+	* compiled them to JS (PLAN §5.4): the same compile, CSS and registry as
+	* the `pre` transform. The pre-scan read the files' scripts; a style call
+	* in a template reaches this transform only, and the safety net says so.
+	*/
+	/**
+	* The modules of installed libraries: they bring the CSS their classes
+	* need, and name the app's custom properties where their JS names the
+	* library's own (`token()`, runtime values) under another prefix.
+	*/
+	const libraries = {
+		name: "vicss:libraries",
+		sharedDuringBuild: true,
+		config(config) {
+			const root = path.resolve(config.root ?? process.cwd());
+			const names = [...new Set(findLibraries(normalizePath(root)).map((library) => library.name))];
+			if (names.length === 0) return void 0;
+			return {
+				optimizeDeps: { exclude: names },
+				ssr: { noExternal: names }
+			};
+		},
+		transform: {
+			filter: libraryFilter,
+			handler(code, id) {
+				const s = ready();
+				const file = fileOf(id);
+				const library = SCRIPT_ID.test(file) ? libraryOf(s.loaded.libraries, file) : void 0;
+				if (s.library || !library) return null;
+				const renamed = library.renames && renameCustomProperties(code, file, library.renames);
+				if (!renamed) return {
+					code: code + libraryImports(s, library),
+					map: null
+				};
+				return {
+					code: renamed.code + libraryImports(s, library),
+					map: renamed.map
+				};
+			}
+		},
+		transformIndexHtml: {
+			order: "pre",
+			handler() {
+				const s = ready();
+				if (!s.dev || s.loaded.libraries.length === 0) return void 0;
+				return [{
+					tag: "script",
+					attrs: { type: "module" },
+					children: libraryImports(s).trim(),
+					injectTo: "head-prepend"
+				}];
+			}
+		}
+	};
+	const frameworks = {
+		name: "vicss:frameworks",
+		enforce: "post",
+		sharedDuringBuild: true,
+		transform: {
+			filter: frameworkFilter,
+			handler(code, id) {
+				return transformStyled(this, code, id);
+			}
+		}
+	};
+	const html = {
+		name: "vicss:tokens-file",
+		apply: "build",
+		sharedDuringBuild: true,
+		transformIndexHtml: {
+			order: "post",
+			handler(_html, ctx) {
+				for (const asset of tokenAssets.values()) if (asset.fileName && ctx.bundle?.[asset.fileName]) {
+					const page = normalizePath(path.relative(asset.config.root, ctx.filename));
+					return [tokensLink(asset.config, asset.fileName, page)];
+				}
+			}
+		},
+		buildEnd(error) {
+			if (error) tokenAssets.delete(this.environment);
+		},
+		closeBundle() {
+			tokenAssets.delete(this.environment);
+		}
+	};
+	/**
+	* Build: what critical CSS did to each page, by its file, until the
+	* bundle that emits the page claims it. The HTML hook has no
+	* environment, and Rolldown hands each hook its own bundle object.
+	*/
+	const criticalPages = /* @__PURE__ */ new Map();
+	/** Build: each bundle's CSS files, parsed once for all of its pages. */
+	const criticalSheets = /* @__PURE__ */ new WeakMap();
+	const criticalCss = {
+		name: "vicss:critical",
+		apply: "build",
+		enforce: "post",
+		sharedDuringBuild: true,
+		transformIndexHtml: {
+			order: "post",
+			handler(html, ctx) {
+				const settings = criticalSettings(options.critical);
+				const bundle = ctx.bundle;
+				if (!settings || !bundle || state?.dev !== false) return void 0;
+				let output = criticalSheets.get(bundle);
+				if (!output) {
+					const assets = Object.values(bundle).flatMap((file) => file.type === "asset" && file.fileName.endsWith(".css") ? [file] : []);
+					const sources = new Map(assets.map((asset) => [asset.fileName, asset.source]));
+					const { publicDir } = state.config;
+					const own = publicDir && existsSync(publicDir) ? publicStylesheets(publicDir) : [];
+					const names = session.scan && printed(session.scan).names;
+					const sheets = new SheetCache((file) => {
+						const source = sources.get(file);
+						if (source !== void 0) return typeof source === "string" ? source : Buffer.from(source).toString();
+						return own.includes(file) ? readFileSync(path.join(publicDir, file), "utf8") : void 0;
+					}, names ? (cls) => names.relates(cls) : void 0);
+					output = {
+						files: [...sources.keys(), ...own],
+						sheets
+					};
+					criticalSheets.set(bundle, output);
+				}
+				const result = criticalPage({
+					page: ctx.path.replace(/^\//, ""),
+					html,
+					...output,
+					requireClasses: true
+				});
+				criticalPages.set(result.page, result);
+				return result.html;
+			}
+		},
+		generateBundle(_options, bundle) {
+			const settings = criticalSettings(options.critical);
+			const pages = [...criticalPages.values()].filter((page) => bundle[page.page]?.type === "asset");
+			if (!settings || pages.length === 0) return;
+			for (const page of pages) criticalPages.delete(page.page);
+			const inlined = pages.some((page) => page.html !== void 0);
+			if (settings.hashes !== false && inlined) this.emitFile({
+				type: "asset",
+				fileName: settings.hashes,
+				source: hashesJson(pages, settings.budget)
+			});
+			const { logger } = this.environment.config;
+			const result = report(pages, settings.budget, inlined && settings.hashes ? settings.hashes : void 0);
+			logger.info(result.summary);
+			for (const warning of result.warnings) logger.warn(`vicss: ${warning}`);
+			for (const page of pages) if (page.skipped !== void 0 && !page.warning) logger.info(`vicss: ${page.page}: left as it was: ${page.skipped}`);
+		}
+	};
+	/** Where a check names the module: relative to the root, as `data-vx-src` does. */
+	const sourceName = (id) => {
+		const file = id.replace(/[?#].*$/, "");
+		const root = ready().root.replace(/\/+$/, "");
+		return file.startsWith(`${root}/`) ? file.slice(root.length + 1) : file;
+	};
+	return [
+		main,
+		{
+			name: "vicss:style-checks",
+			enforce: "pre",
+			apply: "serve",
+			sharedDuringBuild: true,
+			transform: {
+				order: "pre",
+				filter: {
+					id: SCRIPT_ID,
+					code: "style="
+				},
+				handler(code, id) {
+					if (id.includes("/node_modules/") || DECLARATION_ID.test(id)) return null;
+					return checkStyles(code, id, sourceName(id));
+				}
+			}
+		},
+		libraries,
+		frameworks,
+		{
+			name: "vicss:attributes",
+			enforce: "post",
+			sharedDuringBuild: true,
+			transform: {
+				filter: {
+					id: SFC_SCRIPT_ID,
+					code: COMPONENT_CALLS
+				},
+				handler(code, id) {
+					if (id.includes("/node_modules/")) return null;
+					return rewriteComponent(code, id, {
+						dev: ready().dev,
+						src: sourceName(id)
+					});
+				}
+			}
+		},
+		html,
+		criticalCss
+	];
+}
+/** The `.css` files under the public directory, relative to it, as Vite copies them to the output. */
+function publicStylesheets(dir) {
+	return readdirSync(dir, {
+		recursive: true,
+		withFileTypes: true
+	}).flatMap((entry) => entry.isFile() && entry.name.endsWith(".css") ? [normalizePath(path.relative(dir, path.join(entry.parentPath, entry.name)))] : []);
+}
+/**
+* What the scan's worker threads build their compiler from: the merged config
+* as data, or, when it holds functions (utilities), the file that defines
+* it. A config object with functions cannot cross to a thread: no workers.
+*/
+function workerSetup(s) {
+	const { system, file } = s.loaded;
+	const common = {
+		root: s.root,
+		hash: system.hash,
+		sourceMap: s.compile.sourceMap,
+		dev: s.compile.dev === true,
+		placeholders: s.compile.placeholders === true,
+		package: s.pkg,
+		frameworks: s.frameworks
+	};
+	if (!hasFunction(system.config)) return {
+		...common,
+		config: { data: system.config }
+	};
+	return file ? {
+		...common,
+		config: {
+			file,
+			shape: configShape(system.config)
+		}
+	} : void 0;
+}
+/**
+* An error thrown while the config loads (an invalid config, a library the
+* design system does not cover), worded as `fail` words a module's:
+* `vicss(CODE): message` with the hint below it. Vite prints a startup
+* error's message and stack, and the JS API's callers read the message; a
+* VicssError keeps its hint apart. A config error names the config file.
+*/
+function loadFailure(error, root, option) {
+	if (!(error instanceof VicssError)) return error;
+	const { code, hint } = error;
+	const failure = /* @__PURE__ */ new Error(`vicss(${code}): ${error.message}${hint ? `\n${hint}` : ""}`);
+	const file = typeof option === "string" ? normalizePath(path.resolve(root, option)) : option === void 0 ? CONFIG_FILES.map((name) => normalizePath(path.join(root, name))).find(existsSync) : void 0;
+	return Object.assign(failure, {
+		code,
+		plugin: "vicss",
+		...code === "CONFIG" && file ? { id: file } : {}
+	});
+}
+/**
+* What a package manager writes when it installs: lockfiles, and the state
+* files some keep in `node_modules` (Vite's dependency optimizer reads the
+* same). The nearest directory above `root` that has any, as the workspace
+* root of a monorepo does.
+*/
+const LOCKFILES = [
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"npm-shrinkwrap.json",
+	"yarn.lock",
+	"bun.lock",
+	"bun.lockb",
+	"node_modules/.pnpm/lock.yaml",
+	"node_modules/.package-lock.json",
+	"node_modules/.yarn-state.yml"
+];
+function lockfiles(root) {
+	for (let dir = root;; dir = path.dirname(dir)) {
+		const found = LOCKFILES.map((name) => normalizePath(path.join(dir, name))).filter(existsSync);
+		if (found.length > 0 || path.dirname(dir) === dir) return found;
+	}
+}
+/**
+* The lines of a framework file that its compiled output came from, read
+* from the map Vite combined for the module so far; undefined without one.
+*/
+function mappedLines(ctx, id) {
+	const file = fileOf(id);
+	let map;
+	try {
+		map = ctx.getCombinedSourcemap();
+	} catch {
+		return;
+	}
+	const only = map.sources.length === 1;
+	return originalLines(map, (source) => only || normalizePath(path.resolve(path.dirname(file), source)) === file);
+}
+/**
+* Whether a build ships readable names: `classNames.readable`, else
+* `VICSS_READABLE=1` in the environment, which debugs a production build,
+* and runs a test suite's builds, without editing the config.
+*/
+function readableBuild(options) {
+	return options.readable ?? process.env.VICSS_READABLE === "1";
+}
+/**
+* What a build names (core/names.ts): every atom, theme, flattened base and
+* marker of the sheet, and every class compiled code names (`names`, from
+* the scan): markers applied without a style, palette prefixes.
+*/
+function identitiesOf(styles, names) {
+	const out = new Set(names);
+	for (const atom of styles.atoms) {
+		out.add(atom.className);
+		for (const condition of atom.chain) {
+			const marker = /^_vx:m:([gp]):([0-9a-z]{6}):/.exec(condition);
+			if (marker) out.add(`vx-${marker[1]}${marker[2]}_m`);
+		}
+	}
+	for (const rule of styles.rules) if (rule.kind !== "keyframes") out.add(rule.id);
+	return [...out].sort();
+}
+/** One build: the configs it resolved, the environments that closed, its scan. */
+function newSession() {
+	return {
+		started: false,
+		configs: 1,
+		closed: 0,
+		failed: false,
+		scan: void 0
+	};
+}
+/**
+* Resolution for the compiler, through the environment's plugins. Constants
+* become class names the server must render as the client does, so an
+* installed package resolves to the file the client reads, in every
+* environment and in the scan whichever environment starts it; one a server
+* build externalizes is still read at build time.
+*/
+function constantsResolver(s, env, resolve) {
+	return async (source, importer) => {
+		const resolved = await resolve(source, importer);
+		const server = env.config.consumer === "server";
+		if (!resolved || !resolved.external && !(server && resolved.id.includes("/node_modules/"))) return resolved;
+		const { conditions, mainFields } = s.config.environments.client.resolve;
+		s.clientResolve ??= createIdResolver(s.config, {
+			conditions,
+			mainFields,
+			external: [],
+			noExternal: true
+		});
+		const id = await s.clientResolve(env, source, importer);
+		if (id) return { id };
+		if (!resolved.external) return resolved;
+		return path.isAbsolute(resolved.id) ? { id: resolved.id } : null;
+	};
+}
+function contextResolver(s, ctx) {
+	return constantsResolver(s, ctx.environment, (source, importer) => ctx.resolve(source, importer, { skipSelf: true }));
+}
+/** Resolution outside a plugin hook, through the environment's plugins. */
+function envResolver(s, env) {
+	return constantsResolver(s, env, (source, importer) => env.pluginContainer.resolveId(source, importer));
+}
+/**
+* Resolutions by importer directory and request: a request resolves the same
+* from every file of a directory, and most files import the same
+* design-system modules, so each is resolved once.
+*/
+function memoize(resolved, prefix, resolve) {
+	return (source, importer) => {
+		const key = `${prefix}\0${path.dirname(importer)}\0${source}`;
+		let found = resolved.get(key);
+		if (!found) {
+			resolved.set(key, found = resolve(source, importer));
+			found.catch(() => resolved.delete(key));
+		}
+		return found;
+	};
+}
+/** `run` over `items`, `BATCH` at a time, results in order. */
+async function inBatches(items, run) {
+	const out = [];
+	for (let i = 0; i < items.length; i += BATCH) out.push(...await Promise.all(items.slice(i, i + BATCH).map(run)));
+	return out;
+}
+/** The styles of several modules (a framework file's scripts) as one. */
+function mergeStyles(parts) {
+	return {
+		atoms: [...new Map(parts.flatMap((part) => part.atoms).map((a) => [a.className, a])).values()].sort((a, b) => a.className < b.className ? -1 : 1),
+		tokens: parts.flatMap((part) => part.tokens),
+		rules: parts.flatMap((part) => part.rules),
+		dependencies: [...new Set(parts.flatMap((part) => part.dependencies))]
+	};
+}
+/** Whether a module's dev CSS prints alike: the same atoms and flattened bases. */
+const sameCss = (a, b) => {
+	const bases = (styles) => styles.rules.filter((rule) => rule.kind === "base").map((rule) => rule.id);
+	const [x, y] = [bases(a), bases(b)];
+	return a.atoms.length === b.atoms.length && a.atoms.every((atom, i) => atom.className === b.atoms[i].className) && x.length === y.length && x.every((id, i) => id === y[i]);
+};
+/** Why a style in a framework file's template fails (PLAN §5.4). */
+const TEMPLATE_HINT = "styles written in a component's template are not supported, since the pre-scan reads only the file's scripts. Move the style into the <script> (or the frontmatter): `const card = css({ … })`, then use `card` in the template.";
+/** Matches no module id: a filter with no patterns would match every one. */
+const NOTHING = /^\0vicss:no-library$/;
+function hasFunction(value) {
+	if (typeof value === "function") return true;
+	if (typeof value !== "object" || value === null) return false;
+	return Object.values(value).some(hasFunction);
+}
+/**
+* `./X.tsx.vicss.css` from its importer, `/src/X.tsx.vicss.css` from the
+* root (the dev server's URL), or an absolute path (`/@fs/…` or `/@id/…`
+* outside the root).
+*/
+function moduleCssId(root, file, importer) {
+	if (file.startsWith("./") || file.startsWith("../")) {
+		const from = importer ? path.dirname(splitQuery(importer)[0]) : root;
+		return normalizePath(path.resolve(from, file));
+	}
+	if (file.startsWith("/@fs/")) return file.slice(4);
+	if (file.startsWith(`${root}/`)) return file;
+	const source = file.slice(0, -10);
+	return existsSync(source) && !existsSync(root + source) ? file : root + file;
+}
+/** The safety net: a module compiled outside the scan needs atoms or rules the sheet lacks. */
+function checkSheet(ctx, sheet, tokenKeys, result, id, root) {
+	const clean = fileOf(id);
+	const file = path.relative(root, clean) || clean;
+	const why = !sheet.files.includes(clean) ? "the file is outside `include` in vicss.config.ts, so the pre-scan never compiled it. Add it to `include` (or remove it from `exclude`)." : isSfc(clean) ? TEMPLATE_HINT : `the pre-scan compiled this file to other atoms: one of its imports resolves differently in the ${ctx.environment.name} environment, or the file changed during the build.`;
+	const atom = result.atoms.find((a) => !sheet.classes.has(a.className));
+	if (atom) ctx.error({
+		code: "MISSING_ATOM",
+		id,
+		message: `vicss(MISSING_ATOM): ${file} uses the class \`${atom.className}\`, which the sheet lacks: ${why}`
+	});
+	const rule = result.rules.find((r) => !sheet.ruleIds.has(r.id));
+	if (rule) {
+		const kind = rule.kind === "base" ? "flattened recipe base" : rule.kind;
+		ctx.error({
+			code: "MISSING_RULE",
+			id,
+			message: `vicss(MISSING_RULE): ${file} uses the ${kind} \`${rule.id}\`, which the sheet lacks: ${why}`
+		});
+	}
+	const token = result.tokens.find((ref) => !tokenKeys.has(`${ref.scale}:${ref.path}`));
+	if (token) ctx.error({
+		code: "MISSING_TOKEN",
+		id,
+		message: `vicss(MISSING_TOKEN): ${file} uses the token \`${token.scale}.${token.path}\`, which the sheet lacks: ${why}`
+	});
+}
+/**
+* A VicssError becomes a located plugin error reading `vicss(CODE): message`
+* and the hint, with a code frame (PLAN §5.4) as `frame`, which Vite's
+* overlay and logs and Rolldown's build error all print under the message.
+* `code` is the source of `id` as compiled (a framework's output, or a
+* framework file whose scripts compiled with the rest blanked, so lines and
+* columns are the file's); a location in another file is framed from disk.
+*/
+function fail(ctx, error, where) {
+	if (!(error instanceof VicssError)) throw error;
+	const { loc, hint } = error;
+	const message = `vicss(${error.code}): ${error.message}${hint ? `\n${hint}` : ""}`;
+	const id = loc?.file ?? where.id;
+	const source = loc && (loc.file === where.id ? where.code : readSource(loc.file));
+	const frame = loc && source !== void 0 ? codeFrame(source, loc.line, loc.column) : void 0;
+	ctx.error({
+		message,
+		code: error.code,
+		...id ? { id } : {},
+		...loc ? { loc: {
+			file: loc.file,
+			line: loc.line,
+			column: loc.column
+		} } : {},
+		...frame ? { frame } : {}
+	});
+}
+/**
+* Vitest serves modules through a dev server (`command: "serve"`) in mode
+* `test`, or another mode with `--mode`, always with its own `vitest:`
+* plugins. Its output is asserted and snapshotted, where a source line in
+* every `sx()` result would break on any unrelated edit above it.
+*/
+function isTestRunner(config) {
+	return config.mode === "test" || config.plugins.some((plugin) => plugin.name.startsWith("vitest:"));
+}
+function readSource(file) {
+	try {
+		return readFileSync(file.replace(/[?#].*$/, ""), "utf8");
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { critical, vicss as default, vicss };