@menapo/vicss 0.0.0-stage → 1.0.0

package/dist/pool-BGXMhLfL.js

@@ -0,0 +1,2942 @@
+import { $ as keepAtom, A as getProperty, At as splitClasses, Ct as makeClassName, F as markerId, Ft as stableStringify, I as markerLabel, K as placeholder, L as markerSites, M as numberKind, Mt as toRecord, Nt as valueLabel, Ot as propertyKey, P as MarkerValue, Pt as hash, Tt as mergeClassNames, _t as VicssError, at as SPACING_STEP, b as hasPrivateAccess, ct as cssVarName, dt as isScaleName, ft as lookupToken, g as normalizeStyle, h as compileKeyframes, ht as suggestTokens, it as SCALE_NAMESPACES, jt as styleLiteral, k as PROPERTIES, kt as readableClass, lt as didYouMean, mt as scaleTokens, nt as typedPaletteNames, ot as closestNames, rt as SCALES, ut as isPlainObject, vt as classAttribute, x as privateTokenError, xt as fromRecord, yt as compareStrings } from "./print-Ds6fkgio.js";
+import { C as createLocator, _ as evaluate, a as buildRecipe, c as resolveRecipe, h as NOT_HANDLED, i as RecipeValue, m as shadowedByEarlier, n as compileTheme, o as printTable, p as isBaseClass, r as analyzeScopes, s as recipeKey, v as evaluateBinding, y as isDynamic } from "./theme-C-0LpsJx.js";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { availableParallelism } from "node:os";
+import { Worker } from "node:worker_threads";
+//#region src/core/edits.ts
+/**
+* Source edits with a source map (PLAN D20): the few operations the rewrite
+* step needs, without a dependency. Offsets always refer to the original
+* string, so edits can be recorded in any order.
+*/
+var SourceEdits = class {
+	original;
+	/** Sorted by start, never overlapping. */
+	#replacements = [];
+	#inserts = /* @__PURE__ */ new Map();
+	#prefix = "";
+	#keepLines;
+	constructor(original, options = {}) {
+		this.original = original;
+		this.#keepLines = options.keepLines === true;
+	}
+	overwrite(start, end, content) {
+		this.#checkRange(start, end);
+		if (start === end) throw new RangeError(`SourceEdits: empty range at ${start}; use insert()`);
+		let index = this.#replacements.findIndex((r) => r.start >= start);
+		if (index === -1) index = this.#replacements.length;
+		const before = this.#replacements[index - 1];
+		const after = this.#replacements[index];
+		const clash = before && before.end > start ? before : after && after.start < end ? after : null;
+		if (clash) throw new Error(`SourceEdits: [${start}, ${end}) overlaps the overwrite of [${clash.start}, ${clash.end})`);
+		for (const offset of this.#inserts.keys()) if (offset > start && offset < end) throw new Error(`SourceEdits: [${start}, ${end}) would drop the insert at ${offset}`);
+		if (this.#keepLines) content += "\n".repeat(Math.max(0, lineBreaks(this.original, start, end) - lineBreaks(content)));
+		this.#replacements.splice(index, 0, {
+			start,
+			end,
+			content
+		});
+		return this;
+	}
+	/** Inserts before the original character at `offset`; inserts at one offset keep call order. */
+	insert(offset, content) {
+		this.#checkRange(offset, offset);
+		const inside = this.#replacements.find((r) => offset > r.start && offset < r.end);
+		if (inside) throw new Error(`SourceEdits: insert at ${offset} falls inside the overwrite of [${inside.start}, ${inside.end})`);
+		const list = this.#inserts.get(offset);
+		if (list) list.push(content);
+		else this.#inserts.set(offset, [content]);
+		return this;
+	}
+	/** Adds `content` at the very start of the output, before earlier prepends and inserts. */
+	prepend(content) {
+		this.#prefix = content + this.#prefix;
+		return this;
+	}
+	remove(start, end) {
+		this.#checkRange(start, end);
+		return start === end ? this : this.overwrite(start, end, "");
+	}
+	hasChanged() {
+		return this.toString() !== this.original;
+	}
+	toString() {
+		let out = "";
+		for (const chunk of this.#chunks()) out += chunk.text;
+		return out;
+	}
+	/**
+	* Segments start every output line and every edit boundary. Unchanged text
+	* maps 1:1; replaced and inserted text maps to the start of the range it
+	* replaced or to its insertion point.
+	*/
+	generateMap(options) {
+		const locate = createLocator(this.original);
+		let mappings = "";
+		let column = 0;
+		let lineHasSegment = false;
+		let prevColumn = 0;
+		let prevSourceLine = 0;
+		let prevSourceColumn = 0;
+		const add = (offset) => {
+			const { line, column: sourceColumn } = locate(offset);
+			if (lineHasSegment) mappings += ",";
+			mappings += vlq(column - prevColumn) + "A" + vlq(line - 1 - prevSourceLine) + vlq(sourceColumn - prevSourceColumn);
+			lineHasSegment = true;
+			prevColumn = column;
+			prevSourceLine = line - 1;
+			prevSourceColumn = sourceColumn;
+		};
+		for (const { text, origin, copied } of this.#chunks()) {
+			add(origin);
+			for (let i = 0; i < text.length; i++) {
+				if (text.charCodeAt(i) === 10) {
+					mappings += ";";
+					column = 0;
+					prevColumn = 0;
+					lineHasSegment = false;
+				} else column++;
+				const next = i + 1;
+				if (next === text.length) continue;
+				if (column === 0 || options.hires && copied && isWordStart(text, next)) add(copied ? origin + next : origin);
+			}
+		}
+		return {
+			version: 3,
+			...options.file === void 0 ? {} : { file: options.file },
+			sources: [options.source],
+			...options.includeContent ? { sourcesContent: [this.original] } : {},
+			names: [],
+			mappings
+		};
+	}
+	#checkRange(start, end) {
+		if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start || end > this.original.length) throw new RangeError(`SourceEdits: invalid range [${start}, ${end}) for a string of length ${this.original.length}`);
+	}
+	#chunks() {
+		const chunks = [];
+		const push = (text, origin, copied) => {
+			if (text !== "") chunks.push({
+				text,
+				origin,
+				copied
+			});
+		};
+		let pos = 0;
+		const copyTo = (end) => {
+			if (end > pos) push(this.original.slice(pos, end), pos, true);
+			pos = end;
+		};
+		const replacements = this.#replacements;
+		let r = 0;
+		const replaceBefore = (limit) => {
+			for (let next = replacements[r]; next && next.start < limit; next = replacements[++r]) {
+				copyTo(next.start);
+				push(next.content, next.start, false);
+				pos = next.end;
+			}
+		};
+		push(this.#prefix, 0, false);
+		for (const offset of [...this.#inserts.keys()].sort((a, b) => a - b)) {
+			replaceBefore(offset);
+			copyTo(offset);
+			for (const text of this.#inserts.get(offset)) push(text, offset, false);
+		}
+		replaceBefore(Infinity);
+		copyTo(this.original.length);
+		return chunks;
+	}
+};
+const WORD = /[\w$]/;
+function isWordStart(text, i) {
+	return WORD.test(text[i]) && !WORD.test(text[i - 1]);
+}
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/** Base64 VLQ: sign in the lowest bit, then 5-bit groups, least significant first. */
+function vlq(value) {
+	let rest = value < 0 ? -value << 1 | 1 : value << 1;
+	let out = "";
+	do {
+		let digit = rest & 31;
+		rest >>>= 5;
+		if (rest > 0) digit |= 32;
+		out += BASE64[digit];
+	} while (rest > 0);
+	return out;
+}
+/**
+* Reads a map back: the 1-based line of the original source a generated
+* position (1-based line, 0-based column) came from, or undefined where the
+* map says nothing or names another source. For `data-vx-src` in a
+* framework file (PLAN §5.14), whose compiler moved its lines before vicss
+* compiles its output: the map Vite combined says where each line was.
+*/
+function originalLines(map, isSource) {
+	const lines = [];
+	let source = 0;
+	let sourceLine = 0;
+	for (const text of map.mappings.split(";")) {
+		const segments = [];
+		let column = 0;
+		for (const part of text.split(",")) {
+			if (!part) continue;
+			const fields = decodeVlq(part);
+			column += fields[0] ?? 0;
+			if (fields.length < 4) continue;
+			source += fields[1];
+			sourceLine += fields[2];
+			segments.push([
+				column,
+				source,
+				sourceLine
+			]);
+		}
+		lines.push(segments);
+	}
+	const own = map.sources.map((name) => name !== null && isSource(name));
+	return (line, column) => {
+		const segments = lines[line - 1] ?? [];
+		let found = segments[0];
+		for (const segment of segments) {
+			if (segment[0] > column) break;
+			found = segment;
+		}
+		return found && own[found[1]] ? found[2] + 1 : void 0;
+	};
+}
+/** The `\n`s in `text`, or in its range `[start, end)`. */
+function lineBreaks(text, start = 0, end = text.length) {
+	let count = 0;
+	for (let i = text.indexOf("\n", start); i !== -1 && i < end; i = text.indexOf("\n", i + 1)) count++;
+	return count;
+}
+/** The values of one segment's Base64 VLQ fields. */
+function decodeVlq(text) {
+	const out = [];
+	let value = 0;
+	let shift = 0;
+	for (const char of text) {
+		const digit = BASE64.indexOf(char);
+		if (digit === -1) return out;
+		value += (digit & 31) << shift;
+		if (digit & 32) {
+			shift += 5;
+			continue;
+		}
+		out.push(value & 1 ? -(value >>> 1) : value >>> 1);
+		value = 0;
+		shift = 0;
+	}
+	return out;
+}
+//#endregion
+//#region src/core/parser.ts
+let parser;
+let loading;
+/** Installs the parser before the first compile (a worker that loaded it itself). */
+function setParser(parse) {
+	parser = parse;
+}
+/** The parser, loading Vite once if nothing installed one. */
+function loadParser() {
+	if (parser) return parser;
+	return loading ??= import("vite").then((vite) => parser = vite.parseSync);
+}
+//#endregion
+//#region src/core/compile.ts
+/** One entry per module id: an edited module replaces its stale parse. */
+function createModuleCache() {
+	return {
+		parsed: /* @__PURE__ */ new Map(),
+		recipes: /* @__PURE__ */ new WeakMap()
+	};
+}
+/** Distinct recipe definitions a cache keeps per system before it starts over. */
+const RECIPE_CACHE_SIZE = 1e3;
+/** Compiles one module. Throws VicssError, with a location, for anything it refuses. */
+async function compileModule(code, options) {
+	const sources = [.../* @__PURE__ */ new Set([RUNTIME_PACKAGE, ...options.importSources ?? []])];
+	if (!sources.some((source) => code.includes(source))) return unchanged(code);
+	const compiler = new Compiler(code, options, sources, await loadParser());
+	if (compiler.root.runtime.size === 0) return unchanged(code);
+	for (;;) try {
+		return compiler.run();
+	} catch (error) {
+		if (!(error instanceof PendingImport)) throw error;
+		await Promise.all(error.requests.map(([importer, source]) => compiler.load(importer, source, error.probes.has(requestKey(importer, source)))));
+	}
+}
+const RUNTIME_PACKAGE = "@menapo/vicss";
+const RUNTIME_EXPORTS = /* @__PURE__ */ new Set([
+	"css",
+	"sx",
+	"token",
+	"recipe",
+	"theme",
+	"group",
+	"peer",
+	"keyframes"
+]);
+/**
+* What `sx()` returns per framework (PLAN §5.12): the class attribute a
+* folded call sets, the runtime export an `sx` import is pointed at
+* (React's shape is `sx` itself), and the dev variant a runtime call becomes
+* so the element names its source line (runtime/dev.ts). Every shape's
+* `style` is what its framework accepts: an object, or a `a:b;c:d` string.
+* `data-vx-src` is a plain attribute name, which every framework passes
+* through from a spread object as it is.
+*/
+const SX_SHAPES = {
+	react: {
+		attribute: "className",
+		dev: "__vxSxDev"
+	},
+	preact: {
+		attribute: "className",
+		dev: "__vxSxDev"
+	},
+	solid: {
+		attribute: "class",
+		target: "__vxSxClass",
+		dev: "__vxSxDevClass"
+	},
+	vue: {
+		attribute: "class",
+		target: "__vxSxClass",
+		dev: "__vxSxDevClass"
+	},
+	svelte: {
+		attribute: "class",
+		target: "__vxSxString",
+		dev: "__vxSxDevString"
+	},
+	astro: {
+		attribute: "class",
+		target: "__vxSxString",
+		dev: "__vxSxDevString"
+	},
+	vanilla: {
+		attribute: "class",
+		target: "__vxSxString",
+		dev: "__vxSxDevString"
+	}
+};
+/** D18: a folded `sx()` precomputes 2^n strings for n conditional arguments. */
+const MAX_FOLD_CONDITIONS = 2;
+/** Stands for a runtime value while the normaliser checks the rest of a function style. */
+const PLACEHOLDER = "\0vx";
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"ParenthesizedExpression",
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TSTypeAssertion",
+	"TSInstantiationExpression"
+]);
+/** Keys that hold types or metadata: no runtime call lives below them. */
+const SKIPPED_KEYS = /* @__PURE__ */ new Set([
+	"parent",
+	"range",
+	"typeAnnotation",
+	"typeArguments",
+	"typeParameters",
+	"returnType",
+	"superTypeArguments",
+	"implements"
+]);
+/** Tests that read the same without parentheses in front of `?`. */
+const BARE_TESTS = /* @__PURE__ */ new Set([
+	"Identifier",
+	"MemberExpression",
+	"ChainExpression",
+	"CallExpression",
+	"ParenthesizedExpression",
+	"UnaryExpression",
+	"Literal",
+	"ThisExpression"
+]);
+const LANGS = {
+	js: "js",
+	mjs: "js",
+	cjs: "js",
+	jsx: "jsx",
+	ts: "ts",
+	mts: "ts",
+	cts: "ts",
+	tsx: "tsx",
+	vue: "js",
+	svelte: "js",
+	astro: "js"
+};
+/** What a `css()` call is inside another static expression: its classes, as a class list. */
+var CompiledStyle = class {
+	__vxSpecial = "style";
+	classes;
+	constructor(classes) {
+		this.classes = classes;
+	}
+};
+/** A function style inside another expression: never a constant. */
+const FUNCTION_STYLE = { __vxSpecial: "functionStyle" };
+/**
+* Thrown through the evaluator when a constant lives in a module that is not
+* loaded yet. A VicssError, so the evaluator passes it on untouched.
+*/
+var PendingImport = class extends VicssError {
+	/** `[importer, source]` pairs, each once. */
+	requests;
+	/** Keys of the requests only a recipe probe made (`Compiler.probe`). */
+	probes;
+	constructor(requests, probes = false) {
+		super("PENDING_IMPORT", `${requests.map(([, source]) => `"${source}"`).join(", ")} not loaded yet`);
+		this.requests = requests;
+		this.probes = probes === true ? new Set(requests.map((request) => requestKey(...request))) : probes || /* @__PURE__ */ new Set();
+	}
+};
+var Compiler = class {
+	options;
+	system;
+	sources;
+	root;
+	modules = /* @__PURE__ */ new Map();
+	/** `importer\0source` → the module it loads, or why it cannot be loaded. */
+	requests = /* @__PURE__ */ new Map();
+	dependencies = /* @__PURE__ */ new Set();
+	/** Requests a recipe probe made for a package's module, which was not read (`load`). */
+	skipped = /* @__PURE__ */ new Set();
+	/** Above 0 while a callee that may be a recipe is evaluated (`probe`). */
+	probing = 0;
+	/** Exports being resolved, to stop re-export cycles that the evaluator never sees. */
+	resolving = /* @__PURE__ */ new Set();
+	/**
+	* `css()` calls being compiled: a function style evaluates in a context of
+	* its own, where the evaluator cannot see that it reads its own result.
+	*/
+	compiling = /* @__PURE__ */ new Set();
+	/** Every atom compiled in any module, by class name: folded classes report theirs. */
+	atomIndex = /* @__PURE__ */ new Map();
+	/** Every rule compiled in any module, by id. */
+	rules = /* @__PURE__ */ new Map();
+	/**
+	* This module's values outside their scales, by where they are written:
+	* a style evaluated in several passes counts once.
+	*/
+	arbitrary = /* @__PURE__ */ new Set();
+	/** The app's own class names this module's calls write (`CompileResult.names`). */
+	names = /* @__PURE__ */ new Set();
+	/** Module id → whether `privateAccess` lists it (PLAN §4.1). */
+	access = /* @__PURE__ */ new Map();
+	/** Every module's markers by family and id, as messages name them (`[row.hover]`). */
+	markerLabels = /* @__PURE__ */ new Map();
+	parseSync;
+	/** What `sx()` returns in this module, and the runtime functions of that shape. */
+	shape;
+	/** How a class is written into the output: readable, or a build's placeholder. */
+	emit;
+	pass;
+	constructor(code, options, sources, parseSync) {
+		this.options = options;
+		this.system = options.system;
+		this.sources = sources;
+		this.parseSync = parseSync;
+		this.shape = SX_SHAPES[options.framework ?? "react"];
+		this.emit = options.placeholders ? placeholder : readableClass;
+		this.root = this.createModule(options.id, code, options.lang, options.functionBody);
+		this.modules.set(options.id, this.root);
+		this.pass = newPass(code, options.keepLines === true);
+	}
+	run() {
+		const { root } = this;
+		this.pass = newPass(root.code, this.options.keepLines === true);
+		this.rewrite(root.program, this.pass.edits);
+		if (this.pass.pending.size > 0) throw new PendingImport([...this.pass.pending.values()], this.pass.probes);
+		for (const error of this.pass.errors) this.options.onError?.(error);
+		this.pruneImports();
+		const { edits, tokens, folded } = this.pass;
+		if (this.pass.devSx) edits.insert(root.code.length, `\nimport { ${this.shape.dev} } from "${RUNTIME_PACKAGE}";\n`);
+		const names = this.names.size > 0 && { names: [...this.names].sort(compareStrings) };
+		if (!edits.hasChanged()) return {
+			...unchanged(root.code),
+			arbitrary: this.arbitrary.size,
+			...names
+		};
+		const atoms = /* @__PURE__ */ new Map();
+		for (const style of root.styles.values()) for (const atom of style.atoms) keepAtom(atoms, atom);
+		for (const recipe of root.recipes.values()) for (const atom of recipe.atoms) keepAtom(atoms, atom);
+		const own = {
+			classes: [...atoms.keys()].sort(compareStrings),
+			rules: [.../* @__PURE__ */ new Set([...[...root.rules.values()].map((rule) => rule.id), ...[...root.recipes.values()].flatMap((recipe) => recipe.rules.map((rule) => rule.id))])].sort(compareStrings)
+		};
+		for (const cls of folded) {
+			const atom = this.atomIndex.get(cls);
+			if (atom && !atoms.has(cls)) atoms.set(cls, atom);
+		}
+		const file = root.id.replace(/[?#].*$/, "");
+		return {
+			code: edits.toString(),
+			map: this.options.sourceMap === false ? null : edits.generateMap({
+				source: file,
+				file,
+				includeContent: true,
+				hires: true
+			}),
+			atoms: [...atoms.values()].sort((a, b) => compareStrings(a.className, b.className)),
+			dependencies: [...this.dependencies],
+			tokens: [...tokens.values()],
+			rules: [...this.rules.values()].sort((a, b) => compareStrings(a.id, b.id)),
+			arbitrary: this.arbitrary.size,
+			...names,
+			own,
+			changed: true
+		};
+	}
+	/**
+	* Reads a module the evaluation needs. For a `probe`, a module under
+	* `node_modules` is not parsed or recorded as a dependency: any call of an
+	* import (`useState()`, `useQuery({ … })`) is probed for a recipe, and a
+	* package's barrel would otherwise load its whole graph on every compile.
+	* Packages hold compiled code, which never yields a recipe to fold.
+	*/
+	async load(importer, source, probe = false) {
+		const key = requestKey(importer, source);
+		if (this.requests.has(key) || probe && this.skipped.has(key)) return;
+		let loaded = null;
+		let reason = `"${source}" cannot be loaded from ${importer}`;
+		try {
+			loaded = await this.options.loadModule(source, importer);
+		} catch (error) {
+			reason = `"${source}" cannot be loaded from ${importer}: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		if (!loaded) {
+			this.requests.set(key, reason);
+			return;
+		}
+		if (probe && /[\\/]node_modules[\\/]/.test(loaded.id)) {
+			this.skipped.add(key);
+			return;
+		}
+		let target = this.modules.get(loaded.id);
+		if (!target) {
+			try {
+				target = this.createModule(loaded.id, loaded.code);
+			} catch (error) {
+				if (!(error instanceof VicssError)) throw error;
+				this.requests.set(key, `"${source}" (${loaded.id}) cannot be parsed: ${error.message}`);
+				return;
+			}
+			this.modules.set(loaded.id, target);
+		}
+		this.requests.set(key, target);
+		if (target !== this.root) this.dependencies.add(loaded.id);
+	}
+	createModule(id, code, lang, functionBody = false) {
+		const parsedAs = isJson(id) ? "js" : lang ?? langOf(id);
+		const { program, scopes } = this.parse(id, code, parsedAs, functionBody);
+		const ctx = {
+			file: id,
+			code,
+			scopes,
+			resolveImport: (binding) => this.resolveImport(mod, binding),
+			callHandler: (callee, _binding, args, evaluateNode) => this.evaluateCall(mod, callee, args, evaluateNode),
+			isHarmlessCall: (call) => runtimeName(mod, call.callee) !== void 0 || isUnref(mod, call.callee, call.arguments)
+		};
+		const mod = {
+			id,
+			code,
+			program,
+			scopes,
+			runtime: runtimeBindings(program, scopes, this.sources),
+			vue: this.options.framework === "vue" && id === this.options.id,
+			lang: parsedAs,
+			ctx,
+			styles: /* @__PURE__ */ new Map(),
+			rules: /* @__PURE__ */ new Map(),
+			recipes: /* @__PURE__ */ new Map(),
+			markers: /* @__PURE__ */ new Map(),
+			markerKeys: /* @__PURE__ */ new Map(),
+			markerSites: void 0,
+			locate: createLocator(code)
+		};
+		return mod;
+	}
+	/** A parse from the shared cache, or a new one. JSON modules read as their exports. */
+	parse(id, code, lang, functionBody = false) {
+		const key = `${lang === langOf(id) ? id : `${id}\0${lang}`}${functionBody ? "\0body" : ""}`;
+		const cached = this.options.cache?.parsed.get(key);
+		if (cached?.code === code) return cached;
+		const source = isJson(id) ? jsonModule(id, code) : code;
+		const program = parse(this.parseSync, id, source, lang, functionBody);
+		const parsed = {
+			code,
+			program,
+			scopes: analyzeScopes(program)
+		};
+		this.options.cache?.parsed.set(key, parsed);
+		return parsed;
+	}
+	/** Rewrites the runtime calls under `node`. */
+	rewrite(node, editor) {
+		walk(this.root, node, (child) => {
+			if (child.type !== "CallExpression") return true;
+			const name = runtimeName(this.root, child.callee);
+			try {
+				if (name === void 0) return !this.foldRecipeCall(child, editor);
+				return !this.rewriteCall(child, name, editor);
+			} catch (error) {
+				if (error instanceof VicssError && !(error instanceof PendingImport) && this.options.onError) {
+					this.pass.errors.push(error);
+					return false;
+				}
+				if (!(error instanceof PendingImport)) throw error;
+				const { pending, probes } = this.pass;
+				for (const request of error.requests) {
+					const key = requestKey(...request);
+					if (!error.probes.has(key)) probes.delete(key);
+					else if (!pending.has(key)) probes.add(key);
+					pending.set(key, request);
+				}
+				return false;
+			}
+		});
+	}
+	/** Returns whether the call was replaced; otherwise its arguments are rewritten in place. */
+	rewriteCall(call, name, editor) {
+		const { root } = this;
+		const evaluateHere = (node) => evaluate(node, root.ctx);
+		switch (name) {
+			case "css":
+				this.rewriteStyle(call, editor);
+				return true;
+			case "token": {
+				const token = this.tokenOf(root, call.callee, call.arguments, evaluateHere);
+				this.pass.tokens.set(`${token.scale}:${token.path}`, {
+					scale: token.scale,
+					path: token.path
+				});
+				this.replace(editor, call.start, call.end, JSON.stringify(`var(${token.cssVar})`));
+				return true;
+			}
+			case "sx":
+				if (this.fold(call, editor)) return true;
+				if (this.options.dev) this.devCall(call, editor);
+				return false;
+			case "keyframes":
+			case "theme": {
+				const rule = this.compileRule(root, name, call.callee, call.arguments, evaluateHere);
+				const text = name === "theme" ? `(${styleLiteral(rule.id, this.emit)})` : JSON.stringify(rule.id);
+				this.replace(editor, call.start, call.end, text);
+				return true;
+			}
+			case "recipe": {
+				const recipe = this.compileRecipe(root, call.callee, call.arguments, evaluateHere);
+				const helper = this.helper("__vxRecipe");
+				const extra = recipe.table.q ? `, ${this.helper("__vxResponsive")}` : "";
+				const table = this.options.dev && recipe.rules.length > 0 ? {
+					...recipe.table,
+					f: Object.fromEntries(recipe.rules.map((rule) => [rule.id, toRecord((rule.atoms ?? []).map((atom) => atom.className).join(" "))]))
+				} : recipe.table;
+				const text = `/*#__PURE__*/${helper}(${printTable(table, this.emit)}${extra})`;
+				const imports = root.program.body.filter((node) => node.type === "ImportDeclaration");
+				if (editor === this.pass.edits && imports.length > 0 && this.inFunction(call.start)) {
+					const local = this.hoistName();
+					this.pass.edits.insert(imports.at(-1).end, this.options.keepLines ? `;const ${local} = ${text};` : `\nconst ${local} = ${text};`);
+					this.replace(editor, call.start, call.end, local);
+				} else this.replace(editor, call.start, call.end, text);
+				return true;
+			}
+			case "group":
+			case "peer": {
+				const marker = this.markerOf(root, name, call.callee, call.arguments, evaluateHere);
+				this.replace(editor, call.start, call.end, `(${styleLiteral(marker.className, this.emit)})`);
+				return true;
+			}
+			default: return false;
+		}
+	}
+	/** Whether `offset` lies in a function (or a class field), which may run many times. */
+	inFunction(offset) {
+		const { root } = this;
+		if (!root.functions) {
+			const ranges = [];
+			walk(root, root.program, (node) => {
+				if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "PropertyDefinition" && !node.static) {
+					ranges.push([node.start, node.end]);
+					return false;
+				}
+				return true;
+			});
+			root.functions = ranges;
+		}
+		return root.functions.some(([start, end]) => offset > start && offset < end);
+	}
+	/** A module-level name for a hoisted recipe, unused in the module. */
+	hoistName() {
+		const { code } = this.root;
+		let name;
+		do
+			name = `__vxRecipeTable${++this.pass.hoisted}`;
+		while (code.includes(name));
+		return name;
+	}
+	/** The local name of a runtime export the output calls; `pruneImports` adds the import. */
+	helper(name) {
+		const { helpers } = this.pass;
+		const known = helpers.get(name);
+		if (known) return known.local;
+		const { root } = this;
+		for (const binding of root.scopes.moduleBindings.values()) if (binding.kind === "import" && binding.source === RUNTIME_PACKAGE && binding.imported === name) {
+			helpers.set(name, {
+				local: binding.name,
+				add: false
+			});
+			return binding.name;
+		}
+		let local = name;
+		for (let i = 1; root.code.includes(local); i++) local = `${name}${i}`;
+		helpers.set(name, {
+			local,
+			add: true
+		});
+		return local;
+	}
+	/**
+	* `button({ size: "sm" })` with a recipe the compiler knows and literal props
+	* becomes its classes (an object of them for slots), with up to D18's two
+	* runtime tests among the props. Returns whether the call was replaced.
+	*/
+	foldRecipeCall(call, editor) {
+		if (!this.mayBeRecipeCall(call)) return false;
+		const { root } = this;
+		const target = this.probe(() => attempt(() => evaluate(call.callee, root.ctx)));
+		if (!(target?.result instanceof RecipeValue)) return false;
+		const { recipe } = target.result;
+		const [arg] = call.arguments;
+		const props = arg ? this.foldProps(arg) : {
+			tests: [],
+			build: () => void 0
+		};
+		if (!props || props.tests.length > MAX_FOLD_CONDITIONS) return false;
+		const fail = this.propsError(root, call, arg);
+		const n = props.tests.length;
+		const slots = recipe.table.s;
+		const leaves = [];
+		for (let i = 0; i < 2 ** n; i++) {
+			const picks = props.tests.map((_, j) => (i >> n - 1 - j & 1) === 0);
+			const classes = resolveRecipe(recipe, props.build(picks), fail);
+			const styles = slots ? Object.values(classes) : [classes];
+			for (const style of styles) for (const cls of Object.values(style)) this.pass.folded.add(cls);
+			leaves.push(slots ? Object.fromEntries(slots.map((slot) => [slot, styleLiteral(classes[slot], this.emit)])) : { "": styleLiteral(classes, this.emit) });
+		}
+		const tests = props.tests.map((test) => this.testText(test));
+		const choose = (texts, depth = 0, at = 0) => {
+			if (depth === n) return texts[at];
+			const yes = choose(texts, depth + 1, at);
+			const no = choose(texts, depth + 1, at + 2 ** (n - depth - 1));
+			return yes === no ? yes : `${tests[depth]} ? ${yes} : ${no}`;
+		};
+		let text;
+		if (!slots) text = `(${choose(leaves.map((leaf) => leaf[""]))})`;
+		else text = `({ ${slots.map((slot) => {
+			const value = choose(leaves.map((leaf) => leaf[slot]));
+			return `${propertyKey(slot)}: ${value}`;
+		}).join(", ")} })`;
+		this.replace(editor, call.start, call.end, text);
+		return true;
+	}
+	/** Evaluates a callee that may be a recipe: packages it imports are not read (`load`). */
+	probe(evaluateCallee) {
+		this.probing++;
+		try {
+			return evaluateCallee();
+		} finally {
+			this.probing--;
+		}
+	}
+	/**
+	* A call that could be a recipe's: its callee is a binding that can hold
+	* one (a `const` or an import, or a member of one), and it passes nothing
+	* or an object literal. Only these callees are evaluated.
+	*/
+	mayBeRecipeCall(call) {
+		const args = call.arguments;
+		if (args.length > 1 || args[0] && unwrap(args[0]).type !== "ObjectExpression") return false;
+		let target = unwrap(call.callee);
+		if (target.type === "CallExpression" && isUnref(this.root, target.callee, target.arguments)) target = unwrap(target.arguments[0]);
+		if (target.type === "MemberExpression") {
+			if (target.computed && target.property.type !== "Literal") return false;
+			target = unwrap(target.object);
+		}
+		if (target.type !== "Identifier") return false;
+		const binding = this.root.scopes.bindingOf(target);
+		if (!binding) return false;
+		if (binding.kind === "import") return binding.source !== RUNTIME_PACKAGE && !(this.sources.includes(binding.source) && RUNTIME_EXPORTS.has(binding.imported));
+		if (binding.kind !== "const" || !binding.init) return false;
+		const init = unwrap(binding.init).type;
+		return init !== "ArrowFunctionExpression" && init !== "FunctionExpression";
+	}
+	/** Static props, or an object literal of them with runtime tests between static values. */
+	foldProps(node) {
+		const known = attempt(() => evaluate(node, this.root.ctx));
+		if (known) return {
+			tests: [],
+			build: () => known.result
+		};
+		const tests = [];
+		const build = this.propsShape(unwrap(node), tests);
+		return build && {
+			tests,
+			build
+		};
+	}
+	propsShape(node, tests) {
+		if (node.type !== "ObjectExpression") return void 0;
+		const entries = [];
+		for (const property of node.properties) {
+			if (property.type === "SpreadElement" || property.method || property.kind !== "init") return;
+			let key = staticKey(property);
+			if (property.computed) {
+				const value = attempt(() => evaluate(property.key, this.root.ctx))?.result;
+				key = typeof value === "string" || typeof value === "number" ? String(value) : void 0;
+			}
+			const value = key === void 0 ? void 0 : this.propValue(property.value, tests);
+			if (key === void 0 || !value) return void 0;
+			entries.push([key, value]);
+		}
+		return (picks) => Object.fromEntries(entries.map(([key, value]) => [key, value(picks)]));
+	}
+	propValue(node, tests) {
+		const known = attempt(() => evaluate(node, this.root.ctx));
+		if (known) return () => known.result;
+		const inner = unwrap(node);
+		if (inner.type === "ObjectExpression") return this.propsShape(inner, tests);
+		if (inner.type !== "ConditionalExpression") return void 0;
+		const index = tests.push(inner.test) - 1;
+		const yes = this.propValue(inner.consequent, tests);
+		const no = yes && this.propValue(inner.alternate, tests);
+		return yes && no && ((picks) => picks[index] ? yes(picks) : no(picks));
+	}
+	/** Errors in a recipe call's props, located at the prop. */
+	propsError(mod, at, arg) {
+		return (path, message, hint) => new VicssError("BAD_VARIANT", path ? `${path}: ${message}` : message, {
+			loc: arg ? this.locateStyle(mod, arg, path) : this.loc(mod, at),
+			hint
+		});
+	}
+	rewriteStyle(call, editor) {
+		const style = this.compileStyle(this.root, call.callee, call.arguments);
+		const { fn, vars } = style;
+		if (!fn || !vars) {
+			this.replace(editor, call.start, call.end, `(${styleLiteral(style.classes, this.emit)})`);
+			return;
+		}
+		const constant = this.localName("__vxStyle");
+		const memo = this.localName("__vxStyles");
+		const palettes = style.palettes ?? [];
+		this.replace(editor, call.start, fn.start, palettes.length === 0 ? `((${constant}) => ` : `((${constant}, ${memo} = {}) => `);
+		for (const param of fn.params) this.rewrite(param, editor);
+		const entries = [...new Map(vars.map((v) => [v.variable, v])).values()].map((v) => `${JSON.stringify(v.variable)}: ${this.runtimeValue(v.value, v.property)}`);
+		let classes = constant;
+		let body;
+		if (palettes.length === 0) body = entries.length > 0 ? `({ $c: ${classes}, $s: { ${entries.join(", ")} } })` : `({ $c: ${classes} })`;
+		else {
+			const picks = palettes.map((_, i) => `${memo}${i}`);
+			const add = palettes.map((p, i) => `...(${picks[i]} && { ${JSON.stringify(p.prefix.slice(0, -1))}: ${picks[i]} })`).join(", ");
+			classes = `(${memo}[${picks.join(" + \" \" + ")}] ??= { ...${constant}, ${add} })`;
+			const style$ = entries.length > 0 ? `{ $c: ${classes}, $s: { ${entries.join(", ")} } }` : `{ $c: ${classes} }`;
+			body = `((${picks.join(", ")}) => (${style$}))(${palettes.map((p) => this.paletteClass(p.prefix, p.value)).join(", ")})`;
+		}
+		this.replace(editor, fn.body.start, fn.body.end, body);
+		this.replace(editor, fn.end, call.end, `)(${styleLiteral(style.classes, this.emit)})`);
+	}
+	/** A name for a binding the output adds, unused in the module. */
+	localName(base) {
+		const { code } = this.root;
+		let name = base;
+		for (let i = 1; code.includes(name); i++) name = `${base}${i}`;
+		return name;
+	}
+	/** The class a runtime `colorPalette` picks (`"md:palette_" + tone`), or `""` for none. */
+	paletteClass(prefix, value) {
+		const named = JSON.stringify(this.emit(prefix));
+		if (isDynamic(value)) {
+			const { choice } = value;
+			if (choice) return `(${`${this.testText(choice.test)}${choice.nullish ? " != null" : ""}`} ? ${this.paletteClass(prefix, choice.consequent)} : ${this.paletteClass(prefix, choice.alternate)})`;
+			const { node } = value;
+			if (node.type === "Identifier") {
+				const name = node.name;
+				return `(${name} == null ? "" : ${named} + ${name})`;
+			}
+			return `((v) => v == null ? "" : ${named} + v)(${this.copy(node)})`;
+		}
+		return typeof value === "string" ? JSON.stringify(this.emit(prefix + value)) : "\"\"";
+	}
+	/**
+	* The expression that sets a custom property for `property`: tests run,
+	* numbers map like S9 at build time. In dev, a value the browser would
+	* drop warns once (runtime/dev.ts).
+	*/
+	runtimeValue(value, property) {
+		switch (value.kind) {
+			case "static": return value.css === void 0 ? "undefined" : JSON.stringify(value.css);
+			case "choice": return `(${`${this.testText(value.test)}${value.nullish ? " != null" : ""}`} ? ${this.runtimeValue(value.consequent, property)} : ${this.runtimeValue(value.alternate, property)})`;
+			case "token":
+				if (!this.options.dev) return tokenExpression(value.name, value.param);
+				return `${this.helper("__vxDevToken")}(${JSON.stringify(property)}, ${JSON.stringify(value.param.prefix)}, ${value.name})`;
+			case "runtime": {
+				const { node, numbers } = value;
+				const bare = node.type === "Identifier";
+				const text = bare ? node.name : this.copy(node, value.tokens);
+				const checked = (x) => this.options.dev ? `${this.helper("__vxDevValue")}(${JSON.stringify(property)}, ${x})` : x;
+				if (node.type === "TemplateLiteral") return checked(text);
+				const step = cssVarName(this.system.cssVarPrefix, "spacing", SPACING_STEP);
+				const map = (x) => {
+					const lookup = Object.keys(numbers.lookup).length > 0;
+					const fallback = {
+						calc: `"calc(var(${step}) * " + ${x} + ")"`,
+						px: `${x} + "px"`,
+						ms: `${x} + "ms"`,
+						deg: `${x} + "deg"`,
+						plain: `String(${x})`,
+						unset: "undefined"
+					}[numbers.fallback];
+					return `typeof ${x} === "number" ? ${lookup ? `${JSON.stringify(numbers.lookup)}[${x}] ?? ` : ""}${fallback} : ${x}`;
+				};
+				return checked(bare ? map(text) : `((v) => ${map("v")})(${text})`);
+			}
+		}
+	}
+	/**
+	* `sx(a, cond && b, x ? c : d)` with every style known at build time
+	* becomes its merged result, one string per combination of the tests.
+	*/
+	fold(call, editor) {
+		for (const arg of call.arguments) this.noteNames(arg);
+		const parts = [];
+		let conditions = 0;
+		for (const arg of call.arguments) {
+			if (arg.type === "SpreadElement") return false;
+			const known = this.known(arg);
+			if (known !== void 0) {
+				parts.push({ classes: known });
+				continue;
+			}
+			const node = unwrap(arg);
+			let part;
+			if (node.type === "LogicalExpression" && node.operator === "&&") part = {
+				test: node.left,
+				ifTrue: this.known(node.right),
+				ifFalse: ""
+			};
+			else if (node.type === "ConditionalExpression") part = {
+				test: node.test,
+				ifTrue: this.known(node.consequent),
+				ifFalse: this.known(node.alternate)
+			};
+			else return false;
+			if (part.ifTrue === void 0 || part.ifFalse === void 0) return false;
+			parts.push({
+				test: part.test,
+				ifTrue: part.ifTrue,
+				ifFalse: part.ifFalse
+			});
+			conditions++;
+		}
+		if (conditions > MAX_FOLD_CONDITIONS) return false;
+		const tests = parts.flatMap((part) => "test" in part ? [this.testText(part.test)] : []);
+		let dropped = false;
+		let flattened = false;
+		const leaf = (picks) => {
+			let i = 0;
+			const chosen = parts.map((part) => "test" in part ? picks[i++] ? part.ifTrue : part.ifFalse : part.classes);
+			if (!dropped) dropped = this.warnDroppedThemes(call, chosen);
+			if (!flattened) flattened = this.warnFlattenedBases(call, chosen);
+			const merged = mergeClassNames(chosen);
+			for (const cls of merged) if (cls.startsWith("!")) this.names.add(cls.slice(1));
+			else this.pass.folded.add(cls);
+			return classAttribute(merged.join(" "), this.emit);
+		};
+		const choose = (picks) => picks.length === tests.length ? leaf(picks) : `${tests[picks.length]} ? ${choose([...picks, true])} : ${choose([...picks, false])}`;
+		const value = choose([]);
+		const src = this.options.dev ? `, "data-vx-src": ${this.sourceOf(call)}` : "";
+		this.replace(editor, call.start, call.end, `({ ${this.shape.attribute}: ${value}${src} })`);
+		return true;
+	}
+	/**
+	* A theme is one class with one merge key, so `sx(brand, round)` keeps
+	* `round` alone, as it keeps the last value of a property: two themes on
+	* one element could set the same custom properties (a token, or a token
+	* both re-declare as an alias), and the sheet's order, not the call's,
+	* would pick the winner. Folding sees the arguments, so it says so.
+	* Returns whether it warned.
+	*/
+	warnDroppedThemes(call, chosen) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const cls of chosen.flatMap((classes) => classes.split(" "))) {
+			if (!cls.startsWith(`vx-theme_`)) continue;
+			seen.delete(cls);
+			seen.add(cls);
+		}
+		const themes = [...seen];
+		if (themes.length < 2) return false;
+		const kept = themes.at(-1);
+		const lost = themes.slice(0, -1).map((theme) => `\`${theme}\``);
+		const hint = "Write one theme() with every override, or apply the themes to nested elements.";
+		this.options.warn?.(`sx() keeps one theme per element, the last (\`${kept}\`): ${lost.join(", ")} ${lost.length === 1 ? "is" : "are"} dropped. ${hint}`, {
+			code: "DROPPED_THEME",
+			loc: {
+				file: this.root.id,
+				...this.root.locate(call.start)
+			},
+			hint
+		});
+		return true;
+	}
+	/**
+	* Flattened recipe bases (core/flatten.ts) share one merge key, so an
+	* element keeps the last, as with themes; and a flattened base applies
+	* under every atom of its element, so an earlier argument's class it
+	* would have cleared atomically stays. Folding sees both. Returns
+	* whether it warned.
+	*/
+	warnFlattenedBases(call, chosen) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const cls of chosen.flatMap((classes) => classes.split(" "))) {
+			if (!isBaseClass(cls)) continue;
+			seen.delete(cls);
+			seen.add(cls);
+		}
+		if (seen.size === 0) return false;
+		const loc = {
+			file: this.root.id,
+			...this.root.locate(call.start)
+		};
+		const bases = [...seen];
+		if (bases.length > 1) {
+			const kept = bases.at(-1);
+			const lost = bases.slice(0, -1).map((base) => `\`${base}\``);
+			const hint = "Flatten one of the recipes only (`flatten: false` on the other), or apply them to nested elements.";
+			this.options.warn?.(`sx() keeps one flattened recipe base per element, the last (\`${kept}\`): ${lost.join(", ")} ${lost.length === 1 ? "is" : "are"} dropped. ${hint}`, {
+				code: "DROPPED_BASE",
+				loc,
+				hint
+			});
+			return true;
+		}
+		const shadowed = shadowedByEarlier(chosen, (base) => this.rules.get(base)?.atoms?.map((atom) => atom.className));
+		if (!shadowed) return false;
+		const classes = shadowed.classes.map((cls) => `\`${cls}\``).join(", ");
+		const hint = "Pass the recipe's result first (sx(recipe(…), …)), or leave its base atomic (`flatten: false`).";
+		this.options.warn?.(`sx() applies the flattened recipe base \`${shadowed.base}\` under every class of the element: ${classes}, from an earlier argument, ${shadowed.classes.length === 1 ? "wins" : "win"} over what the base sets, which an atomic base would override. ${hint}`, {
+			code: "BASE_ORDER",
+			loc,
+			hint
+		});
+		return true;
+	}
+	/**
+	* `sx(a, b)` → `__vxSxDev("src/Card.tsx:12", a, b)`, in dev, for a call
+	* that stays a runtime call: the variant of the module's shape.
+	*/
+	devCall(call, editor) {
+		const { code } = this.root;
+		const open = skipTrivia(code, Math.max(call.callee.end, call.typeArguments?.end ?? 0));
+		if (call.optional || code[open] !== "(") return;
+		const rest = call.arguments.length > 0 ? ", " : "";
+		const dev = `${this.shape.dev}(${this.sourceOf(call)}${rest}`;
+		this.replace(editor, call.callee.start, open + 1, dev);
+		this.pass.devSx = true;
+	}
+	/** `"src/Card.tsx:12"`: where a call is, for `data-vx-src`. */
+	sourceOf(call) {
+		const file = this.root.id.replace(/[?#].*$/, "");
+		const root = this.options.root?.replace(/\/+$/, "");
+		const name = root && file.startsWith(`${root}/`) ? file.slice(root.length + 1) : file;
+		const { line, column } = this.root.locate(call.start);
+		const at = this.options.sourceLine ? this.options.sourceLine(line, column) : line;
+		return JSON.stringify(at === void 0 ? name : `${name}:${at}`);
+	}
+	/** The classes an `sx()` argument adds, when the compiler knows them. */
+	/** The classes a string written in an `sx()` argument names, through `&&` and `?:`. */
+	noteNames(node) {
+		const inner = unwrap(node);
+		if (inner.type === "Literal" && typeof inner.value === "string") for (const cls of splitClasses(inner.value)) this.names.add(cls);
+		else if (inner.type === "TemplateLiteral") inner.quasis.forEach((quasi, i) => {
+			const text = quasi.value.cooked ?? "";
+			const words = splitClasses(text);
+			if (i > 0 && /^\S/.test(text)) words.shift();
+			if (i < inner.quasis.length - 1 && /\S$/.test(text)) words.pop();
+			for (const cls of words) this.names.add(cls);
+		});
+		else if (inner.type === "LogicalExpression") this.noteNames(inner.right);
+		else if (inner.type === "ConditionalExpression") {
+			this.noteNames(inner.consequent);
+			this.noteNames(inner.alternate);
+		}
+	}
+	known(node) {
+		const value = attempt(() => evaluate(node, this.root.ctx));
+		return value ? classesOf(value.result) : void 0;
+	}
+	testText(test) {
+		const text = this.copy(test);
+		return BARE_TESTS.has(test.type) ? text : `(${text})`;
+	}
+	/**
+	* Source text moved into generated code, with the runtime calls inside it
+	* rewritten, and token-typed parameters read as their `var(--…)`.
+	*/
+	copy(node, tokens) {
+		this.pass.spans.push({
+			start: node.start,
+			end: node.end,
+			live: true
+		});
+		const splice = new Splice(this.root.code, node.start, node.end);
+		this.rewrite(node, splice);
+		if (tokens && tokens.size > 0) {
+			const { scopes } = this.root;
+			const paramOf = (id) => {
+				if (id.type !== "Identifier") return void 0;
+				const binding = scopes.bindingOf(id);
+				return binding && binding.id !== id ? tokens.get(binding) : void 0;
+			};
+			walk(this.root, node, (child) => {
+				if (splice.touches(child.start, child.end)) return false;
+				if (child.type === "Property" && child.shorthand) {
+					const param = paramOf(child.value);
+					if (!param) return true;
+					const name = child.value.name;
+					splice.overwrite(child.start, child.end, `${name}: ${tokenExpression(name, param)}`);
+					return false;
+				}
+				const param = paramOf(child);
+				if (param) {
+					const name = child.name;
+					const text = tokenExpression(name, param);
+					splice.overwrite(child.start, child.end, param.nullable ? text : `(${text})`);
+				}
+				return true;
+			});
+		}
+		return splice.toString();
+	}
+	replace(editor, start, end, content) {
+		this.pass.spans.push({
+			start,
+			end,
+			live: false
+		});
+		if (content === "") editor.remove(start, end);
+		else editor.overwrite(start, end, content);
+	}
+	/**
+	* Drops import specifiers that only rewritten code referenced, and
+	* declarations left empty. Specifiers that were never referenced as values
+	* (types, side effects, JSX the scope analysis does not see) stay. An `sx`
+	* the output still calls is pointed at the framework's shape (PLAN §5.12):
+	* renamed in an import of the runtime, imported from the runtime instead of
+	* a wrapper module (whose re-exports need not include the shapes).
+	*/
+	pruneImports() {
+		const { root } = this;
+		const references = [];
+		const jsx = /* @__PURE__ */ new Set();
+		/** `ns.sx` where `ns` is a namespace import of a runtime source. */
+		const members = [];
+		walk(root, root.program, (node) => {
+			if (node.type === "JSXIdentifier") jsx.add(node.name);
+			if (node.type === "MemberExpression" && memberKey(node) === "sx") {
+				const binding = namespaceOf(root, node.object);
+				if (binding) members.push({
+					node,
+					binding
+				});
+			}
+			if (node.type !== "Identifier") return true;
+			const binding = root.scopes.bindingOf(node);
+			if (binding?.kind === "import" && binding.id !== node) references.push({
+				binding,
+				offset: node.start
+			});
+			return true;
+		});
+		const live = this.liveness(references.map((reference) => reference.offset));
+		const referenced = /* @__PURE__ */ new Set();
+		const kept = /* @__PURE__ */ new Set();
+		references.forEach(({ binding }, i) => {
+			referenced.add(binding);
+			if (live[i]) kept.add(binding);
+		});
+		const { code } = root;
+		const edits = this.pass.edits;
+		const target = this.shape.target;
+		const direct = (locals) => ` import { ${locals.map((local) => `${target} as ${local}`).join(", ")} } from "${RUNTIME_PACKAGE}";`;
+		const renamed = /* @__PURE__ */ new Map();
+		const slice = (node) => renamed.get(node) ?? code.slice(node.start, node.end);
+		const added = [...this.pass.helpers].filter(([, helper]) => helper.add).map(([name, { local }]) => local === name ? name : `${name} as ${local}`);
+		const host = added.length === 0 ? void 0 : root.program.body.find((node) => node.type === "ImportDeclaration" && node.importKind !== "type" && node.source.value === RUNTIME_PACKAGE && node.specifiers.some((s) => s.type === "ImportSpecifier"));
+		if (added.length > 0 && !host) {
+			const first = root.program.body.find((node) => !(node.type === "ExpressionStatement" && typeof node.directive === "string"));
+			const statement = `import { ${added.join(", ")} } from "${RUNTIME_PACKAGE}";`;
+			if (first) edits.insert(first.start, `${statement}${this.options.keepLines ? " " : "\n"}`);
+			else edits.insert(code.length, `\n${statement}\n`);
+		}
+		for (const declaration of root.program.body) {
+			if (declaration.type !== "ImportDeclaration" || declaration.importKind === "type") continue;
+			const remaining = new Set(declaration.specifiers.filter((specifier) => {
+				const binding = root.scopes.bindingOf(specifier.local);
+				return !binding || !referenced.has(binding) || kept.has(binding) || jsx.has(binding.name);
+			}));
+			const moved = [];
+			for (const specifier of target ? remaining : []) {
+				const binding = root.scopes.bindingOf(specifier.local);
+				if (!binding || !kept.has(binding) || root.runtime.get(binding) !== "sx") continue;
+				if (declaration.source.value === RUNTIME_PACKAGE) renamed.set(specifier, `${target} as ${specifier.local.name}`);
+				else {
+					remaining.delete(specifier);
+					moved.push(specifier.local.name);
+				}
+			}
+			if (moved.length > 0) edits.insert(declaration.end, direct(moved));
+			if (declaration === host) {
+				this.addHelpers(declaration, remaining, added, slice);
+				continue;
+			}
+			const named = declaration.specifiers.filter((s) => s.type === "ImportSpecifier");
+			if (named.some((s) => renamed.has(s)) && remaining.size === declaration.specifiers.length) {
+				edits.overwrite(named[0].start, named.at(-1).end, named.map(slice).join(", "));
+				continue;
+			}
+			if (remaining.size === declaration.specifiers.length) continue;
+			if (remaining.size === 0) {
+				if (declaration.source.value !== RUNTIME_PACKAGE) {
+					edits.overwrite(declaration.start, declaration.end, `import ${code.slice(declaration.source.start, declaration.end)}`);
+					continue;
+				}
+				const end = code.startsWith("\r\n", declaration.end) ? declaration.end + 2 : code[declaration.end] === "\n" ? declaration.end + 1 : declaration.end;
+				edits.remove(declaration.start, end);
+				continue;
+			}
+			const clause = declaration.specifiers.find((s) => s.type !== "ImportSpecifier");
+			const namespace = declaration.specifiers.find((s) => s.type === "ImportNamespaceSpecifier");
+			const keptNamed = named.filter((s) => remaining.has(s));
+			if (named.length > 0 && keptNamed.length === 0) {
+				const close = skipTrivia(code, named.at(-1).end);
+				const brace = code[close] === "," ? skipTrivia(code, close + 1) : close;
+				edits.remove(clause.end, brace + 1);
+			} else if (keptNamed.length < named.length || keptNamed.some((s) => renamed.has(s))) edits.overwrite(named[0].start, named.at(-1).end, keptNamed.map(slice).join(", "));
+			const defaulted = declaration.specifiers.find((s) => s.type === "ImportDefaultSpecifier");
+			if (defaulted && !remaining.has(defaulted)) {
+				const next = namespace ?? named[0];
+				edits.remove(defaulted.start, next === namespace ? next.start : openBrace(code, defaulted.end));
+			} else if (namespace && !remaining.has(namespace) && defaulted) edits.remove(defaulted.end, namespace.end);
+		}
+		if (!target) return;
+		let alias = false;
+		for (const { node, binding } of members) {
+			if (this.pass.spans.some((s) => !s.live && s.start <= node.start && node.end <= s.end)) continue;
+			if (binding.source === RUNTIME_PACKAGE) {
+				const property = node.property;
+				edits.overwrite(property.start, property.end, node.computed ? JSON.stringify(target) : target);
+			} else {
+				edits.overwrite(node.start, node.end, "__vxSx");
+				const declaration = root.program.body.find((d) => d.type === "ImportDeclaration" && d.specifiers.some((s) => s === binding.node));
+				if (!alias && declaration) edits.insert(declaration.end, direct(["__vxSx"]));
+				alias = true;
+			}
+		}
+	}
+	/**
+	* Prunes the runtime import that takes the helpers, which has named
+	* specifiers and no namespace: `import { recipe, sx }` → `import { sx, __vxRecipe }`.
+	* `slice` gives a kept specifier's text, an `sx` pointed at its shape included.
+	*/
+	addHelpers(declaration, remaining, added, slice) {
+		const { code } = this.root;
+		const edits = this.pass.edits;
+		const named = declaration.specifiers.filter((s) => s.type === "ImportSpecifier");
+		if (remaining.size === 0) {
+			const from = code.slice(declaration.source.start, declaration.end);
+			edits.overwrite(declaration.start, declaration.end, `import { ${added.join(", ")} } from ${from}`);
+			return;
+		}
+		const keptNamed = named.filter((s) => remaining.has(s)).map(slice);
+		if (keptNamed.length === named.length && named.every((s, i) => keptNamed[i] === code.slice(s.start, s.end))) edits.insert(named.at(-1).end, `, ${added.join(", ")}`);
+		else edits.overwrite(named[0].start, named.at(-1).end, [...keptNamed, ...added].join(", "));
+		const defaulted = declaration.specifiers.find((s) => s.type === "ImportDefaultSpecifier");
+		if (defaulted && !remaining.has(defaulted)) edits.remove(defaulted.start, openBrace(code, defaulted.end));
+	}
+	/**
+	* Whether the output still holds the original code at each offset: the
+	* innermost span around it decides. Spans nest or are disjoint, so one
+	* sweep with a stack of open spans answers every offset.
+	*/
+	liveness(offsets) {
+		const spans = this.pass.spans.map((span, index) => ({
+			span,
+			index
+		})).sort((a, b) => a.span.start - b.span.start || b.span.end - a.span.end || a.index - b.index).map((entry) => entry.span);
+		const order = offsets.map((_, i) => i).sort((a, b) => offsets[a] - offsets[b]);
+		const open = [];
+		const out = [];
+		let next = 0;
+		for (const i of order) {
+			const offset = offsets[i];
+			for (let span = spans[next]; span && span.start <= offset; span = spans[++next]) {
+				while (open.length > 0 && open.at(-1).end <= span.start) open.pop();
+				open.push(span);
+			}
+			while (open.length > 0 && open.at(-1).end <= offset) open.pop();
+			out[i] = open.at(-1)?.live ?? true;
+		}
+		return out;
+	}
+	/** Gives runtime calls their compile-time value inside a static expression. */
+	evaluateCall(mod, callee, args, evaluateNode) {
+		if (isUnref(mod, callee, args)) return evaluateNode(args[0]);
+		const name = runtimeName(mod, callee);
+		if (name === void 0) return this.evaluateRecipeCall(mod, callee, args, evaluateNode);
+		switch (name) {
+			case "css": {
+				const style = this.compileStyle(mod, callee, args);
+				return style.vars ? FUNCTION_STYLE : new CompiledStyle(style.classes);
+			}
+			case "recipe": return new RecipeValue(this.compileRecipe(mod, callee, args, evaluateNode));
+			case "group":
+			case "peer": return this.markerOf(mod, name, callee, args, evaluateNode);
+			case "token": {
+				const token = this.tokenOf(mod, callee, args, evaluateNode);
+				return `{${token.scale}.${token.path}}`;
+			}
+			case "keyframes": return this.compileRule(mod, "keyframes", callee, args, evaluateNode).id;
+			case "theme": return new CompiledStyle(this.compileRule(mod, "theme", callee, args, evaluateNode).id);
+			default: return NOT_HANDLED;
+		}
+	}
+	/**
+	* A call of a recipe with static props, inside a static expression: its
+	* classes, as a compiled style or an object of them per slot. Any other
+	* call is not handled, and the evaluator reports it.
+	*/
+	evaluateRecipeCall(mod, callee, args, evaluateNode) {
+		const [arg] = args;
+		if (args.length > 1 || arg?.type === "SpreadElement") return NOT_HANDLED;
+		const target = this.probe(() => attempt(() => evaluateNode(callee)));
+		if (!(target?.result instanceof RecipeValue)) return NOT_HANDLED;
+		const props = arg ? evaluateNode(arg) : void 0;
+		const { recipe } = target.result;
+		const classes = resolveRecipe(recipe, props, this.propsError(mod, callee, arg));
+		if (!recipe.table.s) return new CompiledStyle(fromRecord(classes));
+		return Object.fromEntries(Object.entries(classes).map(([slot, style]) => [slot, new CompiledStyle(fromRecord(style))]));
+	}
+	/** A `recipe()` call: its table and atoms (PLAN §5.7). */
+	compileRecipe(mod, callee, args, evaluateNode) {
+		const cached = mod.recipes.get(args);
+		if (cached) return cached;
+		const [arg] = args;
+		if (args.length !== 1 || !arg || arg.type === "SpreadElement") throw this.error(mod, callee, "BAD_CALL", "recipe() takes one definition object", RECIPE_HINT);
+		const definition = evaluateNode(arg);
+		const { cache } = this.options;
+		const key = cache?.recipes && (mod !== this.root || !this.options.warn) ? `${recipeKey(definition)}${this.privateAccess(mod) ? "\0private" : ""}` : void 0;
+		let shared = key === void 0 ? void 0 : cache.recipes.get(this.system);
+		if (key !== void 0 && !shared) cache.recipes.set(this.system, shared = /* @__PURE__ */ new Map());
+		const hit = key === void 0 ? void 0 : shared.get(key);
+		const recipe = hit ?? buildRecipe(definition, {
+			system: this.system,
+			normalize: (style, path) => {
+				if (containsCompiled(style)) throw new VicssError("BAD_STYLE", `${path}: a compiled style is used inside a recipe; recipes take style objects`, {
+					loc: this.locateStyle(mod, arg, path),
+					hint: "Write the style object itself."
+				});
+				return normalizeStyle(style, {
+					...this.normalizeContext(mod, arg),
+					root: path
+				});
+			},
+			error: (path, code, message, hint) => new VicssError(code, message, {
+				loc: this.locateStyle(mod, arg, path),
+				hint
+			})
+		});
+		if (key !== void 0 && !hit) {
+			if (shared.size >= RECIPE_CACHE_SIZE) shared.clear();
+			shared.set(key, recipe);
+		}
+		mod.recipes.set(args, recipe);
+		for (const atom of recipe.atoms) if (!this.atomIndex.has(atom.className)) this.atomIndex.set(atom.className, atom);
+		for (const rule of recipe.rules) if (!this.rules.has(rule.id)) this.rules.set(rule.id, rule);
+		return recipe;
+	}
+	/**
+	* A `group()` or `peer()` call. Its key in the module is the name it is
+	* given, else the const it initialises, else its position among the
+	* module's marker calls; the id hashes the key with the module's path.
+	*/
+	markerOf(mod, kind, callee, args, evaluateNode) {
+		const cached = mod.markers.get(args);
+		if (cached) return cached;
+		const [arg] = args;
+		const hint = `Write const row = ${kind}(), or ${kind}("row") to name it.`;
+		if (args.length > 1 || arg?.type === "SpreadElement") throw this.error(mod, callee, "BAD_CALL", `${kind}() takes an optional name`, hint);
+		let name;
+		if (arg) {
+			const value = evaluateNode(arg);
+			if (typeof value !== "string" || !/^[\w$-]+$/.test(value)) throw this.error(mod, arg, "BAD_CALL", `a ${kind}() name is a string of letters, digits, \`_\`, \`$\` or \`-\``, hint);
+			name = value;
+		}
+		mod.markerSites ??= markerSites(mod.program, (call) => {
+			const callName = runtimeName(mod, call.callee);
+			return callName === "group" || callName === "peer";
+		});
+		const site = mod.markerSites.get(args);
+		const key = name ?? site?.binding ?? `#${site?.index ?? 0}`;
+		const family = kind === "group" ? "g" : "p";
+		const claimed = mod.markerKeys.get(`${family}:${key}`);
+		if (claimed && claimed !== args) throw this.error(mod, callee, "DUPLICATE_MARKER", `another ${kind}() in this module is also called \`${key}\`, so the two would mark elements with one class`, `Name one of them: ${kind}("${key}2").`);
+		mod.markerKeys.set(`${family}:${key}`, args);
+		const marker = new MarkerValue(family, markerId(mod.id, this.options.root ?? process.cwd(), key, this.options.package), this.system);
+		mod.markers.set(args, marker);
+		this.markerLabels.set(`${family}:${marker.id}`, markerLabel(family, key));
+		return marker;
+	}
+	/** A `keyframes()` or `theme()` call: its rule, which names the call's result. */
+	compileRule(mod, kind, callee, args, evaluateNode) {
+		const cached = mod.rules.get(args);
+		if (cached) return cached;
+		const [arg] = args;
+		if (args.length !== 1 || !arg || arg.type === "SpreadElement") throw this.error(mod, callee, "BAD_CALL", kind === "theme" ? "theme() takes one object of token overrides" : "keyframes() takes one object of frames", kind === "theme" ? THEME_HINT : KEYFRAMES_HINT);
+		const value = evaluateNode(arg);
+		const rule = kind === "theme" ? compileTheme(value, this.system, { locate: (path) => this.locateStyle(mod, arg, path) }) : compileKeyframes(value, this.normalizeContext(mod, arg));
+		mod.rules.set(args, rule);
+		if (!this.rules.has(rule.id)) this.rules.set(rule.id, rule);
+		return rule;
+	}
+	compileStyle(mod, callee, args) {
+		const cached = mod.styles.get(args);
+		if (cached) return cached;
+		if (this.compiling.has(args)) throw this.error(mod, callee, "NOT_STATIC", "this style reads its own result", "A style cannot depend on the value it compiles to.");
+		this.compiling.add(args);
+		try {
+			return this.compileStyleOnce(mod, callee, args);
+		} finally {
+			this.compiling.delete(args);
+		}
+	}
+	compileStyleOnce(mod, callee, args) {
+		const [arg, options] = args;
+		if (args.length < 1 || args.length > 2 || !arg || arg.type === "SpreadElement" || options?.type === "SpreadElement") throw this.error(mod, callee, "BAD_CALL", "css() takes one style object, and its options", CSS_HINT);
+		const inner = unwrap(arg);
+		if (inner.type === "FunctionExpression") throw this.error(mod, inner, "BAD_STYLE", "a function style is an arrow function", CSS_HINT);
+		const name = options && this.styleName(mod, options);
+		let style = inner.type === "ArrowFunctionExpression" ? this.compileFunctionStyle(mod, inner) : this.compileStaticStyle(mod, arg);
+		if (name) style = {
+			...style,
+			classes: `!${name} ${style.classes}`.trim()
+		};
+		mod.styles.set(args, style);
+		for (const atom of style.atoms) if (!this.atomIndex.has(atom.className)) this.atomIndex.set(atom.className, atom);
+		return style;
+	}
+	/** `css(style, { name: "card" })`: the class the style adds as it is. */
+	styleName(mod, node) {
+		const value = evaluate(node, mod.ctx);
+		const keys = isPlainObject(value) ? Object.keys(value) : void 0;
+		const name = isPlainObject(value) ? value.name : void 0;
+		const bad = keys?.find((key) => key !== "name");
+		if (!keys || bad !== void 0) throw this.error(mod, node, "BAD_CALL", bad === void 0 ? "css() takes its options as an object: { name }" : `\`${bad}\` is not an option of css(): it takes \`name\``, "Write css({ … }, { name: \"card\" }).");
+		if (name === void 0) return void 0;
+		if (typeof name !== "string" || !CLASS_NAME.test(name) || name.startsWith("vx-")) throw this.error(mod, node, "BAD_CALL", typeof name === "string" && name.startsWith("vx-") ? "class names starting with `vx-` are reserved for vicss" : "a style's `name` is one class name: letters, digits, `-` and `_`, not starting with a digit", "Write css({ … }, { name: \"card\" }).");
+		this.names.add(name);
+		return name;
+	}
+	compileStaticStyle(mod, arg) {
+		const value = evaluate(arg, mod.ctx);
+		this.checkComposition(mod, arg, value, mod.ctx);
+		const atoms = normalizeStyle(value, this.normalizeContext(mod, arg));
+		return {
+			classes: classString(atoms),
+			atoms
+		};
+	}
+	/**
+	* PLAN §5.8: parameters are runtime values. Every property they reach
+	* becomes an atom reading `var(--vx-<hash>)`; the rest compiles statically.
+	*/
+	compileFunctionStyle(mod, fn) {
+		if (fn.async) throw this.error(mod, fn, "BAD_STYLE", "a function style cannot be async");
+		const body = unwrap(fn.body);
+		if (body.type !== "ObjectExpression") throw this.error(mod, fn.body, "BAD_STYLE", "a function style must return an object literal", "Write css((value) => ({ width: value })).");
+		const params = /* @__PURE__ */ new Map();
+		for (const param of fn.params) for (const id of bindingIds(param)) {
+			const binding = mod.scopes.bindingOf(id);
+			if (binding) params.set(binding, {
+				__vxSpecial: "dynamic",
+				node: id
+			});
+		}
+		const tokenParams = this.tokenParams(mod, fn);
+		const ctx = {
+			...mod.ctx,
+			params
+		};
+		const value = evaluate(body, ctx);
+		this.checkComposition(mod, body, value, ctx);
+		const found = [];
+		const normalize = this.normalizeContext(mod, body);
+		const { style: withoutPalettes, palettes, paletteAtoms } = this.runtimePalettes(mod, value, normalize);
+		const style = withPlaceholders(withoutPalettes, found);
+		this.checkRuntimeTargets(mod, body, style, "");
+		const vars = [];
+		const atoms = normalizeStyle(style, normalize).map((atom) => {
+			const index = placeholderIndex(atom.value);
+			if (index === void 0) {
+				if (atom.value.includes(PLACEHOLDER)) throw this.error(mod, body, "BAD_STYLE", `\`${atom.property}\` cannot take a runtime value`);
+				return atom;
+			}
+			const dynamic = found[index];
+			const label = valueLabel({
+				kind: "dynamic",
+				property: atom.property,
+				value: `${atom.chain.join(":")}:${sourceText(mod, dynamic.node)}`
+			});
+			const variable = `--vx-${label.slice(1)}`;
+			const tokens = /* @__PURE__ */ new Map();
+			const scales = /* @__PURE__ */ new Set();
+			const info = propertyByCss(atom.property);
+			vars.push({
+				variable,
+				property: atom.property,
+				value: this.describe(mod, body, info, dynamic, {
+					tokens,
+					scales
+				}, tokenParams)
+			});
+			const labels = atom.chain.map((name) => this.system.conditions.get(name).label);
+			return {
+				...atom,
+				className: makeClassName(labels, atom.key, label),
+				value: `var(${variable})`,
+				variable,
+				tokens: [...tokens.values()],
+				...scales.size > 0 ? { scales: [...scales].sort(compareStrings) } : {}
+			};
+		});
+		atoms.sort((a, b) => compareStrings(a.className, b.className));
+		if (palettes.length === 0) return {
+			classes: classString(atoms),
+			atoms,
+			fn,
+			vars
+		};
+		const all = [...atoms, ...paletteAtoms].sort((a, b) => compareStrings(a.className, b.className));
+		return {
+			classes: classString(atoms),
+			atoms: all,
+			fn,
+			vars,
+			palettes
+		};
+	}
+	/**
+	* The `colorPalette` values of a function style that runtime values
+	* choose, taken out of `value`: each becomes a class the function adds
+	* (`RuntimePalette`), and every palette it may name an atom. A parameter
+	* typed as a union of names (`tone: "red" | "blue"`) may name those; any
+	* other runtime value, every palette.
+	*/
+	runtimePalettes(mod, value, normalize) {
+		const palettes = [];
+		const paletteAtoms = /* @__PURE__ */ new Map();
+		const names = [...this.system.palettes?.groups.keys() ?? []];
+		/**
+		* `name` as the style would hold it statically, under the condition
+		* blocks and the value per condition's keys it is written in: anything
+		* but a palette's name fails here, with the path a static value has.
+		*/
+		const compileOne = (blocks, conditions, name, any = false) => {
+			let value = name;
+			for (const key of [...conditions].reverse()) value = { [key]: value };
+			let style = { colorPalette: value };
+			for (const key of [...blocks].reverse()) style = { [key]: style };
+			const [compiled] = normalizeStyle(style, normalize);
+			const atom = any ? {
+				...compiled,
+				anyPalette: true
+			} : compiled;
+			keepAtom(paletteAtoms, atom);
+			return atom;
+		};
+		/** Each palette name `v` may hold at runtime, compiled where it is written; its class prefix. */
+		const candidates = (v, blocks, conditions) => {
+			let prefix;
+			const add = (name, any = false) => {
+				const atom = compileOne(blocks, conditions, name, any);
+				prefix ??= atom.className.slice(0, -name.length);
+			};
+			const visit = (x) => {
+				if (isDynamic(x)) {
+					if (x.choice) {
+						visit(x.choice.consequent);
+						visit(x.choice.alternate);
+						return;
+					}
+					if (names.length === 0) compileOne(blocks, conditions, "");
+					const typed = typedPaletteNames(mod.scopes, x.node);
+					for (const name of typed ?? names) add(name, typed === void 0);
+					return;
+				}
+				if (typeof x === "string") add(x);
+				else if (x !== void 0 && x !== null && x !== false) compileOne(blocks, conditions, x);
+			};
+			visit(v);
+			return prefix;
+		};
+		const take = (node, blocks) => {
+			if (!isPlainObject(node) || isDynamic(node)) return node;
+			const out = {};
+			for (const [key, inner] of Object.entries(node)) {
+				if (key === "colorPalette" && containsDynamic(inner)) {
+					const leaves = (v, conditions) => {
+						if (isPlainObject(v) && !isDynamic(v)) {
+							const kept = {};
+							for (const [k, x] of Object.entries(v)) {
+								const rest = leaves(x, [...conditions, k]);
+								if (rest !== void 0) kept[k] = rest;
+							}
+							return Object.keys(kept).length > 0 ? kept : void 0;
+						}
+						if (!containsDynamic(v)) return v;
+						const prefix = candidates(v, blocks, conditions);
+						if (prefix !== void 0) palettes.push({
+							prefix,
+							value: v
+						});
+					};
+					const rest = leaves(inner, []);
+					if (rest !== void 0) out[key] = rest;
+					continue;
+				}
+				out[key] = key.startsWith("_") ? take(inner, [...blocks, key]) : inner;
+			}
+			return out;
+		};
+		return {
+			style: take(value, []),
+			palettes,
+			paletteAtoms: [...paletteAtoms.values()]
+		};
+	}
+	/**
+	* How a runtime value reaches `info`: the branches of a runtime test are
+	* compiled now, with the token check and S9, so `on ? "accent" : 4` sets
+	* `var(--color-accent)` or `calc(var(--spacing) * 4)`. `named` collects
+	* the tokens the value may name, and the scales a Token-typed parameter
+	* may name any token of: those stay scales, so an app that prints a
+	* library's atom counts its own tokens of them, not the library's.
+	*/
+	describe(mod, root, info, value, named, tokenParams) {
+		const use = (refs) => {
+			for (const ref of refs) named.tokens.set(`${ref.scale}:${ref.path}`, ref);
+		};
+		if (isDynamic(value)) {
+			const { choice } = value;
+			if (!choice) {
+				const { node } = value;
+				const binding = node.type === "Identifier" ? mod.scopes.bindingOf(node) : void 0;
+				const param = binding && tokenParams.get(binding);
+				if (param) {
+					this.checkTokenTarget(mod, root, info, binding.name, param);
+					named.scales.add(param.scale);
+					return {
+						kind: "token",
+						name: binding.name,
+						param
+					};
+				}
+				const read = /* @__PURE__ */ new Map();
+				if (tokenParams.size > 0) walk(mod, node, (child) => {
+					const ref = child.type === "Identifier" ? mod.scopes.bindingOf(child) : void 0;
+					const token = ref && tokenParams.get(ref);
+					if (token) read.set(ref, token);
+					return true;
+				});
+				for (const token of read.values()) named.scales.add(token.scale);
+				const numbers = this.numberMapping(info);
+				if (node.type !== "TemplateLiteral") use(numbers.tokens);
+				return {
+					kind: "runtime",
+					node,
+					numbers: numbers.mapping,
+					...read.size > 0 ? { tokens: read } : {}
+				};
+			}
+			return {
+				kind: "choice",
+				test: choice.test,
+				nullish: choice.nullish ?? false,
+				consequent: this.describe(mod, root, info, choice.consequent, named, tokenParams),
+				alternate: this.describe(mod, root, info, choice.alternate, named, tokenParams)
+			};
+		}
+		if (value === void 0 || value === null || value === false) return {
+			kind: "static",
+			css: void 0
+		};
+		if (isPlainObject(value)) throw this.error(mod, root, "BAD_STYLE", `\`${info.name}\`: a runtime test chooses between values, not between values per condition`, "Put the test inside each condition: { base: on ? a : b, _md: on ? c : d }.");
+		const atom = normalizeStyle({ [info.name]: value }, this.normalizeContext(mod, root)).find((a) => a.property === info.css);
+		if (!atom) throw this.error(mod, root, "BAD_STYLE", `\`${info.name}\` cannot take this value`);
+		use(atom.tokens);
+		return {
+			kind: "static",
+			css: atom.value
+		};
+	}
+	/**
+	* Parameters typed `Token<"scale">`, with `Token` imported from a vicss
+	* import source under any name (`T<"colors">`, `vx.Token<"colors">`),
+	* plain, defaulted or destructured from a type literal.
+	*/
+	tokenParams(mod, fn) {
+		const out = /* @__PURE__ */ new Map();
+		const types = /* @__PURE__ */ new Set();
+		const namespaces = /* @__PURE__ */ new Set();
+		for (const node of mod.program.body) {
+			if (node.type !== "ImportDeclaration" || !this.sources.includes(node.source.value)) continue;
+			for (const specifier of node.specifiers) if (specifier.type === "ImportNamespaceSpecifier") namespaces.add(specifier.local.name);
+			else if (specifier.type === "ImportSpecifier" && importedName(specifier) === "Token") types.add(specifier.local.name);
+		}
+		if (types.size === 0 && namespaces.size === 0) return out;
+		const isToken = (name) => name.type === "Identifier" ? types.has(name.name) : name.type === "TSQualifiedName" && name.left.type === "Identifier" && namespaces.has(name.left.name) && name.right.name === "Token";
+		const visit = (pattern, type, optional) => {
+			const annotation = pattern.typeAnnotation?.typeAnnotation ?? type;
+			switch (pattern.type) {
+				case "Identifier": {
+					const param = annotation && this.tokenParam(mod, annotation, isToken, optional || pattern.optional === true);
+					const binding = param && mod.scopes.bindingOf(pattern);
+					if (param && binding) out.set(binding, param);
+					return;
+				}
+				case "AssignmentPattern":
+					visit(pattern.left, annotation, optional);
+					return;
+				case "ObjectPattern":
+					if (annotation?.type !== "TSTypeLiteral") return;
+					for (const property of pattern.properties) {
+						if (property.type === "RestElement") continue;
+						const key = patternKey(property);
+						const member = annotation.members.find((m) => m.type === "TSPropertySignature" && !m.computed && (m.key.type === "Identifier" ? m.key.name : String(m.key.value)) === key);
+						if (member) visit(property.value, member.typeAnnotation?.typeAnnotation, member.optional);
+					}
+					return;
+			}
+		};
+		for (const param of fn.params) visit(param, void 0, false);
+		return out;
+	}
+	/** `Token<"colors">`, alone or with undefined or null: the scale and how to read it. */
+	tokenParam(mod, annotation, isToken, optional) {
+		let type = annotation;
+		let nullable = optional;
+		if (type.type === "TSUnionType") {
+			const rest = type.types.filter((t) => t.type !== "TSUndefinedKeyword" && t.type !== "TSNullKeyword");
+			if (rest.length !== 1) return void 0;
+			nullable ||= rest.length < type.types.length;
+			type = rest[0];
+		}
+		if (type.type !== "TSTypeReference" || !isToken(type.typeName)) return void 0;
+		const [arg, ...more] = type.typeArguments?.params ?? [];
+		const value = arg?.type === "TSLiteralType" && arg.literal.type === "Literal" && more.length === 0 ? arg.literal.value : void 0;
+		const literal = typeof value === "string" ? value : void 0;
+		const hint = "Name the scale as a literal: (tone: Token<\"colors\">) => ({ background: tone }).";
+		if (literal === void 0) throw this.error(mod, type, "BAD_STYLE", "Token<…> takes one scale name", hint);
+		if (!isScaleName(literal)) throw this.error(mod, type, "UNKNOWN_TOKEN", `\`${literal}\` is not a scale`, didYouMean(closestNames(literal, SCALES)) ?? hint);
+		const scale = literal;
+		if (scaleTokens(this.system, scale).length === 0) throw this.error(mod, type, "NOT_A_TOKEN", `the ${scale} scale has no tokens to name`, scale === "spacing" && this.system.spacingStep !== void 0 ? "The spacing scale is a step: type the parameter as a number, which counts steps." : `Add ${scale} tokens to the config, or type the parameter as a string.`);
+		return {
+			scale,
+			prefix: `--${this.system.cssVarPrefix}${SCALE_NAMESPACES[scale]}-`,
+			nullable
+		};
+	}
+	/** A token of one scale on a property that draws from another is a mistake, not a value. */
+	checkTokenTarget(mod, root, info, name, param) {
+		const { scale } = info;
+		if (!scale || scale === param.scale || scale === "sizes" && param.scale === "spacing") return;
+		throw new VicssError("BAD_STYLE", `\`${info.name}\` takes ${scale} tokens, and \`${name}\` names ${param.scale} tokens`, {
+			loc: this.locateStyle(mod, root, info.name),
+			hint: `Type the parameter Token<"${scale}">.`
+		});
+	}
+	/** S9 at runtime for `info`, and the tokens it may name. */
+	numberMapping(info) {
+		const lookup = {};
+		const tokens = [];
+		const named = (scale) => {
+			for (const token of this.system.tokens.get(scale)?.values() ?? []) {
+				if (token.path in lookup || String(Number(token.path)) !== token.path) continue;
+				lookup[token.path] = `var(${token.cssVar})`;
+				tokens.push({
+					scale,
+					path: token.path
+				});
+			}
+		};
+		if (info.scale) named(info.scale);
+		const kind = numberKind(info);
+		let fallback;
+		if (kind === "spacing" || kind === "sizes") {
+			if (this.system.spacingStep !== void 0) {
+				fallback = "calc";
+				tokens.push({
+					scale: "spacing",
+					path: SPACING_STEP
+				});
+			} else {
+				if (kind === "sizes") named("spacing");
+				fallback = "unset";
+			}
+		} else fallback = kind === "length" ? "px" : kind === "time" ? "ms" : kind === "angle" ? "deg" : "plain";
+		return {
+			mapping: {
+				lookup,
+				fallback
+			},
+			tokens
+		};
+	}
+	/** Runtime values only reach properties that keep their value whole. */
+	checkRuntimeTargets(mod, root, style, path) {
+		if (!isPlainObject(style)) return;
+		for (const [key, value] of Object.entries(style)) {
+			if (!hasPlaceholder(value)) continue;
+			const here = path ? `${path}.${key}` : key;
+			if (key.startsWith("_")) {
+				this.checkRuntimeTargets(mod, root, value, here);
+				continue;
+			}
+			if (this.system.utilities.has(key)) continue;
+			if (key === "textStyle" || getProperty(key)?.expand) throw new VicssError("BAD_STYLE", `${here}: \`${key}\` cannot take a runtime value`, {
+				loc: this.locateStyle(mod, root, here),
+				hint: key === "textStyle" ? "Text styles are chosen at build time." : "It is split into longhands at build time; set the longhands instead."
+			});
+		}
+	}
+	/** A compiled style is a class string: it composes through sx(), never inside a style object. */
+	checkComposition(mod, arg, value, ctx) {
+		if (value instanceof CompiledStyle) throw this.error(mod, arg, "BAD_STYLE", "this style is already compiled; css() takes a style object", "Combine compiled styles with sx(): sx(base, css({ … })).");
+		const spreads = [];
+		collectSpreads(arg, spreads);
+		for (const spread of spreads) {
+			const result = attempt(() => evaluate(spread.argument, ctx))?.result;
+			if (result instanceof MarkerValue) throw this.error(mod, spread, "BAD_STYLE", `\`${excerpt(mod.code, spread)}\` spreads a marker: a marker is applied with sx(), and its states are condition keys`, "sx(row, css({ opacity: { base: 0, [row.hover]: 1 } })).");
+			if (result instanceof CompiledStyle || typeof result === "string") throw this.error(mod, spread, "BAD_STYLE", `\`${excerpt(mod.code, spread)}\` spreads a compiled style: compose compiled styles with sx(), not with spread`, "sx(base, css({ … })) merges them, last value wins.");
+		}
+		if (containsCompiled(value)) throw this.error(mod, arg, "BAD_STYLE", "a compiled style is used inside a style object: compose compiled styles with sx(), not with spread", "sx(base, css({ … })) merges them, last value wins.");
+	}
+	/** Whether styles written in `mod` may name private tokens: `privateAccess` lists it. */
+	privateAccess(mod) {
+		let access = this.access.get(mod.id);
+		if (access === void 0) {
+			access = hasPrivateAccess(this.system, this.options.root ?? process.cwd(), mod.id);
+			this.access.set(mod.id, access);
+		}
+		return access;
+	}
+	normalizeContext(mod, root) {
+		const { options } = this;
+		return {
+			system: this.system,
+			privateAccess: this.privateAccess(mod),
+			locate: (path) => this.locateStyle(mod, root, path),
+			markerLabels: this.markerLabels,
+			...options.warn && mod === this.root ? { warn: (message, warning) => options.warn?.(message, warning) } : {},
+			...mod === this.root && { arbitrary: ({ value, path }) => this.arbitrary.add(`${root.start}:${path}:${value}`) }
+		};
+	}
+	/** Where a style path (`padding._md`) was written: its property, or the closest enclosing one. */
+	locateStyle(mod, root, path) {
+		let at = root;
+		let value = root;
+		for (const key of path === "" ? [] : path.split(".")) {
+			const property = findProperty(mod, value, key);
+			if (!property) break;
+			at = property;
+			value = property.value;
+		}
+		return this.loc(mod, at);
+	}
+	tokenOf(mod, callee, args, evaluateNode) {
+		const [arg] = args;
+		if (args.length !== 1 || !arg || arg.type === "SpreadElement") throw this.error(mod, callee, "BAD_CALL", "token() takes one token path", TOKEN_HINT);
+		const path = evaluateNode(arg);
+		if (typeof path !== "string") throw this.error(mod, arg, "BAD_CALL", "token() takes a token path string", TOKEN_HINT);
+		const dot = path.indexOf(".");
+		const scale = dot === -1 ? path : path.slice(0, dot);
+		if (dot === -1 || !isScaleName(scale)) throw this.error(mod, arg, "UNKNOWN_TOKEN", `\`${path}\` does not start with a scale`, didYouMean(closestNames(scale, SCALES).map((s) => `${s}.…`)) ?? TOKEN_HINT);
+		const rest = path.slice(dot + 1);
+		const token = lookupToken(this.system, scale, rest);
+		if (!token) throw this.error(mod, arg, "UNKNOWN_TOKEN", `\`${path}\` names no token`, didYouMean(suggestTokens(this.system, scale, rest).map((p) => `${scale}.${p}`)));
+		if (token.private && !this.privateAccess(mod)) {
+			const e = privateTokenError(this.system, token);
+			throw this.error(mod, arg, e.code, e.message, e.hint);
+		}
+		return token;
+	}
+	resolveImport(mod, binding) {
+		const source = binding.source;
+		const name = binding.imported;
+		if (this.sources.includes(source) && (name === "*" || RUNTIME_EXPORTS.has(name))) throw new Error("it is part of the vicss runtime, not a value");
+		if (!this.options.loadModule) throw new Error("the compiler was given no module loader");
+		return this.exportValue(this.target(mod.id, source), name);
+	}
+	target(importer, source) {
+		const key = requestKey(importer, source);
+		const entry = this.requests.get(key);
+		if (entry === void 0) {
+			if (this.probing > 0 && this.skipped.has(key)) throw new Error(notSearched(source));
+			throw new PendingImport([[importer, source]], this.probing > 0);
+		}
+		if (typeof entry === "string") throw new Error(entry);
+		return entry;
+	}
+	/**
+	* The modules `mod` star-exports, loaded or failed. A barrel of a hundred
+	* `export *` loads its targets together rather than one per pass.
+	*/
+	stars(mod) {
+		const probing = this.probing > 0;
+		const missing = mod.scopes.starExports.filter((star) => {
+			const key = requestKey(mod.id, star);
+			return !this.requests.has(key) && !(probing && this.skipped.has(key));
+		});
+		if (missing.length > 0) throw new PendingImport(missing.map((star) => [mod.id, star]), probing);
+		return mod.scopes.starExports.map((star) => this.requests.get(requestKey(mod.id, star)) ?? notSearched(star));
+	}
+	exportValue(mod, name) {
+		const key = requestKey(mod.id, name);
+		if (this.resolving.has(key)) throw new Error(`\`${name}\` of ${mod.id} depends on itself through an import cycle`);
+		this.resolving.add(key);
+		try {
+			if (name === "*") return this.namespace(mod);
+			const entry = mod.scopes.exports.get(name);
+			if (entry?.local !== void 0) {
+				const binding = mod.scopes.moduleBindings.get(entry.local);
+				if (!binding) throw new Error(`${mod.id} exports \`${name}\` without declaring it`);
+				return evaluateBinding(binding, mod.ctx);
+			}
+			if (entry?.source !== void 0) return this.exportValue(this.target(mod.id, entry.source), entry.imported);
+			const unread = [];
+			for (const inner of this.stars(mod)) if (typeof inner === "string") unread.push(inner);
+			else if (this.exportsName(inner, name, /* @__PURE__ */ new Set(), unread)) return this.exportValue(inner, name);
+			throw new Error(`${mod.id} has no export \`${name}\`${unread.length > 0 ? `; ${unread.join("; ")}` : ""}`);
+		} finally {
+			this.resolving.delete(key);
+		}
+	}
+	exportsName(mod, name, seen, unread) {
+		if (seen.has(mod)) return false;
+		seen.add(mod);
+		if (mod.scopes.exports.has(name)) return true;
+		return this.stars(mod).some((inner) => {
+			if (typeof inner !== "string") return this.exportsName(inner, name, seen, unread);
+			unread.push(inner);
+			return false;
+		});
+	}
+	/** Every name `mod` exports, its `export *` targets' included (never their default). */
+	exportNames(mod, seen = /* @__PURE__ */ new Set()) {
+		const names = new Set(mod.scopes.exports.keys());
+		if (seen.has(mod)) return names;
+		seen.add(mod);
+		for (const inner of this.stars(mod)) {
+			if (typeof inner === "string") continue;
+			for (const name of this.exportNames(inner, seen)) if (name !== "default") names.add(name);
+		}
+		return names;
+	}
+	/** `import * as ns`: exports are evaluated when read, so non-static siblings do not matter. */
+	namespace(mod) {
+		const { exports } = mod.scopes;
+		const has = (key) => typeof key === "string" && (exports.has(key) || key !== "default" && this.exportsName(mod, key, /* @__PURE__ */ new Set(), []));
+		return new Proxy({}, {
+			ownKeys: () => [...this.exportNames(mod)],
+			has: (_, key) => has(key),
+			get: (_, key) => has(key) ? this.exportValue(mod, key) : void 0,
+			getOwnPropertyDescriptor: (_, key) => has(key) ? {
+				value: this.exportValue(mod, key),
+				enumerable: true,
+				configurable: true
+			} : void 0
+		});
+	}
+	loc(mod, node) {
+		return {
+			file: mod.id,
+			...mod.locate(node.start)
+		};
+	}
+	error(mod, node, code, message, hint) {
+		return new VicssError(code, message, {
+			loc: this.loc(mod, node),
+			hint
+		});
+	}
+};
+/** A class an app names: what `css(style, { name })` takes. */
+const CLASS_NAME = /^-?[A-Za-z_][\w-]*$/;
+const CSS_HINT = "Write css({ padding: 4 }), or css((value) => ({ width: value })) for runtime values.";
+const TOKEN_HINT = "Write token(\"colors.accent\"): a scale, then the token path.";
+const THEME_HINT = "Write theme({ colors: { accent: \"{colors.red.600}\" } }).";
+const KEYFRAMES_HINT = "Write keyframes({ from: { opacity: 0 }, to: { opacity: 1 } }).";
+const RECIPE_HINT = "Write recipe({ base: { … }, variants: { size: { sm: { … } } } }).";
+/** The first position at or after `pos` that is not whitespace or a comment. */
+function skipTrivia(code, pos) {
+	for (let i = pos; i < code.length;) if (/\s/.test(code[i])) i++;
+	else if (code.startsWith("//", i)) i = code.includes("\n", i) ? code.indexOf("\n", i) : code.length;
+	else if (code.startsWith("/*", i)) i = code.indexOf("*/", i + 2) + 2;
+	else return i;
+	return code.length;
+}
+/** After a default import specifier: the `{` that opens the named ones. */
+function openBrace(code, pos) {
+	const comma = skipTrivia(code, pos);
+	return skipTrivia(code, code[comma] === "," ? comma + 1 : comma);
+}
+function unchanged(code) {
+	return {
+		code,
+		map: null,
+		atoms: [],
+		dependencies: [],
+		tokens: [],
+		rules: [],
+		arbitrary: 0,
+		changed: false
+	};
+}
+function newPass(code, keepLines) {
+	return {
+		edits: new SourceEdits(code, { keepLines }),
+		spans: [],
+		tokens: /* @__PURE__ */ new Map(),
+		folded: /* @__PURE__ */ new Set(),
+		pending: /* @__PURE__ */ new Map(),
+		probes: /* @__PURE__ */ new Set(),
+		helpers: /* @__PURE__ */ new Map(),
+		hoisted: 0,
+		devSx: false,
+		errors: []
+	};
+}
+function notSearched(source) {
+	return `"${source}" is a package, which is not searched for recipes`;
+}
+function requestKey(a, b) {
+	return `${a}\0${b}`;
+}
+const isJson = (id) => /\.json$/i.test(id.replace(/[?#].*$/, ""));
+const RESERVED = new Set("await break case catch class const continue debugger default delete do else enum export extends false finally for function if implements import in instanceof interface let new null package private protected public return static super switch this throw true try typeof var void while with yield".split(" "));
+/**
+* A JSON module as the JS module bundlers make of it: the value as the
+* default export, and its top-level keys that are identifiers as named ones.
+*/
+function jsonModule(id, code) {
+	let value;
+	try {
+		value = JSON.parse(code);
+	} catch (error) {
+		throw new VicssError("PARSE_ERROR", error instanceof Error ? error.message : String(error), { loc: {
+			file: id,
+			line: 1,
+			column: 0
+		} });
+	}
+	let out = `export default ${JSON.stringify(value)};\n`;
+	if (isPlainObject(value)) {
+		for (const [key, item] of Object.entries(value)) if (/^[A-Za-z_$][\w$]*$/.test(key) && !RESERVED.has(key)) out += `export const ${key} = ${JSON.stringify(item)};\n`;
+	}
+	return out;
+}
+function langOf(id) {
+	const ext = /\.([a-z]+)$/i.exec(id.replace(/[?#].*$/, ""))?.[1]?.toLowerCase();
+	return ext !== void 0 && LANGS[ext] || "tsx";
+}
+function parse(parseSync, id, code, lang, functionBody) {
+	const { program, errors } = parseSync(id, code, {
+		lang,
+		sourceType: "module"
+	});
+	const returns = functionBody && errors.length > 0 ? topLevelReturns(program) : void 0;
+	const error = errors.find((e) => e.severity === "Error" && !(returns && e.labels.length === 1 && returns.has(e.labels[0].start)));
+	if (error) {
+		const start = error.labels[0]?.start;
+		throw new VicssError("PARSE_ERROR", error.message, {
+			loc: start === void 0 ? void 0 : {
+				file: id,
+				...createLocator(code)(start)
+			},
+			hint: error.helpMessage ?? void 0
+		});
+	}
+	return program;
+}
+/** Where the `return` statements outside any function start. */
+function topLevelReturns(program) {
+	const out = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (Array.isArray(value)) return value.forEach(visit);
+		if (!isNode(value)) return;
+		if (FUNCTIONS.has(value.type)) return;
+		if (value.type === "ReturnStatement") out.add(value.start);
+		for (const key in value) if (key !== "type") visit(value[key]);
+	};
+	visit(program.body);
+	return out;
+}
+const FUNCTIONS = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression",
+	"ClassDeclaration",
+	"ClassExpression"
+]);
+function runtimeBindings(program, scopes, sources) {
+	const out = /* @__PURE__ */ new Map();
+	for (const node of program.body) {
+		if (node.type !== "ImportDeclaration" || node.importKind === "type") continue;
+		if (!sources.includes(node.source.value)) continue;
+		for (const specifier of node.specifiers) {
+			const binding = scopes.bindingOf(specifier.local);
+			const name = binding?.imported;
+			if (binding && name && (name === "*" || RUNTIME_EXPORTS.has(name))) out.set(binding, name);
+		}
+	}
+	return out;
+}
+/**
+* The runtime function a callee names: `css`, an alias of it, or `ns.css` —
+* shadowing respected. In a Vue component's output, a template reaches the
+* script's `css` as `_unref(css)`, `$setup.css` or `_ctx.css` too.
+*/
+function runtimeName(mod, callee) {
+	const target = unwrap(callee);
+	if (target.type === "Identifier") {
+		const binding = mod.scopes.bindingOf(target);
+		const name = binding && mod.runtime.get(binding);
+		return name === "*" ? void 0 : name;
+	}
+	if (target.type === "CallExpression") {
+		const [arg] = target.arguments;
+		return arg && isUnref(mod, target.callee, target.arguments) ? runtimeName(mod, arg) : void 0;
+	}
+	if (target.type !== "MemberExpression") return void 0;
+	const key = memberKey(target);
+	if (key === void 0) return void 0;
+	const setup = vueBinding(mod, target);
+	if (setup) {
+		const imported = mod.runtime.get(setup);
+		return imported === "*" ? void 0 : imported;
+	}
+	return namespaceOf(mod, target.object) && RUNTIME_EXPORTS.has(key) ? key : void 0;
+}
+/**
+* The namespace import of a runtime source that `node` reads: `ns`, or in a
+* Vue component's output `_unref(ns)`, `$setup.ns` and `_ctx.ns`.
+*/
+function namespaceOf(mod, node) {
+	const target = unwrap(node);
+	let binding;
+	if (target.type === "Identifier") binding = mod.scopes.bindingOf(target);
+	else if (target.type === "CallExpression") {
+		const [arg] = target.arguments;
+		return arg && isUnref(mod, target.callee, target.arguments) ? namespaceOf(mod, arg) : void 0;
+	} else if (target.type === "MemberExpression") binding = vueBinding(mod, target);
+	return binding && mod.runtime.get(binding) === "*" ? binding : void 0;
+}
+/**
+* The script binding a Vue render function reads as `$setup.x` or `_ctx.x`:
+* those hold the script's bindings by name.
+*/
+function vueBinding(mod, node) {
+	if (!mod.vue) return void 0;
+	const object = unwrap(node.object);
+	const key = memberKey(node);
+	if (object.type !== "Identifier" || key === void 0) return void 0;
+	const { name } = object;
+	if (name !== "$setup" && name !== "_ctx") return void 0;
+	const own = mod.scopes.bindingOf(object);
+	if (own && own.kind !== "param") return void 0;
+	return mod.scopes.moduleBindings.get(key);
+}
+/** `ns.name` or `ns["name"]`: the name. */
+function memberKey(node) {
+	if (!node.computed) return node.property.name;
+	const property = node.property;
+	return property.type === "Literal" && typeof property.value === "string" ? property.value : void 0;
+}
+/** A call of Vue's `unref` (`_unref(x)` in compiled templates): x itself for a constant. */
+function isUnref(mod, callee, args) {
+	const target = unwrap(callee);
+	if (target.type !== "Identifier" || args.length !== 1 || args[0].type === "SpreadElement") return false;
+	const binding = mod.scopes.bindingOf(target);
+	return binding?.kind === "import" && binding.source === "vue" && binding.imported === "unref";
+}
+function unwrap(node) {
+	let inner = node;
+	while (WRAPPERS.has(inner.type)) inner = inner.expression;
+	return inner;
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+const CHILD_KEYS = {
+	js: /* @__PURE__ */ new Map(),
+	ts: /* @__PURE__ */ new Map()
+};
+function childKeys(node, cache) {
+	let keys = cache.get(node.type);
+	if (!keys) {
+		const record = node;
+		keys = Object.keys(record).filter((key) => {
+			if (SKIPPED_KEYS.has(key)) return false;
+			const value = record[key];
+			return value === null || value === void 0 || typeof value === "object";
+		});
+		cache.set(node.type, keys);
+	}
+	return keys;
+}
+/** Depth-first, `node` first; children are skipped when `enter` returns false. */
+function walk(mod, node, enter) {
+	const cache = CHILD_KEYS[mod.lang === "ts" || mod.lang === "tsx" ? "ts" : "js"];
+	const visit = (current) => {
+		if (!enter(current)) return;
+		const record = current;
+		for (const key of childKeys(current, cache)) {
+			const value = record[key];
+			if (Array.isArray(value)) {
+				for (const item of value) if (isNode(item)) visit(item);
+			} else if (isNode(value)) visit(value);
+		}
+	};
+	visit(node);
+}
+/** Identifiers a parameter pattern declares. */
+function bindingIds(pattern, out = []) {
+	switch (pattern.type) {
+		case "Identifier":
+			out.push(pattern);
+			break;
+		case "AssignmentPattern":
+			bindingIds(pattern.left, out);
+			break;
+		case "RestElement":
+			bindingIds(pattern.argument, out);
+			break;
+		case "ObjectPattern":
+			for (const p of pattern.properties) bindingIds(p.type === "RestElement" ? p : p.value, out);
+			break;
+		case "ArrayPattern":
+			for (const element of pattern.elements) if (element) bindingIds(element, out);
+			break;
+		case "TSParameterProperty": bindingIds(pattern.parameter, out);
+	}
+	return out;
+}
+/** Spreads inside a style literal, where a compiled style would be flattened into keys. */
+function collectSpreads(node, out) {
+	const inner = unwrap(node);
+	if (inner.type === "ObjectExpression") for (const property of inner.properties) if (property.type === "SpreadElement") out.push(property);
+	else collectSpreads(property.value, out);
+	else if (inner.type === "ConditionalExpression") {
+		collectSpreads(inner.consequent, out);
+		collectSpreads(inner.alternate, out);
+	} else if (inner.type === "LogicalExpression") collectSpreads(inner.right, out);
+}
+function containsCompiled(value) {
+	if (value instanceof CompiledStyle) return true;
+	if (Array.isArray(value)) return value.some(containsCompiled);
+	if (!isPlainObject(value)) return false;
+	if (value.__vxSpecial === "style") return true;
+	if (Object.hasOwn(value, "__vxSpecial")) return false;
+	return Object.values(value).some(containsCompiled);
+}
+/** The class string a value adds to `sx()`: falsy values add nothing. Undefined when unknown. */
+function classesOf(value) {
+	if (value === false || value === null || value === void 0 || value === 0 || value === "") return "";
+	if (typeof value === "string") return splitClasses(value).map((cls) => "!" + cls).join(" ");
+	if (value instanceof CompiledStyle) return value.classes;
+	if (value instanceof MarkerValue) return value.className;
+	if (Array.isArray(value)) {
+		const parts = value.map(classesOf);
+		return parts.every((part) => part !== void 0) ? mergeClassNames(parts).join(" ") : void 0;
+	}
+}
+function classString(atoms) {
+	return atoms.map((atom) => atom.className).join(" ");
+}
+/** Runs `fn`; a VicssError (other than a pending import) means "not known". */
+function attempt(fn) {
+	try {
+		return { result: fn() };
+	} catch (error) {
+		if (error instanceof PendingImport || !(error instanceof VicssError)) throw error;
+		return;
+	}
+}
+function withPlaceholders(value, found) {
+	if (isDynamic(value)) {
+		found.push(value);
+		return `${PLACEHOLDER}${found.length - 1}`;
+	}
+	if (Array.isArray(value)) return value.map((item) => withPlaceholders(item, found));
+	if (!isPlainObject(value) || Object.hasOwn(value, "__vxSpecial")) return value;
+	const out = {};
+	for (const [key, item] of Object.entries(value)) out[key] = withPlaceholders(item, found);
+	return out;
+}
+/** Whether a runtime value sits in `value`, at any depth. */
+function containsDynamic(value) {
+	if (isDynamic(value)) return true;
+	if (Array.isArray(value)) return value.some(containsDynamic);
+	return isPlainObject(value) && Object.values(value).some(containsDynamic);
+}
+function hasPlaceholder(value) {
+	if (typeof value === "string") return value.startsWith(PLACEHOLDER);
+	if (Array.isArray(value)) return value.some(hasPlaceholder);
+	return isPlainObject(value) && Object.values(value).some(hasPlaceholder);
+}
+function placeholderIndex(value) {
+	if (!value.startsWith(PLACEHOLDER)) return void 0;
+	const index = value.slice(3);
+	return /^\d+$/.test(index) ? Number(index) : void 0;
+}
+let byCss;
+function propertyByCss(css) {
+	byCss ??= new Map([...PROPERTIES.values()].map((info) => [info.css, info]));
+	return byCss.get(css);
+}
+/** The text a runtime value hashes by: a parameter by its name, without its type annotation. */
+function sourceText(mod, node) {
+	return node.type === "Identifier" ? node.name : mod.code.slice(node.start, node.end);
+}
+/** The property written last under `key` in the object `node` is, or is bound to in this module. */
+function findProperty(mod, node, key) {
+	let target = unwrap(node);
+	if (target.type === "Identifier") {
+		const binding = mod.scopes.bindingOf(target);
+		if (binding?.kind !== "const" || !binding.init || binding.path) return void 0;
+		target = unwrap(binding.init);
+	}
+	if (target.type !== "ObjectExpression") return void 0;
+	for (let i = target.properties.length - 1; i >= 0; i--) {
+		const property = target.properties[i];
+		if (property.type === "Property" && staticKey(property) === key) return property;
+	}
+}
+function staticKey(property) {
+	const { key } = property;
+	if (key.type === "Identifier" && !property.computed) return key.name;
+	if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) return String(key.value);
+}
+/**
+* A token-typed parameter's custom property: a string transform, so no
+* token table ships to the browser (PLAN §4.6). A value that names no
+* token is written as it is (D33), which `var()`'s fallback does with no
+* table either: no token declares the property it reads. A value that
+* cannot be part of a property's name is the value itself.
+*/
+function tokenExpression(name, param) {
+	const read = `((v) => /^[\\w.-]+$/.test(v) ? "var(${param.prefix}" + v.replace(/\\./g, "-") + ", " + v + ")" : v)(String(${name}))`;
+	return param.nullable ? `(${name} == null ? undefined : ${read})` : read;
+}
+/** The name an import specifier takes from its module (`Token` in `{ Token as T }`). */
+function importedName(specifier) {
+	const { imported } = specifier;
+	return imported.type === "Identifier" ? imported.name : String(imported.value);
+}
+/** The key a destructuring property reads, when it is written out. */
+function patternKey(property) {
+	const { key } = property;
+	if (key.type === "Identifier" && !property.computed) return key.name;
+	if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) return String(key.value);
+}
+function excerpt(code, node) {
+	const text = code.slice(node.start, node.end).replace(/\s+/g, " ");
+	return text.length > 60 ? `${text.slice(0, 59)}…` : text;
+}
+/** An editor over one range of the source, for code copied into generated text. */
+var Splice = class {
+	#code;
+	#start;
+	#end;
+	#edits = [];
+	constructor(code, start, end) {
+		this.#code = code;
+		this.#start = start;
+		this.#end = end;
+	}
+	overwrite(start, end, content) {
+		this.#edits.push({
+			start,
+			end,
+			content
+		});
+		return this;
+	}
+	remove(start, end) {
+		return start === end ? this : this.overwrite(start, end, "");
+	}
+	/** Whether an edit overlaps `[start, end)`. */
+	touches(start, end) {
+		return this.#edits.some((edit) => edit.start < end && start < edit.end);
+	}
+	toString() {
+		let out = "";
+		let pos = this.#start;
+		for (const edit of [...this.#edits].sort((a, b) => a.start - b.start)) {
+			out += this.#code.slice(pos, edit.start) + edit.content;
+			pos = edit.end;
+		}
+		return out + this.#code.slice(pos, this.#end);
+	}
+};
+//#endregion
+//#region src/vite/framework.ts
+/**
+* Which framework a module belongs to (PLAN §5.12), which decides the shape
+* `sx()` returns, and the framework files (`.vue`, `.svelte`, `.astro`) the
+* plugin compiles after their own compiler and pre-scans by their scripts
+* (§5.4). Plain data in, plain data out: the scan's workers use it too.
+*/
+const FRAMEWORKS = [
+	"react",
+	"preact",
+	"solid",
+	"vue",
+	"svelte",
+	"astro",
+	"vanilla"
+];
+/** Root dependencies that name a project's framework, the first found winning. */
+const DEPENDENCIES = [
+	["vue", "vue"],
+	["svelte", "svelte"],
+	["solid-js", "solid"],
+	["preact", "preact"],
+	["react", "react"],
+	["astro", "astro"]
+];
+/** Extensions whose files a framework compiler turns into JS first; the patterns below list them. */
+const SFC_EXTENSIONS = [
+	"vue",
+	"svelte",
+	"astro"
+];
+const SFC_EXTENSION = `(?:${SFC_EXTENSIONS.join("|")})`;
+/** `X.vue`, `X.svelte`, `X.astro`, with or without a query. */
+const SFC_FILE = new RegExp(`\\.${SFC_EXTENSION}(?:[?#]|$)`);
+/**
+* The modules of a framework file that hold its compiled scripts: the file
+* itself, or a script sub-module (`X.vue?vue&type=script&setup=true&lang.ts`,
+* `X.astro?astro&type=script&index=0&lang.ts`). Styles, templates and other
+* sub-modules are left alone.
+*/
+const SFC_SCRIPT_ID = new RegExp(`\\.${SFC_EXTENSION}(?:$|\\?(?:[^#]*&)?type=script(?:[&#]|$))`);
+function isSfc(id) {
+	return SFC_FILE.test(id);
+}
+/** The framework of a module, from its id, its code and the project's settings. */
+function frameworkOf(id, code, settings) {
+	const file = id.replace(/[?#].*$/, "");
+	const ext = /\.([a-z]+)$/i.exec(file)?.[1]?.toLowerCase();
+	if (SFC_EXTENSIONS.includes(ext ?? "")) return ext;
+	if (ext === "jsx" || ext === "tsx") {
+		const pragma = /@jsxImportSource\s+([^\s*]+)/.exec(code)?.[1];
+		return jsxFramework(pragma ?? settings.jsxImportSource ?? "react");
+	}
+	return settings.scripts;
+}
+/** `preact`, `solid-js`, `vue` (and their subpaths) by name; anything else takes React's props. */
+function jsxFramework(source) {
+	const name = source.startsWith("@") ? source.split("/", 2).join("/") : source.split("/")[0];
+	if (name === "preact") return "preact";
+	if (name === "solid-js") return "solid";
+	if (name === "vue") return "vue";
+	return "react";
+}
+/** The framework the root `package.json` depends on, if one of the known ones. */
+function detectFramework(root) {
+	const pkg = readJson(path.join(root, "package.json"));
+	if (!pkg) return void 0;
+	const names = /* @__PURE__ */ new Set([...Object.keys(deps(pkg.dependencies)), ...Object.keys(deps(pkg.devDependencies))]);
+	return DEPENDENCIES.find(([name]) => names.has(name))?.[1];
+}
+/**
+* The project's JSX import source: the Vite config's (`oxc.jsx.importSource`,
+* or esbuild's `jsxImportSource`), else the root tsconfig's, following
+* `extends` and, for a solution file, its `references`.
+*/
+function configuredJsxSource(config, root) {
+	const jsx = record(record(config.oxc)?.jsx);
+	const esbuild = record(config.esbuild);
+	return string(jsx?.importSource) ?? string(esbuild?.jsxImportSource) ?? tsconfigJsxSource(path.join(root, "tsconfig.json"), /* @__PURE__ */ new Set());
+}
+function tsconfigJsxSource(file, seen) {
+	if (seen.has(file)) return void 0;
+	seen.add(file);
+	const tsconfig = readJson(file, true);
+	if (!tsconfig) return void 0;
+	const own = string(record(tsconfig.compilerOptions)?.jsxImportSource);
+	if (own) return own;
+	const dir = path.dirname(file);
+	const parents = Array.isArray(tsconfig.extends) ? tsconfig.extends : [tsconfig.extends];
+	for (const parent of parents.toReversed()) {
+		const resolved = typeof parent === "string" ? resolveExtends(parent, dir) : void 0;
+		const found = resolved && tsconfigJsxSource(resolved, seen);
+		if (found) return found;
+	}
+	for (const reference of Array.isArray(tsconfig.references) ? tsconfig.references : []) {
+		const target = string(record(reference)?.path);
+		if (!target) continue;
+		const full = path.resolve(dir, target);
+		const found = tsconfigJsxSource(full.endsWith(".json") ? full : path.join(full, "tsconfig.json"), seen);
+		if (found) return found;
+	}
+}
+function resolveExtends(specifier, dir) {
+	if (specifier.startsWith(".") || path.isAbsolute(specifier)) {
+		const full = path.resolve(dir, specifier);
+		return existsSync(full) ? full : `${full}.json`;
+	}
+	try {
+		return createRequire(path.join(dir, "tsconfig.json")).resolve(specifier.endsWith(".json") ? specifier : `${specifier}.json`);
+	} catch {
+		try {
+			return createRequire(path.join(dir, "tsconfig.json")).resolve(specifier);
+		} catch {
+			return;
+		}
+	}
+}
+/**
+* An opening `<script>` tag and the element's text. Attribute values are
+* matched whole, so a `>` inside quotes (Vue's `generic="T extends
+* Record<K, V>"`, Svelte's `generics`) does not end the tag.
+*/
+const SCRIPT_ELEMENT = /<script\b((?:\s+[^\s"'>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'>]+))?)*)\s*>([\s\S]*?)<\/script\s*>/dgi;
+const ATTRIBUTE = /([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+/**
+* The scripts of a `.vue` (`<script>` and `<script setup>`, one module as
+* Vue merges them), `.svelte` (instance and module scripts, one module) or
+* `.astro` file (the frontmatter, and each `<script>` Astro bundles, each a
+* module of its own). A script with `src` is a file of its own, scanned as
+* one if `include` has it.
+*/
+function extractScripts(id, code) {
+	const ext = /\.([a-z]+)(?:[?#].*)?$/i.exec(id)?.[1]?.toLowerCase();
+	const markup = code.replace(/<!--[\s\S]*?-->/g, blank);
+	const blocks = [];
+	for (const match of markup.matchAll(SCRIPT_ELEMENT)) {
+		const [start, end] = match.indices[2];
+		blocks.push({
+			start,
+			end,
+			attributes: attributesOf(match[1])
+		});
+	}
+	if (ext === "astro") {
+		const units = [];
+		const fence = /^(\s*)---[^\S\r\n]*\r?\n([\s\S]*?)\r?\n---/.exec(code);
+		if (fence) {
+			const start = fence[0].indexOf("\n", fence[1].length) + 1;
+			units.push({
+				code: keep(code, [[start, start + fence[2].length]]),
+				lang: "ts",
+				functionBody: true
+			});
+		}
+		const after = fence ? fence.index + fence[0].length : 0;
+		for (const block of blocks) {
+			if (block.start < after || block.attributes.size > 0) continue;
+			units.push({
+				code: keep(code, [[block.start, block.end]]),
+				lang: "ts"
+			});
+		}
+		return units;
+	}
+	const scripts = blocks.filter(({ attributes }) => {
+		const type = attributes.get("type");
+		return !attributes.has("src") && (type === void 0 || type === "module" || /^(?:text|application)\/(?:java|type)script$/.test(type));
+	});
+	if (scripts.length === 0) return [];
+	const lang = scripts.map((block) => block.attributes.get("lang")).some((l) => l === "tsx" || l === "jsx") ? "tsx" : "ts";
+	return [{
+		code: keep(code, scripts.map((block) => [block.start, block.end])),
+		lang
+	}];
+}
+/** A tag's attributes by lower-cased name, `""` for a bare one; the first of a name wins. */
+function attributesOf(text) {
+	const out = /* @__PURE__ */ new Map();
+	for (const match of text.matchAll(ATTRIBUTE)) {
+		const name = match[1].toLowerCase();
+		if (!out.has(name)) out.set(name, match[2] ?? match[3] ?? match[4] ?? "");
+	}
+	return out;
+}
+/** `code` with everything outside `ranges` blanked, line breaks kept. */
+function keep(code, ranges) {
+	let out = "";
+	let at = 0;
+	for (const [start, end] of ranges) {
+		out += blank(code.slice(at, start)) + code.slice(start, end);
+		at = end;
+	}
+	return out + blank(code.slice(at));
+}
+const blank = (text) => text.replace(/[^\r\n]/g, " ");
+function readJson(file, comments = false) {
+	let text;
+	try {
+		text = readFileSync(file, "utf8");
+	} catch {
+		return;
+	}
+	try {
+		return record(JSON.parse(comments ? stripJsonComments(text) : text));
+	} catch {
+		return;
+	}
+}
+/** JSONC as tsconfig files use it: comments and trailing commas. */
+function stripJsonComments(text) {
+	let out = "";
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (c === "\"") {
+			const end = /"(?:[^"\\]|\\.)*"/y;
+			end.lastIndex = i;
+			const literal = end.exec(text)?.[0] ?? text.slice(i);
+			out += literal;
+			i += literal.length - 1;
+		} else if (text.startsWith("//", i)) {
+			const next = text.indexOf("\n", i);
+			i = next === -1 ? text.length : next - 1;
+		} else if (text.startsWith("/*", i)) {
+			const close = text.indexOf("*/", i + 2);
+			i = close === -1 ? text.length : close + 1;
+		} else out += c;
+	}
+	return out.replace(/,(\s*[}\]])/g, "$1");
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+const string = (value) => typeof value === "string" && value ? value : void 0;
+const deps = (value) => record(value) ?? {};
+//#endregion
+//#region src/vite/compile.ts
+/**
+* The plugin's side of compiling one module: imported constants are found
+* through Vite's resolver, read from disk and reported as dependencies, so
+* tsconfig paths, aliases and workspaces work as they do for the app.
+*/
+const REACT = {
+	scripts: "react",
+	jsxImportSource: void 0
+};
+/** The file the compiler reads for an import, or "" when it reads none. */
+async function resolveFile(resolve, source, importer) {
+	const resolved = await resolve(source, importer);
+	if (!resolved || resolved.external || resolved.id.startsWith("\0")) return "";
+	return resolved.id.replace(/[?#].*$/, "");
+}
+/** Whether every recorded import resolves to the same file through `resolve`. */
+async function resolvesAlike(resolutions, resolve) {
+	for (const [request, file] of Object.entries(resolutions)) {
+		const at = request.indexOf("\0");
+		if (await resolve(request.slice(at + 1), request.slice(0, at)) !== file) return false;
+	}
+	return true;
+}
+/** `this.resolve` without our own `resolveId`, as a module loader for the compiler. */
+function moduleLoader(resolve, resolutions = {}) {
+	return async (source, importer) => {
+		const id = await resolveFile(resolve, source, importer);
+		resolutions[`${importer}\0${source}`] = id;
+		if (!id) return null;
+		try {
+			return {
+				id,
+				code: readFileSync(id, "utf8")
+			};
+		} catch {
+			return null;
+		}
+	};
+}
+/**
+* Compiles one module. `script` is set for a script the pre-scan extracted
+* from a framework file, whose id names the file rather than how it parses;
+* `sourceLine`, in dev, for a framework's output, whose lines its compiler
+* moved (`CompileOptions.sourceLine`).
+*/
+async function compile(ctx, id, code, resolve, script, sourceLine) {
+	const resolutions = {};
+	const warnings = [];
+	return {
+		...await compileModule(code, {
+			system: ctx.system,
+			id,
+			importSources: ctx.importSources,
+			loadModule: moduleLoader(resolve, resolutions),
+			framework: frameworkOf(id, code, ctx.frameworks ?? REACT),
+			...script ? {
+				lang: script.lang,
+				functionBody: script.functionBody === true
+			} : {},
+			sourceMap: ctx.sourceMap,
+			cache: ctx.parsed,
+			dev: ctx.dev === true,
+			placeholders: ctx.placeholders === true,
+			keepLines: ctx.keepLines === true,
+			...ctx.root === void 0 ? {} : { root: ctx.root },
+			...ctx.package ? { package: ctx.package } : {},
+			...sourceLine ? { sourceLine } : {},
+			warn: (message) => warnings.push(message)
+		}),
+		resolutions,
+		warnings
+	};
+}
+/**
+* Parsed modules, most recently used last. A design system's barrel is read
+* by most styled modules, so it stays; the ASTs of the modules themselves
+* (about 20 times their source size) are not all kept for the server's life.
+*/
+function createParseCache(limit = 256) {
+	return { parsed: new LruMap(limit) };
+}
+var LruMap = class extends Map {
+	#limit;
+	constructor(limit) {
+		super();
+		this.#limit = limit;
+	}
+	get(key) {
+		const value = super.get(key);
+		if (value !== void 0) {
+			super.delete(key);
+			super.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		super.delete(key);
+		super.set(key, value);
+		if (this.size > this.#limit) super.delete(this.keys().next().value);
+		return this;
+	}
+};
+//#endregion
+//#region src/vite/pool.ts
+/**
+* The pre-scan's worker threads (PLAN D17). A cold scan is CPU-bound: every
+* module is parsed, evaluated and normalised. With more than `POOL_MIN`
+* modules to compile, worker threads run the same compiler on the files'
+* contents next to the main thread. The main thread keeps what must stay
+* one: resolution through Vite's plugins, the cache and the order results
+* are combined in. Only plain data crosses: jobs, resolution requests and
+* results, and errors as their fields.
+*/
+/** Jobs a worker holds at once, so one waiting for a resolution leaves it busy. */
+const IN_FLIGHT = 16;
+/**
+* A config's hash with its functions counted rather than read: the main
+* thread loads a TypeScript config through Vite, which prints a function's
+* source otherwise than Node's type stripping does in a worker.
+*/
+function configShape(config) {
+	return hash(stableStringify(config, () => "\0function"), 8);
+}
+function toErrorData(error) {
+	if (error instanceof VicssError) return {
+		name: error.name,
+		message: error.message,
+		code: error.code,
+		...error.hint === void 0 ? {} : { hint: error.hint },
+		...error.loc === void 0 ? {} : { loc: error.loc }
+	};
+	const e = error instanceof Error ? error : new Error(String(error));
+	return {
+		name: e.name,
+		message: e.message,
+		...e.stack ? { stack: e.stack } : {}
+	};
+}
+function fromErrorData(data) {
+	if (data.name === "VicssError" && data.code !== void 0) return new VicssError(data.code, data.message, {
+		...data.loc ? { loc: data.loc } : {},
+		...data.hint === void 0 ? {} : { hint: data.hint }
+	});
+	const error = new Error(data.message);
+	error.name = data.name;
+	if (data.stack) error.stack = data.stack;
+	return error;
+}
+/** A job a worker took and could not finish: the thread died. The caller runs it itself. */
+var WorkerLost = class extends Error {};
+/**
+* Threads for this many compiles: one per 100 modules, leaving a core to the
+* main thread (which compiles too) and one to Rolldown's own threads. On
+* four cores, three workers were no faster than two.
+*/
+function poolSize(jobs) {
+	return Math.max(0, Math.min(availableParallelism() - 2, Math.ceil(jobs / 100), 7));
+}
+var CompilePool = class CompilePool {
+	workers;
+	#threads;
+	#use;
+	#used = false;
+	constructor(workers, threads, use) {
+		this.workers = workers;
+		this.#threads = threads;
+		this.#use = use;
+	}
+	/**
+	* Starts `size` threads, which load the compiler and wait for `use()`; a
+	* build spawns them before its config is loaded, which takes as long as
+	* their start. Unreferenced until used, so a config resolved for a build
+	* that never runs leaves nothing alive. Undefined when threads cannot start.
+	*/
+	static spawn(size) {
+		if (size < 1) return void 0;
+		const threads = [];
+		try {
+			for (let i = 0; i < size; i++) threads.push(new Worker(WORKER_URL));
+		} catch {
+			for (const thread of threads) thread.terminate();
+			return;
+		}
+		for (const thread of threads) thread.unref();
+		let current;
+		let warned = false;
+		const warn = (message) => {
+			if (warned) return;
+			warned = true;
+			current?.warn?.(message);
+		};
+		const resolve = (source, importer) => current ? current.resolve(source, importer) : Promise.resolve("");
+		const workers = threads.map((thread) => connect(thread, resolve, warn));
+		return new CompilePool(workers, threads, (use) => {
+			current = use;
+			for (const thread of threads) {
+				thread.ref();
+				try {
+					thread.postMessage({
+						type: "setup",
+						setup: use.setup
+					});
+				} catch (error) {
+					warn(`the scan runs on one thread: ${error instanceof Error ? error.message : String(error)}`);
+					thread.terminate();
+				}
+			}
+		});
+	}
+	/** Sends the scan's setup; the workers report ready once they built the compiler. */
+	use(use) {
+		if (this.#used) throw new Error("vicss: a scan pool serves one scan");
+		this.#used = true;
+		this.#use(use);
+		return this;
+	}
+	/** Ends the threads; a pool is closed once, whoever closes it. */
+	async close() {
+		await Promise.all(this.#threads.map((thread) => thread.terminate()));
+	}
+};
+/** `src/vite/worker.ts` next to this file, or `dist/worker.js` next to the bundled plugin. */
+const WORKER_URL = new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js", import.meta.url);
+function connect(thread, resolve, warn) {
+	const jobs = /* @__PURE__ */ new Map();
+	let next = 0;
+	let alive = true;
+	let settle;
+	const ready = new Promise((resolve) => settle = resolve);
+	const lost = (why) => {
+		if (!alive) return;
+		alive = false;
+		settle(false);
+		for (const job of jobs.values()) job.reject(new WorkerLost(why));
+		jobs.clear();
+	};
+	thread.on("message", (message) => {
+		switch (message.type) {
+			case "ready":
+				settle(true);
+				return;
+			case "unavailable":
+				warn(`a scan worker could not start, so the main thread compiles more: ${message.message}`);
+				lost(message.message);
+				thread.terminate();
+				return;
+			case "resolve":
+				resolve(message.source, message.importer).then((file) => post({
+					type: "resolved",
+					request: message.request,
+					file
+				}), () => post({
+					type: "resolved",
+					request: message.request,
+					file: ""
+				}));
+				return;
+			case "done":
+			case "failed": {
+				const job = jobs.get(message.job);
+				jobs.delete(message.job);
+				if (message.type === "done") job?.resolve(message.result);
+				else job?.reject(fromErrorData(message.error));
+				return;
+			}
+		}
+	});
+	thread.on("error", (error) => {
+		const why = error instanceof Error ? error.message : String(error);
+		warn(`a scan worker stopped, so the main thread compiles more: ${why}`);
+		lost(why);
+	});
+	thread.on("exit", () => lost("the worker exited"));
+	const post = (message) => {
+		if (alive) thread.postMessage(message);
+	};
+	return {
+		ready,
+		capacity: IN_FLIGHT,
+		compile(job) {
+			if (!alive) return Promise.reject(new WorkerLost("the worker exited"));
+			const id = next++;
+			return new Promise((resolve, reject) => {
+				jobs.set(id, {
+					resolve,
+					reject
+				});
+				post({
+					type: "compile",
+					job: id,
+					id: job.id,
+					code: job.code,
+					...job.script ? { script: job.script } : {}
+				});
+			});
+		}
+	};
+}
+//#endregion
+export { originalLines as S, isSfc as _, toErrorData as a, setParser as b, moduleLoader as c, FRAMEWORKS as d, SFC_SCRIPT_ID as f, frameworkOf as g, extractScripts as h, poolSize as i, resolveFile as l, detectFramework as m, WorkerLost as n, compile as o, configuredJsxSource as p, configShape as r, createParseCache as s, CompilePool as t, resolvesAlike as u, compileModule as v, SourceEdits as x, createModuleCache as y };