@animus-ui/extract 0.1.19 → 0.1.21

package/dist/{pipeline-CD2qmEEn.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",
@@ -105,7 +110,8 @@ function buildAnalyzeProjectArgs(inputs) {
 		inputs.transformSourcesJson,
 		inputs.transformProvenanceJson ?? null
 	];
-	if (inputs.declarationScalesJson) args.push(inputs.declarationScalesJson);
+	if (inputs.declarationScalesJson || inputs.analysisContextJson) args.push(inputs.declarationScalesJson);
+	if (inputs.analysisContextJson) args.push(inputs.analysisContextJson);
 	return args;
 }
 //#endregion
@@ -125,6 +131,282 @@ function parseInternalWire(json, wire) {
 	return parsed;
 }
 //#endregion
+//#region pipeline/manifest-diagnostics.ts
+/** Stable code for selector forms with no substitutable subject; the
+*  extraction engine mints the same string. */
+const SELECTOR_UNSUPPORTED_SUBJECT = "animus.selector.unsupported-subject";
+/** The one matcher for the engine's unresolved-parent chain-drop message;
+*  consumers match through the exported helpers, never their own copy. */
+const UNRESOLVED_PARENT_RE = /chain dropped: could not resolve parent component '([^']+)'/;
+function isUnresolvedParentDrop(diagnostic) {
+	return UNRESOLVED_PARENT_RE.test(diagnostic.message);
+}
+function unresolvedParentName(diagnostic) {
+	return UNRESOLVED_PARENT_RE.exec(diagnostic.message)?.[1] ?? null;
+}
+/** True when the selector carries at least one substitutable `&` subject
+*  outside quoted text. */
+function hasSelectorSubject(value) {
+	let quote = null;
+	let escaped = false;
+	for (const c of value) {
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (c === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote !== null) {
+			if (c === quote) quote = null;
+		} else if (c === "\"" || c === "'") quote = c;
+		else if (c === "&") return true;
+	}
+	return false;
+}
+/**
+* Coded diagnostics for selector-shaped alias values with no substitutable
+* subject; alias values never reach the evaluator's own key guard.
+*/
+function collectSelectorAliasDiagnostics(selectorAliasesJson) {
+	if (!selectorAliasesJson) return [];
+	const aliases = parseInternalWire(selectorAliasesJson, "selectorAliasesJson (the system loader's selector-alias registry)");
+	const diagnostics = [];
+	for (const [name, value] of Object.entries(aliases)) if (value.includes("&") && !hasSelectorSubject(value)) diagnostics.push({
+		file: "system",
+		component: name,
+		kind: "warn",
+		message: `selector alias '${name}' value '${value}' has no substitutable '&' subject outside quoted text (${SELECTOR_UNSUPPORTED_SUBJECT})`,
+		code: SELECTOR_UNSUPPORTED_SUBJECT,
+		severity: severityFor(SELECTOR_UNSUPPORTED_SUBJECT)
+	});
+	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";
+/**
+* A configured source file that could not be read is a LOST INPUT: the
+* emitted artifacts silently lack whatever that file declared.
+*/
+/** Whether a failed source read means the file was deleted after discovery
+*  (an editor's delete-and-recreate, a branch switch): a deletion, not lost
+*  input. */
+function isDeletedSource(error) {
+	return error?.code === "ENOENT";
+}
+function unreadableSourceDiagnostic(relPath, error) {
+	return {
+		file: relPath,
+		component: "source",
+		kind: "warn",
+		message: `configured source file ${relPath} could not be read: ${String(error)} (${SKIPPED_SOURCE_COST})`,
+		code: UNREADABLE_SOURCE_FILE,
+		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. */
+const INVALID_PROPERTY_REGISTRATION = "animus.theme.invalid-property-registration";
+/** Minted when a sealed kit with registered vocabulary is consumed through
+*  the deprecated `from()`/`includes:` verbs. */
+const VOCABULARY_LEGACY_VERB = "animus.vocabulary.legacy-verb";
+/** A `var()` fallback that never applies: the property is registered with an
+*  initial value. */
+const PROPERTY_FALLBACK_SUPPRESSED = "animus.property.fallback-suppressed";
+/** The same, where the fallback heads a chain of further `var()` reads. */
+const PROPERTY_FALLBACK_CHAIN_SUPPRESSED = "animus.property.fallback-chain-suppressed";
+/** A declared property set in keyframes or transitioned without a typed
+*  registration, so it does not interpolate. */
+const PROPERTY_UNREGISTERED_ANIMATION = "animus.property.unregistered-animation";
+/** A custom property whose resolved value is `var()` of itself, which makes
+*  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: 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"],
+	[PROPERTY_FALLBACK_SUPPRESSED, "info"],
+	[PROPERTY_FALLBACK_CHAIN_SUPPRESSED, "warn"],
+	[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"],
+	[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. */
+function severityFor(code) {
+	return (code === void 0 ? void 0 : DIAGNOSTIC_SEVERITY.get(code)) ?? "warn";
+}
+/**
+* The one mapper of a sealed system's witness entries for every host: the
+* loader's evaluation host shims `console`, so the record is the channel.
+*/
+function vocabularyWitnessDiagnostics(vocabularyWitnessesJson) {
+	if (!vocabularyWitnessesJson) return [];
+	const entries = parseInternalWire(vocabularyWitnessesJson, "vocabularyWitnessesJson (the sealed system's vocabulary witness record)");
+	const diagnostics = [];
+	for (const entry of entries) if (entry.code === "animus.vocabulary.collision") diagnostics.push({
+		file: "system",
+		component: entry.name ?? "keyframes",
+		kind: "warn",
+		message: `keyframes vocabulary "${entry.name}" is registered by both ${entry.loser} and ${entry.winner} — ${entry.winner} wins; rename one collection (${entry.code})`,
+		code: entry.code,
+		severity: severityFor(entry.code)
+	});
+	else if (entry.code === "animus.vocabulary.legacy-verb") diagnostics.push({
+		file: "system",
+		component: "keyframes",
+		kind: "warn",
+		message: `a sealed system (${entry.source ?? `'${entry.verb}' source`}) with registered vocabulary [${(entry.names ?? []).join(", ")}] was consumed through the deprecated '${entry.verb}' verb, which cannot carry it — those collections do NOT reach this consumer; use createSystem().extend(source) (${entry.code})`,
+		code: entry.code,
+		severity: severityFor(entry.code)
+	});
+	else diagnostics.push({
+		file: "system",
+		component: "vocabulary",
+		kind: "warn",
+		message: `unrecognized vocabulary witness entry ${JSON.stringify(entry)} — a newer @animus-ui/system may have recorded a witness kind this host predates${entry.code ? ` (${entry.code})` : ""}`,
+		code: entry.code,
+		severity: severityFor(entry.code)
+	});
+	return diagnostics;
+}
+/** The diagnostics a loaded system's own records carry: vocabulary
+*  witnesses and invalid `@property` registrations. */
+function systemLoadDiagnostics(system) {
+	const registrations = (system.invalidPropertyRegistrations ?? []).map(({ name, reason }) => ({
+		file: "system",
+		component: name,
+		kind: "warn",
+		message: `@property ${name} was not emitted: ${reason}. Browsers ignore an invalid registration and minifying it fails; fix it where the theme declares ${name} (${INVALID_PROPERTY_REGISTRATION})`,
+		code: INVALID_PROPERTY_REGISTRATION,
+		severity: severityFor(INVALID_PROPERTY_REGISTRATION)
+	}));
+	const prefixed = system.legacyPrefixedContextualVars ?? [];
+	const unprefixed = prefixed.length === 0 ? [] : [{
+		file: "system",
+		component: "prefix",
+		kind: "warn",
+		message: `the prefix renames the contextual variables ${prefixed.join(", ")}, but their declared names are still read and written as written, so scale reads of them fail and their writes miss. Set prefixContextualVars: true to resolve them under the prefix (${PREFIX_CONTEXTUAL_VARS_UNPREFIXED})`,
+		code: PREFIX_CONTEXTUAL_VARS_UNPREFIXED,
+		severity: severityFor(PREFIX_CONTEXTUAL_VARS_UNPREFIXED)
+	}];
+	const conflicts = (system.prefixNameConflicts ?? []).map(({ name, final, reason }) => ({
+		file: "system",
+		component: `--${name}`,
+		kind: "error",
+		message: reason === "transport" ? `the prefix would emit the contextual variable ${name} as --${final}, inside the --animus- names of the runtime's transport variables, where it can collide with a prop's own variable. Use a different prefix (${PREFIX_NAME_CONFLICT})` : `the theme variable --${name} is spelled like the final name of the contextual variable ${final}, so under prefixContextualVars a reference to --${name} reaches ${final} and the theme variable is unreachable. Rename one of them (${PREFIX_NAME_CONFLICT})`,
+		code: PREFIX_NAME_CONFLICT,
+		severity: severityFor(PREFIX_NAME_CONFLICT)
+	}));
+	return [
+		...vocabularyWitnessDiagnostics(system.vocabularyWitnessesJson),
+		...registrations,
+		...unprefixed,
+		...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.
+*/
+function surfaceManifestDiagnostics(manifest, warn, policy = {}) {
+	const errors = [];
+	const diagnostics = policy.prepend?.length ? [...policy.prepend, ...manifest.diagnostics ?? []] : manifest.diagnostics ?? [];
+	for (const diagnostic of diagnostics) {
+		let line = null;
+		if (diagnostic.kind === "bail") line = `⚠ ${diagnostic.component} not extracted: ${diagnostic.message}`;
+		else if (diagnostic.kind === "skip") line = `⚠ ${diagnostic.component}: skipped ${diagnostic.message}`;
+		else if (diagnostic.kind === "warn") line = `${diagnostic.severity === "info" ? "ℹ" : "⚠"} ${diagnostic.file}: ${diagnostic.component}: ${diagnostic.message}`;
+		if (line === null) continue;
+		if (diagnostic.code && !diagnostic.message.includes(diagnostic.code)) line += ` [${diagnostic.code}]`;
+		if (diagnostic.severity === "info") {
+			policy.info?.(line);
+			continue;
+		}
+		if (policy.strict && diagnostic.severity === "error") {
+			errors.push(`${diagnostic.code ?? "error"} — ${diagnostic.component}: ${diagnostic.message}`);
+			continue;
+		}
+		warn(line);
+	}
+	if (errors.length > 0) throw new Error(`[animus] strict: ${errors.length} error diagnostic(s):\n${errors.join("\n")}`);
+}
+//#endregion
 //#region pipeline/mdx-preprocessor.ts
 /**
 * MDX compiled to scanner-consumable JSX, plus the extension sets every
@@ -1049,7 +1331,8 @@ function withoutInvalidOriginals(result, invalidOriginals) {
 		...result,
 		originalEntries: result.originalEntries.filter((entry) => !invalidOriginals.has(entry.path)),
 		analysisEntries: result.analysisEntries.filter((entry) => analysisPaths.has(entry.path)),
-		ownership
+		ownership,
+		skippedOriginals: [...invalidOriginals].sort()
 	};
 }
 /**
@@ -1089,11 +1372,12 @@ function createSourceIngestor(host) {
 			const invalidOriginals = new Set(fatal.map((diagnostic) => diagnostic.originalPath));
 			if (diagnostics.length === 0) return invalidOriginals;
 			if (host.strict() && fatal.length > 0) {
-				const lines = fatal.map((diagnostic) => `${diagnostic.code} ${diagnostic.originalPath}: ${diagnostic.message}`);
+				const lines = fatal.map((diagnostic) => `${diagnostic.code} ${diagnostic.originalPath}: ${diagnostic.message} (${SKIPPED_SOURCE_COST})`);
 				throw new Error(`${host.prefix} ${lines.join(`\n${host.prefix} `)}`);
 			}
 			for (const diagnostic of diagnostics) {
-				const line = `${diagnostic.code} ${diagnostic.originalPath}: ${diagnostic.message}`;
+				const skipped = isAdvisorySourceDiagnostic(diagnostic) ? "" : ` (${SKIPPED_SOURCE_COST})`;
+				const line = `${diagnostic.code} ${diagnostic.originalPath}: ${diagnostic.message}${skipped}`;
 				let warned = warnedByOriginal.get(diagnostic.originalPath);
 				if (!warned) {
 					warned = /* @__PURE__ */ new Set();
@@ -1128,7 +1412,7 @@ function createV2EngineApi(deps) {
 		return {
 			loadSystemModule: (...args) => native.loadSystemModule(...args),
 			extractFacts: (filesJson) => native.extractFacts(filesJson),
-			analyzeProject: (filesJsonRaw, scalesJson, variableMapJson, contextualVarsJson, propConfigJson, groupRegistryJson, packageResolutionJson, devMode, emitterConfigJson, selectorAliasesJson, _selectorOrderJson, globalStyleBlocksJson, pathAliasesJson, keyframesJson, staticCssJson, conditionAliasesJson, externalDirsJson, transformSourcesJson, transformProvenanceJson, declarationScalesJson) => {
+			analyzeProject: (filesJsonRaw, scalesJson, variableMapJson, contextualVarsJson, propConfigJson, groupRegistryJson, packageResolutionJson, devMode, emitterConfigJson, selectorAliasesJson, _selectorOrderJson, globalStyleBlocksJson, pathAliasesJson, keyframesJson, staticCssJson, conditionAliasesJson, externalDirsJson, transformSourcesJson, transformProvenanceJson, declarationScalesJson, analysisContextJson) => {
 				const filesJson = deps.rehydrateFilesJson ? deps.rehydrateFilesJson(filesJsonRaw) : filesJsonRaw;
 				const sent = /* @__PURE__ */ new Map();
 				for (const entry of parseFilesJson(filesJson, label)) sent.set(entry.path, entry.source);
@@ -1155,6 +1439,7 @@ function createV2EngineApi(deps) {
 					transformSourcesJson: transformSourcesJson ?? void 0,
 					transformProvenanceJson: transformProvenanceJson ?? void 0,
 					declarationScalesJson,
+					analysisContextJson,
 					devMode
 				};
 				const engine = new native.ExtractEngine(config);
@@ -1227,6 +1512,7 @@ const CORE_OPTION_KEYS = /* @__PURE__ */ new Set([
 	"strict",
 	"verbose",
 	"prefix",
+	"prefixContextualVars",
 	"targets",
 	"minify",
 	"staticCss",
@@ -1320,6 +1606,11 @@ const CORE_VALUE_GATES = [
 		ok: isString,
 		expected: "a string"
 	},
+	{
+		key: "prefixContextualVars",
+		ok: isBoolean,
+		expected: "a boolean"
+	},
 	{
 		key: "targets",
 		ok: isStringOrStringArray,
@@ -1581,13 +1872,195 @@ function createSourceIdentity(rootDir) {
 	};
 }
 //#endregion
-//#region pipeline/discover-packages.ts
-function findPackageRoot(absEntryPath) {
-	let pkgRoot = (0, path.dirname)(absEntryPath);
-	while (pkgRoot !== (0, path.dirname)(pkgRoot) && !(0, fs.existsSync)((0, path.join)(pkgRoot, "package.json"))) pkgRoot = (0, path.dirname)(pkgRoot);
-	return pkgRoot;
+//#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");
 }
-const PACKAGE_SRC_EXCLUDES = [
+/** `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);
+	while (pkgRoot !== (0, path.dirname)(pkgRoot) && !(0, fs.existsSync)((0, path.join)(pkgRoot, "package.json"))) pkgRoot = (0, path.dirname)(pkgRoot);
+	return pkgRoot;
+}
+const PACKAGE_SRC_EXCLUDES = [
 	"dist",
 	"node_modules",
 	".test.",
@@ -1606,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;
 	}
@@ -1634,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;
@@ -1654,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 = {};
@@ -1691,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);
@@ -1699,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)) {
@@ -1764,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",
@@ -1774,6 +2348,7 @@ async function collectExternalPackageSources(opts) {
 		entries,
 		packageMap,
 		sourceEntries,
+		sourceEntrySideEffects,
 		packageDirs,
 		dirOwnerSets,
 		dirExtensions,
@@ -1797,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)) {
@@ -1821,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,
@@ -1840,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;
@@ -1860,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) => {
@@ -1880,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 (;;) {
@@ -1889,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];
@@ -1906,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) {
@@ -1944,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);
@@ -2018,31 +2717,113 @@ function createSourceCorpus(host, ingestor = createSourceIngestor(host)) {
 //#endregion
 //#region pipeline/asset-placeholders.ts
 const ASSET_PLACEHOLDER_PREFIX = "animus-asset:";
-const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-const PREFIX_RE = escapeRegExp(ASSET_PLACEHOLDER_PREFIX);
-const QUOTED_PLACEHOLDER_RE = new RegExp(`(['"])${PREFIX_RE}([^'"]*?)\\1`, "g");
-const BARE_PLACEHOLDER_RE = new RegExp(`${PREFIX_RE}([^'")\\s]+)`, "g");
-function findAssetSpecifiers(css) {
+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(css, open) {
+	let depth = 0;
+	let quote = null;
+	for (let i = open; i < css.length; i += 1) {
+		const c = css[i];
+		if (quote !== null) {
+			if (c === quote) quote = null;
+		} else if (c === "\"" || c === "'") quote = c;
+		else if (c === "(") depth += 1;
+		else if (c === ")") {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return css.length;
+}
+function quotedReference(css, quoteAt) {
+	const start = quoteAt + 1;
+	if (!css.startsWith("animus-asset:", start)) return null;
+	const end = css.indexOf(css[quoteAt], start);
+	if (end === -1) return null;
+	return {
+		start,
+		end,
+		specifier: css.slice(start + 13, end)
+	};
+}
+function assetReferences(css) {
 	if (!css.includes("animus-asset:")) return [];
-	const seen = /* @__PURE__ */ new Set();
-	const remainder = css.replace(QUOTED_PLACEHOLDER_RE, (_match, _quote, specifier) => {
-		seen.add(specifier);
-		return "";
-	});
-	for (const match of remainder.matchAll(BARE_PLACEHOLDER_RE)) seen.add(match[1]);
-	return [...seen];
+	const references = [];
+	for (const open of css.matchAll(URL_OPEN_RE)) {
+		const at = (open.index ?? 0) + open[0].length;
+		if (open[1]) {
+			const reference = quotedReference(css, at - 1);
+			if (reference) references.push(reference);
+			continue;
+		}
+		if (!css.startsWith("animus-asset:", at)) continue;
+		const specifier = BARE_SPECIFIER_RE.exec(css.slice(at + 13))?.[0];
+		if (specifier === void 0) continue;
+		const end = at + 13 + specifier.length;
+		references.push({
+			start: at,
+			end,
+			specifier
+		});
+	}
+	for (const open of css.matchAll(IMAGE_SET_OPEN_RE)) {
+		const paren = (open.index ?? 0) + open[0].length - 1;
+		const close = closingParen(css, paren);
+		let depth = 0;
+		let candidateStart = true;
+		for (let i = paren + 1; i < close; i += 1) {
+			const c = css[i];
+			if (/\s/.test(c)) continue;
+			if (c === "\"" || c === "'") {
+				if (depth === 0 && candidateStart) {
+					const reference = quotedReference(css, i);
+					if (reference) references.push(reference);
+				}
+				const end = css.indexOf(c, i + 1);
+				i = end === -1 ? close : end;
+			} else if (c === "(") depth += 1;
+			else if (c === ")") depth -= 1;
+			else if (c === "," && depth === 0) {
+				candidateStart = true;
+				continue;
+			}
+			candidateStart = false;
+		}
+	}
+	return references.sort((a, b) => a.start - b.start);
+}
+function findAssetSpecifiers(css) {
+	return [...new Set(assetReferences(css).map((reference) => reference.specifier))];
 }
 function substituteAssetPlaceholders(css, urlBySpecifier) {
 	if (urlBySpecifier.size === 0) return css;
-	if (!css.includes("animus-asset:")) return css;
-	const specifiers = [...urlBySpecifier.keys()].sort((a, b) => b.length - a.length);
 	let out = css;
-	for (const specifier of specifiers) {
-		const placeholder = new RegExp(escapeRegExp(ASSET_PLACEHOLDER_PREFIX + specifier) + String.raw`(?=['")\s]|$)`, "g");
-		out = out.replace(placeholder, () => urlBySpecifier.get(specifier));
+	for (const reference of assetReferences(css).reverse()) {
+		const url = urlBySpecifier.get(reference.specifier);
+		if (url === void 0) continue;
+		out = out.slice(0, reference.start) + url + out.slice(reference.end);
 	}
 	return out;
 }
+/**
+* Specifiers of placeholder text anywhere inside a `url()` or `image-set()`
+* call, a reference or not: after substitution any of it is a broken load.
+*/
+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(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)) {
+		if (!calls.some(([open, close]) => open < at && at < close)) continue;
+		found.add(/^[^'")\s,]*/.exec(css.slice(at + 13))[0]);
+	}
+	return [...found];
+}
 function findSheetAssetSpecifiers(sheets) {
 	return [.../* @__PURE__ */ new Set([
 		...findAssetSpecifiers(sheets.variableCss),
@@ -2062,12 +2843,22 @@ const UNSUBSTITUTED_ASSET_CODE = "animus.asset.unsubstituted-placeholder";
 /** A placeholder in emitted CSS is a broken URL in the browser: it fails a
 *  strict build and warns otherwise. */
 function reportSurvivingAssetPlaceholders(css, report) {
-	const specifiers = findAssetSpecifiers(css);
+	const specifiers = placeholdersInAssetCalls(css);
 	if (specifiers.length === 0) return;
-	const message = `${report.prefix} asset() placeholders reached emitted CSS unsubstituted: ${specifiers.join(", ")} (${UNSUBSTITUTED_ASSET_CODE})`;
+	const message = `${report.prefix} asset() placeholders reached ${report.surface ?? "emitted CSS"} unsubstituted: ${specifiers.join(", ")} (${UNSUBSTITUTED_ASSET_CODE})`;
 	if (report.strict) throw new Error(message);
 	report.warn(message);
 }
+/**
+* The runtime code an analysis generates: each dynamic prop config, which the
+* shared prop map module carries, and each component's replacement. Extraction
+* lifts asset() out of them into root variables, so none should hold one.
+* Both embed values as JSON strings, so their quote and backslash escapes are
+* undone for scanning: the text is for `findAssetSpecifiers`, not to run.
+*/
+function generatedModuleCode(manifest) {
+	return [JSON.stringify(manifest.dynamic_props), ...Object.values(manifest.components).map((component) => component.replacement)].join("\n").replace(/\\(["\\])/g, "$1");
+}
 //#endregion
 //#region pipeline/resolve-asset.ts
 /**
@@ -2266,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;
@@ -2291,186 +3077,28 @@ function postProcessCss(css, opts) {
 	}
 }
 //#endregion
-//#region pipeline/manifest-diagnostics.ts
-/** Stable code for selector forms with no substitutable subject; the
-*  extraction engine mints the same string. */
-const SELECTOR_UNSUPPORTED_SUBJECT = "animus.selector.unsupported-subject";
-/** The one matcher for the engine's unresolved-parent chain-drop message;
-*  consumers match through the exported helpers, never their own copy. */
-const UNRESOLVED_PARENT_RE = /chain dropped: could not resolve parent component '([^']+)'/;
-function isUnresolvedParentDrop(diagnostic) {
-	return UNRESOLVED_PARENT_RE.test(diagnostic.message);
-}
-function unresolvedParentName(diagnostic) {
-	return UNRESOLVED_PARENT_RE.exec(diagnostic.message)?.[1] ?? null;
-}
-/** True when the selector carries at least one substitutable `&` subject
-*  outside quoted text. */
-function hasSelectorSubject(value) {
-	let quote = null;
-	let escaped = false;
-	for (const c of value) {
-		if (escaped) {
-			escaped = false;
-			continue;
-		}
-		if (c === "\\") {
-			escaped = true;
-			continue;
-		}
-		if (quote !== null) {
-			if (c === quote) quote = null;
-		} else if (c === "\"" || c === "'") quote = c;
-		else if (c === "&") return true;
-	}
-	return false;
-}
-/**
-* Coded diagnostics for selector-shaped alias values with no substitutable
-* subject; alias values never reach the evaluator's own key guard.
-*/
-function collectSelectorAliasDiagnostics(selectorAliasesJson) {
-	if (!selectorAliasesJson) return [];
-	const aliases = parseInternalWire(selectorAliasesJson, "selectorAliasesJson (the system loader's selector-alias registry)");
-	const diagnostics = [];
-	for (const [name, value] of Object.entries(aliases)) if (value.includes("&") && !hasSelectorSubject(value)) diagnostics.push({
-		file: "system",
-		component: name,
-		kind: "warn",
-		message: `selector alias '${name}' value '${value}' has no substitutable '&' subject outside quoted text (${SELECTOR_UNSUPPORTED_SUBJECT})`,
-		code: SELECTOR_UNSUPPORTED_SUBJECT,
-		severity: severityFor(SELECTOR_UNSUPPORTED_SUBJECT)
-	});
-	return diagnostics;
-}
-const UNREADABLE_SOURCE_FILE = "animus.ingestion.unreadable-source-file";
-/**
-* A configured source file that could not be read is a LOST INPUT: the
-* emitted artifacts silently lack whatever that file declared.
-*/
-function unreadableSourceDiagnostic(relPath, error) {
-	return {
-		file: relPath,
-		component: "source",
-		kind: "warn",
-		message: `configured source file ${relPath} could not be read and was skipped: ${String(error)}`,
-		code: UNREADABLE_SOURCE_FILE,
-		severity: severityFor(UNREADABLE_SOURCE_FILE)
-	};
-}
-/** 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. */
-const INVALID_PROPERTY_REGISTRATION = "animus.theme.invalid-property-registration";
-/** Minted when a sealed kit with registered vocabulary is consumed through
-*  the deprecated `from()`/`includes:` verbs. */
-const VOCABULARY_LEGACY_VERB = "animus.vocabulary.legacy-verb";
-/** A `var()` fallback that never applies: the property is registered with an
-*  initial value. */
-const PROPERTY_FALLBACK_SUPPRESSED = "animus.property.fallback-suppressed";
-/** The same, where the fallback heads a chain of further `var()` reads. */
-const PROPERTY_FALLBACK_CHAIN_SUPPRESSED = "animus.property.fallback-chain-suppressed";
-/** A declared property set in keyframes or transitioned without a typed
-*  registration, so it does not interpolate. */
-const PROPERTY_UNREGISTERED_ANIMATION = "animus.property.unregistered-animation";
-/** The same, where `allow-discrete` shows interpolation was intended. */
-const PROPERTY_DISCRETE_ANIMATION = "animus.property.discrete-animation";
-/** A custom property whose resolved value is `var()` of itself, which makes
-*  it invalid at computed-value time. */
-const PROPERTY_SELF_REFERENCE = "animus.property.self-reference";
-const DIAGNOSTIC_SEVERITY = /* @__PURE__ */ new Map([
-	[SELECTOR_UNSUPPORTED_SUBJECT, "error"],
-	[UNREADABLE_SOURCE_FILE, "error"],
-	[VOCABULARY_COLLISION, "warn"],
-	[VOCABULARY_LEGACY_VERB, "warn"],
-	[INVALID_PROPERTY_REGISTRATION, "error"],
-	[PROPERTY_FALLBACK_SUPPRESSED, "info"],
-	[PROPERTY_FALLBACK_CHAIN_SUPPRESSED, "warn"],
-	[PROPERTY_UNREGISTERED_ANIMATION, "info"],
-	[PROPERTY_DISCRETE_ANIMATION, "warn"],
-	[PROPERTY_SELF_REFERENCE, "warn"]
-]);
-/** 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. */
-function severityFor(code) {
-	return (code === void 0 ? void 0 : DIAGNOSTIC_SEVERITY.get(code)) ?? "warn";
-}
-/**
-* The one mapper of a sealed system's witness entries for every host: the
-* loader's evaluation host shims `console`, so the record is the channel.
-*/
-function vocabularyWitnessDiagnostics(vocabularyWitnessesJson) {
-	if (!vocabularyWitnessesJson) return [];
-	const entries = parseInternalWire(vocabularyWitnessesJson, "vocabularyWitnessesJson (the sealed system's vocabulary witness record)");
-	const diagnostics = [];
-	for (const entry of entries) if (entry.code === "animus.vocabulary.collision") diagnostics.push({
-		file: "system",
-		component: entry.name ?? "keyframes",
-		kind: "warn",
-		message: `keyframes vocabulary "${entry.name}" is registered by both ${entry.loser} and ${entry.winner} — ${entry.winner} wins; rename one collection (${entry.code})`,
-		code: entry.code,
-		severity: severityFor(entry.code)
-	});
-	else if (entry.code === "animus.vocabulary.legacy-verb") diagnostics.push({
-		file: "system",
-		component: "keyframes",
-		kind: "warn",
-		message: `a sealed system (${entry.source ?? `'${entry.verb}' source`}) with registered vocabulary [${(entry.names ?? []).join(", ")}] was consumed through the deprecated '${entry.verb}' verb, which cannot carry it — those collections do NOT reach this consumer; use createSystem().extend(source) (${entry.code})`,
-		code: entry.code,
-		severity: severityFor(entry.code)
-	});
-	else diagnostics.push({
-		file: "system",
-		component: "vocabulary",
-		kind: "warn",
-		message: `unrecognized vocabulary witness entry ${JSON.stringify(entry)} — a newer @animus-ui/system may have recorded a witness kind this host predates${entry.code ? ` (${entry.code})` : ""}`,
-		code: entry.code,
-		severity: severityFor(entry.code)
-	});
-	return diagnostics;
-}
-/** The diagnostics a loaded system's own records carry: vocabulary
-*  witnesses and invalid `@property` registrations. */
-function systemLoadDiagnostics(system) {
-	const registrations = (system.invalidPropertyRegistrations ?? []).map(({ name, reason }) => ({
-		file: "system",
-		component: name,
-		kind: "warn",
-		message: `@property ${name} was not emitted: ${reason}. Browsers ignore an invalid registration and minifying it fails; fix it where the theme declares ${name} (${INVALID_PROPERTY_REGISTRATION})`,
-		code: INVALID_PROPERTY_REGISTRATION,
-		severity: severityFor(INVALID_PROPERTY_REGISTRATION)
-	}));
-	return [...vocabularyWitnessDiagnostics(system.vocabularyWitnessesJson), ...registrations];
-}
-/**
-* The single strict-escalation policy point for both extraction plugins:
-* error-severity diagnostics throw together under `strict`, else warn.
-*/
-function surfaceManifestDiagnostics(manifest, warn, policy = {}) {
-	const errors = [];
-	const diagnostics = policy.prepend?.length ? [...policy.prepend, ...manifest.diagnostics ?? []] : manifest.diagnostics ?? [];
-	for (const diagnostic of diagnostics) {
-		let line = null;
-		if (diagnostic.kind === "bail") line = `⚠ ${diagnostic.component} not extracted: ${diagnostic.message}`;
-		else if (diagnostic.kind === "skip") line = `⚠ ${diagnostic.component}: skipped ${diagnostic.message}`;
-		else if (diagnostic.kind === "warn") line = `${diagnostic.severity === "info" ? "ℹ" : "⚠"} ${diagnostic.file}: ${diagnostic.component}: ${diagnostic.message}`;
-		if (line === null) continue;
-		if (diagnostic.code && !diagnostic.message.includes(diagnostic.code)) line += ` [${diagnostic.code}]`;
-		if (diagnostic.severity === "info") {
-			policy.info?.(line);
-			continue;
-		}
-		if (policy.strict && diagnostic.severity === "error") {
-			errors.push(`${diagnostic.code ?? "error"} — ${diagnostic.component}: ${diagnostic.message}`);
-			continue;
-		}
-		warn(line);
+//#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
+		});
 	}
-	if (errors.length > 0) throw new Error(`[animus] strict: ${errors.length} error diagnostic(s):\n${errors.join("\n")}`);
+	return rules;
 }
-//#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",
@@ -2490,44 +3118,40 @@ const SYNTAX_TYPES = /* @__PURE__ */ new Set([
 	"url"
 ]);
 const SYNTAX_COMPONENT = /^(?:<([a-z-]+)>[+#]?|-?[a-zA-Z_][\w-]*)$/;
-/** The syntax types whose values can carry a font- or container-relative
-*  unit, which makes a typed initial value depend on context. */
-const DIMENSION_TYPES = /* @__PURE__ */ new Set([
-	"image",
-	"length",
-	"length-percentage",
-	"transform-function",
-	"transform-list"
-]);
-const RELATIVE_UNIT = /(?:\d|\.)(?:r?em|r?ex|r?cap|r?ch|r?ic|r?lh|cq(?:w|h|i|b|min|max))\b/i;
-const SUBSTITUTION = /\b(?:var|env|attr)\(/i;
-/** Quoted strings and `url()` hold text, never units or substitutions. */
-const LITERAL_TEXT = /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|url\([^)]*\)/gi;
+const INITIAL_VALUE = /(initial-value\s*:\s*)([^;}]*)/;
+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 depends on context, or one the syntax does not accept.
-* Minifying a stylesheet that contains such a rule can also fail.
+* 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 reason = registrationFailure(rule);
-			if (reason === null) return rule;
-			invalid.push({
-				name,
-				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) {
@@ -2536,42 +3160,56 @@ function readRegistration(rule) {
 		initialValue: /initial-value\s*:\s*([^;}]*)/.exec(rule)?.[1]?.trim()
 	};
 }
-function registrationFailure(rule) {
+/** The rule to keep, with an all-absolute math initial value folded, or why
+*  a browser would ignore it. */
+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 components = syntax.split("|").map((component) => ({
+		const unknown = syntax.split("|").map((component) => ({
 			text: component.trim(),
 			match: SYNTAX_COMPONENT.exec(component.trim())
-		}));
-		const unknown = components.find(({ match }) => match === null || match[1] !== void 0 && !SYNTAX_TYPES.has(match[1]));
-		if (unknown !== void 0) return `syntax "${syntax}" has the unknown component "${unknown.text}"`;
-		if (initialValue === void 0) return `syntax "${syntax}" needs an initialValue`;
-		const dimensional = components.some(({ match }) => match?.[1] !== void 0 && DIMENSION_TYPES.has(match[1]));
-		const value = initialValue.replace(LITERAL_TEXT, "");
-		if (SUBSTITUTION.test(value) || dimensional && RELATIVE_UNIT.test(value)) return `initialValue "${initialValue}" depends on context; font- and container-relative units and var(), env() and attr() are not allowed`;
+		})).find(({ match }) => match === null || match[1] !== void 0 && !SYNTAX_TYPES.has(match[1]));
+		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` };
+		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)({
 			filename: "animus-registrations.css",
-			code: Buffer.from(rule)
+			code: Buffer.from(kept)
 		});
-		return null;
+		return { rule: kept };
 	} catch (error) {
 		const detail = error instanceof Error ? error.message : String(error);
-		return `the CSS parser rejects \`${rule.trim()}\` (${detail})`;
+		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})` };
 	}
 }
 //#endregion
 //#region pipeline/property-diagnostics.ts
 /**
 * Reports custom properties that will not behave as their CSS suggests: a
-* property that refers to itself and, once the system emits an `@property`
-* rule, a fallback an initial value suppresses and an animated property that
-* cannot interpolate. The CSS itself is never changed.
+* property that refers to itself, a fallback a registered initial value
+* 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 = declaredProperties(input.system.contextualVarsJson);
+	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,
@@ -2581,8 +3219,20 @@ function checkCustomProperties(input) {
 		owner: globalOwner
 	}];
 	for (const { css, owner } of sheets) {
+		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,
@@ -2590,139 +3240,275 @@ 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 (registered.size === 0) continue;
-			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, chain ? `var(${read.name}, ${read.fallback}) never reads its fallback chain: ${read.name} is registered with initial-value ${registration.initialValue}, which applies whenever it is unset. Remove the initial value or reorder the chain` : `var(${read.name}, ${read.fallback}) never uses its fallback: ${read.name} is registered with initial-value ${registration.initialValue}, which applies whenever it is unset`);
+				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 (!declared.has(animated.name)) continue;
+				if (animated.discrete || !declared.has(animated.name)) continue;
 				const reason = interpolationGap(registered.get(animated.name));
 				if (reason === null) continue;
-				if (animated.discrete) found(PROPERTY_DISCRETE_ANIMATION, animated.name, `${animated.name} is transitioned with allow-discrete but ${reason}, so it flips at the midpoint instead of interpolating. Register it with a typed syntax`);
-				else found(PROPERTY_UNREGISTERED_ANIMATION, animated.name, `${animated.name} is ${animated.how} but ${reason}, so it changes in one step instead of interpolating. Register it with a typed syntax to animate it`);
+				found(PROPERTY_UNREGISTERED_ANIMATION, animated.name, `${animated.name} is ${animated.how} but ${reason}, so it changes in one step instead of interpolating. Register it with a typed syntax to animate it`);
 			}
 		}
 	}
 	return toDiagnostics(findings);
 }
-function declaredProperties(contextualVarsJson) {
-	if (!contextualVarsJson) return /* @__PURE__ */ new Set();
-	const byScale = parseInternalWire(contextualVarsJson, "contextualVarsJson (the theme's contextual variable names)");
-	return new Set(Object.values(byScale).flatMap((names) => names.map((name) => `--${name}`)));
+/**
+* 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;
 }
-/** Declarations in engine-emitted CSS: one `property: value` per `;`. */
-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)
-		});
+/** `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);
 	};
-	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;
+	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);
 		}
-		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
+	};
+	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 = [];
+	let rules = 0;
+	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;
 }
-function isSelfReference(declaration) {
-	return declaration.property.startsWith("--") && declaration.value.replace(/\s+/g, "") === `var(${declaration.property})`;
-}
-/** Every `var()` read in `value`, nested fallbacks included. */
-function varReads(value) {
-	const reads = [];
-	for (const match of value.matchAll(/var\(\s*(--[\w-]+)\s*/g)) {
-		const after = (match.index ?? 0) + match[0].length;
-		if (value[after] !== ",") {
-			reads.push({
-				name: match[1],
-				fallback: void 0
-			});
-			continue;
+/** 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 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;
+}
+/**
+* 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));
+		}
+		for (const component of stronglyConnected(edges)) {
+			if (component.length < 2) continue;
+			cycles.push([...writes.values()].filter((d) => component.includes(d.property)));
 		}
-		let depth = 1;
-		let close = after + 1;
-		for (; close < value.length && depth > 0; close += 1) if (value[close] === "(") depth += 1;
-		else if (value[close] === ")") depth -= 1;
-		reads.push({
-			name: match[1],
-			fallback: value.slice(after + 1, close - 1).trim()
-		});
 	}
-	return reads;
+	return cycles;
+}
+/** 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;
+}
+/** 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"));
-	if (keyframes !== void 0 && declaration.property.startsWith("--")) return [{
+	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 = item.trim().split(/\s+/)[0] ?? "";
-		return property.startsWith("--") ? [{
-			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)
 		}] : [];
 	});
 }
-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. */
@@ -2732,7 +3518,7 @@ function interpolationGap(registration) {
 	return null;
 }
 function componentOwner(manifest) {
-	const components = Object.values(manifest.components);
+	const components = Object.values(manifest.components ?? {});
 	return (declaration) => {
 		const selector = [...declaration.context].reverse().find((prelude) => !prelude.startsWith("@"));
 		const classes = (selector ?? "").match(/\.-?[_a-zA-Z][\w-]*/g) ?? [];
@@ -2854,12 +3640,33 @@ function buildAnalysisInputs(opts) {
 		externalDirsJson: opts.externalDirs?.length && hasSourceThemeManifests(opts.system) ? JSON.stringify(opts.externalDirs) : null
 	};
 	if (opts.system.declarationScalesJson) inputs.declarationScalesJson = opts.system.declarationScalesJson;
+	const context = opts.analysisContext;
+	if (context?.skippedSources?.length || context?.unbundledComputedImports || context?.packageDirs?.length) inputs.analysisContextJson = JSON.stringify({
+		skippedSources: context.skippedSources ?? [],
+		unbundledComputedImports: context.unbundledComputedImports ?? false,
+		packageDirs: context.packageDirs ?? []
+	});
 	return inputs;
 }
 function hasSourceThemeManifests(system) {
 	const json = system.sourceThemeManifestsJson ?? "";
 	return json.length > 0 && json !== "{}";
 }
+/** Systems whose load diagnostics were surfaced: each loaded system reports
+*  them once, not again on every analysis and hot update. The set is per
+*  process. Next's webpack compilers share one analysis in one process, but
+*  its build worker and Turbopack builds analyze in two processes, which
+*  repeat every diagnostic alike, component ones included. */
+const surfacedSystems = /* @__PURE__ */ new WeakSet();
+/** The loaded system's own diagnostics, the first time it is analyzed. A
+*  strict error keeps failing every analysis until the system changes. */
+function systemDiagnostics(system, strict) {
+	const diagnostics = [...collectSelectorAliasDiagnostics(system.selectorAliasesJson), ...systemLoadDiagnostics(system)];
+	const blocking = strict === true && diagnostics.some((d) => d.severity === "error");
+	if (surfacedSystems.has(system) && !blocking) return [];
+	surfacedSystems.add(system);
+	return diagnostics;
+}
 /**
 * The one analysis invocation both plugins share. Error handling stays at
 * the call site (strict-mode throw vs warn).
@@ -2874,18 +3681,20 @@ function runProjectAnalysis(engineApi, opts) {
 	const extractMs = Math.round(performance.now() - t);
 	t = performance.now();
 	const manifest = JSON.parse(manifestJson);
+	const systemErrors = systemLoadDiagnostics(opts.system).filter((diagnostic) => diagnostic.kind === "error");
+	if (systemErrors.length > 0) manifest.diagnostics = [...systemErrors, ...manifest.diagnostics ?? []];
+	const componentCss = applyUnitFallback(manifest.css);
 	const propertyDiagnostics = checkCustomProperties({
 		system: opts.system,
 		manifest,
-		componentCss: applyUnitFallback(manifest.css),
+		componentCss,
 		globalCss: manifest.sheets.global
 	});
 	surfaceManifestDiagnostics(manifest, opts.warn, {
 		strict: opts.strict,
 		info: opts.info,
 		prepend: [
-			...collectSelectorAliasDiagnostics(opts.system.selectorAliasesJson),
-			...systemLoadDiagnostics(opts.system),
+			...systemDiagnostics(opts.system, opts.strict),
 			...propertyDiagnostics,
 			...opts.extraDiagnostics ?? []
 		]
@@ -2895,7 +3704,7 @@ function runProjectAnalysis(engineApi, opts) {
 		manifest,
 		manifestJson,
 		globalCss: manifest.sheets.global,
-		componentCss: applyUnitFallback(manifest.css),
+		componentCss,
 		inputs,
 		timings: {
 			serializeMs,
@@ -2947,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) {
@@ -2980,6 +3830,61 @@ function applyPrefix(prefix, variableMapJson, variableCss, themeJson, contextual
 	}
 	return result;
 }
+/** The runtime's transport variables are `--animus-<prop>`. */
+const TRANSPORT_NAMESPACE = "animus-";
+/**
+* The prefix applied through one map: every variable the theme defines and
+* every declared contextual variable takes `--${prefix}-${name}`, each
+* reference renamed once. Each contextual entry carries its declared and
+* final name, so lookups run on the declared identity and the extractor
+* emits the final name.
+*/
+function applyPropertyNames(prefix, artifacts) {
+	const byScale = artifacts.contextualVarsJson ? parseInternalWire(artifacts.contextualVarsJson, "contextualVarsJson (the theme's contextual variable names)") : null;
+	const declared = Object.values(byScale ?? {}).flat();
+	const variableMap = parseInternalWire(artifacts.variableMapJson, "variableMapJson (the theme's token variables)");
+	const managed = createPropertyNames(declared, prefix, [...Object.values(variableMap).map((name) => name.replace(/^--/, "")), ...[...artifacts.variableCss.matchAll(THEME_DEFINITION)].map((m) => m[1])]);
+	const nameConflicts = [...[...new Set(declared)].flatMap((name) => {
+		const final = managed.finalName(name) ?? name;
+		return final.startsWith(TRANSPORT_NAMESPACE) ? [{
+			name,
+			final,
+			reason: "transport"
+		}] : [];
+	}), ...managed.ambiguous().map(({ name, contextual }) => ({
+		name,
+		final: contextual,
+		reason: "theme-variable"
+	}))];
+	const rename = (value) => renameCustomProperties(value, managed);
+	return {
+		variableMapJson: JSON.stringify(Object.fromEntries(Object.entries(variableMap).map(([key, name]) => [key, rename(name)]))),
+		variableCss: rename(artifacts.variableCss),
+		themeJson: renameTokenValues(artifacts.themeJson, rename),
+		contextualVarsJson: byScale === null ? null : JSON.stringify(Object.fromEntries(Object.entries(byScale).map(([scale, names]) => [scale, names.map((name) => ({
+			name,
+			var: managed.finalName(name) ?? name
+		}))]))),
+		declarationScalesJson: artifacts.declarationScalesJson === null ? null : renameDeclarationRecords(artifacts.declarationScalesJson, rename),
+		nameConflicts,
+		contextualProperties: [...new Set(declared)].map((name) => `--${managed.finalName(name) ?? name}`)
+	};
+}
+/** A custom property the theme's CSS defines or registers. */
+const THEME_DEFINITION = /(?:@property\s+|(?:^|[\s;{]))--([\w-]+)(?=\s*[:{])/g;
+/** Renames inside the token map's values. */
+function renameTokenValues(themeJson, rename) {
+	const tokens = parseInternalWire(themeJson, "themeJson (the theme's flattened token values)");
+	return JSON.stringify(Object.fromEntries(Object.entries(tokens).map(([path, value]) => [path, rename(value)])));
+}
+/** Renames inside every declaration-scale record value. */
+function renameDeclarationRecords(declarationScalesJson, rename) {
+	const scales = parseInternalWire(declarationScalesJson, "declarationScalesJson (the theme's declaration scales)");
+	return JSON.stringify(Object.fromEntries(Object.entries(scales).map(([name, scale]) => [name, {
+		...scale,
+		values: Object.fromEntries(Object.entries(scale.values).map(([key, record]) => [key, Object.fromEntries(Object.entries(record).map(([property, value]) => [property, rename(value)]))]))
+	}])));
+}
 //#endregion
 //#region pipeline/system-config.ts
 /**
@@ -2995,7 +3900,28 @@ function loadSystemConfig(engineApi, opts) {
 	let variableCss = registrations.css;
 	let contextualVarsJson = config.contextualVarsJson || null;
 	let declarationScalesJson = config.declarationScalesJson || null;
-	if (opts.prefix) {
+	const declaredNames = Object.values(parseInternalWire(contextualVarsJson ?? "{}", "contextualVarsJson (the theme's contextual variable names)")).flat();
+	let contextualProperties = declaredNames.map((name) => `--${name}`);
+	let legacyPrefixedContextualVars = [];
+	let prefixNameConflicts = [];
+	if (opts.prefix && opts.prefixContextualVars) {
+		const resolved = applyPropertyNames(opts.prefix, {
+			variableMapJson,
+			variableCss,
+			themeJson: scalesJson,
+			contextualVarsJson,
+			declarationScalesJson
+		});
+		variableMapJson = resolved.variableMapJson;
+		variableCss = resolved.variableCss;
+		scalesJson = resolved.themeJson;
+		contextualVarsJson = resolved.contextualVarsJson;
+		contextualProperties = resolved.contextualProperties;
+		prefixNameConflicts = resolved.nameConflicts;
+		declarationScalesJson = resolved.declarationScalesJson;
+	} else if (opts.prefix) {
+		legacyPrefixedContextualVars = declaredNames;
+		contextualProperties = declaredNames.map((name) => `--${opts.prefix}-${name}`);
 		const prefixed = applyPrefix(opts.prefix, variableMapJson, variableCss, scalesJson, contextualVarsJson || void 0);
 		variableMapJson = prefixed.variableMapJson;
 		variableCss = prefixed.variableCss;
@@ -3010,6 +3936,7 @@ function loadSystemConfig(engineApi, opts) {
 		variableMapJson,
 		variableCss,
 		contextualVarsJson,
+		contextualProperties: [...new Set(contextualProperties)],
 		selectorAliasesJson: config.selectorAliases || null,
 		conditionAliasesJson: config.conditionAliases || null,
 		transformSourcesJson: config.transformSources || null,
@@ -3023,6 +3950,8 @@ function loadSystemConfig(engineApi, opts) {
 	if (declarationScalesJson) system.declarationScalesJson = declarationScalesJson;
 	if (config.propertyRecordsJson) system.propertyRecordsJson = config.propertyRecordsJson;
 	if (registrations.invalid.length > 0) system.invalidPropertyRegistrations = registrations.invalid;
+	if (prefixNameConflicts.length > 0) system.prefixNameConflicts = prefixNameConflicts;
+	if (legacyPrefixedContextualVars.length > 0) system.legacyPrefixedContextualVars = [...new Set(legacyPrefixedContextualVars)];
 	return system;
 }
 //#endregion
@@ -3033,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({
@@ -3042,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;
 }
@@ -3076,6 +4012,7 @@ function buildDynamicPropConfig(dynamicProps) {
 		if (meta.negative) entry.negative = true;
 		if (meta.strict) entry.strict = true;
 		if (meta.keywords?.length) entry.keywords = meta.keywords;
+		if (meta.currentVar) entry.currentVar = meta.currentVar;
 		configEntries[propName] = entry;
 	}
 	return configEntries;
@@ -3106,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");
@@ -3594,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() {
@@ -3630,6 +4391,12 @@ Object.defineProperty(exports, "firstOwners", {
 		return firstOwners;
 	}
 });
+Object.defineProperty(exports, "generatedModuleCode", {
+	enumerable: true,
+	get: function() {
+		return generatedModuleCode;
+	}
+});
 Object.defineProperty(exports, "hashReplacementPlans", {
 	enumerable: true,
 	get: function() {
@@ -3648,6 +4415,12 @@ Object.defineProperty(exports, "isAdvisorySourceDiagnostic", {
 		return isAdvisorySourceDiagnostic;
 	}
 });
+Object.defineProperty(exports, "isDeletedSource", {
+	enumerable: true,
+	get: function() {
+		return isDeletedSource;
+	}
+});
 Object.defineProperty(exports, "isEngineTransformExtension", {
 	enumerable: true,
 	get: function() {
@@ -3660,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() {
@@ -3678,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() {