@animus-ui/extract 0.1.18 → 0.1.20

package/dist/{pipeline-Dr-I4Xhl.mjs → pipeline-6wmD00rr.mjs}

@@ -7,7 +7,7 @@ import { realpathSync as realpathSync$1 } from "node:fs";
 import { createRequire as createRequire$1 } from "module";
 import browserslist from "browserslist";
 import { browserslistToTargets, transform } from "lightningcss";
-import { isUnitlessProperty } from "@animus-ui/properties";
+import { dependsOnContext, foldInitialValue, isUnitlessProperty, substitutesValue } from "@animus-ui/properties";
 //#region \0rolldown/runtime.js
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
@@ -85,7 +85,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
@@ -105,6 +106,224 @@ 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";
+/** 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)
+	};
+}
+/** 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, so whether it is cyclic depends on the browser. */
+const PROPERTY_FALLBACK_SELF_REFERENCE = "animus.property.fallback-self-reference";
+/** 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";
+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_SELF_REFERENCE, "warn"],
+	[PROPERTY_FALLBACK_SELF_REFERENCE, "warn"],
+	[PREFIX_CONTEXTUAL_VARS_UNPREFIXED, "warn"],
+	[PREFIX_NAME_CONFLICT, "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
+	];
+}
+/**
+* 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
@@ -1029,7 +1248,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()
 	};
 }
 /**
@@ -1069,11 +1289,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();
@@ -1108,7 +1329,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);
@@ -1135,6 +1356,7 @@ function createV2EngineApi(deps) {
 					transformSourcesJson: transformSourcesJson ?? void 0,
 					transformProvenanceJson: transformProvenanceJson ?? void 0,
 					declarationScalesJson,
+					analysisContextJson,
 					devMode
 				};
 				const engine = new native.ExtractEngine(config);
@@ -1166,7 +1388,7 @@ function createV2EngineApi(deps) {
 }
 //#endregion
 //#region pipeline/engine-retirement.ts
-const RETIRED_ENGINE_MESSAGE = "animus: extraction engine 'v1' was retired (openspec: retire-extract-v1) — v2 is the only engine; remove the engine option / ANIMUS_ENGINE override";
+const RETIRED_ENGINE_MESSAGE = "animus: the 'v1' extraction engine is no longer supported, and v2 is the only engine. Remove the engine option from your Animus config and unset the ANIMUS_ENGINE environment variable.";
 function assertNoRetiredEngineSelection(engineOption) {
 	if (engineOption === "v1" || process.env.ANIMUS_ENGINE === "v1") throw new Error(RETIRED_ENGINE_MESSAGE);
 }
@@ -1207,6 +1429,7 @@ const CORE_OPTION_KEYS = /* @__PURE__ */ new Set([
 	"strict",
 	"verbose",
 	"prefix",
+	"prefixContextualVars",
 	"targets",
 	"minify",
 	"staticCss",
@@ -1300,6 +1523,11 @@ const CORE_VALUE_GATES = [
 		ok: isString,
 		expected: "a string"
 	},
+	{
+		key: "prefixContextualVars",
+		ok: isBoolean,
+		expected: "a boolean"
+	},
 	{
 		key: "targets",
 		ok: isStringOrStringArray,
@@ -1998,31 +2226,148 @@ 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$1(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$1(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$1(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),
+		...findAssetSpecifiers(sheets.globalCss),
+		...findAssetSpecifiers(sheets.componentCss)
+	])];
+}
+/** The one substitution step every emitted sheet passes through. */
+function substituteSheetAssets(sheets, urlBySpecifier) {
+	return {
+		variableCss: substituteAssetPlaceholders(sheets.variableCss, urlBySpecifier),
+		globalCss: substituteAssetPlaceholders(sheets.globalCss, urlBySpecifier),
+		componentCss: substituteAssetPlaceholders(sheets.componentCss, urlBySpecifier)
+	};
+}
+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 = placeholdersInAssetCalls(css);
+	if (specifiers.length === 0) return;
+	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
 /**
@@ -2246,160 +2591,505 @@ 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;
+//#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
+		}))
+	};
 }
-/** 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;
+const NAME_CHAR = /[\w-]/;
+/**
+* The name starting at `from`, read as CSS tokenizes an identifier: ASCII
+* letters, digits, `-` and `_`, every non-ASCII code point, and escapes.
+*/
+function readCustomPropertyName(css, from) {
+	let end = from;
+	let name = "";
+	while (end < css.length) {
+		if (isNameChar(css[end])) {
+			name += css[end];
+			end += 1;
 			continue;
 		}
-		if (quote !== null) {
-			if (c === quote) quote = null;
-		} else if (c === "\"" || c === "'") quote = c;
-		else if (c === "&") return true;
+		const escape = escapeAt(css, end);
+		if (escape === null) break;
+		name += escape.codePoint;
+		end += escape.length;
 	}
-	return false;
+	return {
+		end,
+		name
+	};
+}
+/** A valid escape at `at`: up to six hex digits and one following
+*  whitespace, or any other code point but a newline. */
+function escapeAt(css, at) {
+	if (css[at] !== "\\") return null;
+	const next = css.codePointAt(at + 1);
+	if (next === void 0 || next === 10 || next === 13 || next === 12) return null;
+	const digits = /^[0-9a-fA-F]{1,6}/.exec(css.slice(at + 1, at + 7))?.[0];
+	if (digits === void 0) return {
+		codePoint: String.fromCodePoint(next),
+		length: 1 + String.fromCodePoint(next).length
+	};
+	const after = css.slice(at + 1 + digits.length);
+	const space = after.startsWith("\r\n") ? 2 : /^[ \t\n\r\f]/.test(after) ? 1 : 0;
+	const value = parseInt(digits, 16);
+	const valid = value !== 0 && value <= 1114111 && (value < 55296 || value > 57343);
+	return {
+		codePoint: String.fromCodePoint(valid ? value : 65533),
+		length: 1 + digits.length + space
+	};
 }
 /**
-* Coded diagnostics for selector-shaped alias values with no substitutable
-* subject; alias values never reach the evaluator's own key guard.
+* Gives every custom-property token that names a managed property its final
+* name, in one pass: declaration keys, `var()` reads at any depth (fallbacks
+* included), `@property` names, transition-property lists and style queries.
+* A name is read whole, escapes decoded, so an undeclared name that starts
+* with a managed one is never renamed in part. Quoted strings, `url()` and
+* comments are copied unchanged.
 */
-function 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;
+function renameCustomProperties(css, names) {
+	let out = "";
+	let i = 0;
+	while (i < css.length) {
+		const c = css[i];
+		if (c === "\"" || c === "'") {
+			const end = closingQuote$1(css, i);
+			out += css.slice(i, end);
+			i = end;
+		} else if (css.startsWith("/*", i)) {
+			const close = css.indexOf("*/", i + 2);
+			const end = close === -1 ? css.length : close + 2;
+			out += css.slice(i, end);
+			i = end;
+		} else if (/^url\(/i.test(css.slice(i, i + 4)) && !isNameChar(css[i - 1])) {
+			const end = closingUrl(css, i + 4);
+			out += css.slice(i, end);
+			i = end;
+		} else if (css.startsWith("--", i) && !isNameChar(css[i - 1])) {
+			const { end, name } = readCustomPropertyName(css, i + 2);
+			const identity = names.identity(name);
+			const final = identity === void 0 ? void 0 : names.finalName(identity);
+			out += final === void 0 ? css.slice(i, end) : `--${final}`;
+			i = end;
+		} else {
+			out += c;
+			i += 1;
+		}
+	}
+	return out;
 }
-const UNREADABLE_SOURCE_FILE = "animus.ingestion.unreadable-source-file";
+/** A name code point, or a UTF-16 unit of a non-ASCII one. */
+function isNameChar(c) {
+	return c !== void 0 && (NAME_CHAR.test(c) || c.charCodeAt(0) >= 128);
+}
+function closingQuote$1(css, open) {
+	const quote = css[open];
+	let i = open + 1;
+	while (i < css.length && css[i] !== quote) i += css[i] === "\\" ? 2 : 1;
+	return Math.min(i + 1, css.length);
+}
+/** The index after the `)` that closes an unquoted or quoted `url(`. */
+function closingUrl(css, from) {
+	let i = from;
+	while (i < css.length && css[i] !== ")") i = css[i] === "\"" || css[i] === "'" ? closingQuote$1(css, i) : i + 1;
+	return Math.min(i + 1, css.length);
+}
+//#endregion
+//#region pipeline/property-registrations.ts
+const PROPERTY_RULE = /@property\s+(--[\w-]+)\s*\{[^}]*\}\n?/g;
+/** The data types a registration's `syntax` may name. */
+const SYNTAX_TYPES = /* @__PURE__ */ new Set([
+	"angle",
+	"color",
+	"custom-ident",
+	"image",
+	"integer",
+	"length",
+	"length-percentage",
+	"number",
+	"percentage",
+	"resolution",
+	"string",
+	"time",
+	"transform-function",
+	"transform-list",
+	"url"
+]);
+const SYNTAX_COMPONENT = /^(?:<([a-z-]+)>[+#]?|-?[a-zA-Z_][\w-]*)$/;
+const INITIAL_VALUE = /(initial-value\s*:\s*)([^;}]*)/;
+const MATH_FUNCTION = /\b(?:calc|min|max|clamp)\(/i;
 /**
-* A configured source file that could not be read is a LOST INPUT: the
-* emitted artifacts silently lack whatever that file declared.
+* Removes the `@property` rules browsers would ignore — an unknown syntax
+* component, a syntax other than `*` without an initial value, an initial
+* value that substitutes another value or depends on context, or one the
+* syntax does not accept. Minifying a stylesheet that contains such a rule
+* can also fail. An all-absolute math initial value is written as its
+* computed value, which the minifier reads.
 */
-function unreadableSourceDiagnostic(relPath, error) {
+function splitInvalidPropertyRegistrations(css) {
+	const invalid = [];
 	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)
+		css: css.replace(PROPERTY_RULE, (rule, name) => {
+			const checked = checkRegistration(rule);
+			if ("rule" in checked) return checked.rule;
+			invalid.push({
+				name,
+				reason: checked.reason
+			});
+			return "";
+		}),
+		invalid
 	};
 }
-/** 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";
-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"]
-]);
-/** 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 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]));
+	return registrations;
 }
-/**
-* 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;
+function readRegistration(rule) {
+	return {
+		syntax: /syntax:\s*"([^"]*)"/.exec(rule)?.[1]?.trim() ?? "",
+		initialValue: /initial-value\s*:\s*([^;}]*)/.exec(rule)?.[1]?.trim()
+	};
 }
-/** 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 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 && substitutesValue(initialValue)) return { reason: `initialValue "${initialValue}" substitutes another value; var(), env() and attr() are not allowed in an initial value` };
+	let kept = rule;
+	if (syntax !== "*") {
+		const unknown = syntax.split("|").map((component) => ({
+			text: component.trim(),
+			match: SYNTAX_COMPONENT.exec(component.trim())
+		})).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 (dependsOnContext(initialValue)) return { reason: `initialValue "${initialValue}" depends on context; font- and container-relative units are not allowed` };
+		const folded = foldInitialValue(syntax, initialValue);
+		if (folded !== void 0 && !folded.accepted) return { reason: `initialValue "${initialValue}" computes to the ${folded.type} ${folded.text}, which syntax "${syntax}" does not accept` };
+		if (folded !== void 0) kept = rule.replace(INITIAL_VALUE, `$1${folded.text}`);
+	}
+	try {
+		transform({
+			filename: "animus-registrations.css",
+			code: Buffer.from(kept)
+		});
+		return { rule: kept };
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		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
 /**
-* The single strict-escalation policy point for both extraction plugins:
-* error-severity diagnostics throw together under `strict`, else warn.
+* Reports custom properties that will not behave as their CSS suggests: a
+* property that refers to itself, a fallback a registered initial value
+* applies ahead of, and an animated property that cannot interpolate. Names
+* are read as CSS tokenizes them, so escapes, function case, comments and
+* quoted text match the prefix pass. The CSS itself is never changed.
 */
-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.file}: ${diagnostic.component}: ${diagnostic.message}`;
-		if (line === null) continue;
-		if (diagnostic.code && !diagnostic.message.includes(diagnostic.code)) line += ` [${diagnostic.code}]`;
-		if (policy.strict && diagnostic.severity === "error") {
-			errors.push(`${diagnostic.code ?? "error"} — ${diagnostic.component}: ${diagnostic.message}`);
+function checkCustomProperties(input) {
+	const registered = propertyRegistrations(input.system.variableCss);
+	const declared = new Set(input.system.contextualProperties ?? []);
+	const findings = [];
+	const sheets = [{
+		css: input.componentCss,
+		owner: componentOwner(input.manifest)
+	}, {
+		css: input.globalCss,
+		owner: globalOwner
+	}];
+	for (const { css, owner } of sheets) {
+		if (!/var\(|transition|@keyframes/i.test(css)) 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 declaration of parsed) {
+			const found = (code, property, message) => findings.push({
+				code,
+				property,
+				message,
+				owner: owner(declaration)
+			});
+			if (isSelfReference(declaration)) {
+				found(PROPERTY_SELF_REFERENCE, declaration.property, `${declaration.property} resolves to var(${declaration.property}), a reference to itself, so it is invalid at computed-value time. Give it a value other than its own name`);
+				continue;
+			}
+			if (readsItselfOnlyInFallback(declaration)) found(PROPERTY_FALLBACK_SELF_REFERENCE, declaration.property, `${declaration.property}: ${declaration.value} reads ${declaration.property} only inside another var()'s fallback, so the result depends on how the browser treats fallback references: one that evaluates a fallback only when it is used keeps the value, one that counts every reference makes ${declaration.property} cyclic and invalid at computed-value time`);
+			for (const read of varReads(declaration.value)) {
+				const registration = registered.get(read.name);
+				if (read.fallback === void 0 || registration?.initialValue === void 0) continue;
+				const chain = read.fallback.startsWith("var(");
+				found(chain ? PROPERTY_FALLBACK_CHAIN_SUPPRESSED : PROPERTY_FALLBACK_SUPPRESSED, read.name, `var(${read.name}, ${read.fallback}): where its registration applies, ${read.name}'s initial-value ${registration.initialValue} is used ahead of the ${chain ? "fallback chain" : "fallback"} whenever ${read.name} is unset; the fallback still serves browsers without the registration`);
+			}
+			for (const animated of animatedProperties(declaration, discreteRules)) {
+				if (animated.discrete || !declared.has(animated.name)) continue;
+				const reason = interpolationGap(registered.get(animated.name));
+				if (reason === null) continue;
+				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);
+}
+/** 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)
+		});
+	};
+	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;
 		}
-		warn(line);
+		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
+			});
+			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;
+		}
+	}
+	return found;
+}
+/** `text` as a whole custom-property name, escapes decoded; `undefined`
+*  when it is not one. */
+function customPropertyName(text) {
+	if (!text.startsWith("--")) return void 0;
+	const { end, name } = readCustomPropertyName(text, 2);
+	return end === text.length ? `--${name}` : void 0;
+}
+function isSelfReference(declaration) {
+	const property = customPropertyName(declaration.property);
+	const reads = varReads(declaration.value);
+	return property !== void 0 && reads.length === 1 && reads[0].name === property && reads[0].fallback === void 0 && withoutComments(declaration.value).trim() === withoutComments(declaration.value.slice(reads[0].start, reads[0].end)).trim();
+}
+/** Whether every read of the declared property sits inside another read's
+*  fallback, as in `--a: var(--b, var(--a))`. */
+function readsItselfOnlyInFallback(declaration) {
+	const property = customPropertyName(declaration.property);
+	if (property === void 0) return false;
+	const reads = varReads(declaration.value);
+	const own = reads.filter((read) => read.name === property);
+	return own.length > 0 && own.every((read) => reads.some((outer) => outer !== read && outer.start < read.start && read.end <= outer.end));
+}
+/** Every `var()` read in `value`, nested fallbacks included, in any case
+*  and spacing. Quoted text and comments hold none. */
+function varReads(value) {
+	const reads = [];
+	for (let at = 0; at < value.length;) {
+		const c = value[at];
+		if (c === "\"" || c === "'") {
+			at = closingQuote(value, at);
+			continue;
+		}
+		if (value.startsWith("/*", at)) {
+			at = skipSpace(value, at);
+			continue;
+		}
+		if (value.slice(at, at + 4).toLowerCase() !== "var(" || /[\w-]/.test(value[at - 1] ?? "")) {
+			at += 1;
+			continue;
+		}
+		const nameAt = skipSpace(value, at + 4);
+		if (!value.startsWith("--", nameAt)) {
+			at += 4;
+			continue;
+		}
+		const { end: nameEnd, name } = readCustomPropertyName(value, nameAt + 2);
+		const after = skipSpace(value, nameEnd);
+		const close = closingParen(value, at + 4);
+		reads.push({
+			name: `--${name}`,
+			fallback: value[after] === "," ? value.slice(after + 1, close - 1).trim() : void 0,
+			start: at,
+			end: close
+		});
+		at = after;
+	}
+	return reads;
+}
+/** The index after the `)` that closes the call whose arguments start at
+*  `from`. Quoted text and comments are skipped. */
+function closingParen(value, from) {
+	let depth = 1;
+	let at = from;
+	while (at < value.length && depth > 0) {
+		const c = value[at];
+		if (c === "\"" || c === "'") at = closingQuote(value, at);
+		else if (value.startsWith("/*", at)) at = skipSpace(value, at);
+		else {
+			if (c === "(") depth += 1;
+			else if (c === ")") depth -= 1;
+			at += 1;
+		}
+	}
+	return at;
+}
+function closingQuote(value, open) {
+	let at = open + 1;
+	while (at < value.length && value[at] !== value[open]) at += value[at] === "\\" ? 2 : 1;
+	return Math.min(at + 1, value.length);
+}
+/** The index after CSS whitespace and comments starting at `from`. */
+function skipSpace(value, from) {
+	let at = from;
+	for (;;) {
+		while (/[ \t\n\r\f]/.test(value[at] ?? "")) at += 1;
+		if (!value.startsWith("/*", at)) return at;
+		const close = value.indexOf("*/", at + 2);
+		at = close === -1 ? value.length : close + 2;
+	}
+}
+function withoutComments(text) {
+	return text.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+/** Custom properties this declaration sets in a keyframe or names in a
+*  transition. */
+function animatedProperties(declaration, discreteRules) {
+	const keyframes = declaration.context.find((prelude) => prelude.startsWith("@keyframes"));
+	const set = customPropertyName(declaration.property);
+	if (keyframes !== void 0 && set !== void 0) return [{
+		name: set,
+		how: `set in ${keyframes}`,
+		discrete: false
+	}];
+	if (declaration.property !== "transition" && declaration.property !== "transition-property") return [];
+	return topLevelItems(declaration.value).flatMap((item) => {
+		const property = topLevelTokens(item.replace(/\/\*[\s\S]*?\*\//g, " ")).map(customPropertyName).find((name) => name !== void 0);
+		return property !== void 0 ? [{
+			name: property,
+			how: "transitioned",
+			discrete: /\ballow-discrete\b/.test(item) || discreteRules.has(declaration.rule)
+		}] : [];
+	});
+}
+/** The whitespace-separated tokens of `item` outside any parentheses. */
+function topLevelTokens(item) {
+	const tokens = [];
+	let depth = 0;
+	let token = "";
+	for (const c of item) {
+		if (c === "(") depth += 1;
+		else if (c === ")") depth -= 1;
+		if (depth === 0 && /\s/.test(c)) {
+			if (token) tokens.push(token);
+			token = "";
+		} else token += c;
+	}
+	if (token) tokens.push(token);
+	return tokens;
+}
+function topLevelItems(value) {
+	const items = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < value.length; i += 1) if (value[i] === "(") depth += 1;
+	else if (value[i] === ")") depth -= 1;
+	else if (value[i] === "," && depth === 0) {
+		items.push(value.slice(start, i));
+		start = i + 1;
+	}
+	items.push(value.slice(start));
+	return items;
+}
+/** Why a property cannot interpolate, or `null` when it can. */
+function interpolationGap(registration) {
+	if (registration === void 0) return "it is not registered";
+	if (registration.syntax === "*") return "it is registered with the universal syntax \"*\"";
+	return null;
+}
+function componentOwner(manifest) {
+	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) ?? [];
+		for (const dotted of classes) {
+			const name = dotted.slice(1);
+			const owner = components.find((component) => name === component.class_name || name.startsWith(`${component.class_name}--`) || component.replacement.includes(`"${name}"`));
+			if (owner) return {
+				file: owner.file,
+				component: owner.binding
+			};
+		}
+		return {
+			file: "styles",
+			component: selector ?? "stylesheet"
+		};
+	};
+}
+function globalOwner(declaration) {
+	const keyframes = declaration.context.find((prelude) => prelude.startsWith("@keyframes"));
+	const selector = [...declaration.context].reverse().find((prelude) => !prelude.startsWith("@"));
+	return {
+		file: "system",
+		component: keyframes ?? selector ?? "global styles"
+	};
+}
+/** One diagnostic per code, property and owner. */
+function toDiagnostics(findings) {
+	const seen = /* @__PURE__ */ new Set();
+	const diagnostics = [];
+	for (const finding of findings) {
+		const key = `${finding.code}|${finding.property}|${finding.owner.file}|${finding.owner.component}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		diagnostics.push({
+			file: finding.owner.file,
+			component: finding.owner.component,
+			kind: "warn",
+			message: `${finding.message} (${finding.code})`,
+			code: finding.code,
+			severity: severityFor(finding.code)
+		});
 	}
-	if (errors.length > 0) throw new Error(`[animus] strict: ${errors.length} error diagnostic(s):\n${errors.join("\n")}`);
+	return diagnostics;
 }
 //#endregion
 //#region pipeline/unit-fallback.ts
@@ -2478,12 +3168,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).
@@ -2498,11 +3209,21 @@ 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,
+		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 ?? []
 		]
 	});
@@ -2511,7 +3232,7 @@ function runProjectAnalysis(engineApi, opts) {
 		manifest,
 		manifestJson,
 		globalCss: manifest.sheets.global,
-		componentCss: applyUnitFallback(manifest.css),
+		componentCss,
 		inputs,
 		timings: {
 			serializeMs,
@@ -2596,87 +3317,60 @@ function applyPrefix(prefix, variableMapJson, variableCss, themeJson, contextual
 	}
 	return result;
 }
-//#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",
-	"color",
-	"custom-ident",
-	"image",
-	"integer",
-	"length",
-	"length-percentage",
-	"number",
-	"percentage",
-	"resolution",
-	"string",
-	"time",
-	"transform-function",
-	"transform-list",
-	"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;
+/** The runtime's transport variables are `--animus-<prop>`. */
+const TRANSPORT_NAMESPACE = "animus-";
 /**
-* 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.
+* 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 splitInvalidPropertyRegistrations(css) {
-	const invalid = [];
+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 {
-		css: css.replace(PROPERTY_RULE, (rule, name) => {
-			const reason = registrationFailure(rule);
-			if (reason === null) return rule;
-			invalid.push({
-				name,
-				reason
-			});
-			return "";
-		}),
-		invalid
+		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}`)
 	};
 }
-function registrationFailure(rule) {
-	const syntax = /syntax:\s*"([^"]*)"/.exec(rule)?.[1]?.trim() ?? "";
-	const initialValue = /initial-value\s*:\s*([^;}]*)/.exec(rule)?.[1]?.trim();
-	if (syntax !== "*") {
-		const components = 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`;
-	}
-	try {
-		transform({
-			filename: "animus-registrations.css",
-			code: Buffer.from(rule)
-		});
-		return null;
-	} catch (error) {
-		const detail = error instanceof Error ? error.message : String(error);
-		return `the CSS parser rejects \`${rule.trim()}\` (${detail})`;
-	}
+/** 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
@@ -2693,7 +3387,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;
@@ -2708,6 +3423,7 @@ function loadSystemConfig(engineApi, opts) {
 		variableMapJson,
 		variableCss,
 		contextualVarsJson,
+		contextualProperties: [...new Set(contextualProperties)],
 		selectorAliasesJson: config.selectorAliases || null,
 		conditionAliasesJson: config.conditionAliases || null,
 		transformSourcesJson: config.transformSources || null,
@@ -2719,7 +3435,10 @@ function loadSystemConfig(engineApi, opts) {
 		sourceThemeManifestsJson: config.sourceThemeManifests || null
 	};
 	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
@@ -2773,6 +3492,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;
@@ -2803,31 +3523,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/timing-waterfall.ts
-const RUST_TIMING_PHASES = [
-	["parseAndWalk", "parse+walk"],
-	["importResolution", "imports"],
-	["extensionProvenance", "provenance"],
-	["topologicalSort", "topo-sort"],
-	["chainEvaluation", "chains"],
-	["jsxScanning", "jsx-scan"],
-	["systemPropAggregation", "sys-props"],
-	["usageLedger", "usage"],
-	["reconciliation", "reconcile"],
-	["cssGeneration", "css-gen"],
-	["manifestSerialization", "serialize"]
-];
-function formatRustTimingWaterfall(timing, opts) {
-	const lines = [];
-	for (const [key, label] of RUST_TIMING_PHASES) {
-		const ms = timing[key] ?? 0;
-		const pad = " ".repeat(Math.max(0, opts.labelWidth - label.length));
-		const extra = key === "parseAndWalk" ? `  (${timing.fileCount ?? 0} files, ${timing.cacheHits ?? 0} cached)` : "";
-		lines.push(`${opts.indent}${label}${pad}${String(ms).padStart(5)}ms${extra}`);
-	}
-	return lines;
-}
-//#endregion
 //#region pipeline/tsconfig-paths.ts
 /**
 * tsconfig `paths` → alias pairs, for drivers with no live bundler config.
@@ -3094,4 +3789,4 @@ function realpathThroughNearestExistingAncestor(path) {
 	}
 }
 //#endregion
-export { AnimusConfigError as $, resolveLightningTargets as A, extractSystemFilePackages as B, isUnresolvedParentDrop as C, ANIMUS_LAYERS as Ct, unresolvedParentName as D, __require as Dt, unreadableSourceDiagnostic as E, validateLayerOrder as Et, findAssetSpecifiers as F, staleDistIncludesMessage as G, firstOwners as H, substituteAssetPlaceholders as I, createSourceIdentity as J, unresolvableIncludesMessage as K, createSourceCorpus as L, enforceExternalTokenContracts as M, resolveAssetFile as N, vocabularyWitnessDiagnostics as O, resolveThroughPathAliases as P, discoverFiles as Q, collectExternalPackageSources as R, VOCABULARY_LEGACY_VERB as S, buildAnalyzeProjectArgs as St, systemLoadDiagnostics as T, stripLeadingLayerDeclaration as Tt, isExcludedPackageRelativePath as U, findPackageRoot as V, resolveAbsolutePathSpecifier as W, sharesVolumeRoot as X, isPathWithinRoot as Y, compareDiscoveryOrder as Z, clearEngineCache as _, DEFAULT_EXTENSIONS as _t, assertNoErrorDiagnostics as a, assertKnownOptionKeys as at, INVALID_PROPERTY_REGISTRATION as b, preprocessMdx as bt, buildSystemPropsModule as c, resolveVerbosity as ct, loadSystemConfig as d, createV2EngineApi as dt, CORE_OPTION_KEYS as et, applyPrefix as f, ingestSourceEntries as ft, buildAnalysisInputs as g, adaptSvelteSource as gt, stableStringify as h, projectExternalFileOwners as ht, snapshotFilePlans as i, STRUCTURAL_EXCLUDE as it, buildPathAliasesJson as j, postProcessCss as k, buildDynamicPropConfig as l, RETIRED_ENGINE_MESSAGE as lt, camelToKebab as m, parseFilesJson as mt, diffFilePlans as n, DRIVER_NAMESPACES as nt, readTsconfigAliasPairs as o, createExcludeMatcher as ot, serializeStaticCss as p, isAdvisorySourceDiagnostic as pt, walkPackageSources as q, hashReplacementPlans as r, REPLACEABLE_DEFAULT_EXCLUDE as rt, formatRustTimingWaterfall as s, resolveMode as st, toWatchKeys as t, DEFAULT_EXCLUDE as tt, runStructuralSelfCheck as u, assertNoRetiredEngineSelection as ut, runProjectAnalysis as v, ENGINE_TRANSFORM_EXTENSIONS as vt, surfaceManifestDiagnostics as w, assembleStylesheet as wt, VOCABULARY_COLLISION as x, contentHash as xt, applyUnitFallback as y, isEngineTransformExtension as yt, excludeCollectedPackages as z };
+export { assertKnownOptionKeys as $, substituteSheetAssets as A, validateLayerOrder as At, unresolvableIncludesMessage as B, resolveAssetFile as C, unresolvedParentName as Ct, generatedModuleCode as D, ANIMUS_LAYERS as Dt, findSheetAssetSpecifiers as E, buildAnalyzeProjectArgs as Et, findPackageRoot as F, compareDiscoveryOrder as G, createSourceIdentity as H, firstOwners as I, CORE_OPTION_KEYS as J, discoverFiles as K, isExcludedPackageRelativePath as L, collectExternalPackageSources as M, excludeCollectedPackages as N, reportSurvivingAssetPlaceholders as O, assembleStylesheet as Ot, extractSystemFilePackages as P, STRUCTURAL_EXCLUDE as Q, resolveAbsolutePathSpecifier as R, enforceExternalTokenContracts as S, unreadableSourceDiagnostic as St, findAssetSpecifiers as T, contentHash as Tt, isPathWithinRoot as U, walkPackageSources as V, sharesVolumeRoot as W, DRIVER_NAMESPACES as X, DEFAULT_EXCLUDE as Y, REPLACEABLE_DEFAULT_EXCLUDE as Z, runProjectAnalysis as _, VOCABULARY_LEGACY_VERB as _t, assertNoErrorDiagnostics as a, createV2EngineApi as at, resolveLightningTargets as b, surfaceManifestDiagnostics as bt, buildDynamicPropConfig as c, parseFilesJson as ct, applyPrefix as d, DEFAULT_EXTENSIONS as dt, createExcludeMatcher as et, serializeStaticCss as f, ENGINE_TRANSFORM_EXTENSIONS as ft, clearEngineCache as g, VOCABULARY_COLLISION as gt, buildAnalysisInputs as h, INVALID_PROPERTY_REGISTRATION as ht, snapshotFilePlans as i, assertNoRetiredEngineSelection as it, createSourceCorpus as j, __require as jt, substituteAssetPlaceholders as k, stripLeadingLayerDeclaration as kt, runStructuralSelfCheck as l, projectExternalFileOwners as lt, stableStringify as m, preprocessMdx as mt, diffFilePlans as n, resolveVerbosity as nt, readTsconfigAliasPairs as o, ingestSourceEntries as ot, camelToKebab as p, isEngineTransformExtension as pt, AnimusConfigError as q, hashReplacementPlans as r, RETIRED_ENGINE_MESSAGE as rt, buildSystemPropsModule as s, isAdvisorySourceDiagnostic as st, toWatchKeys as t, resolveMode as tt, loadSystemConfig as u, adaptSvelteSource as ut, applyUnitFallback as v, isDeletedSource as vt, resolveThroughPathAliases as w, vocabularyWitnessDiagnostics as wt, buildPathAliasesJson as x, systemLoadDiagnostics as xt, postProcessCss as y, isUnresolvedParentDrop as yt, staleDistIncludesMessage as z };