@animus-ui/extract 0.1.18 → 0.1.20

package/dist/{pipeline-OKnmnyFu.cjs → pipeline-A54wEQEg.cjs}

@@ -105,7 +105,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 +126,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
@@ -1049,7 +1268,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 +1309,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 +1349,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 +1376,7 @@ function createV2EngineApi(deps) {
 					transformSourcesJson: transformSourcesJson ?? void 0,
 					transformProvenanceJson: transformProvenanceJson ?? void 0,
 					declarationScalesJson,
+					analysisContextJson,
 					devMode
 				};
 				const engine = new native.ExtractEngine(config);
@@ -1186,7 +1408,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);
 }
@@ -1227,6 +1449,7 @@ const CORE_OPTION_KEYS = /* @__PURE__ */ new Set([
 	"strict",
 	"verbose",
 	"prefix",
+	"prefixContextualVars",
 	"targets",
 	"minify",
 	"staticCss",
@@ -1320,6 +1543,11 @@ const CORE_VALUE_GATES = [
 		ok: isString,
 		expected: "a string"
 	},
+	{
+		key: "prefixContextualVars",
+		ok: isBoolean,
+		expected: "a boolean"
+	},
 	{
 		key: "targets",
 		ok: isStringOrStringArray,
@@ -2018,31 +2246,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
 /**
@@ -2266,160 +2611,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 && (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;
+	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 ((0, _animus_ui_properties.dependsOnContext)(initialValue)) return { reason: `initialValue "${initialValue}" depends on context; font- and container-relative units are not allowed` };
+		const folded = (0, _animus_ui_properties.foldInitialValue)(syntax, initialValue);
+		if (folded !== void 0 && !folded.accepted) return { reason: `initialValue "${initialValue}" computes to the ${folded.type} ${folded.text}, which syntax "${syntax}" does not accept` };
+		if (folded !== void 0) kept = rule.replace(INITIAL_VALUE, `$1${folded.text}`);
+	}
+	try {
+		(0, lightningcss.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;
+		}
 	}
-	if (errors.length > 0) throw new Error(`[animus] strict: ${errors.length} error diagnostic(s):\n${errors.join("\n")}`);
+	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)
+		});
+	}
+	return diagnostics;
 }
 //#endregion
 //#region pipeline/unit-fallback.ts
@@ -2498,12 +3188,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).
@@ -2518,11 +3229,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 ?? []
 		]
 	});
@@ -2531,7 +3252,7 @@ function runProjectAnalysis(engineApi, opts) {
 		manifest,
 		manifestJson,
 		globalCss: manifest.sheets.global,
-		componentCss: applyUnitFallback(manifest.css),
+		componentCss,
 		inputs,
 		timings: {
 			serializeMs,
@@ -2616,87 +3337,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 {
-		(0, lightningcss.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
@@ -2713,7 +3407,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;
@@ -2728,6 +3443,7 @@ function loadSystemConfig(engineApi, opts) {
 		variableMapJson,
 		variableCss,
 		contextualVarsJson,
+		contextualProperties: [...new Set(contextualProperties)],
 		selectorAliasesJson: config.selectorAliases || null,
 		conditionAliasesJson: config.conditionAliases || null,
 		transformSourcesJson: config.transformSources || null,
@@ -2739,7 +3455,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
@@ -2793,6 +3512,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;
@@ -2823,31 +3543,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.
@@ -3360,16 +4055,22 @@ Object.defineProperty(exports, "findPackageRoot", {
 		return findPackageRoot;
 	}
 });
+Object.defineProperty(exports, "findSheetAssetSpecifiers", {
+	enumerable: true,
+	get: function() {
+		return findSheetAssetSpecifiers;
+	}
+});
 Object.defineProperty(exports, "firstOwners", {
 	enumerable: true,
 	get: function() {
 		return firstOwners;
 	}
 });
-Object.defineProperty(exports, "formatRustTimingWaterfall", {
+Object.defineProperty(exports, "generatedModuleCode", {
 	enumerable: true,
 	get: function() {
-		return formatRustTimingWaterfall;
+		return generatedModuleCode;
 	}
 });
 Object.defineProperty(exports, "hashReplacementPlans", {
@@ -3390,6 +4091,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() {
@@ -3450,6 +4157,12 @@ Object.defineProperty(exports, "readTsconfigAliasPairs", {
 		return readTsconfigAliasPairs;
 	}
 });
+Object.defineProperty(exports, "reportSurvivingAssetPlaceholders", {
+	enumerable: true,
+	get: function() {
+		return reportSurvivingAssetPlaceholders;
+	}
+});
 Object.defineProperty(exports, "resolveAbsolutePathSpecifier", {
 	enumerable: true,
 	get: function() {
@@ -3540,6 +4253,12 @@ Object.defineProperty(exports, "substituteAssetPlaceholders", {
 		return substituteAssetPlaceholders;
 	}
 });
+Object.defineProperty(exports, "substituteSheetAssets", {
+	enumerable: true,
+	get: function() {
+		return substituteSheetAssets;
+	}
+});
 Object.defineProperty(exports, "surfaceManifestDiagnostics", {
 	enumerable: true,
 	get: function() {