@animus-ui/extract 0.1.20 → 0.1.21

package/dist/{pipeline-A54wEQEg.cjs → pipeline-D7B1z0-1.cjs}

@@ -32,6 +32,11 @@ browserslist = __toESM(browserslist);
 let lightningcss = require("lightningcss");
 let _animus_ui_properties = require("@animus-ui/properties");
 //#region pipeline/assemble-stylesheet.ts
+/**
+* The cascade layer order, outermost first: its one definition. The engine
+* reads it from `crates/extract-v2/src/layer_order.json`, which
+* `scripts/layer-order.ts --write` writes from here.
+*/
 const ANIMUS_LAYERS = [
 	"anm-global",
 	"anm-base",
@@ -179,6 +184,8 @@ function collectSelectorAliasDiagnostics(selectorAliasesJson) {
 	return diagnostics;
 }
 const UNREADABLE_SOURCE_FILE = "animus.ingestion.unreadable-source-file";
+/** A kit the system extends resolved, yet discovery found none of its files. */
+const NO_KIT_FILES = "animus.discovery.no-kit-files";
 /** What a skipped source file costs: the analysis never sees what it
 *  renders. */
 const SKIPPED_SOURCE_COST = "skipped: its renders are not seen, so nothing is pruned and every component, variant option and state is kept until it is analyzed";
@@ -202,6 +209,18 @@ function unreadableSourceDiagnostic(relPath, error) {
 		severity: severityFor(UNREADABLE_SOURCE_FILE)
 	};
 }
+/** One warning per kit the system extends that resolved, yet yielded no
+*  files: none of its components are extracted. */
+function noKitFilesDiagnostics(outcomes) {
+	return outcomes.filter((record) => record.outcome === "empty").map((record) => ({
+		file: record.specifier,
+		component: "kit",
+		kind: "warn",
+		message: "resolved, but discovery found none of its files, so none of its components are extracted — check that the package ships its src/ directory or a readable entry",
+		code: NO_KIT_FILES,
+		severity: severityFor(NO_KIT_FILES)
+	}));
+}
 /** The collision entry code minted by the system package's merge. */
 const VOCABULARY_COLLISION = "animus.vocabulary.collision";
 /** A theme `@property` registration browsers would ignore; it is not emitted. */
@@ -221,17 +240,28 @@ const PROPERTY_UNREGISTERED_ANIMATION = "animus.property.unregistered-animation"
 *  it invalid at computed-value time. */
 const PROPERTY_SELF_REFERENCE = "animus.property.self-reference";
 /** A custom property that reads itself only inside another `var()`'s
-*  fallback, so whether it is cyclic depends on the browser. */
+*  fallback: cyclic wherever that fallback is used. */
 const PROPERTY_FALLBACK_SELF_REFERENCE = "animus.property.fallback-self-reference";
+/** Custom properties that `currentVar` writes in one rule, each reading
+*  another directly, so every property in the cycle is invalid at
+*  computed-value time. */
+const PROPERTY_CURRENT_VAR_CYCLE = "animus.property.current-var-cycle";
 /** A prefix renamed contextual variables without `prefixContextualVars`, so
 *  their declared names no longer resolve. */
 const PREFIX_CONTEXTUAL_VARS_UNPREFIXED = "animus.prefix.contextual-vars-unprefixed";
 /** Under `prefixContextualVars`, a final name that collides with a runtime
 *  transport variable or a theme variable of the same spelling. */
 const PREFIX_NAME_CONFLICT = "animus.prefix.name-conflict";
+/** A contextual variable declared on a scale that also holds a token of its
+*  name: scale reads resolve to the token. */
+const PROPERTY_LEGACY_TOKEN_COLLISION = "animus.property.legacy-token-collision";
+/** A theme property declared on a scale that also holds a token of its
+*  name. */
+const PROPERTY_TOKEN_COLLISION = "animus.property.token-collision";
 const DIAGNOSTIC_SEVERITY = /* @__PURE__ */ new Map([
 	[SELECTOR_UNSUPPORTED_SUBJECT, "error"],
 	[UNREADABLE_SOURCE_FILE, "error"],
+	[NO_KIT_FILES, "warn"],
 	[VOCABULARY_COLLISION, "warn"],
 	[VOCABULARY_LEGACY_VERB, "warn"],
 	[INVALID_PROPERTY_REGISTRATION, "error"],
@@ -240,8 +270,11 @@ const DIAGNOSTIC_SEVERITY = /* @__PURE__ */ new Map([
 	[PROPERTY_UNREGISTERED_ANIMATION, "info"],
 	[PROPERTY_SELF_REFERENCE, "warn"],
 	[PROPERTY_FALLBACK_SELF_REFERENCE, "warn"],
+	[PROPERTY_CURRENT_VAR_CYCLE, "warn"],
 	[PREFIX_CONTEXTUAL_VARS_UNPREFIXED, "warn"],
-	[PREFIX_NAME_CONFLICT, "error"]
+	[PREFIX_NAME_CONFLICT, "error"],
+	[PROPERTY_LEGACY_TOKEN_COLLISION, "warn"],
+	[PROPERTY_TOKEN_COLLISION, "error"]
 ]);
 /** An unlisted code is `warn`: a witness kind from a newer system package
 *  must not fail the strict build of a host that predates its writer. */
@@ -314,10 +347,40 @@ function systemLoadDiagnostics(system) {
 		...vocabularyWitnessDiagnostics(system.vocabularyWitnessesJson),
 		...registrations,
 		...unprefixed,
-		...conflicts
+		...conflicts,
+		...tokenCollisionDiagnostics(system)
 	];
 }
 /**
+* Each declared property whose name is also a token on a scale it is
+* declared on. A scale read of that key, a prop value or a `{scale.key}`
+* reference, resolves to the token, so the property is unreachable through
+* the scale. A legacy declaration warns and the token stays the winner; any
+* other is an error in every mode.
+*/
+function tokenCollisionDiagnostics(system) {
+	if (!system.propertyRecordsJson) return [];
+	const declared = parseInternalWire(system.propertyRecordsJson, "propertyRecordsJson (the theme's properties)").flatMap((record) => record.scales.map((scale) => ({
+		record,
+		scale,
+		path: `${scale}.${record.name}`
+	})));
+	if (declared.length === 0) return [];
+	const tokens = parseInternalWire(system.scalesJson, "scalesJson (the theme's scale tokens)");
+	return declared.filter(({ path }) => Object.hasOwn(tokens, path)).map(({ record, scale, path }) => {
+		const code = record.legacy ? PROPERTY_LEGACY_TOKEN_COLLISION : PROPERTY_TOKEN_COLLISION;
+		const declaration = record.legacy ? `the contextual variable ${record.name}, which declareContextualVars declares on ${scale},` : `the theme property ${record.name}, declared on ${scale},`;
+		return {
+			file: "system",
+			component: path,
+			kind: record.legacy ? "warn" : "error",
+			message: `the ${scale} token ${record.name} (${tokens[path]}) and ${declaration} share this key. A scale read of it, such as {${path}} or a prop on the ${scale} scale set to '${record.name}', resolves to the token, so the ${record.legacy ? "contextual variable" : "property"} is unreachable through ${scale}. Rename one of them (${code})`,
+			code,
+			severity: severityFor(code)
+		};
+	});
+}
+/**
 * The single strict-escalation policy point for both extraction plugins:
 * error-severity diagnostics throw together under `strict`, else warn.
 */
@@ -1809,6 +1872,188 @@ function createSourceIdentity(rootDir) {
 	};
 }
 //#endregion
+//#region pipeline/tsconfig-paths.ts
+/**
+* tsconfig `paths` → alias pairs, for drivers with no live bundler config.
+* The nearest config declaring `paths` wins wholesale — TS never merges.
+*/
+function stripJsonc(text) {
+	let out = "";
+	let inString = false;
+	let inLine = false;
+	let inBlock = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		const next = text[i + 1];
+		if (inLine) {
+			if (ch === "\n") {
+				inLine = false;
+				out += ch;
+			}
+			continue;
+		}
+		if (inBlock) {
+			if (ch === "*" && next === "/") {
+				inBlock = false;
+				i++;
+			}
+			continue;
+		}
+		if (inString) {
+			out += ch;
+			if (ch === "\\") {
+				out += next ?? "";
+				i++;
+			} else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			out += ch;
+			continue;
+		}
+		if (ch === "/" && next === "/") {
+			inLine = true;
+			i++;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			inBlock = true;
+			i++;
+			continue;
+		}
+		out += ch;
+	}
+	return out.replace(/,(\s*[}\]])/g, "$1");
+}
+/** `Object(value) === value` holds for exactly the blocks and lists
+*  `JSON.parse` produces; the `[object Object]` tag separates the two. */
+function isJsonBlock(value) {
+	return Object(value) === value && Object.prototype.toString.call(value) === "[object Object]";
+}
+/** A block or a list. A declared `paths` OWNS the setting and blocks its
+*  parents' even when it contributes nothing usable. */
+function isJsonKeyed(value) {
+	return Object(value) === value;
+}
+/** A JSON string, excluding the boxed `String` object, which no path join
+*  accepts. */
+function isJsonString(value) {
+	return Object(value) !== value && Object.prototype.toString.call(value) === "[object String]";
+}
+function decodePaths(value) {
+	if (!isJsonKeyed(value)) return null;
+	const decoded = /* @__PURE__ */ new Map();
+	for (const [pattern, targets] of Object.entries(value)) {
+		const [first] = Array.isArray(targets) ? targets : [];
+		if (isJsonString(first)) decoded.set(pattern, first);
+	}
+	return decoded;
+}
+/** TypeScript accepts one specifier or an array; a non-string member names
+*  no config and is dropped here. */
+function decodeExtends(value) {
+	return (Array.isArray(value) ? value : [value]).filter(isJsonString);
+}
+function readConfig(path$4) {
+	let raw;
+	try {
+		raw = (0, fs.readFileSync)(path$4, "utf-8");
+	} catch {
+		return null;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(stripJsonc(raw));
+	} catch {
+		return null;
+	}
+	const root = isJsonBlock(parsed) ? parsed : {};
+	const compilerOptions = isJsonBlock(root.compilerOptions) ? root.compilerOptions : {};
+	return {
+		dir: (0, path.dirname)(path$4),
+		baseUrl: isJsonString(compilerOptions.baseUrl) ? compilerOptions.baseUrl : null,
+		paths: decodePaths(compilerOptions.paths),
+		extends: decodeExtends(root.extends)
+	};
+}
+function resolveExtendsTarget(specifier, fromDir) {
+	if (specifier.startsWith(".") || (0, path.isAbsolute)(specifier)) {
+		const base = (0, path.resolve)(fromDir, specifier);
+		for (const candidate of [
+			base,
+			`${base}.json`,
+			(0, path.join)(base, "tsconfig.json")
+		]) if ((0, fs.existsSync)(candidate)) return candidate;
+		return null;
+	}
+	try {
+		return require.resolve(specifier.endsWith(".json") ? specifier : `${specifier}/tsconfig.json`, { paths: [fromDir] });
+	} catch {
+		try {
+			return require.resolve(specifier, { paths: [fromDir] });
+		} catch {
+			return null;
+		}
+	}
+}
+/** Child-first flattened extends chain starting at `entryPath`. */
+function loadChain(entryPath) {
+	const chain = [];
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [entryPath];
+	while (queue.length > 0) {
+		const path$5 = queue.shift();
+		const key = (0, path.resolve)(path$5);
+		if (visited.has(key)) continue;
+		visited.add(key);
+		const node = readConfig(key);
+		if (!node) continue;
+		chain.push(node);
+		for (const parent of node.extends) {
+			const resolved = resolveExtendsTarget(parent, node.dir);
+			if (resolved) queue.push(resolved);
+		}
+	}
+	return chain;
+}
+/**
+* The project's tsconfig path aliases as `buildPathAliasesJson` pairs; empty
+* when no readable tsconfig, or no usable `paths`, exists.
+*/
+function readTsconfigAliasPairs(rootDir) {
+	const chain = loadChain((0, path.join)(rootDir, "tsconfig.json"));
+	if (chain.length === 0) return [];
+	const pathsOwner = chain.find((node) => node.paths !== null);
+	const paths = pathsOwner?.paths ?? null;
+	if (pathsOwner === void 0 || paths === null) return [];
+	const baseOwner = chain.find((node) => node.baseUrl !== null);
+	const baseUrl = baseOwner?.baseUrl ?? null;
+	const base = baseOwner !== void 0 && baseUrl !== null ? (0, path.resolve)(baseOwner.dir, baseUrl) : pathsOwner.dir;
+	const pairs = [];
+	for (const [pattern, target] of paths) {
+		const patternStars = pattern.split("*").length - 1;
+		const targetStars = target.split("*").length - 1;
+		if (pattern === "*" || patternStars > 1 || targetStars > 1) continue;
+		if (pattern.endsWith("/*")) {
+			if (!target.endsWith("/*")) continue;
+			pairs.push({
+				pattern: pattern.slice(0, -2),
+				target: (0, path.resolve)(base, target.slice(0, -2)),
+				kind: "prefix"
+			});
+			continue;
+		}
+		if (patternStars > 0 || targetStars > 0) continue;
+		pairs.push({
+			pattern,
+			target: (0, path.resolve)(base, target),
+			kind: "exact"
+		});
+	}
+	return pairs;
+}
+//#endregion
 //#region pipeline/discover-packages.ts
 function findPackageRoot(absEntryPath) {
 	let pkgRoot = (0, path.dirname)(absEntryPath);
@@ -1834,9 +2079,9 @@ const PACKAGE_OUTPUT_EXCLUDES = [
 	".d.ts",
 	".map"
 ];
-const isFile = (path$4) => {
+const isFile = (path$2) => {
 	try {
-		return (0, fs.statSync)(path$4).isFile();
+		return (0, fs.statSync)(path$2).isFile();
 	} catch {
 		return false;
 	}
@@ -1862,6 +2107,77 @@ function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
 	const subpath = specifier.slice(packageName.length + 1);
 	return resolveAbsolutePathSpecifier((0, path.join)(srcDir, subpath || "index"), extensionsSet);
 }
+/**
+* A package's `sideEffects` field, decoded the way Vite reads it: a boolean
+* as written, or the list's globs, one with no `/` matching the basename
+* anywhere and any other rooted at the package. Undefined without a readable
+* field, or with glob syntax this matcher lacks (braces, classes, negation,
+* extglobs), which leaves the bundler's side-effectful default.
+*/
+function readPackageSideEffects(pkgRoot) {
+	let manifest;
+	try {
+		manifest = JSON.parse((0, fs.readFileSync)((0, path.join)(pkgRoot, "package.json"), "utf-8"));
+	} catch {
+		return;
+	}
+	const field = isJsonBlock(manifest) ? manifest.sideEffects : void 0;
+	if (field === true || field === false) return field;
+	if (!Array.isArray(field)) return void 0;
+	const globs = field.filter(isJsonString);
+	if (globs.some((glob) => /[{}[\]()!+@]/.test(glob))) return void 0;
+	return globs.map((glob) => globToRegExp(glob.includes("/") ? glob.replace(/^\.?\//, "") : `**/${glob}`));
+}
+function matchesSideEffects(globs, pkgRoot, absFiles) {
+	return absFiles.some((file) => {
+		const relPath = (0, path.relative)(pkgRoot, file).split(path.sep).join("/");
+		return globs.some((glob) => glob.test(relPath));
+	});
+}
+/** An exports target under the `import` condition, then `default`, as the
+*  system loader reads it; an array offers its targets in order. */
+function exportTarget(value) {
+	if (isJsonString(value)) return value;
+	if (Array.isArray(value)) {
+		for (const entry of value) {
+			const target = exportTarget(entry);
+			if (target !== null) return target;
+		}
+		return null;
+	}
+	if (!isJsonBlock(value)) return null;
+	return exportTarget(value.import) ?? exportTarget(value.default);
+}
+/** Each exact `exports` entry of the package at `pkgRoot`, as its subpath
+*  and absolute target; `*` patterns name no single file and are skipped. */
+function packageExportEntries(pkgRoot) {
+	let manifest;
+	try {
+		manifest = JSON.parse((0, fs.readFileSync)((0, path.join)(pkgRoot, "package.json"), "utf-8"));
+	} catch {
+		return [];
+	}
+	const exports = isJsonBlock(manifest) ? manifest.exports : void 0;
+	if (exports === void 0 || exports === null) return [];
+	const subpaths = isJsonBlock(exports) && Object.keys(exports).some((k) => k.startsWith(".")) ? exports : { ".": exports };
+	const entries = [];
+	for (const [subpath, value] of Object.entries(subpaths)) {
+		if (!subpath.startsWith(".") || subpath.includes("*")) continue;
+		const target = exportTarget(value);
+		if (target !== null) entries.push([subpath, (0, path.resolve)(pkgRoot, target)]);
+	}
+	return entries;
+}
+/** Installed content is release content, and unpacking can leave any file
+*  times, so only a package whose real path is outside `node_modules`, such
+*  as a workspace link, is judged stale by them. */
+function isInstalledPackage(pkgRoot) {
+	let realRoot = pkgRoot;
+	try {
+		realRoot = (0, fs.realpathSync)(pkgRoot);
+	} catch {}
+	return realRoot.split(/[\\/]/).includes("node_modules");
+}
 function distEntryIsStale(absEntry, srcDir, srcFiles) {
 	if (isPathWithinRoot(srcDir, absEntry)) return false;
 	let distMtime;
@@ -1882,6 +2198,20 @@ async function collectExternalPackageSources(opts) {
 	const pushed = /* @__PURE__ */ new Set();
 	const packageMap = {};
 	const sourceEntries = /* @__PURE__ */ new Map();
+	const sourceEntrySideEffects = /* @__PURE__ */ new Map();
+	/** `replaced` names the entry the redirect stands in for; it is only
+	*  needed, and so only resolved, for a glob list. */
+	const redirect = async (specifier, srcEntry, pkgRoot, replaced) => {
+		sourceEntries.set(specifier, srcEntry);
+		const field = readPackageSideEffects(pkgRoot);
+		if (field === void 0) return;
+		if (field === true || field === false) {
+			sourceEntrySideEffects.set(specifier, field);
+			return;
+		}
+		const replacedEntry = await replaced();
+		sourceEntrySideEffects.set(specifier, replacedEntry === null || matchesSideEffects(field, pkgRoot, [srcEntry, replacedEntry]));
+	};
 	const packageDirs = [];
 	const dirOwnerSets = {};
 	const dirExtensions = {};
@@ -1919,7 +2249,8 @@ async function collectExternalPackageSources(opts) {
 			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
 			if (srcEntry) {
 				packageMap[specifier] = (0, path.relative)(rootDir, srcEntry);
-				sourceEntries.set(specifier, srcEntry);
+				const replaced = absEntry;
+				await redirect(specifier, srcEntry, pkgRoot, async () => replaced);
 			} else packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
 			if (!(0, path.isAbsolute)(specifier)) {
 				const packageName = bareSpecifierPackageName(specifier);
@@ -1927,12 +2258,18 @@ async function collectExternalPackageSources(opts) {
 					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
 					if (rootEntry) {
 						packageMap[packageName] = (0, path.relative)(rootDir, rootEntry);
-						sourceEntries.set(packageName, rootEntry);
+						await redirect(packageName, rootEntry, pkgRoot, async () => {
+							try {
+								return await resolveSpecifier(packageName);
+							} catch {
+								return null;
+							}
+						});
 					}
 				}
 			}
 			const pkgFiles = walkPackageSources(srcDir, extensionsSet);
-			staleDist = distEntryIsStale(absEntry, srcDir, pkgFiles);
+			staleDist = !isInstalledPackage(pkgRoot) && distEntryIsStale(absEntry, srcDir, pkgFiles);
 			for (const pkgFile of pkgFiles) {
 				const relPath = (0, path.relative)(rootDir, pkgFile);
 				if (alreadyIngested(relPath)) {
@@ -1992,6 +2329,15 @@ async function collectExternalPackageSources(opts) {
 				fileCount++;
 			}
 		}
+		if (!(0, path.isAbsolute)(specifier)) {
+			const packageName = bareSpecifierPackageName(specifier);
+			for (const [subpath, target] of packageExportEntries(pkgRoot)) {
+				const entrySpecifier = packageName + subpath.slice(1);
+				const targetRelPath = (0, path.relative)(rootDir, target);
+				if (entrySpecifier in packageMap || !alreadyIngested(targetRelPath)) continue;
+				packageMap[entrySpecifier] = targetRelPath;
+			}
+		}
 		outcomes.push({
 			specifier,
 			outcome: staleDist ? "stale-dist" : fileCount > 0 ? "resolved" : "empty",
@@ -2002,6 +2348,7 @@ async function collectExternalPackageSources(opts) {
 		entries,
 		packageMap,
 		sourceEntries,
+		sourceEntrySideEffects,
 		packageDirs,
 		dirOwnerSets,
 		dirExtensions,
@@ -2025,9 +2372,12 @@ function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
 		packageMap[specifier] = relTarget;
 	}
 	const sourceEntries = /* @__PURE__ */ new Map();
+	const sourceEntrySideEffects = /* @__PURE__ */ new Map();
 	for (const [specifier, absEntry] of collected.sourceEntries) {
 		if (targetRejected(specifier, absEntry)) continue;
 		sourceEntries.set(specifier, absEntry);
+		const sideEffects = collected.sourceEntrySideEffects.get(specifier);
+		if (sideEffects !== void 0) sourceEntrySideEffects.set(specifier, sideEffects);
 	}
 	const dirOwnerSets = {};
 	for (const [dir, specs] of Object.entries(collected.dirOwnerSets)) {
@@ -2049,6 +2399,7 @@ function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
 		entries: collected.entries.filter((entry) => !rejectedSpecifiers.has(collected.fileOwners[entry.path])),
 		packageMap,
 		sourceEntries,
+		sourceEntrySideEffects,
 		packageDirs: collected.packageDirs.filter((dir) => !rejectedDirs.includes(dir)),
 		dirOwnerSets,
 		dirExtensions,
@@ -2068,15 +2419,50 @@ function staleDistIncludesMessage(outcomes) {
 	if (stale.length === 0) return null;
 	return `[animus-extract] stale dist for include specifier(s): ${stale.join(", ")} — dist entry is older than the newest src/ file; rebuild the package(s) before extracting`;
 }
-function extractSystemFilePackages(systemFilePath) {
+/** The engine's own parse of a module's imports, through its
+*  `extractFacts`; undefined for an engine without one. A parse that
+*  panicked reports no imports, so it counts as no parse. */
+function engineImportParser(engine) {
+	const { extractFacts } = engine;
+	if (!extractFacts) return void 0;
+	return (source, path$3) => {
+		try {
+			const facts = parseInternalWire(extractFacts(JSON.stringify([{
+				path: path$3,
+				source
+			}])), "extractFacts").files[path$3];
+			return facts && !facts.parsePanicked ? facts.imports : null;
+		} catch {
+			return null;
+		}
+	};
+}
+/** A pattern matching a call of any of `callees` as a whole name, or null
+*  when there is none to anchor on. */
+function rootCallPattern(callees) {
+	if (callees.length === 0) return null;
+	return `(?<![a-zA-Z0-9_$.])(?:${callees.map((callee) => callee.replace(/[.$]/g, "\\$&")).join("|")})`;
+}
+function extractSystemFilePackages(systemFilePath, parseImports) {
 	let source;
 	try {
 		source = (0, fs.readFileSync)(systemFilePath, "utf-8");
 	} catch {
 		return [];
 	}
+	const parsed = parseImports?.(source, systemFilePath) ?? null;
+	const parsedImports = parsed && parsed.length > 0 ? parsed : null;
+	let rootCall = "createSystem";
+	if (parsedImports) {
+		const shadowed = parsedImports.some((binding) => binding.local === "createSystem" && binding.imported !== "createSystem") || /\b(?:function\*?|class)\s+createSystem\b|\b(?:const|let|var)\s+createSystem\b/.test(source);
+		rootCall = rootCallPattern([.../* @__PURE__ */ new Set([
+			...parsedImports.filter((binding) => binding.imported === "createSystem").map((binding) => binding.local),
+			...Array.from(source.matchAll(/\bimport\s+(?:[a-zA-Z_$][a-zA-Z0-9_$]*\s*,\s*)?\*\s*as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s+from\s+['"]@animus-ui\/system(?:\/[^'"]*)?['"]/g), (match) => `${match[1]}.createSystem`),
+			...shadowed ? [] : ["createSystem"]
+		])]);
+	}
 	const identifiers = /* @__PURE__ */ new Set();
-	const constructorRegex = /createSystem\s*\(\s*\{[^}]*?\bincludes\s*:\s*\[([^\]]*)\]/gs;
+	const constructorRegex = rootCall === null ? null : new RegExp(`${rootCall}\\s*\\(\\s*\\{[^}]*?\\bincludes\\s*:\\s*\\[([^\\]]*)\\]`, "gs");
 	const chainRegex = /\.includes\s*\(\s*\[([^\]]*)\]\s*\)/gs;
 	const collectIdentifiers = (regex) => {
 		let match;
@@ -2088,7 +2474,7 @@ function extractSystemFilePackages(systemFilePath) {
 			}
 		}
 	};
-	collectIdentifiers(constructorRegex);
+	if (constructorRegex) collectIdentifiers(constructorRegex);
 	collectIdentifiers(chainRegex);
 	const IDENT_START_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*/;
 	const skipTrivia = (from) => {
@@ -2108,6 +2494,38 @@ function extractSystemFilePackages(systemFilePath) {
 			return pos;
 		}
 	};
+	/** The index after the string literal opening at `from`. */
+	const skipString = (from) => {
+		const quote = source[from];
+		let pos = from + 1;
+		while (pos < source.length && source[pos] !== quote) pos += source[pos] === "\\" ? 2 : 1;
+		return pos + 1;
+	};
+	/** The index after the bracketed span opening at `from`, balanced across
+	*  `<>`, `()`, `[]` and `{}`, or -1 when it never closes. An arrow type's
+	*  `=>` closes nothing. */
+	const skipBalanced = (from) => {
+		let depth = 0;
+		let pos = from;
+		while (pos < source.length) {
+			const ch = source[pos];
+			if (ch === "'" || ch === "\"" || ch === "`") {
+				pos = skipString(pos);
+				continue;
+			}
+			if (source.startsWith("//", pos) || source.startsWith("/*", pos)) {
+				pos = skipTrivia(pos);
+				continue;
+			}
+			if ("<([{".includes(ch)) depth++;
+			else if (")]}".includes(ch) || ch === ">" && source[pos - 1] !== "=") {
+				depth--;
+				if (depth === 0) return pos + 1;
+			}
+			pos++;
+		}
+		return -1;
+	};
 	const consumeChainLinks = (from) => {
 		let pos = from;
 		for (;;) {
@@ -2117,6 +2535,11 @@ function extractSystemFilePackages(systemFilePath) {
 			const method = IDENT_START_RE.exec(source.slice(cursor))?.[0];
 			if (method !== "extend" && method !== "from") return pos;
 			cursor = skipTrivia(cursor + method.length);
+			if (source[cursor] === "<") {
+				const afterTypeArguments = skipBalanced(cursor);
+				if (afterTypeArguments === -1) return pos;
+				cursor = skipTrivia(afterTypeArguments);
+			}
 			if (source[cursor] !== "(") return pos;
 			cursor = skipTrivia(cursor + 1);
 			const base = IDENT_START_RE.exec(source.slice(cursor))?.[0];
@@ -2134,14 +2557,47 @@ function extractSystemFilePackages(systemFilePath) {
 			pos = cursor + 1;
 		}
 	};
+	const bindingAt = /* @__PURE__ */ new Map();
+	const aliasOf = /* @__PURE__ */ new Map();
+	const declarationRe = /\b(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+	let declaration;
+	while ((declaration = declarationRe.exec(source)) !== null) {
+		const name = declaration[1];
+		let cursor = skipTrivia(declaration.index + declaration[0].length);
+		if (source[cursor] === ":") {
+			cursor++;
+			while (cursor < source.length) {
+				const ch = source[cursor];
+				if (ch === ";" || ch === ",") break;
+				if (ch === "\n" && /^\s*(?:export\s+)?(?:const|let|var|function|class|type|interface|import)\b/.test(source.slice(cursor + 1, cursor + 80))) break;
+				if (ch === "=" && source[cursor + 1] !== ">") break;
+				if ("<([{".includes(ch) || ch === "'" || ch === "\"" || ch === "`") {
+					const after = "<([{".includes(ch) ? skipBalanced(cursor) : skipString(cursor);
+					if (after === -1) break;
+					cursor = after;
+					continue;
+				}
+				cursor = ch === "=" ? cursor + 2 : cursor + 1;
+			}
+		}
+		if (source[cursor] !== "=" || source[cursor + 1] === "=") continue;
+		const initializer = skipTrivia(cursor + 1);
+		bindingAt.set(initializer, name);
+		const target = IDENT_START_RE.exec(source.slice(initializer))?.[0];
+		if (!target) continue;
+		const rest = source.slice(initializer + target.length);
+		if (/^[ \t]*(?:(?:as|satisfies)\s[^;\n]*)?(?:\/\/[^\n]*)?(?:;|\r?\n(?!\s*[.([?`])|$)/.test(rest)) aliasOf.set(name, target);
+	}
 	const boundIdentifierBefore = (index) => {
+		const declared = bindingAt.get(index);
+		if (declared) return declared;
 		const match = /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*$/.exec(source.slice(0, index));
 		return match ? match[1] : null;
 	};
 	const chainRootIdentifiers = /* @__PURE__ */ new Set();
-	const createSystemAnchor = /createSystem\s*\(/g;
+	const createSystemAnchor = rootCall === null ? null : new RegExp(`${rootCall}\\s*\\(`, "g");
 	let anchorMatch;
-	while ((anchorMatch = createSystemAnchor.exec(source)) !== null) {
+	while ((anchorMatch = createSystemAnchor?.exec(source) ?? null) !== null) {
 		let pos = anchorMatch.index + anchorMatch[0].length;
 		let depth = 1;
 		while (pos < source.length && depth > 0) {
@@ -2172,22 +2628,37 @@ function extractSystemFilePackages(systemFilePath) {
 	}
 	if (identifiers.size === 0) return [];
 	const importMap = /* @__PURE__ */ new Map();
+	for (const binding of parsedImports ?? []) importMap.set(binding.local, binding.source);
 	const importRegex = /^\s*import\s+(?:([a-zA-Z_$][a-zA-Z0-9_$]*)\s*,\s*)?(?:\{([^}]*)\}|([a-zA-Z_$][a-zA-Z0-9_$]*))\s+from\s+['"]([^'"]+)['"]/gm;
-	let importMatch;
-	while ((importMatch = importRegex.exec(source)) !== null) {
-		const [, comboDefault, namedImports, defaultImport, specifier] = importMatch;
-		if (comboDefault) importMap.set(comboDefault, specifier);
-		if (defaultImport) importMap.set(defaultImport, specifier);
-		if (namedImports) for (const binding of namedImports.split(",")) {
-			const parts = binding.trim().split(/\s+as\s+/);
-			const localName = (parts[1] || parts[0]).trim();
-			if (localName) importMap.set(localName, specifier);
+	if (!parsedImports) {
+		let importMatch;
+		while ((importMatch = importRegex.exec(source)) !== null) {
+			const [, comboDefault, namedImports, defaultImport, specifier] = importMatch;
+			if (comboDefault) importMap.set(comboDefault, specifier);
+			if (defaultImport) importMap.set(defaultImport, specifier);
+			if (namedImports) for (const binding of namedImports.split(",")) {
+				const parts = binding.trim().split(/\s+as\s+/);
+				const localName = (parts[1] || parts[0]).trim();
+				if (localName) importMap.set(localName, specifier);
+			}
 		}
 	}
 	const systemFileDir = (0, path.dirname)(systemFilePath);
 	const packages = /* @__PURE__ */ new Set();
+	/** The import a local alias chain ends at, or the identifier itself. */
+	const throughAliases = (id) => {
+		const seen = /* @__PURE__ */ new Set();
+		let current = id;
+		while (!importMap.has(current) && !seen.has(current)) {
+			seen.add(current);
+			const target = aliasOf.get(current);
+			if (!target) break;
+			current = target;
+		}
+		return current;
+	};
 	for (const id of identifiers) {
-		const specifier = importMap.get(id);
+		const specifier = importMap.get(throughAliases(id));
 		if (!specifier) continue;
 		if (specifier.startsWith(".")) packages.add((0, path.resolve)(systemFileDir, specifier));
 		else packages.add(specifier);
@@ -2250,7 +2721,7 @@ const URL_OPEN_RE = /url\(\s*(['"]?)/gi;
 const IMAGE_SET_OPEN_RE = /(?:-webkit-)?image-set\(/gi;
 const BARE_SPECIFIER_RE = /^[^'")\s]+/;
 /** The index of the `)` that closes the `(` at `open`, outside strings. */
-function closingParen$1(css, open) {
+function closingParen(css, open) {
 	let depth = 0;
 	let quote = null;
 	for (let i = open; i < css.length; i += 1) {
@@ -2299,7 +2770,7 @@ function assetReferences(css) {
 	}
 	for (const open of css.matchAll(IMAGE_SET_OPEN_RE)) {
 		const paren = (open.index ?? 0) + open[0].length - 1;
-		const close = closingParen$1(css, paren);
+		const close = closingParen(css, paren);
 		let depth = 0;
 		let candidateStart = true;
 		for (let i = paren + 1; i < close; i += 1) {
@@ -2344,7 +2815,7 @@ function placeholdersInAssetCalls(css) {
 	if (!css.includes("animus-asset:")) return [];
 	const calls = [...css.matchAll(URL_OPEN_RE), ...css.matchAll(IMAGE_SET_OPEN_RE)].map((open) => {
 		const paren = css.indexOf("(", open.index ?? 0);
-		return [paren, closingParen$1(css, paren)];
+		return [paren, closingParen(css, paren)];
 	});
 	const found = /* @__PURE__ */ new Set();
 	for (let at = css.indexOf(ASSET_PLACEHOLDER_PREFIX); at !== -1; at = css.indexOf(ASSET_PLACEHOLDER_PREFIX, at + 1)) {
@@ -2586,14 +3057,9 @@ function buildPathAliasesJson(pairs, rootDir) {
 //#endregion
 //#region pipeline/post-process-css.ts
 function resolveLightningTargets(explicitTargets, rootDir) {
-	let queries;
-	if (explicitTargets) queries = Array.isArray(explicitTargets) ? explicitTargets : [explicitTargets];
-	else {
-		const detected = (0, browserslist.default)(void 0, { path: rootDir });
-		queries = detected.length > 0 ? detected : (0, browserslist.default)("defaults");
-	}
-	const [firstQuery] = queries;
-	return (0, lightningcss.browserslistToTargets)(firstQuery !== void 0 && firstQuery.includes(" ") ? (0, browserslist.default)(queries) : queries);
+	if (explicitTargets) return (0, lightningcss.browserslistToTargets)((0, browserslist.default)(explicitTargets));
+	const detected = (0, browserslist.default)(void 0, { path: rootDir });
+	return (0, lightningcss.browserslistToTargets)(detected.length > 0 ? detected : (0, browserslist.default)("defaults"));
 }
 function postProcessCss(css, opts) {
 	if (!css) return css;
@@ -2611,125 +3077,28 @@ function postProcessCss(css, opts) {
 	}
 }
 //#endregion
-//#region pipeline/property-names.ts
-function createPropertyNames(declared, prefix, themeNames = []) {
-	const finals = /* @__PURE__ */ new Map();
-	for (const name of [...new Set(declared)].sort()) finals.set(name, `${prefix}-${name}`);
-	const aliases = /* @__PURE__ */ new Map();
-	for (const [name, final] of finals) if (!finals.has(final)) aliases.set(final, name);
-	const others = /* @__PURE__ */ new Map();
-	for (const name of [...new Set(themeNames)].sort()) if (!finals.has(name)) others.set(name, `${prefix}-${name}`);
-	return {
-		identity: (spelling) => finals.has(spelling) ? spelling : aliases.get(spelling) ?? (others.has(spelling) ? spelling : void 0),
-		finalName: (name) => finals.get(name) ?? others.get(name),
-		ambiguous: () => [...others.keys()].filter((name) => aliases.has(name)).map((name) => ({
-			name,
-			contextual: aliases.get(name) ?? name
-		}))
-	};
-}
-const NAME_CHAR = /[\w-]/;
-/**
-* The name starting at `from`, read as CSS tokenizes an identifier: ASCII
-* letters, digits, `-` and `_`, every non-ASCII code point, and escapes.
-*/
-function readCustomPropertyName(css, from) {
-	let end = from;
-	let name = "";
-	while (end < css.length) {
-		if (isNameChar(css[end])) {
-			name += css[end];
-			end += 1;
-			continue;
-		}
-		const escape = escapeAt(css, end);
-		if (escape === null) break;
-		name += escape.codePoint;
-		end += escape.length;
-	}
-	return {
-		end,
-		name
-	};
-}
-/** A valid escape at `at`: up to six hex digits and one following
-*  whitespace, or any other code point but a newline. */
-function escapeAt(css, at) {
-	if (css[at] !== "\\") return null;
-	const next = css.codePointAt(at + 1);
-	if (next === void 0 || next === 10 || next === 13 || next === 12) return null;
-	const digits = /^[0-9a-fA-F]{1,6}/.exec(css.slice(at + 1, at + 7))?.[0];
-	if (digits === void 0) return {
-		codePoint: String.fromCodePoint(next),
-		length: 1 + String.fromCodePoint(next).length
-	};
-	const after = css.slice(at + 1 + digits.length);
-	const space = after.startsWith("\r\n") ? 2 : /^[ \t\n\r\f]/.test(after) ? 1 : 0;
-	const value = parseInt(digits, 16);
-	const valid = value !== 0 && value <= 1114111 && (value < 55296 || value > 57343);
-	return {
-		codePoint: String.fromCodePoint(valid ? value : 65533),
-		length: 1 + digits.length + space
-	};
-}
-/**
-* Gives every custom-property token that names a managed property its final
-* name, in one pass: declaration keys, `var()` reads at any depth (fallbacks
-* included), `@property` names, transition-property lists and style queries.
-* A name is read whole, escapes decoded, so an undeclared name that starts
-* with a managed one is never renamed in part. Quoted strings, `url()` and
-* comments are copied unchanged.
-*/
-function renameCustomProperties(css, names) {
-	let out = "";
-	let i = 0;
-	while (i < css.length) {
-		const c = css[i];
-		if (c === "\"" || c === "'") {
-			const end = closingQuote$1(css, i);
-			out += css.slice(i, end);
-			i = end;
-		} else if (css.startsWith("/*", i)) {
-			const close = css.indexOf("*/", i + 2);
-			const end = close === -1 ? css.length : close + 2;
-			out += css.slice(i, end);
-			i = end;
-		} else if (/^url\(/i.test(css.slice(i, i + 4)) && !isNameChar(css[i - 1])) {
-			const end = closingUrl(css, i + 4);
-			out += css.slice(i, end);
-			i = end;
-		} else if (css.startsWith("--", i) && !isNameChar(css[i - 1])) {
-			const { end, name } = readCustomPropertyName(css, i + 2);
-			const identity = names.identity(name);
-			const final = identity === void 0 ? void 0 : names.finalName(identity);
-			out += final === void 0 ? css.slice(i, end) : `--${final}`;
-			i = end;
-		} else {
-			out += c;
-			i += 1;
-		}
+//#region pipeline/property-registrations.ts
+const PROPERTY_AT_RULE = /@property\s+/gi;
+const RULE_BODY = /\s*\{[^}]*\}\n?/y;
+/** Each `@property` rule, through one newline after it, with its name read
+*  as CSS tokenizes an identifier: escapes decoded, non-ASCII included. */
+function propertyRules(css) {
+	const rules = [];
+	for (const match of css.matchAll(PROPERTY_AT_RULE)) {
+		if (match.index < (rules.at(-1)?.end ?? 0)) continue;
+		const name = (0, _animus_ui_properties.identifierAt)(css, match.index + match[0].length);
+		if (!name?.name.startsWith("--")) continue;
+		RULE_BODY.lastIndex = name.end;
+		const body = RULE_BODY.exec(css);
+		if (body === null) continue;
+		rules.push({
+			start: match.index,
+			end: name.end + body[0].length,
+			name: name.name
+		});
 	}
-	return out;
-}
-/** A name code point, or a UTF-16 unit of a non-ASCII one. */
-function isNameChar(c) {
-	return c !== void 0 && (NAME_CHAR.test(c) || c.charCodeAt(0) >= 128);
-}
-function closingQuote$1(css, open) {
-	const quote = css[open];
-	let i = open + 1;
-	while (i < css.length && css[i] !== quote) i += css[i] === "\\" ? 2 : 1;
-	return Math.min(i + 1, css.length);
+	return rules;
 }
-/** The index after the `)` that closes an unquoted or quoted `url(`. */
-function closingUrl(css, from) {
-	let i = from;
-	while (i < css.length && css[i] !== ")") i = css[i] === "\"" || css[i] === "'" ? closingQuote$1(css, i) : i + 1;
-	return Math.min(i + 1, css.length);
-}
-//#endregion
-//#region pipeline/property-registrations.ts
-const PROPERTY_RULE = /@property\s+(--[\w-]+)\s*\{[^}]*\}\n?/g;
 /** The data types a registration's `syntax` may name. */
 const SYNTAX_TYPES = /* @__PURE__ */ new Set([
 	"angle",
@@ -2754,30 +3123,35 @@ const MATH_FUNCTION = /\b(?:calc|min|max|clamp)\(/i;
 /**
 * Removes the `@property` rules browsers would ignore — an unknown syntax
 * component, a syntax other than `*` without an initial value, an initial
-* value that substitutes another value or depends on context, or one the
-* syntax does not accept. Minifying a stylesheet that contains such a rule
-* can also fail. An all-absolute math initial value is written as its
-* computed value, which the minifier reads.
+* value that substitutes another value or depends on context, math that
+* breaks calculation syntax, or a value the syntax does not accept.
+* Minifying a stylesheet that contains such a rule can also fail. An
+* all-absolute math initial value is written as its computed value, which
+* the minifier reads.
 */
 function splitInvalidPropertyRegistrations(css) {
 	const invalid = [];
+	let kept = "";
+	let copied = 0;
+	for (const { start, end, name } of propertyRules(css)) {
+		const checked = checkRegistration(css.slice(start, end));
+		kept += css.slice(copied, start);
+		if ("rule" in checked) kept += checked.rule;
+		else invalid.push({
+			name,
+			reason: checked.reason
+		});
+		copied = end;
+	}
 	return {
-		css: css.replace(PROPERTY_RULE, (rule, name) => {
-			const checked = checkRegistration(rule);
-			if ("rule" in checked) return checked.rule;
-			invalid.push({
-				name,
-				reason: checked.reason
-			});
-			return "";
-		}),
+		css: kept + css.slice(copied),
 		invalid
 	};
 }
 /** The registrations in `css`, by custom-property name. */
 function propertyRegistrations(css) {
 	const registrations = /* @__PURE__ */ new Map();
-	for (const match of css.matchAll(PROPERTY_RULE)) registrations.set(match[1], readRegistration(match[0]));
+	for (const { start, end, name } of propertyRules(css)) registrations.set(name, readRegistration(css.slice(start, end)));
 	return registrations;
 }
 function readRegistration(rule) {
@@ -2792,6 +3166,7 @@ function checkRegistration(rule) {
 	const { syntax, initialValue } = readRegistration(rule);
 	if (initialValue !== void 0 && (0, _animus_ui_properties.substitutesValue)(initialValue)) return { reason: `initialValue "${initialValue}" substitutes another value; var(), env() and attr() are not allowed in an initial value` };
 	let kept = rule;
+	let folded;
 	if (syntax !== "*") {
 		const unknown = syntax.split("|").map((component) => ({
 			text: component.trim(),
@@ -2800,9 +3175,10 @@ function checkRegistration(rule) {
 		if (unknown !== void 0) return { reason: `syntax "${syntax}" has the unknown component "${unknown.text}"` };
 		if (initialValue === void 0) return { reason: `syntax "${syntax}" needs an initialValue` };
 		if ((0, _animus_ui_properties.dependsOnContext)(initialValue)) return { reason: `initialValue "${initialValue}" depends on context; font- and container-relative units are not allowed` };
-		const folded = (0, _animus_ui_properties.foldInitialValue)(syntax, initialValue);
-		if (folded !== void 0 && !folded.accepted) return { reason: `initialValue "${initialValue}" computes to the ${folded.type} ${folded.text}, which syntax "${syntax}" does not accept` };
-		if (folded !== void 0) kept = rule.replace(INITIAL_VALUE, `$1${folded.text}`);
+		folded = (0, _animus_ui_properties.foldInitialValue)(syntax, initialValue);
+		if (folded?.kind === "invalid") return { reason: `initialValue "${initialValue}" is not a valid calculation: ${folded.reason}` };
+		if (folded?.kind === "rejected") return { reason: `initialValue "${initialValue}" computes to the ${folded.type} ${folded.text}, which syntax "${syntax}" does not accept` };
+		if (folded?.kind === "folded") kept = rule.replace(INITIAL_VALUE, `$1${folded.text}`);
 	}
 	try {
 		(0, lightningcss.transform)({
@@ -2812,6 +3188,7 @@ function checkRegistration(rule) {
 		return { rule: kept };
 	} catch (error) {
 		const detail = error instanceof Error ? error.message : String(error);
+		if (folded?.kind === "not-finite") return { reason: `initialValue "${initialValue}" computes to an infinite or NaN value, which browsers clamp and which has no plain CSS value to write instead, and the CSS parser that builds the stylesheet cannot read the math (${detail})` };
 		if (initialValue !== void 0 && MATH_FUNCTION.test(initialValue)) return { reason: `the CSS parser that builds the stylesheet cannot read the math in initialValue "${initialValue}" (${detail}); write its computed value instead` };
 		return { reason: `the CSS parser rejects \`${kept.trim()}\` (${detail})` };
 	}
@@ -2821,13 +3198,18 @@ function checkRegistration(rule) {
 /**
 * Reports custom properties that will not behave as their CSS suggests: a
 * property that refers to itself, a fallback a registered initial value
-* applies ahead of, and an animated property that cannot interpolate. Names
-* are read as CSS tokenizes them, so escapes, function case, comments and
-* quoted text match the prefix pass. The CSS itself is never changed.
+* applies ahead of, and an animated property that cannot interpolate. Sheets
+* are read through the shared CSS tokenizer, as the prefix pass reads them:
+* comments are trivia, quoted text holds no names, and escapes and function
+* case are decoded. The CSS itself is never changed.
 */
 function checkCustomProperties(input) {
 	const registered = propertyRegistrations(input.system.variableCss);
-	const declared = new Set(input.system.contextualProperties ?? []);
+	const declaredNames = input.system.contextualProperties ?? [];
+	const declared = new Set(declaredNames);
+	const withInitialValue = [...registered].filter(([, registration]) => registration.initialValue !== void 0).map(([name]) => name);
+	const writers = currentVarWriters(input.system.propConfigJson);
+	const currentVars = new Set(writers.keys());
 	const findings = [];
 	const sheets = [{
 		css: input.componentCss,
@@ -2837,9 +3219,20 @@ function checkCustomProperties(input) {
 		owner: globalOwner
 	}];
 	for (const { css, owner } of sheets) {
-		if (!/var\(|transition|@keyframes/i.test(css)) continue;
+		if (!mayHoldFinding(css, withInitialValue, declaredNames, currentVars)) continue;
 		const parsed = declarations(css);
-		const discreteRules = new Set(parsed.filter((d) => d.property === "transition-behavior" && /\ballow-discrete\b/.test(d.value)).map((d) => d.rule));
+		for (const cycle of currentVarCycles(parsed, currentVars)) {
+			const [first] = cycle;
+			const names = cycle.map((d) => d.property);
+			const props = [...new Set(cycle.flatMap((d) => writers.get(d.property) ?? []))];
+			findings.push({
+				code: PROPERTY_CURRENT_VAR_CYCLE,
+				property: first.property,
+				message: `${cycle.map((d) => `${d.property}: ${d.value}`).join("; ")} are written by the currentVar of ${props.join(", ")} in one rule and read each other, a cycle, so ${names.join(", ")} are invalid at computed-value time wherever this rule applies. Give one of the props a value that does not read another's current variable`,
+				owner: owner(first)
+			});
+		}
+		const discreteRules = new Set(parsed.filter((d) => d.property === "transition-behavior" && topLevelItems(d.values).some(isDiscrete)).map((d) => d.rule));
 		for (const declaration of parsed) {
 			const found = (code, property, message) => findings.push({
 				code,
@@ -2847,16 +3240,26 @@ function checkCustomProperties(input) {
 				message,
 				owner: owner(declaration)
 			});
-			if (isSelfReference(declaration)) {
+			const reads = (0, _animus_ui_properties.variableReads)(declaration.values);
+			if (isSelfReference(declaration, reads)) {
 				found(PROPERTY_SELF_REFERENCE, declaration.property, `${declaration.property} resolves to var(${declaration.property}), a reference to itself, so it is invalid at computed-value time. Give it a value other than its own name`);
 				continue;
 			}
-			if (readsItselfOnlyInFallback(declaration)) found(PROPERTY_FALLBACK_SELF_REFERENCE, declaration.property, `${declaration.property}: ${declaration.value} reads ${declaration.property} only inside another var()'s fallback, so the result depends on how the browser treats fallback references: one that evaluates a fallback only when it is used keeps the value, one that counts every reference makes ${declaration.property} cyclic and invalid at computed-value time`);
-			for (const read of varReads(declaration.value)) {
+			if (readsItselfDirectly(declaration, reads)) {
+				const { property, value } = declaration;
+				found(PROPERTY_SELF_REFERENCE, property, `${property}: ${value} reads ${property} directly, a reference to itself, so it is invalid at computed-value time; a fallback inside that var() does not break the cycle. Give it a value that does not read its own name`);
+				continue;
+			}
+			if (readsItselfOnlyInFallback(declaration, reads)) {
+				const { property, value } = declaration;
+				found(PROPERTY_FALLBACK_SELF_REFERENCE, property, `${property}: ${value} reads ${property} inside another var()'s fallback. Wherever that fallback is used, ${property} refers to itself, a cycle in every browser, so ${property} is invalid at computed-value time, or takes its registered initial value, and so is every property that reads it; where it is not used, browsers differ on whether the cycle still counts. Without this declaration, descendants read the inherited ${property} instead, also where the outer variable is set, which is what a prop with currentVar does for such a value`);
+			}
+			for (const read of reads) {
 				const registration = registered.get(read.name);
 				if (read.fallback === void 0 || registration?.initialValue === void 0) continue;
-				const chain = read.fallback.startsWith("var(");
-				found(chain ? PROPERTY_FALLBACK_CHAIN_SUPPRESSED : PROPERTY_FALLBACK_SUPPRESSED, read.name, `var(${read.name}, ${read.fallback}): where its registration applies, ${read.name}'s initial-value ${registration.initialValue} is used ahead of the ${chain ? "fallback chain" : "fallback"} whenever ${read.name} is unset; the fallback still serves browsers without the registration`);
+				const { fallback } = read;
+				const chain = reads.some((other) => other.start === fallback.first);
+				found(chain ? PROPERTY_FALLBACK_CHAIN_SUPPRESSED : PROPERTY_FALLBACK_SUPPRESSED, read.name, `var(${read.name}, ${css.slice(fallback.start, fallback.end).trim()}): where its registration applies, ${read.name}'s initial-value ${registration.initialValue} is used ahead of the ${chain ? "fallback chain" : "fallback"} whenever ${read.name} is unset; the fallback still serves browsers without the registration`);
 			}
 			for (const animated of animatedProperties(declaration, discreteRules)) {
 				if (animated.discrete || !declared.has(animated.name)) continue;
@@ -2868,195 +3271,244 @@ function checkCustomProperties(input) {
 	}
 	return toDiagnostics(findings);
 }
-/** Declarations in engine-emitted CSS: one `property: value` per `;`. */
+/**
+* Whether a sheet can hold a finding, shown by its text before anything is
+* parsed: a custom property reading its own name, a `var(` with a fallback
+* of a registration that has an initial value, a transition or keyframes
+* and a declared contextual variable's name, or a `var(` of a currentVar name
+* when two or more props write one. An escape or a comment can hide
+* a name or a function from the text, so a sheet with either is always
+* parsed.
+*/
+function mayHoldFinding(css, withInitialValue, declared, currentVars) {
+	return css.includes("\\") || css.includes("/*") || readsOwnName(css) || withInitialValue.some((name) => new RegExp(String.raw`var\(\s*${escapeRegExp(name)}\s*,`, "i").test(css)) || declared.some((name) => css.includes(name)) && /transition|@keyframes/i.test(css) || currentVars.size > 1 && [...currentVars].some((name) => new RegExp(String.raw`var\(\s*${escapeRegExp(name)}`, "i").test(css));
+}
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** A custom-property declaration key, as the text shows one: anything but
+*  CSS whitespace and the characters that end a name, so a non-ASCII space
+*  stays part of the name, as CSS reads it. */
+const CUSTOM_PROPERTY_KEY = /(--[^\t\n\f\r :;{}()"'\\/]+)[\t\n\f\r ]*:/g;
+const VAR_OPEN = /var\(\s*/iy;
+const isNameCode = (c) => c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 45 || c === 95 || c >= 128;
+/**
+* Whether a custom-property declaration has `var(` of its own whole name in
+* its value, bounded as the declaration scanner bounds one: by a `;`, `{` or
+* `}` outside parentheses, brackets and quoted text. `var` matches in any
+* case, so this errs toward parsing.
+*/
+function readsOwnName(css) {
+	for (const match of css.matchAll(CUSTOM_PROPERTY_KEY)) {
+		const name = match[1];
+		let depth = 0;
+		let quote = -1;
+		for (let i = match.index + match[0].length; i < css.length; i += 1) {
+			const c = css.charCodeAt(i);
+			if (quote !== -1) {
+				if (c === quote || c === 10 || c === 13 || c === 12) quote = -1;
+			} else if (c === 34 || c === 39) quote = c;
+			else if (c === 40 || c === 91) depth += 1;
+			else if (c === 41 || c === 93) depth = Math.max(0, depth - 1);
+			else if (depth === 0 && (c === 59 || c === 123 || c === 125)) break;
+			else if (c === 118 || c === 86) {
+				VAR_OPEN.lastIndex = i;
+				const at = VAR_OPEN.test(css) ? VAR_OPEN.lastIndex : -1;
+				if (at !== -1 && css.startsWith(name, at) && !isNameCode(css.charCodeAt(at + name.length))) return true;
+			}
+		}
+	}
+	return false;
+}
+/** `items` as text without comments, at-keywords decoded. */
+function textOf(css, items) {
+	let text = "";
+	const add = (token) => {
+		if (token.type === "whitespace") text += " ";
+		else if (token.type === "at-keyword") text += `@${token.value.toLowerCase()}`;
+		else text += css.slice(token.start, token.end);
+	};
+	const walk = (list) => {
+		for (const item of list) if (item.kind === "token") add(item.token);
+		else {
+			add(item.open);
+			walk(item.children);
+			if (item.close) add(item.close);
+		}
+	};
+	walk(items);
+	return text.trim();
+}
+/** Declarations in a sheet: one `property: value` per `;` inside a `{}`
+*  block, read from component values, so comments separate nothing. */
 function declarations(css) {
 	const found = [];
-	const stack = [];
 	let rules = 0;
-	let segment = 0;
-	let parens = 0;
-	let quote = null;
-	const take = (end) => {
-		const text = css.slice(segment, end);
-		const colon = text.indexOf(":");
-		const current = stack[stack.length - 1];
-		if (current === void 0 || colon <= 0) return;
-		found.push({
-			property: text.slice(0, colon).trim(),
-			value: text.slice(colon + 1).replace(/;$/, "").trim(),
-			start: segment + (text.length - text.trimStart().length),
-			end,
-			rule: current.rule,
-			context: stack.map((entry) => entry.prelude)
-		});
-	};
-	for (let i = 0; i < css.length; i += 1) {
-		const c = css[i];
-		if (quote !== null) {
-			if (c === "\\") i += 1;
-			else if (c === quote) quote = null;
-			continue;
-		}
-		if (c === "\"" || c === "'") quote = c;
-		else if (c === "(") parens += 1;
-		else if (c === ")") parens -= 1;
-		else if (parens === 0 && c === "{") {
-			stack.push({
-				prelude: css.slice(segment, i).trim(),
-				rule: rules
+	const visit = (items, context, rule) => {
+		let segment = [];
+		const take = () => {
+			const declaration = declarationOf(css, segment);
+			if (rule !== void 0 && declaration !== void 0) found.push({
+				...declaration,
+				rule,
+				context
 			});
+			segment = [];
+		};
+		for (const item of items) if (item.kind === "block" && item.open.type === "{") {
+			const prelude = textOf(css, segment);
+			segment = [];
 			rules += 1;
-			segment = i + 1;
-		} else if (parens === 0 && c === ";") {
-			take(i + 1);
-			segment = i + 1;
-		} else if (parens === 0 && c === "}") {
-			take(i);
-			stack.pop();
-			segment = i + 1;
-		}
-	}
+			visit(item.children, [...context, prelude], rules - 1);
+		} else if (item.kind === "token" && item.token.type === ";") take();
+		else segment.push(item);
+		take();
+	};
+	visit((0, _animus_ui_properties.componentValues)((0, _animus_ui_properties.tokenize)(css)), [], void 0);
 	return found;
 }
-/** `text` as a whole custom-property name, escapes decoded; `undefined`
-*  when it is not one. */
-function customPropertyName(text) {
-	if (!text.startsWith("--")) return void 0;
-	const { end, name } = readCustomPropertyName(text, 2);
-	return end === text.length ? `--${name}` : void 0;
+/** The declaration a `;`-separated segment holds, if any. A bad string or
+*  url makes a declaration invalid, so browsers drop it, and so does this. */
+function declarationOf(css, segment) {
+	const colon = segment.findIndex((item) => item.kind === "token" && item.token.type === ":");
+	const named = segment.slice(0, Math.max(colon, 0)).filter((i) => !(0, _animus_ui_properties.isSpace)(i));
+	const values = trimSpace(segment.slice(colon + 1));
+	if (colon === -1 || named.length === 0 || (0, _animus_ui_properties.someValue)(values, (v) => v.kind === "token" && (v.token.type === "bad-url" || v.token.type === "bad-string"))) return;
+	const [only] = named;
+	const ident = named.length === 1 && only.kind === "token" && only.token.type === "ident" ? only.token.value : void 0;
+	const custom = ident?.startsWith("--") === true;
+	return {
+		property: custom && ident !== void 0 ? ident : (ident ?? textOf(css, named)).toLowerCase(),
+		custom,
+		value: values.length > 0 ? css.slice(values[0].start, values[values.length - 1].end) : "",
+		values
+	};
 }
-function isSelfReference(declaration) {
-	const property = customPropertyName(declaration.property);
-	const reads = varReads(declaration.value);
-	return property !== void 0 && reads.length === 1 && reads[0].name === property && reads[0].fallback === void 0 && withoutComments(declaration.value).trim() === withoutComments(declaration.value.slice(reads[0].start, reads[0].end)).trim();
+function trimSpace(items) {
+	let start = 0;
+	let end = items.length;
+	while (start < end && (0, _animus_ui_properties.isSpace)(items[start])) start += 1;
+	while (end > start && (0, _animus_ui_properties.isSpace)(items[end - 1])) end -= 1;
+	return items.slice(start, end);
+}
+/** Whether the value is exactly `var()` of the declared property. */
+function isSelfReference(declaration, reads) {
+	return declaration.custom && reads.length === 1 && reads[0].name === declaration.property && reads[0].fallback === void 0 && declaration.values.length === 1 && declaration.values[0].start === reads[0].start;
+}
+/** Whether a read of the declared property sits outside every other read's
+*  fallback, as in `--a: var(--a, red)` or `--a: calc(var(--a) + 1px)`: cyclic
+*  whatever the fallback, as the bare `var(--a)` is. */
+function readsItselfDirectly(declaration, reads) {
+	return declaration.custom && reads.some((read) => read.name === declaration.property && isDirectRead(read, reads));
+}
+/** Whether `read` sits outside every other read's fallback, so it is taken
+*  whenever the declaration is. */
+function isDirectRead(read, reads) {
+	return !reads.some((outer) => outer !== read && outer.fallback !== void 0 && outer.fallback.start <= read.start && read.end <= outer.fallback.end);
+}
+/** Each custom property a `currentVar` writes, with the props writing it. */
+function currentVarWriters(propConfigJson) {
+	const writers = /* @__PURE__ */ new Map();
+	if (propConfigJson === void 0) return writers;
+	const config = JSON.parse(propConfigJson);
+	for (const [prop, entry] of Object.entries(config)) {
+		if (!entry.currentVar) continue;
+		writers.set(entry.currentVar, [...writers.get(entry.currentVar) ?? [], prop]);
+	}
+	return writers;
 }
-/** Whether every read of the declared property sits inside another read's
-*  fallback, as in `--a: var(--b, var(--a))`. */
-function readsItselfOnlyInFallback(declaration) {
-	const property = customPropertyName(declaration.property);
-	if (property === void 0) return false;
-	const reads = varReads(declaration.value);
-	const own = reads.filter((read) => read.name === property);
-	return own.length > 0 && own.every((read) => reads.some((outer) => outer !== read && outer.start < read.start && read.end <= outer.end));
-}
-/** Every `var()` read in `value`, nested fallbacks included, in any case
-*  and spacing. Quoted text and comments hold none. */
-function varReads(value) {
-	const reads = [];
-	for (let at = 0; at < value.length;) {
-		const c = value[at];
-		if (c === "\"" || c === "'") {
-			at = closingQuote(value, at);
-			continue;
-		}
-		if (value.startsWith("/*", at)) {
-			at = skipSpace(value, at);
-			continue;
-		}
-		if (value.slice(at, at + 4).toLowerCase() !== "var(" || /[\w-]/.test(value[at - 1] ?? "")) {
-			at += 1;
-			continue;
-		}
-		const nameAt = skipSpace(value, at + 4);
-		if (!value.startsWith("--", nameAt)) {
-			at += 4;
-			continue;
+/**
+* Cycles among the `currentVar` writes of one rule, read directly. One rule
+* is one element under one set of conditions, so its writes are always
+* active together; writes in different rules, or a read only inside another
+* read's fallback, are left alone. Each cycle is listed once, in declaration
+* order.
+*/
+function currentVarCycles(parsed, currentVars) {
+	if (currentVars.size === 0) return [];
+	const byRule = /* @__PURE__ */ new Map();
+	for (const declaration of parsed) {
+		if (!declaration.custom || !currentVars.has(declaration.property)) continue;
+		const writes = byRule.get(declaration.rule) ?? /* @__PURE__ */ new Map();
+		writes.set(declaration.property, declaration);
+		byRule.set(declaration.rule, writes);
+	}
+	const cycles = [];
+	for (const writes of byRule.values()) {
+		const edges = /* @__PURE__ */ new Map();
+		for (const [name, declaration] of writes) {
+			const reads = (0, _animus_ui_properties.variableReads)(declaration.values);
+			edges.set(name, reads.filter((read) => read.name !== name && writes.has(read.name) && isDirectRead(read, reads)).map((read) => read.name));
 		}
-		const { end: nameEnd, name } = readCustomPropertyName(value, nameAt + 2);
-		const after = skipSpace(value, nameEnd);
-		const close = closingParen(value, at + 4);
-		reads.push({
-			name: `--${name}`,
-			fallback: value[after] === "," ? value.slice(after + 1, close - 1).trim() : void 0,
-			start: at,
-			end: close
-		});
-		at = after;
-	}
-	return reads;
-}
-/** The index after the `)` that closes the call whose arguments start at
-*  `from`. Quoted text and comments are skipped. */
-function closingParen(value, from) {
-	let depth = 1;
-	let at = from;
-	while (at < value.length && depth > 0) {
-		const c = value[at];
-		if (c === "\"" || c === "'") at = closingQuote(value, at);
-		else if (value.startsWith("/*", at)) at = skipSpace(value, at);
-		else {
-			if (c === "(") depth += 1;
-			else if (c === ")") depth -= 1;
-			at += 1;
+		for (const component of stronglyConnected(edges)) {
+			if (component.length < 2) continue;
+			cycles.push([...writes.values()].filter((d) => component.includes(d.property)));
 		}
 	}
-	return at;
+	return cycles;
 }
-function closingQuote(value, open) {
-	let at = open + 1;
-	while (at < value.length && value[at] !== value[open]) at += value[at] === "\\" ? 2 : 1;
-	return Math.min(at + 1, value.length);
-}
-/** The index after CSS whitespace and comments starting at `from`. */
-function skipSpace(value, from) {
-	let at = from;
-	for (;;) {
-		while (/[ \t\n\r\f]/.test(value[at] ?? "")) at += 1;
-		if (!value.startsWith("/*", at)) return at;
-		const close = value.indexOf("*/", at + 2);
-		at = close === -1 ? value.length : close + 2;
-	}
+/** Tarjan's strongly connected components of a small graph. */
+function stronglyConnected(edges) {
+	const index = /* @__PURE__ */ new Map();
+	const low = /* @__PURE__ */ new Map();
+	const stack = [];
+	const onStack = /* @__PURE__ */ new Set();
+	const components = [];
+	const visit = (node) => {
+		index.set(node, index.size);
+		low.set(node, index.get(node));
+		stack.push(node);
+		onStack.add(node);
+		for (const next of edges.get(node) ?? []) if (!index.has(next)) {
+			visit(next);
+			low.set(node, Math.min(low.get(node), low.get(next)));
+		} else if (onStack.has(next)) low.set(node, Math.min(low.get(node), index.get(next)));
+		if (low.get(node) === index.get(node)) {
+			const component = [];
+			let member;
+			do {
+				member = stack.pop();
+				onStack.delete(member);
+				component.push(member);
+			} while (member !== node);
+			components.push(component);
+		}
+	};
+	for (const node of edges.keys()) if (!index.has(node)) visit(node);
+	return components;
 }
-function withoutComments(text) {
-	return text.replace(/\/\*[\s\S]*?\*\//g, "");
+/** Whether every read of the declared property sits inside another read's
+*  fallback, as in `--a: var(--b, var(--a))`. */
+function readsItselfOnlyInFallback(declaration, reads) {
+	if (!declaration.custom) return false;
+	const own = reads.filter((read) => read.name === declaration.property);
+	return own.length > 0 && own.every((read) => reads.some((outer) => outer.fallback !== void 0 && outer.fallback.start <= read.start && read.end <= outer.fallback.end));
 }
 /** Custom properties this declaration sets in a keyframe or names in a
 *  transition. */
 function animatedProperties(declaration, discreteRules) {
 	const keyframes = declaration.context.find((prelude) => prelude.startsWith("@keyframes"));
-	const set = customPropertyName(declaration.property);
-	if (keyframes !== void 0 && set !== void 0) return [{
-		name: set,
+	if (keyframes !== void 0 && declaration.custom) return [{
+		name: declaration.property,
 		how: `set in ${keyframes}`,
 		discrete: false
 	}];
 	if (declaration.property !== "transition" && declaration.property !== "transition-property") return [];
-	return topLevelItems(declaration.value).flatMap((item) => {
-		const property = topLevelTokens(item.replace(/\/\*[\s\S]*?\*\//g, " ")).map(customPropertyName).find((name) => name !== void 0);
-		return property !== void 0 ? [{
-			name: property,
+	return topLevelItems(declaration.values).flatMap((item) => {
+		const named = item.find((value) => value.kind === "token" && value.token.type === "ident" && value.token.value.startsWith("--"));
+		return named?.kind === "token" ? [{
+			name: named.token.value,
 			how: "transitioned",
-			discrete: /\ballow-discrete\b/.test(item) || discreteRules.has(declaration.rule)
+			discrete: isDiscrete(item) || discreteRules.has(declaration.rule)
 		}] : [];
 	});
 }
-/** The whitespace-separated tokens of `item` outside any parentheses. */
-function topLevelTokens(item) {
-	const tokens = [];
-	let depth = 0;
-	let token = "";
-	for (const c of item) {
-		if (c === "(") depth += 1;
-		else if (c === ")") depth -= 1;
-		if (depth === 0 && /\s/.test(c)) {
-			if (token) tokens.push(token);
-			token = "";
-		} else token += c;
-	}
-	if (token) tokens.push(token);
-	return tokens;
-}
-function topLevelItems(value) {
-	const items = [];
-	let depth = 0;
-	let start = 0;
-	for (let i = 0; i < value.length; i += 1) if (value[i] === "(") depth += 1;
-	else if (value[i] === ")") depth -= 1;
-	else if (value[i] === "," && depth === 0) {
-		items.push(value.slice(start, i));
-		start = i + 1;
-	}
-	items.push(value.slice(start));
+function isDiscrete(item) {
+	return item.some((value) => value.kind === "token" && value.token.type === "ident" && value.token.value.toLowerCase() === "allow-discrete");
+}
+/** The comma-separated items of a value, each its top-level values. */
+function topLevelItems(values) {
+	const items = [[]];
+	for (const value of values) if (value.kind === "token" && value.token.type === ",") items.push([]);
+	else items[items.length - 1].push(value);
 	return items;
 }
 /** Why a property cannot interpolate, or `null` when it can. */
@@ -3304,6 +3756,47 @@ function serializeStaticCss(config) {
 	return json === "{}" ? null : json;
 }
 //#endregion
+//#region pipeline/property-names.ts
+function createPropertyNames(declared, prefix, themeNames = []) {
+	const finals = /* @__PURE__ */ new Map();
+	for (const name of [...new Set(declared)].sort()) finals.set(name, `${prefix}-${name}`);
+	const aliases = /* @__PURE__ */ new Map();
+	for (const [name, final] of finals) if (!finals.has(final)) aliases.set(final, name);
+	const others = /* @__PURE__ */ new Map();
+	for (const name of [...new Set(themeNames)].sort()) if (!finals.has(name)) others.set(name, `${prefix}-${name}`);
+	return {
+		identity: (spelling) => finals.has(spelling) ? spelling : aliases.get(spelling) ?? (others.has(spelling) ? spelling : void 0),
+		finalName: (name) => finals.get(name) ?? others.get(name),
+		ambiguous: () => [...others.keys()].filter((name) => aliases.has(name)).map((name) => ({
+			name,
+			contextual: aliases.get(name) ?? name
+		}))
+	};
+}
+/**
+* Gives every custom-property token that names a managed property its final
+* name, in one pass: declaration keys, `var()` reads at any depth (fallbacks
+* included), `@property` names, transition-property lists and style queries.
+* Names are read through the shared CSS tokenizer, whole and with escapes
+* decoded, escaped leading dashes included, so an undeclared identifier that
+* contains or starts with a managed name is never renamed in part. Quoted
+* strings, `url()` and comments are copied unchanged.
+*/
+function renameCustomProperties(css, names) {
+	let out = "";
+	let copied = 0;
+	for (const token of (0, _animus_ui_properties.tokenize)(css)) {
+		if (token.type !== "ident" || !token.value.startsWith("--")) continue;
+		const spelling = token.value.slice(2);
+		const identity = names.identity(spelling);
+		const final = identity === void 0 ? void 0 : names.finalName(identity);
+		if (final === void 0 || final === spelling) continue;
+		out += `${css.slice(copied, token.start)}--${final}`;
+		copied = token.end;
+	}
+	return out + css.slice(copied);
+}
+//#endregion
 //#region pipeline/prefix.ts
 /** Prefix variable references without changing their matching rules. */
 function prefixVariableReferences(prefix, value) {
@@ -3469,7 +3962,7 @@ function runStructuralSelfCheck(input) {
 	else if (input.assembledCss !== void 0 ? !/@layer\s+anm-base\s*\{/.test(input.assembledCss) : input.componentCss.trim().length === 0) failures.push(`${input.componentCount} component(s) discovered but the emitted component CSS is empty`);
 	for (const { specifier, outcome } of input.externalOutcomes ?? []) if (outcome === "empty") failures.push(`include '${specifier}' resolved but discovered no component sources`);
 	else if (outcome === "unresolvable") failures.push(`include '${specifier}' could not be resolved`);
-	if (!input.variableCss.includes(":root")) failures.push("No :root variable block found in variable CSS");
+	if ((input.variableMapJson == null || Object.keys(parseInternalWire(input.variableMapJson, "variableMapJson (the theme's token → variable map)")).length > 0) && !input.variableCss.includes(":root")) failures.push("No :root variable block found in variable CSS");
 	if ((input.assembledCss ?? `${input.variableCss}\n${input.globalCss}\n${input.componentCss}`).includes("__TRANSFORM__")) failures.push("Unresolved __TRANSFORM__ placeholders found in CSS output");
 	if (input.componentCount > 0 && (input.componentCss.length > 0 || input.assembledCss !== void 0)) {
 		const assembled = input.assembledCss ?? assembleStylesheet({
@@ -3478,9 +3971,16 @@ function runStructuralSelfCheck(input) {
 			globalCss: input.globalCss,
 			componentCss: input.componentCss
 		});
-		const baseIdx = assembled.search(/@layer\s+anm-base\s*\{/);
-		const variantsIdx = assembled.search(/@layer\s+anm-variants\s*\{/);
-		if (baseIdx !== -1 && variantsIdx !== -1 && baseIdx >= variantsIdx) failures.push(`CSS layer ordering violated — @layer anm-base (offset ${baseIdx}) must precede @layer anm-variants (offset ${variantsIdx})`);
+		const blocks = ANIMUS_LAYERS.map((layer) => ({
+			layer,
+			offset: assembled.search(new RegExp(`@layer\\s+${layer}\\s*\\{`))
+		})).filter(({ offset }) => offset !== -1);
+		const misplaced = blocks.findIndex(({ offset }, index) => index > 0 && offset <= blocks[index - 1].offset);
+		if (misplaced !== -1) {
+			const earlier = blocks[misplaced - 1];
+			const later = blocks[misplaced];
+			failures.push(`CSS layer ordering violated — @layer ${earlier.layer} (offset ${earlier.offset}) must precede @layer ${later.layer} (offset ${later.offset})`);
+		}
 	}
 	return failures;
 }
@@ -3543,188 +4043,6 @@ function buildSystemPropsModule(opts) {
 	return `export const systemPropMap = ${opts.systemPropMapJson};\nexport const systemPropGroups = ${opts.groupRegistryJson};\nexport const dynamicPropConfig = ${JSON.stringify(dynamicPropConfig)};\nexport const transforms = ${transformsSource(opts.admittedTransforms)};\n` + (opts.typedSystemProps.length > 0 ? `export const typedSystemProps = ${JSON.stringify(opts.typedSystemProps)};\n` : "");
 }
 //#endregion
-//#region pipeline/tsconfig-paths.ts
-/**
-* tsconfig `paths` → alias pairs, for drivers with no live bundler config.
-* The nearest config declaring `paths` wins wholesale — TS never merges.
-*/
-function stripJsonc(text) {
-	let out = "";
-	let inString = false;
-	let inLine = false;
-	let inBlock = false;
-	for (let i = 0; i < text.length; i++) {
-		const ch = text[i];
-		const next = text[i + 1];
-		if (inLine) {
-			if (ch === "\n") {
-				inLine = false;
-				out += ch;
-			}
-			continue;
-		}
-		if (inBlock) {
-			if (ch === "*" && next === "/") {
-				inBlock = false;
-				i++;
-			}
-			continue;
-		}
-		if (inString) {
-			out += ch;
-			if (ch === "\\") {
-				out += next ?? "";
-				i++;
-			} else if (ch === "\"") inString = false;
-			continue;
-		}
-		if (ch === "\"") {
-			inString = true;
-			out += ch;
-			continue;
-		}
-		if (ch === "/" && next === "/") {
-			inLine = true;
-			i++;
-			continue;
-		}
-		if (ch === "/" && next === "*") {
-			inBlock = true;
-			i++;
-			continue;
-		}
-		out += ch;
-	}
-	return out.replace(/,(\s*[}\]])/g, "$1");
-}
-/** `Object(value) === value` holds for exactly the blocks and lists
-*  `JSON.parse` produces; the `[object Object]` tag separates the two. */
-function isJsonBlock(value) {
-	return Object(value) === value && Object.prototype.toString.call(value) === "[object Object]";
-}
-/** A block or a list. A declared `paths` OWNS the setting and blocks its
-*  parents' even when it contributes nothing usable. */
-function isJsonKeyed(value) {
-	return Object(value) === value;
-}
-/** A JSON string, excluding the boxed `String` object, which no path join
-*  accepts. */
-function isJsonString(value) {
-	return Object(value) !== value && Object.prototype.toString.call(value) === "[object String]";
-}
-function decodePaths(value) {
-	if (!isJsonKeyed(value)) return null;
-	const decoded = /* @__PURE__ */ new Map();
-	for (const [pattern, targets] of Object.entries(value)) {
-		const [first] = Array.isArray(targets) ? targets : [];
-		if (isJsonString(first)) decoded.set(pattern, first);
-	}
-	return decoded;
-}
-/** TypeScript accepts one specifier or an array; a non-string member names
-*  no config and is dropped here. */
-function decodeExtends(value) {
-	return (Array.isArray(value) ? value : [value]).filter(isJsonString);
-}
-function readConfig(path$2) {
-	let raw;
-	try {
-		raw = (0, fs.readFileSync)(path$2, "utf-8");
-	} catch {
-		return null;
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(stripJsonc(raw));
-	} catch {
-		return null;
-	}
-	const root = isJsonBlock(parsed) ? parsed : {};
-	const compilerOptions = isJsonBlock(root.compilerOptions) ? root.compilerOptions : {};
-	return {
-		dir: (0, path.dirname)(path$2),
-		baseUrl: isJsonString(compilerOptions.baseUrl) ? compilerOptions.baseUrl : null,
-		paths: decodePaths(compilerOptions.paths),
-		extends: decodeExtends(root.extends)
-	};
-}
-function resolveExtendsTarget(specifier, fromDir) {
-	if (specifier.startsWith(".") || (0, path.isAbsolute)(specifier)) {
-		const base = (0, path.resolve)(fromDir, specifier);
-		for (const candidate of [
-			base,
-			`${base}.json`,
-			(0, path.join)(base, "tsconfig.json")
-		]) if ((0, fs.existsSync)(candidate)) return candidate;
-		return null;
-	}
-	try {
-		return require.resolve(specifier.endsWith(".json") ? specifier : `${specifier}/tsconfig.json`, { paths: [fromDir] });
-	} catch {
-		try {
-			return require.resolve(specifier, { paths: [fromDir] });
-		} catch {
-			return null;
-		}
-	}
-}
-/** Child-first flattened extends chain starting at `entryPath`. */
-function loadChain(entryPath) {
-	const chain = [];
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [entryPath];
-	while (queue.length > 0) {
-		const path$3 = queue.shift();
-		const key = (0, path.resolve)(path$3);
-		if (visited.has(key)) continue;
-		visited.add(key);
-		const node = readConfig(key);
-		if (!node) continue;
-		chain.push(node);
-		for (const parent of node.extends) {
-			const resolved = resolveExtendsTarget(parent, node.dir);
-			if (resolved) queue.push(resolved);
-		}
-	}
-	return chain;
-}
-/**
-* The project's tsconfig path aliases as `buildPathAliasesJson` pairs; empty
-* when no readable tsconfig, or no usable `paths`, exists.
-*/
-function readTsconfigAliasPairs(rootDir) {
-	const chain = loadChain((0, path.join)(rootDir, "tsconfig.json"));
-	if (chain.length === 0) return [];
-	const pathsOwner = chain.find((node) => node.paths !== null);
-	const paths = pathsOwner?.paths ?? null;
-	if (pathsOwner === void 0 || paths === null) return [];
-	const baseOwner = chain.find((node) => node.baseUrl !== null);
-	const baseUrl = baseOwner?.baseUrl ?? null;
-	const base = baseOwner !== void 0 && baseUrl !== null ? (0, path.resolve)(baseOwner.dir, baseUrl) : pathsOwner.dir;
-	const pairs = [];
-	for (const [pattern, target] of paths) {
-		const patternStars = pattern.split("*").length - 1;
-		const targetStars = target.split("*").length - 1;
-		if (pattern === "*" || patternStars > 1 || targetStars > 1) continue;
-		if (pattern.endsWith("/*")) {
-			if (!target.endsWith("/*")) continue;
-			pairs.push({
-				pattern: pattern.slice(0, -2),
-				target: (0, path.resolve)(base, target.slice(0, -2)),
-				kind: "prefix"
-			});
-			continue;
-		}
-		if (patternStars > 0 || targetStars > 0) continue;
-		pairs.push({
-			pattern,
-			target: (0, path.resolve)(base, target),
-			kind: "exact"
-		});
-	}
-	return pairs;
-}
-//#endregion
 //#region pipeline/error-diagnostics.ts
 function assertNoErrorDiagnostics(diagnostics) {
 	const errors = (diagnostics ?? []).filter((diagnostic) => diagnostic.kind === "error");
@@ -4031,6 +4349,12 @@ Object.defineProperty(exports, "enforceExternalTokenContracts", {
 		return enforceExternalTokenContracts;
 	}
 });
+Object.defineProperty(exports, "engineImportParser", {
+	enumerable: true,
+	get: function() {
+		return engineImportParser;
+	}
+});
 Object.defineProperty(exports, "excludeCollectedPackages", {
 	enumerable: true,
 	get: function() {
@@ -4109,6 +4433,18 @@ Object.defineProperty(exports, "isExcludedPackageRelativePath", {
 		return isExcludedPackageRelativePath;
 	}
 });
+Object.defineProperty(exports, "isJsonBlock", {
+	enumerable: true,
+	get: function() {
+		return isJsonBlock;
+	}
+});
+Object.defineProperty(exports, "isJsonString", {
+	enumerable: true,
+	get: function() {
+		return isJsonString;
+	}
+});
 Object.defineProperty(exports, "isPathWithinRoot", {
 	enumerable: true,
 	get: function() {
@@ -4127,12 +4463,24 @@ Object.defineProperty(exports, "loadSystemConfig", {
 		return loadSystemConfig;
 	}
 });
+Object.defineProperty(exports, "noKitFilesDiagnostics", {
+	enumerable: true,
+	get: function() {
+		return noKitFilesDiagnostics;
+	}
+});
 Object.defineProperty(exports, "parseFilesJson", {
 	enumerable: true,
 	get: function() {
 		return parseFilesJson;
 	}
 });
+Object.defineProperty(exports, "parseInternalWire", {
+	enumerable: true,
+	get: function() {
+		return parseInternalWire;
+	}
+});
 Object.defineProperty(exports, "postProcessCss", {
 	enumerable: true,
 	get: function() {