@animus-ui/extract 0.1.22 → 0.1.24

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

@@ -31,6 +31,8 @@ let browserslist = require("browserslist");
 browserslist = __toESM(browserslist);
 let lightningcss = require("lightningcss");
 let _animus_ui_properties = require("@animus-ui/properties");
+let node_child_process = require("node:child_process");
+let node_module = require("node:module");
 //#region pipeline/assemble-stylesheet.ts
 /**
 * The cascade layer order, outermost first: its one definition. The engine
@@ -110,8 +112,13 @@ function buildAnalyzeProjectArgs(inputs) {
 		inputs.transformSourcesJson,
 		inputs.transformProvenanceJson ?? null
 	];
-	if (inputs.declarationScalesJson || inputs.analysisContextJson) args.push(inputs.declarationScalesJson);
-	if (inputs.analysisContextJson) args.push(inputs.analysisContextJson);
+	const tail = [
+		inputs.declarationScalesJson,
+		inputs.analysisContextJson,
+		inputs.generatedNamesJson
+	];
+	const last = tail.findLastIndex((slot) => slot !== void 0 && slot !== "");
+	for (const slot of tail.slice(0, last + 1)) args.push(slot || void 0);
 	return args;
 }
 //#endregion
@@ -131,7 +138,180 @@ function parseInternalWire(json, wire) {
 	return parsed;
 }
 //#endregion
+//#region pipeline/asset-placeholders.ts
+const ASSET_PLACEHOLDER_PREFIX = "animus-asset:";
+const URL_OPEN_RE = /url\(\s*(['"]?)/gi;
+const IMAGE_SET_OPEN_RE = /(?:-webkit-)?image-set\(/gi;
+const BARE_SPECIFIER_RE = /^[^'")\s]+/;
+/** The index of the `)` that closes the `(` at `open`, outside strings. */
+function closingParen(css, open) {
+	let depth = 0;
+	let quote = null;
+	for (let i = open; i < css.length; i += 1) {
+		const c = css[i];
+		if (quote !== null) {
+			if (c === quote) quote = null;
+		} else if (c === "\"" || c === "'") quote = c;
+		else if (c === "(") depth += 1;
+		else if (c === ")") {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return css.length;
+}
+function quotedReference(css, quoteAt) {
+	const start = quoteAt + 1;
+	if (!css.startsWith("animus-asset:", start)) return null;
+	const end = css.indexOf(css[quoteAt], start);
+	if (end === -1) return null;
+	return {
+		start,
+		end,
+		specifier: css.slice(start + 13, end)
+	};
+}
+function assetReferences(css) {
+	if (!css.includes("animus-asset:")) return [];
+	const references = [];
+	for (const open of css.matchAll(URL_OPEN_RE)) {
+		const at = (open.index ?? 0) + open[0].length;
+		if (open[1]) {
+			const reference = quotedReference(css, at - 1);
+			if (reference) references.push(reference);
+			continue;
+		}
+		if (!css.startsWith("animus-asset:", at)) continue;
+		const specifier = BARE_SPECIFIER_RE.exec(css.slice(at + 13))?.[0];
+		if (specifier === void 0) continue;
+		const end = at + 13 + specifier.length;
+		references.push({
+			start: at,
+			end,
+			specifier
+		});
+	}
+	for (const open of css.matchAll(IMAGE_SET_OPEN_RE)) {
+		const paren = (open.index ?? 0) + open[0].length - 1;
+		const close = closingParen(css, paren);
+		let depth = 0;
+		let candidateStart = true;
+		for (let i = paren + 1; i < close; i += 1) {
+			const c = css[i];
+			if (/\s/.test(c)) continue;
+			if (c === "\"" || c === "'") {
+				if (depth === 0 && candidateStart) {
+					const reference = quotedReference(css, i);
+					if (reference) references.push(reference);
+				}
+				const end = css.indexOf(c, i + 1);
+				i = end === -1 ? close : end;
+			} else if (c === "(") depth += 1;
+			else if (c === ")") depth -= 1;
+			else if (c === "," && depth === 0) {
+				candidateStart = true;
+				continue;
+			}
+			candidateStart = false;
+		}
+	}
+	return references.sort((a, b) => a.start - b.start);
+}
+function findAssetSpecifiers(css) {
+	return [...new Set(assetReferences(css).map((reference) => reference.specifier))];
+}
+function substituteAssetPlaceholders(css, urlBySpecifier) {
+	if (urlBySpecifier.size === 0) return css;
+	let out = css;
+	for (const reference of assetReferences(css).reverse()) {
+		const url = urlBySpecifier.get(reference.specifier);
+		if (url === void 0) continue;
+		out = out.slice(0, reference.start) + url + out.slice(reference.end);
+	}
+	return out;
+}
+/**
+* Specifiers of placeholder text anywhere inside a `url()` or `image-set()`
+* call, a reference or not: after substitution any of it is a broken load.
+*/
+function placeholdersInAssetCalls(css) {
+	if (!css.includes("animus-asset:")) return [];
+	const calls = [...css.matchAll(URL_OPEN_RE), ...css.matchAll(IMAGE_SET_OPEN_RE)].map((open) => {
+		const paren = css.indexOf("(", open.index ?? 0);
+		return [paren, closingParen(css, paren)];
+	});
+	const found = /* @__PURE__ */ new Set();
+	for (let at = css.indexOf(ASSET_PLACEHOLDER_PREFIX); at !== -1; at = css.indexOf(ASSET_PLACEHOLDER_PREFIX, at + 1)) {
+		if (!calls.some(([open, close]) => open < at && at < close)) continue;
+		found.add(/^[^'")\s,]*/.exec(css.slice(at + 13))[0]);
+	}
+	return [...found];
+}
+function findSheetAssetSpecifiers(sheets) {
+	return [.../* @__PURE__ */ new Set([
+		...findAssetSpecifiers(sheets.variableCss),
+		...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, strict development reports it, and it 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) {
+		report.warn(message);
+		return;
+	}
+	if (!report.reportErrors) throw new Error(message);
+	report.reportErrors(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/manifest-diagnostics.ts
+/** `file`, then its line and column where the record has them. */
+function locationOf(diagnostic) {
+	if (diagnostic.line === void 0) return diagnostic.file;
+	if (diagnostic.column === void 0) return `${diagnostic.file}:${diagnostic.line}`;
+	return `${diagnostic.file}:${diagnostic.line}:${diagnostic.column}`;
+}
+/** A located record's `file:line:column: `; nothing for one without a line,
+*  whose message names its file. */
+function locatedPrefix(diagnostic) {
+	return diagnostic.line === void 0 ? "" : `${locationOf(diagnostic)}: `;
+}
+/** What the record dropped, when its message does not already quote it. */
+function droppedSuffix(diagnostic) {
+	return diagnostic.dropped && !diagnostic.message.includes(diagnostic.dropped) ? ` — dropped: ${diagnostic.dropped}` : "";
+}
+/** The record's code, when its message does not already quote it. */
+function codeSuffix(diagnostic) {
+	return diagnostic.code && !diagnostic.message.includes(diagnostic.code) ? ` [${diagnostic.code}]` : "";
+}
+/** A warn-kind record's line after its mark:
+*  `file:line:column: component: message [code]`. */
+function warnLine(diagnostic) {
+	return `${locationOf(diagnostic)}: ${diagnostic.component}: ${diagnostic.message}${droppedSuffix(diagnostic)}${codeSuffix(diagnostic)}`;
+}
 /** Stable code for selector forms with no substitutable subject; the
 *  extraction engine mints the same string. */
 const SELECTOR_UNSUPPORTED_SUBJECT = "animus.selector.unsupported-subject";
@@ -144,6 +324,81 @@ function isUnresolvedParentDrop(diagnostic) {
 function unresolvedParentName(diagnostic) {
 	return UNRESOLVED_PARENT_RE.exec(diagnostic.message)?.[1] ?? null;
 }
+const DIAGNOSTIC_LEVELS = /* @__PURE__ */ new Set([
+	"off",
+	"info",
+	"warn",
+	"error"
+]);
+/** A key that selects every record of a kind: `kind:bail`, `kind:skip`,
+*  `kind:warn` or `kind:error`. */
+const KIND_KEY = "kind:";
+const DIAGNOSTIC_KINDS = /* @__PURE__ */ new Set([
+	"bail",
+	"skip",
+	"warn",
+	"error"
+]);
+/** The level `levels` sets for `code`: its exact entry, else the entry of
+*  the longest prefix it starts with. */
+function codeLevel(code, levels) {
+	if (code === void 0) return void 0;
+	if (Object.hasOwn(levels, code)) return levels[code];
+	let longest;
+	for (const [key, level] of Object.entries(levels)) {
+		if (!key.endsWith(".*")) continue;
+		const prefix = key.slice(0, -1);
+		if (code.startsWith(prefix) && prefix.length > (longest?.length ?? -1)) longest = {
+			length: prefix.length,
+			level
+		};
+	}
+	return longest?.level;
+}
+/** The level `levels` sets for a record: its code's level, else its kind's. */
+function levelFor({ code, kind }, levels) {
+	if (levels === void 0) return void 0;
+	const kindKey = `${KIND_KEY}${kind}`;
+	return codeLevel(code, levels) ?? (Object.hasOwn(levels, kindKey) ? levels[kindKey] : void 0);
+}
+/** The level a record prints at: the option's entry for its code, else
+*  `error` for a hard error (an `error`-kind record) or an error-severity
+*  record under `strict`, else its own. */
+function effectiveLevel(diagnostic, policy) {
+	const level = levelFor(diagnostic, policy.levels);
+	if (level !== void 0) return level;
+	if (diagnostic.kind === "error") return "error";
+	if (diagnostic.severity === "info") return "info";
+	return policy.strict && diagnostic.severity === "error" ? "error" : "warn";
+}
+/** Every code Animus is known to report: the engine's table, as the native
+*  module publishes it (`diagnosticCodes()`), the pipeline's, and the asset
+*  code. The system package mints vocabulary codes at run time, so a valid
+*  code can be missing. */
+function knownDiagnosticCodes(engineCodesJson) {
+	const engineCodes = engineCodesJson ? Object.keys(parseInternalWire(engineCodesJson, "diagnosticCodes (the engine code table)")) : [];
+	return /* @__PURE__ */ new Set([
+		...engineCodes,
+		...DIAGNOSTIC_SEVERITY.keys(),
+		UNSUBSTITUTED_ASSET_CODE
+	]);
+}
+/** The keys of `levels` that name no known code, exactly or as a prefix. */
+function unknownDiagnosticKeys(levels, known) {
+	return Object.keys(levels).filter((key) => {
+		if (key.startsWith(KIND_KEY)) return !DIAGNOSTIC_KINDS.has(key.slice(5));
+		if (!key.endsWith(".*")) return !known.has(key);
+		const prefix = key.slice(0, -1);
+		return ![...known].some((code) => code.startsWith(prefix));
+	});
+}
+/** The failure of diagnostics at `error` level, from `strict` or the
+*  `diagnostics` option: a host fails the build on it whatever its own
+*  strictness. It prints as the plain `Error` strict always threw. */
+var DiagnosticFailure = class extends Error {};
+/** Level options already checked against the known codes: one warning per
+*  unknown key, however often a host analyzes. */
+const checkedLevels = /* @__PURE__ */ new WeakSet();
 /** True when the selector carries at least one substitutable `&` subject
 *  outside quoted text. */
 function hasSelectorSubject(value) {
@@ -186,6 +441,22 @@ function collectSelectorAliasDiagnostics(selectorAliasesJson) {
 const UNREADABLE_SOURCE_FILE = "animus.ingestion.unreadable-source-file";
 /** A kit the system extends resolved, yet discovery found none of its files. */
 const NO_KIT_FILES = "animus.discovery.no-kit-files";
+/** A kit with no `animus` export condition: discovery guesses its source
+*  from `src/`. */
+const KIT_WITHOUT_SOURCE_CONDITION = "animus.discovery.kit-without-source-condition";
+/** A kit's `animus` export condition names a file that is missing or outside
+*  its package, so that entry is not read from source. */
+const INVALID_KIT_SOURCE_CONDITION = "animus.discovery.invalid-source-condition";
+/** A kit the application imports whose system the application's system
+*  does not include: its components are not extracted. */
+const KIT_SYSTEM_NOT_INCLUDED = "animus.kit.system-not-included";
+/** A system file's `createSystem` binding that discovery could not follow to
+*  Animus's factory, so it is no root. */
+const UNPROVEN_ROOT_BINDING = "animus.discovery.unproven-root-binding";
+/** A system file calls `createSystem` with no import or local binding. The
+*  system loader evaluates the file without auto-imports, where the name is
+*  undefined, so the call is no root. */
+const UNIMPORTED_CREATE_SYSTEM = "animus.discovery.unimported-create-system";
 /** 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";
@@ -221,6 +492,11 @@ function noKitFilesDiagnostics(outcomes) {
 		severity: severityFor(NO_KIT_FILES)
 	}));
 }
+/** A kit's descriptor declares a format this Animus does not read. */
+const KIT_UNSUPPORTED_FORMAT = "animus.kit.unsupported-format";
+/** A kit's descriptor records a definition its shipped source no longer
+*  declares. */
+const KIT_STALE_DESCRIPTOR = "animus.kit.stale-descriptor";
 /** 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. */
@@ -246,9 +522,6 @@ const PROPERTY_FALLBACK_SELF_REFERENCE = "animus.property.fallback-self-referenc
 *  another directly, so every property in the cycle is invalid at
 *  computed-value time. */
 const PROPERTY_CURRENT_VAR_CYCLE = "animus.property.current-var-cycle";
-/** A prefix renamed contextual variables without `prefixContextualVars`, so
-*  their declared names no longer resolve. */
-const PREFIX_CONTEXTUAL_VARS_UNPREFIXED = "animus.prefix.contextual-vars-unprefixed";
 /** Under `prefixContextualVars`, a final name that collides with a runtime
 *  transport variable or a theme variable of the same spelling. */
 const PREFIX_NAME_CONFLICT = "animus.prefix.name-conflict";
@@ -262,6 +535,13 @@ const DIAGNOSTIC_SEVERITY = /* @__PURE__ */ new Map([
 	[SELECTOR_UNSUPPORTED_SUBJECT, "error"],
 	[UNREADABLE_SOURCE_FILE, "error"],
 	[NO_KIT_FILES, "warn"],
+	[KIT_WITHOUT_SOURCE_CONDITION, "warn"],
+	[INVALID_KIT_SOURCE_CONDITION, "error"],
+	[KIT_SYSTEM_NOT_INCLUDED, "error"],
+	[KIT_UNSUPPORTED_FORMAT, "error"],
+	[KIT_STALE_DESCRIPTOR, "warn"],
+	[UNPROVEN_ROOT_BINDING, "warn"],
+	[UNIMPORTED_CREATE_SYSTEM, "warn"],
 	[VOCABULARY_COLLISION, "warn"],
 	[VOCABULARY_LEGACY_VERB, "warn"],
 	[INVALID_PROPERTY_REGISTRATION, "error"],
@@ -271,7 +551,6 @@ const DIAGNOSTIC_SEVERITY = /* @__PURE__ */ new Map([
 	[PROPERTY_SELF_REFERENCE, "warn"],
 	[PROPERTY_FALLBACK_SELF_REFERENCE, "warn"],
 	[PROPERTY_CURRENT_VAR_CYCLE, "warn"],
-	[PREFIX_CONTEXTUAL_VARS_UNPREFIXED, "warn"],
 	[PREFIX_NAME_CONFLICT, "error"],
 	[PROPERTY_LEGACY_TOKEN_COLLISION, "warn"],
 	[PROPERTY_TOKEN_COLLISION, "error"]
@@ -326,15 +605,6 @@ function systemLoadDiagnostics(system) {
 		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}`,
@@ -346,7 +616,6 @@ function systemLoadDiagnostics(system) {
 	return [
 		...vocabularyWitnessDiagnostics(system.vocabularyWitnessesJson),
 		...registrations,
-		...unprefixed,
 		...conflicts,
 		...tokenCollisionDiagnostics(system)
 	];
@@ -382,29 +651,44 @@ function tokenCollisionDiagnostics(system) {
 }
 /**
 * The single strict-escalation policy point for both extraction plugins:
-* error-severity diagnostics throw together under `strict`, else warn.
+* error-severity diagnostics throw together under `strict`, else warn. A
+* development session reports them through `reportErrors` instead.
 */
 function surfaceManifestDiagnostics(manifest, warn, policy = {}) {
-	const errors = [];
+	const errors = /* @__PURE__ */ new Set();
+	if (policy.levels && policy.knownCodes && !checkedLevels.has(policy.levels)) {
+		checkedLevels.add(policy.levels);
+		for (const key of unknownDiagnosticKeys(policy.levels, policy.knownCodes)) warn(key.startsWith(KIND_KEY) ? `⚠ diagnostics option: '${key}' names no diagnostic kind — use kind:bail, kind:skip, kind:warn or kind:error` : `⚠ diagnostics option: '${key}' matches no Animus diagnostic code — check its spelling (a code the system package mints at run time is known only once it is reported)`);
+	}
 	const diagnostics = policy.prepend?.length ? [...policy.prepend, ...manifest.diagnostics ?? []] : manifest.diagnostics ?? [];
 	for (const diagnostic of diagnostics) {
+		const level = effectiveLevel(diagnostic, policy);
+		if (level === "off") continue;
 		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}`;
+		const mark = level === "info" ? "ℹ" : "⚠";
+		const message = `${diagnostic.message}${droppedSuffix(diagnostic)}`;
+		if (diagnostic.kind === "bail") line = `${mark} ${locatedPrefix(diagnostic)}${diagnostic.component} not extracted: ${message}${codeSuffix(diagnostic)}`;
+		else if (diagnostic.kind === "skip") line = `${mark} ${locatedPrefix(diagnostic)}${diagnostic.component}: skipped ${message}${codeSuffix(diagnostic)}`;
+		else if (diagnostic.kind === "warn" || diagnostic.kind === "error") line = `${mark} ${warnLine(diagnostic)}`;
 		if (line === null) continue;
-		if (diagnostic.code && !diagnostic.message.includes(diagnostic.code)) line += ` [${diagnostic.code}]`;
-		if (diagnostic.severity === "info") {
+		if (level === "info") {
 			policy.info?.(line);
 			continue;
 		}
-		if (policy.strict && diagnostic.severity === "error") {
-			errors.push(`${diagnostic.code ?? "error"} — ${diagnostic.component}: ${diagnostic.message}`);
+		if (level === "error") {
+			const subject = diagnostic.kind === "warn" || diagnostic.kind === "error" ? `${locationOf(diagnostic)}: ` : locatedPrefix(diagnostic);
+			errors.add(`${diagnostic.code ?? "error"} — ${subject}${diagnostic.component}: ${message}`);
 			continue;
 		}
 		warn(line);
 	}
-	if (errors.length > 0) throw new Error(`[animus] strict: ${errors.length} error diagnostic(s):\n${errors.join("\n")}`);
+	if (errors.size === 0) return;
+	const message = `[animus] strict: ${errors.size} error diagnostic(s):\n${[...errors].join("\n")}`;
+	if (policy.reportErrors) {
+		policy.reportErrors(message);
+		return;
+	}
+	throw new DiagnosticFailure(message);
 }
 //#endregion
 //#region pipeline/mdx-preprocessor.ts
@@ -1056,17 +1340,17 @@ const NODE_NEXT_EXTENSION_MAP = {
 	".mjs": [".mts"],
 	".cjs": [".cts"]
 };
-function resolveRelativeSource(importerPath, specifier, files) {
-	if (!specifier.startsWith(".")) return null;
+/** The paths a relative specifier can name from `importerPath`, in probe
+*  order: as written with each source suffix, then a NodeNext emitted
+*  extension's sources. Empty for a non-relative specifier. */
+function relativeSourceCandidates(importerPath, specifier) {
+	if (!specifier.startsWith(".")) return [];
 	const base = node_path.posix.normalize(node_path.posix.join(node_path.posix.dirname(canonicalResolverPath(importerPath)), specifier));
-	for (const suffix of RELATIVE_PROBE_SUFFIXES) {
-		const candidate = `${base}${suffix}`;
-		const actualPath = files.get(candidate);
-		if (actualPath !== void 0) return actualPath;
-	}
 	const explicitExtension = extension(base);
-	for (const sourceExtension of NODE_NEXT_EXTENSION_MAP[explicitExtension] ?? []) {
-		const candidate = `${base.slice(0, -explicitExtension.length)}${sourceExtension}`;
+	return [...RELATIVE_PROBE_SUFFIXES.map((suffix) => `${base}${suffix}`), ...(NODE_NEXT_EXTENSION_MAP[explicitExtension] ?? []).map((sourceExtension) => `${base.slice(0, -explicitExtension.length)}${sourceExtension}`)];
+}
+function resolveRelativeSource(importerPath, specifier, files) {
+	for (const candidate of relativeSourceCandidates(importerPath, specifier)) {
 		const actualPath = files.get(candidate);
 		if (actualPath !== void 0) return actualPath;
 	}
@@ -1371,7 +1655,8 @@ function createSourceIngestor(host) {
 			const fatal = diagnostics.filter((diagnostic) => !isAdvisorySourceDiagnostic(diagnostic));
 			const invalidOriginals = new Set(fatal.map((diagnostic) => diagnostic.originalPath));
 			if (diagnostics.length === 0) return invalidOriginals;
-			if (host.strict() && fatal.length > 0) {
+			const reportError = host.strict() ? host.reportErrors?.() : void 0;
+			if (host.strict() && fatal.length > 0 && !reportError) {
 				const lines = fatal.map((diagnostic) => `${diagnostic.code} ${diagnostic.originalPath}: ${diagnostic.message} (${SKIPPED_SOURCE_COST})`);
 				throw new Error(`${host.prefix} ${lines.join(`\n${host.prefix} `)}`);
 			}
@@ -1385,7 +1670,8 @@ function createSourceIngestor(host) {
 				}
 				if (warned.has(line)) continue;
 				warned.add(line);
-				host.warn(`${host.prefix} ${line}`);
+				if (reportError && skipped) reportError(`${host.prefix} ${line}`);
+				else host.warn(`${host.prefix} ${line}`);
 			}
 			return invalidOriginals;
 		},
@@ -1412,7 +1698,9 @@ 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, analysisContextJson) => {
+			moduleSpecifiers: (filesJson) => native.moduleSpecifiers(filesJson),
+			diagnosticCodes: () => native.diagnosticCodes(),
+			analyzeProject: (filesJsonRaw, scalesJson, variableMapJson, contextualVarsJson, propConfigJson, groupRegistryJson, packageResolutionJson, devMode, emitterConfigJson, selectorAliasesJson, _selectorOrderJson, globalStyleBlocksJson, pathAliasesJson, keyframesJson, staticCssJson, conditionAliasesJson, externalDirsJson, transformSourcesJson, transformProvenanceJson, declarationScalesJson, analysisContextJson, generatedNamesJson) => {
 				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);
@@ -1440,6 +1728,7 @@ function createV2EngineApi(deps) {
 					transformProvenanceJson: transformProvenanceJson ?? void 0,
 					declarationScalesJson,
 					analysisContextJson,
+					generatedNamesJson,
 					devMode
 				};
 				const engine = new native.ExtractEngine(config);
@@ -1477,6 +1766,10 @@ function assertNoRetiredEngineSelection(engineOption) {
 }
 //#endregion
 //#region pipeline/core-options.ts
+/**
+* One option schema shared by the Vite, Next, and CLI drivers: key semantics,
+* default exclusions, and mode authority cannot drift per driver.
+*/
 const DRIVER_NAMESPACES = [
 	"vite",
 	"next",
@@ -1510,6 +1803,7 @@ const CORE_OPTION_KEYS = /* @__PURE__ */ new Set([
 	"exclude",
 	"extensions",
 	"strict",
+	"diagnostics",
 	"verbose",
 	"prefix",
 	"prefixContextualVars",
@@ -1569,6 +1863,7 @@ const isString = (value) => Object(value) !== value && Object.prototype.toString
 const isBoolean = (value) => Object(value) !== value && Object.prototype.toString.call(value) === "[object Boolean]";
 const isVerbose = (value) => isBoolean(value) || value === "trace";
 const isStringArray = (value) => Array.isArray(value) && value.every(isString);
+const isDiagnosticLevels = (value) => Object.prototype.toString.call(value) === "[object Object]" && Object.values(Object(value)).every((level) => isString(level) && DIAGNOSTIC_LEVELS.has(level));
 const isStringOrStringArray = (value) => isString(value) || isStringArray(value);
 const CORE_VALUE_GATES = [
 	{
@@ -1591,6 +1886,11 @@ const CORE_VALUE_GATES = [
 		ok: isBoolean,
 		expected: "a boolean"
 	},
+	{
+		key: "diagnostics",
+		ok: isDiagnosticLevels,
+		expected: "an object mapping codes to 'off', 'info', 'warn' or 'error'"
+	},
 	{
 		key: "verbose",
 		ok: isVerbose,
@@ -1764,177 +2064,69 @@ function walkFiles(dir, rootDir, exclude, extensionsSet) {
 	return results;
 }
 //#endregion
-//#region pipeline/source-identity.ts
-/**
-* One derivation of source identity for discovery, watch ingestion, ownership
-* and deletion: event paths are lookup INPUTS only and never fork identity.
-*/
+//#region pipeline/tsconfig-paths.ts
 /**
-* True when `target` is `root` or a descendant, decided by `relative()`
-* shape: string prefixing would let `/ui` claim `/ui-old`.
+* tsconfig `paths` → alias pairs, for drivers with no live bundler config.
+* The nearest config declaring `paths` wins wholesale — TS never merges.
 */
-function isPathWithinRoot(root, target, pathApi = node_path.default) {
-	const rel = pathApi.relative(root, target);
-	return rel === "" || !pathApi.isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + pathApi.sep);
+function stripJsonc(text) {
+	let out = "";
+	let inString = false;
+	let inLine = false;
+	let inBlock = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		const next = text[i + 1];
+		if (inLine) {
+			if (ch === "\n") {
+				inLine = false;
+				out += ch;
+			}
+			continue;
+		}
+		if (inBlock) {
+			if (ch === "*" && next === "/") {
+				inBlock = false;
+				i++;
+			}
+			continue;
+		}
+		if (inString) {
+			out += ch;
+			if (ch === "\\") {
+				out += next ?? "";
+				i++;
+			} else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			out += ch;
+			continue;
+		}
+		if (ch === "/" && next === "/") {
+			inLine = true;
+			i++;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			inBlock = true;
+			i++;
+			continue;
+		}
+		out += ch;
+	}
+	return out.replace(/,(\s*[}\]])/g, "$1");
 }
-/**
-* True when two paths share a platform root (win32 drive letter or UNC
-* share; always true on posix). Drive letters compare case-insensitively.
-*/
-function sharesVolumeRoot(a, b, pathApi = node_path.default) {
-	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
-	return volumeOf(a) === volumeOf(b);
+/** `Object(value) === value` holds for exactly the blocks and lists
+*  `JSON.parse` produces; the `[object Object]` tag separates the two. */
+function isJsonBlock(value) {
+	return Object(value) === value && Object.prototype.toString.call(value) === "[object Object]";
 }
-function canonicalize(p) {
-	try {
-		return (0, node_fs.realpathSync)(p);
-	} catch {
-		return null;
-	}
-}
-function createSourceIdentity(rootDir) {
-	const normalizedRootDir = node_path.default.normalize(rootDir);
-	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
-	const roots = [];
-	const aliases = /* @__PURE__ */ new Map();
-	const owningRecord = (canonicalPath) => {
-		let owner = null;
-		for (const record of roots) {
-			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
-			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-		}
-		return owner;
-	};
-	return {
-		rootDir: normalizedRootDir,
-		canonicalRootDir,
-		registerExternalRoot(root) {
-			const asRegistered = node_path.default.normalize(root);
-			const canonical = canonicalize(asRegistered) ?? asRegistered;
-			const existing = roots.find((record) => record.canonical === canonical);
-			if (existing) return existing.canonical;
-			roots.push({
-				asRegistered,
-				canonical
-			});
-			return canonical;
-		},
-		externalRoots() {
-			return roots.map((record) => record.canonical);
-		},
-		resolveSourceId(inputPath) {
-			const lexical = node_path.default.normalize(inputPath);
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			const owner = owningRecord(canonical);
-			const ownedBy = (record) => {
-				const pathInRoot = node_path.default.relative(record.canonical, canonical);
-				return {
-					sourceKey: node_path.default.relative(normalizedRootDir, node_path.default.join(record.asRegistered, pathInRoot)),
-					owningRoot: record.canonical,
-					pathInRoot
-				};
-			};
-			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
-			let resolved;
-			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
-				const key = node_path.default.relative(canonicalRootDir, canonical);
-				resolved = {
-					sourceKey: key,
-					owningRoot: null,
-					pathInRoot: key
-				};
-			} else if (owner) resolved = ownedBy(owner);
-			else return null;
-			aliases.set(lexical, resolved);
-			aliases.set(canonical, resolved);
-			return resolved;
-		},
-		resolveDeletedSourceId(inputPath) {
-			return aliases.get(node_path.default.normalize(inputPath)) ?? null;
-		},
-		containingExternalRoot(inputPath) {
-			const lexical = node_path.default.normalize(inputPath);
-			let owner = null;
-			for (const record of roots) {
-				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
-				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-			}
-			if (owner) return owner.canonical;
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			for (const record of roots) {
-				if (!isPathWithinRoot(record.canonical, canonical)) continue;
-				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-			}
-			return owner?.canonical ?? null;
-		}
-	};
-}
-//#endregion
-//#region pipeline/tsconfig-paths.ts
-/**
-* tsconfig `paths` → alias pairs, for drivers with no live bundler config.
-* The nearest config declaring `paths` wins wholesale — TS never merges.
-*/
-function stripJsonc(text) {
-	let out = "";
-	let inString = false;
-	let inLine = false;
-	let inBlock = false;
-	for (let i = 0; i < text.length; i++) {
-		const ch = text[i];
-		const next = text[i + 1];
-		if (inLine) {
-			if (ch === "\n") {
-				inLine = false;
-				out += ch;
-			}
-			continue;
-		}
-		if (inBlock) {
-			if (ch === "*" && next === "/") {
-				inBlock = false;
-				i++;
-			}
-			continue;
-		}
-		if (inString) {
-			out += ch;
-			if (ch === "\\") {
-				out += next ?? "";
-				i++;
-			} else if (ch === "\"") inString = false;
-			continue;
-		}
-		if (ch === "\"") {
-			inString = true;
-			out += ch;
-			continue;
-		}
-		if (ch === "/" && next === "/") {
-			inLine = true;
-			i++;
-			continue;
-		}
-		if (ch === "/" && next === "*") {
-			inBlock = true;
-			i++;
-			continue;
-		}
-		out += ch;
-	}
-	return out.replace(/,(\s*[}\]])/g, "$1");
-}
-/** `Object(value) === value` holds for exactly the blocks and lists
-*  `JSON.parse` produces; the `[object Object]` tag separates the two. */
-function isJsonBlock(value) {
-	return Object(value) === value && Object.prototype.toString.call(value) === "[object Object]";
-}
-/** A block or a list. A declared `paths` OWNS the setting and blocks its
-*  parents' even when it contributes nothing usable. */
-function isJsonKeyed(value) {
-	return Object(value) === value;
+/** A block or a list. A declared `paths` OWNS the setting and blocks its
+*  parents' even when it contributes nothing usable. */
+function isJsonKeyed(value) {
+	return Object(value) === value;
 }
 /** A JSON string, excluding the boxed `String` object, which no path join
 *  accepts. */
@@ -1955,10 +2147,10 @@ function decodePaths(value) {
 function decodeExtends(value) {
 	return (Array.isArray(value) ? value : [value]).filter(isJsonString);
 }
-function readConfig(path$4) {
+function readConfig(path$8) {
 	let raw;
 	try {
-		raw = (0, fs.readFileSync)(path$4, "utf-8");
+		raw = (0, fs.readFileSync)(path$8, "utf-8");
 	} catch {
 		return null;
 	}
@@ -1971,7 +2163,7 @@ function readConfig(path$4) {
 	const root = isJsonBlock(parsed) ? parsed : {};
 	const compilerOptions = isJsonBlock(root.compilerOptions) ? root.compilerOptions : {};
 	return {
-		dir: (0, path.dirname)(path$4),
+		dir: (0, path.dirname)(path$8),
 		baseUrl: isJsonString(compilerOptions.baseUrl) ? compilerOptions.baseUrl : null,
 		paths: decodePaths(compilerOptions.paths),
 		extends: decodeExtends(root.extends)
@@ -2003,8 +2195,8 @@ function loadChain(entryPath) {
 	const visited = /* @__PURE__ */ new Set();
 	const queue = [entryPath];
 	while (queue.length > 0) {
-		const path$5 = queue.shift();
-		const key = (0, path.resolve)(path$5);
+		const path$9 = queue.shift();
+		const key = (0, path.resolve)(path$9);
 		if (visited.has(key)) continue;
 		visited.add(key);
 		const node = readConfig(key);
@@ -2054,6 +2246,216 @@ function readTsconfigAliasPairs(rootDir) {
 	return pairs;
 }
 //#endregion
+//#region pipeline/kit-descriptor.ts
+/** A kit's description, which `animus build --kit` writes at its package
+*  root and the kit exports as `./animus.json`. */
+const KIT_DESCRIPTOR_FILE = "animus.json";
+/** A path with `/` separators, as descriptors key their components. */
+function posixPath$1(path) {
+	return path.split(node_path.sep).join("/");
+}
+/** The descriptor of the kit a build analysed. */
+function buildKitDescriptor(manifest) {
+	const components = {};
+	for (const id of Object.keys(manifest.components).sort()) {
+		const component = manifest.components[id];
+		components[posixPath$1(id)] = {
+			definition: component.definition_fingerprint,
+			runtimeProps: [...new Set(component.system_prop_names)].sort()
+		};
+	}
+	return {
+		format: 1,
+		system: manifest.system_fingerprint,
+		components
+	};
+}
+/** Reads the descriptor at a kit's package root; `null` when it has none. */
+function readKitDescriptor(pkgRoot, rootDir) {
+	const path = (0, node_path.join)(pkgRoot, KIT_DESCRIPTOR_FILE);
+	if (!(0, node_fs.existsSync)(path)) return null;
+	const packageRoot = posixPath$1((0, node_path.relative)(rootDir, pkgRoot));
+	let wire;
+	try {
+		wire = JSON.parse((0, node_fs.readFileSync)(path, "utf-8"));
+	} catch {
+		return {
+			packageRoot,
+			unreadable: "is not valid JSON: rebuild it with animus build --kit"
+		};
+	}
+	const block = isJsonBlock(wire) ? wire : {};
+	if (block.format !== 1) return {
+		packageRoot,
+		unreadable: `declares descriptor format ${JSON.stringify(block.format ?? null)}, which this Animus does not read (it reads format 1): upgrade Animus, or install a kit built for this version`
+	};
+	const definitions = {};
+	const components = isJsonBlock(block.components) ? block.components : {};
+	for (const [id, component] of Object.entries(components)) {
+		const definition = isJsonBlock(component) ? component.definition : null;
+		if (isJsonString(definition)) definitions[posixPath$1(id)] = definition;
+	}
+	return {
+		packageRoot,
+		definitions
+	};
+}
+/**
+* A descriptor in a format this Animus cannot read fails the build; one
+* whose component definitions differ from the kit's shipped source, as the
+* analysis read it, or that describes a component its analysed file no
+* longer declares, was built from other source and is stale.
+*/
+function kitDescriptorDiagnostics(records, manifest) {
+	if (records.length === 0) return [];
+	const diagnostics = [];
+	const analysedById = new Map(Object.entries(manifest.components).map(([id, component]) => [posixPath$1(id), component]));
+	const analysedFiles = new Set(Object.keys(manifest.fileFacts).map(posixPath$1));
+	const declared = new Set(Object.entries(manifest.fileFacts).flatMap(([file, facts]) => facts.chains.map((chain) => `${posixPath$1(file)}::${chain.descriptor.binding}`)));
+	for (const record of records) {
+		const file = `${record.packageRoot}/${KIT_DESCRIPTOR_FILE}`;
+		if ("unreadable" in record) {
+			diagnostics.push({
+				file,
+				component: "kit",
+				kind: "error",
+				message: record.unreadable,
+				code: KIT_UNSUPPORTED_FORMAT,
+				severity: severityFor(KIT_UNSUPPORTED_FORMAT)
+			});
+			continue;
+		}
+		for (const [id, definition] of Object.entries(record.definitions)) {
+			const key = `${record.packageRoot}/${id}`;
+			const analysed = analysedById.get(key);
+			const fileAnalysed = analysedFiles.has(key.slice(0, key.lastIndexOf("::")));
+			let stale;
+			if (analysed) {
+				if (analysed.definition_fingerprint === definition) continue;
+				stale = `describes ${id} with a definition other than the one its shipped source declares`;
+			} else if (fileAnalysed && !declared.has(key)) stale = `describes ${id}, which its shipped source no longer declares`;
+			else continue;
+			diagnostics.push({
+				file,
+				component: analysed?.binding ?? id.slice(id.lastIndexOf("::") + 2),
+				kind: "warn",
+				message: `${stale}, so the descriptor is stale: rebuild it with animus build --kit`,
+				code: KIT_STALE_DESCRIPTOR,
+				severity: severityFor(KIT_STALE_DESCRIPTOR)
+			});
+		}
+	}
+	return diagnostics;
+}
+//#endregion
+//#region pipeline/source-identity.ts
+/**
+* One derivation of source identity for discovery, watch ingestion, ownership
+* and deletion: event paths are lookup INPUTS only and never fork identity.
+*/
+/**
+* True when `target` is `root` or a descendant, decided by `relative()`
+* shape: string prefixing would let `/ui` claim `/ui-old`.
+*/
+function isPathWithinRoot(root, target, pathApi = node_path.default) {
+	const rel = pathApi.relative(root, target);
+	return rel === "" || !pathApi.isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + pathApi.sep);
+}
+/**
+* True when two paths share a platform root (win32 drive letter or UNC
+* share; always true on posix). Drive letters compare case-insensitively.
+*/
+function sharesVolumeRoot(a, b, pathApi = node_path.default) {
+	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
+	return volumeOf(a) === volumeOf(b);
+}
+function canonicalize(p) {
+	try {
+		return (0, node_fs.realpathSync)(p);
+	} catch {
+		return null;
+	}
+}
+function createSourceIdentity(rootDir) {
+	const normalizedRootDir = node_path.default.normalize(rootDir);
+	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
+	const roots = [];
+	const aliases = /* @__PURE__ */ new Map();
+	const owningRecord = (canonicalPath) => {
+		let owner = null;
+		for (const record of roots) {
+			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
+			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+		}
+		return owner;
+	};
+	return {
+		rootDir: normalizedRootDir,
+		canonicalRootDir,
+		registerExternalRoot(root) {
+			const asRegistered = node_path.default.normalize(root);
+			const canonical = canonicalize(asRegistered) ?? asRegistered;
+			const existing = roots.find((record) => record.canonical === canonical);
+			if (existing) return existing.canonical;
+			roots.push({
+				asRegistered,
+				canonical
+			});
+			return canonical;
+		},
+		externalRoots() {
+			return roots.map((record) => record.canonical);
+		},
+		resolveSourceId(inputPath) {
+			const lexical = node_path.default.normalize(inputPath);
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			const owner = owningRecord(canonical);
+			const ownedBy = (record) => {
+				const pathInRoot = node_path.default.relative(record.canonical, canonical);
+				return {
+					sourceKey: node_path.default.relative(normalizedRootDir, node_path.default.join(record.asRegistered, pathInRoot)),
+					owningRoot: record.canonical,
+					pathInRoot
+				};
+			};
+			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
+			let resolved;
+			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
+				const key = node_path.default.relative(canonicalRootDir, canonical);
+				resolved = {
+					sourceKey: key,
+					owningRoot: null,
+					pathInRoot: key
+				};
+			} else if (owner) resolved = ownedBy(owner);
+			else return null;
+			aliases.set(lexical, resolved);
+			aliases.set(canonical, resolved);
+			return resolved;
+		},
+		resolveDeletedSourceId(inputPath) {
+			return aliases.get(node_path.default.normalize(inputPath)) ?? null;
+		},
+		containingExternalRoot(inputPath) {
+			const lexical = node_path.default.normalize(inputPath);
+			let owner = null;
+			for (const record of roots) {
+				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			if (owner) return owner.canonical;
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			for (const record of roots) {
+				if (!isPathWithinRoot(record.canonical, canonical)) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			return owner?.canonical ?? null;
+		}
+	};
+}
+//#endregion
 //#region pipeline/discover-packages.ts
 function findPackageRoot(absEntryPath) {
 	let pkgRoot = (0, path.dirname)(absEntryPath);
@@ -2079,7 +2481,7 @@ const PACKAGE_OUTPUT_EXCLUDES = [
 	".d.ts",
 	".map"
 ];
-const isFile = (path$2) => {
+const isFile$1 = (path$2) => {
 	try {
 		return (0, fs.statSync)(path$2).isFile();
 	} catch {
@@ -2091,8 +2493,9 @@ function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
 		absSpecifier,
 		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
 		...Array.from(extensionsSet, (ext) => (0, path.join)(absSpecifier, `index${ext}`))
-	].find(isFile) ?? null;
+	].find(isFile$1) ?? null;
 }
+/** The package a bare specifier names: `@scope/name` or `name`. */
 function bareSpecifierPackageName(specifier) {
 	const segments = specifier.split("/");
 	return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
@@ -2107,6 +2510,76 @@ function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
 	const subpath = specifier.slice(packageName.length + 1);
 	return resolveAbsolutePathSpecifier((0, path.join)(srcDir, subpath || "index"), extensionsSet);
 }
+/** The package's parsed `package.json`, or null when it cannot be read. */
+function readPackageManifest(pkgRoot) {
+	try {
+		return JSON.parse((0, fs.readFileSync)((0, path.join)(pkgRoot, "package.json"), "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/** Each `exports` subpath and its value; a bare target or condition object
+*  is the `.` entry. */
+function exportsSubpaths(manifest) {
+	const exports = isJsonBlock(manifest) ? manifest.exports : void 0;
+	if (exports === void 0 || exports === null) return [];
+	const subpaths = isJsonBlock(exports) && Object.keys(exports).some((k) => k.startsWith(".")) ? exports : { ".": exports };
+	return Object.entries(subpaths).filter(([subpath]) => subpath.startsWith("."));
+}
+/**
+* The export condition a kit gives each public entry's original source:
+* `{ "types": …, "animus": "./src/system.ts", "import": …, "default": … }`.
+* Hosts never resolve through it; discovery reads it, redirects the entry to
+* its source in every host, and the system loader prefers it.
+*/
+const KIT_SOURCE_CONDITION = "animus";
+/** The package's kit source condition, or null when no exact `exports`
+*  entry declares it: the package is no source kit. */
+function readKitSourceCondition(pkgRoot) {
+	const condition = {
+		entries: [],
+		invalid: [],
+		root: null
+	};
+	for (const [subpath, value] of exportsSubpaths(readPackageManifest(pkgRoot))) {
+		if (subpath.includes("*") || !isJsonBlock(value)) continue;
+		const target = value[KIT_SOURCE_CONDITION];
+		if (!isJsonString(target)) continue;
+		const file = (0, path.resolve)(pkgRoot, target);
+		if (isPathWithinRoot(pkgRoot, file) && isFile$1(file)) condition.entries.push([subpath, file]);
+		else condition.invalid.push([subpath, target]);
+	}
+	if (condition.entries.length === 0 && condition.invalid.length === 0) return null;
+	condition.root = condition.entries.reduce((root, [, file]) => root === null ? (0, path.dirname)(file) : commonDirectory(root, (0, path.dirname)(file)), null);
+	return condition;
+}
+function commonDirectory(a, b) {
+	let dir = a;
+	while (!isPathWithinRoot(dir, b)) dir = (0, path.dirname)(dir);
+	return dir;
+}
+/** Whether the manifest at `dir` names the package `name`. */
+function isPackageNamed(dir, name) {
+	const manifest = readPackageManifest(dir);
+	return isJsonBlock(manifest) && manifest.name === name;
+}
+function realPath(path$3) {
+	try {
+		return (0, fs.realpathSync)(path$3);
+	} catch {
+		return path$3;
+	}
+}
+/** The root of the installed package `name` as Node finds it from `fromDir`,
+*  the first `node_modules/<name>` up the directory tree, at its real path,
+*  as host resolvers report a linked package. */
+function locatePackageRoot(name, fromDir) {
+	for (let dir = fromDir;; dir = (0, path.dirname)(dir)) {
+		const candidate = (0, path.join)(dir, "node_modules", name);
+		if ((0, fs.existsSync)((0, path.join)(candidate, "package.json"))) return realPath(candidate);
+		if (dir === (0, path.dirname)(dir)) return null;
+	}
+}
 /**
 * A package's `sideEffects` field, decoded the way Vite reads it: a boolean
 * as written, or the list's globs, one with no `/` matching the basename
@@ -2115,12 +2588,7 @@ function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
 * extglobs), which leaves the bundler's side-effectful default.
 */
 function readPackageSideEffects(pkgRoot) {
-	let manifest;
-	try {
-		manifest = JSON.parse((0, fs.readFileSync)((0, path.join)(pkgRoot, "package.json"), "utf-8"));
-	} catch {
-		return;
-	}
+	const manifest = readPackageManifest(pkgRoot);
 	const field = isJsonBlock(manifest) ? manifest.sideEffects : void 0;
 	if (field === true || field === false) return field;
 	if (!Array.isArray(field)) return void 0;
@@ -2128,6 +2596,77 @@ function readPackageSideEffects(pkgRoot) {
 	if (globs.some((glob) => /[{}[\]()!+@]/.test(glob))) return void 0;
 	return globs.map((glob) => globToRegExp(glob.includes("/") ? glob.replace(/^\.?\//, "") : `**/${glob}`));
 }
+/** Whether a bundler that reads the nearest `package.json`'s `sideEffects`
+*  against the file's own path keeps `absFile`; undefined without a field
+*  it reads, which keeps the bundler's side-effectful default. */
+function fileSideEffects(absFile) {
+	const pkgRoot = findPackageRoot(absFile);
+	const field = readPackageSideEffects(pkgRoot);
+	if (field === void 0 || field === true || field === false) return field;
+	return matchesSideEffects(field, pkgRoot, [absFile]);
+}
+/** Whether a `sideEffects` glob can name a code file: a last segment with
+*  no extension can name any file, and an extension with glob syntax or of
+*  a script can name code; `*.css` cannot. Brace alternatives are each read,
+*  and braces this reading cannot expand count as naming code. */
+function globNamesCode(glob) {
+	const alternatives = expandBraces(glob);
+	if (alternatives === null) return true;
+	return alternatives.some((alternative) => {
+		const last = alternative.split("/").at(-1) ?? "";
+		const dot = last.lastIndexOf(".");
+		if (dot === -1) return true;
+		const extension = last.slice(dot + 1);
+		return /[*?[]/.test(extension) || /^[cm]?[jt]sx?$/.test(extension);
+	});
+}
+/** Every alternative a glob's `{a,b}` groups spell, nested groups included;
+*  null when its braces do not balance. */
+function expandBraces(glob) {
+	const open = glob.indexOf("{");
+	if (open === -1) return glob.includes("}") ? null : [glob];
+	let depth = 0;
+	const commas = [];
+	for (let at = open; at < glob.length; at++) if (glob[at] === "{") depth++;
+	else if (glob[at] === "," && depth === 1) commas.push(at);
+	else if (glob[at] === "}" && --depth === 0) {
+		const bounds = [
+			open,
+			...commas,
+			at
+		];
+		const rest = expandBraces(glob.slice(at + 1));
+		if (rest === null) return null;
+		const expanded = [];
+		for (let i = 0; i < bounds.length - 1; i++) {
+			const inner = expandBraces(glob.slice(bounds[i] + 1, bounds[i + 1]));
+			if (inner === null) return null;
+			for (const middle of inner) for (const tail of rest) expanded.push(glob.slice(0, open) + middle + tail);
+		}
+		return expanded;
+	}
+	return null;
+}
+/**
+* True when a source module of the package that owns `absFile` must stay
+* side-effectful: its `sideEffects` list names shipped code, and no proven
+* map takes a shipped file to its source module, so a bundler that reads
+* the list against the source path can drop a listed effect. Undefined
+* leaves the bundler's own reading, which no list naming code can mislead.
+*/
+function kitSourceModuleSideEffects(absFile) {
+	const manifest = readPackageManifest(findPackageRoot(absFile));
+	const field = isJsonBlock(manifest) ? manifest.sideEffects : void 0;
+	if (!Array.isArray(field)) return void 0;
+	return field.some((glob) => isJsonString(glob) && globNamesCode(glob)) ? true : void 0;
+}
+/** Whether a host keeps the module at `file` side-effectful: it lies under
+*  one of the discovered kit source directories, and its package's list
+*  could misread it (see `kitSourceModuleSideEffects`). A host asks this of
+*  the resolved module, never of its importer alone. */
+function keepsKitSourceEffects(file, kitDirs) {
+	return kitDirs.some((dir) => isPathWithinRoot(dir, file)) && kitSourceModuleSideEffects(file) === true;
+}
 function matchesSideEffects(globs, pkgRoot, absFiles) {
 	return absFiles.some((file) => {
 		const relPath = (0, path.relative)(pkgRoot, file).split(path.sep).join("/");
@@ -2151,18 +2690,9 @@ function exportTarget(value) {
 /** Each exact `exports` entry of the package at `pkgRoot`, as its subpath
 *  and absolute target; `*` patterns name no single file and are skipped. */
 function packageExportEntries(pkgRoot) {
-	let manifest;
-	try {
-		manifest = JSON.parse((0, fs.readFileSync)((0, path.join)(pkgRoot, "package.json"), "utf-8"));
-	} catch {
-		return [];
-	}
-	const exports = isJsonBlock(manifest) ? manifest.exports : void 0;
-	if (exports === void 0 || exports === null) return [];
-	const subpaths = isJsonBlock(exports) && Object.keys(exports).some((k) => k.startsWith(".")) ? exports : { ".": exports };
 	const entries = [];
-	for (const [subpath, value] of Object.entries(subpaths)) {
-		if (!subpath.startsWith(".") || subpath.includes("*")) continue;
+	for (const [subpath, value] of exportsSubpaths(readPackageManifest(pkgRoot))) {
+		if (subpath.includes("*")) continue;
 		const target = exportTarget(value);
 		if (target !== null) entries.push([subpath, (0, path.resolve)(pkgRoot, target)]);
 	}
@@ -2201,6 +2731,16 @@ async function collectExternalPackageSources(opts) {
 	const sourceEntrySideEffects = /* @__PURE__ */ new Map();
 	/** `replaced` names the entry the redirect stands in for; it is only
 	*  needed, and so only resolved, for a glob list. */
+	/** The entry `subpath` of the package resolves to without the redirect.
+	*  A resolver with no `import` condition, as Node's `require` has none,
+	*  finds no ESM-only entry, so the manifest's own target answers then. */
+	const shippedEntry = async (specifier, pkgRoot, subpath) => {
+		try {
+			const resolved = await resolveSpecifier(specifier);
+			if (resolved) return resolved;
+		} catch {}
+		return packageExportEntries(pkgRoot).find(([entry]) => entry === subpath)?.[1] ?? null;
+	};
 	const redirect = async (specifier, srcEntry, pkgRoot, replaced) => {
 		sourceEntries.set(specifier, srcEntry);
 		const field = readPackageSideEffects(pkgRoot);
@@ -2213,6 +2753,8 @@ async function collectExternalPackageSources(opts) {
 		sourceEntrySideEffects.set(specifier, replacedEntry === null || matchesSideEffects(field, pkgRoot, [srcEntry, replacedEntry]));
 	};
 	const packageDirs = [];
+	const linkedDirs = [];
+	const outputDirs = [];
 	const dirOwnerSets = {};
 	const dirExtensions = {};
 	const fileOwners = {};
@@ -2221,6 +2763,31 @@ async function collectExternalPackageSources(opts) {
 		(dirOwnerSets[dir] ??= []).push(specifier);
 	};
 	const alreadyIngested = (relPath) => hasEntry(relPath) || pushed.has(relPath);
+	/** Adds `file` to the analysis set unless it is there; false when it
+	*  cannot be read. */
+	const ingest = (file, specifier) => {
+		const relPath = (0, path.relative)(rootDir, file);
+		if (alreadyIngested(relPath)) return true;
+		let source;
+		try {
+			source = (0, fs.readFileSync)(file, "utf-8");
+		} catch (err) {
+			onUnreadable(relPath, err);
+			return false;
+		}
+		onSourceRead?.(source, relPath, file);
+		entries.push({
+			path: relPath,
+			source
+		});
+		pushed.add(relPath);
+		fileOwners[relPath] ??= specifier;
+		return true;
+	};
+	const diagnostics = [];
+	const reportedPackages = /* @__PURE__ */ new Set();
+	const kitDescriptors = [];
+	const describedRoots = /* @__PURE__ */ new Set();
 	for (const specifier of specifiers) {
 		let absEntry;
 		try {
@@ -2229,7 +2796,14 @@ async function collectExternalPackageSources(opts) {
 			absEntry = null;
 		}
 		if (!absEntry && (0, path.isAbsolute)(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
-		if (!absEntry) {
+		const packageName = (0, path.isAbsolute)(specifier) ? null : bareSpecifierPackageName(specifier);
+		const resolvedRoot = absEntry ? findPackageRoot(absEntry) : null;
+		const locatedRoot = packageName && locatePackageRoot(packageName, rootDir);
+		const pkgRoot = resolvedRoot && (!locatedRoot || isPackageNamed(resolvedRoot, packageName) || realPath(resolvedRoot) === locatedRoot) ? resolvedRoot : locatedRoot || resolvedRoot;
+		const condition = packageName && pkgRoot ? readKitSourceCondition(pkgRoot) : null;
+		const entryKey = packageName && `.${specifier.slice(packageName.length)}`;
+		absEntry ??= condition?.entries.find(([entry]) => entry === entryKey)?.[1] ?? null;
+		if (!absEntry || !pkgRoot) {
 			outcomes.push({
 				specifier,
 				outcome: "unresolvable",
@@ -2237,12 +2811,38 @@ async function collectExternalPackageSources(opts) {
 			});
 			continue;
 		}
-		const pkgRoot = findPackageRoot(absEntry);
+		const realRoot = realPath(pkgRoot);
+		if (!describedRoots.has(realRoot)) {
+			describedRoots.add(realRoot);
+			const described = readKitDescriptor(pkgRoot, rootDir);
+			if (described) kitDescriptors.push(described);
+		}
+		const linked = !isInstalledPackage(pkgRoot);
 		const srcDir = (0, path.join)(pkgRoot, "src");
 		let fileCount = 0;
 		let staleDist = false;
-		if ((0, fs.existsSync)(srcDir)) {
+		if (packageName && !reportedPackages.has(packageName)) {
+			reportedPackages.add(packageName);
+			diagnostics.push(...sourceConditionDiagnostics(packageName, condition));
+		}
+		if (condition && packageName) {
+			for (const [entry, target] of condition.entries) {
+				const entrySpecifier = packageName + entry.slice(1);
+				packageMap[entrySpecifier] = (0, path.relative)(rootDir, target);
+				await redirect(entrySpecifier, target, pkgRoot, () => shippedEntry(entrySpecifier, pkgRoot, entry));
+			}
+			packageMap[specifier] ??= (0, path.relative)(rootDir, absEntry);
+			if (condition.root) {
+				packageDirs.push(condition.root);
+				if (linked) linkedDirs.push(condition.root);
+				claimDir(condition.root, specifier);
+				dirExtensions[condition.root] = [...extensionsSet];
+				onPackageResolved?.(specifier, condition.root);
+				for (const file of walkPackageSources(condition.root, extensionsSet)) if (ingest(file, specifier)) fileCount++;
+			}
+		} else if ((0, fs.existsSync)(srcDir)) {
 			packageDirs.push(srcDir);
+			if (linked) linkedDirs.push(srcDir);
 			claimDir(srcDir, specifier);
 			dirExtensions[srcDir] = [...extensionsSet];
 			onPackageResolved?.(specifier, srcDir);
@@ -2252,49 +2852,23 @@ async function collectExternalPackageSources(opts) {
 				const replaced = absEntry;
 				await redirect(specifier, srcEntry, pkgRoot, async () => replaced);
 			} else packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
-			if (!(0, path.isAbsolute)(specifier)) {
-				const packageName = bareSpecifierPackageName(specifier);
+			if (packageName) {
 				if (packageName !== specifier && !(packageName in packageMap)) {
 					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
 					if (rootEntry) {
 						packageMap[packageName] = (0, path.relative)(rootDir, rootEntry);
-						await redirect(packageName, rootEntry, pkgRoot, async () => {
-							try {
-								return await resolveSpecifier(packageName);
-							} catch {
-								return null;
-							}
-						});
+						await redirect(packageName, rootEntry, pkgRoot, () => shippedEntry(packageName, pkgRoot, "."));
 					}
 				}
 			}
 			const pkgFiles = walkPackageSources(srcDir, extensionsSet);
-			staleDist = !isInstalledPackage(pkgRoot) && distEntryIsStale(absEntry, srcDir, pkgFiles);
-			for (const pkgFile of pkgFiles) {
-				const relPath = (0, path.relative)(rootDir, pkgFile);
-				if (alreadyIngested(relPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = (0, fs.readFileSync)(pkgFile, "utf-8");
-				} catch (err) {
-					onUnreadable(relPath, err);
-					continue;
-				}
-				onSourceRead?.(source, relPath, pkgFile);
-				entries.push({
-					path: relPath,
-					source
-				});
-				pushed.add(relPath);
-				fileOwners[relPath] ??= specifier;
-				fileCount++;
-			}
+			staleDist = linked && distEntryIsStale(absEntry, srcDir, pkgFiles);
+			for (const pkgFile of pkgFiles) if (ingest(pkgFile, specifier)) fileCount++;
 		} else {
 			const outputDir = (0, path.dirname)(absEntry);
 			packageDirs.push(outputDir);
+			if (linked) linkedDirs.push(outputDir);
+			outputDirs.push(outputDir);
 			claimDir(outputDir, specifier);
 			onPackageResolved?.(specifier, outputDir);
 			packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
@@ -2306,37 +2880,13 @@ async function collectExternalPackageSources(opts) {
 				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
 			});
 			if (!outputFiles.includes(absEntry)) outputFiles.unshift(absEntry);
-			for (const outputFile of outputFiles) {
-				const outputRelPath = (0, path.relative)(rootDir, outputFile);
-				if (alreadyIngested(outputRelPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = (0, fs.readFileSync)(outputFile, "utf-8");
-				} catch (err) {
-					onUnreadable(outputRelPath, err);
-					continue;
-				}
-				onSourceRead?.(source, outputRelPath, outputFile);
-				entries.push({
-					path: outputRelPath,
-					source
-				});
-				pushed.add(outputRelPath);
-				fileOwners[outputRelPath] ??= specifier;
-				fileCount++;
-			}
+			for (const outputFile of outputFiles) if (ingest(outputFile, specifier)) fileCount++;
 		}
-		if (!(0, path.isAbsolute)(specifier)) {
-			const packageName = bareSpecifierPackageName(specifier);
-			for (const [subpath, target] of packageExportEntries(pkgRoot)) {
-				const entrySpecifier = packageName + subpath.slice(1);
-				const targetRelPath = (0, path.relative)(rootDir, target);
-				if (entrySpecifier in packageMap || !alreadyIngested(targetRelPath)) continue;
-				packageMap[entrySpecifier] = targetRelPath;
-			}
+		if (packageName) for (const [subpath, target] of packageExportEntries(pkgRoot)) {
+			const entrySpecifier = packageName + subpath.slice(1);
+			const targetRelPath = (0, path.relative)(rootDir, target);
+			if (entrySpecifier in packageMap || !alreadyIngested(targetRelPath)) continue;
+			packageMap[entrySpecifier] = targetRelPath;
 		}
 		outcomes.push({
 			specifier,
@@ -2350,12 +2900,112 @@ async function collectExternalPackageSources(opts) {
 		sourceEntries,
 		sourceEntrySideEffects,
 		packageDirs,
+		linkedDirs,
+		outputDirs,
 		dirOwnerSets,
 		dirExtensions,
 		fileOwners,
-		outcomes
+		outcomes,
+		diagnostics: [...diagnostics, ...noKitFilesDiagnostics(outcomes)],
+		kitDescriptors
 	};
 }
+/** The dependency names a manifest lists in `fields`. */
+function dependencyNames(manifest, fields) {
+	if (!isJsonBlock(manifest)) return [];
+	const names = /* @__PURE__ */ new Set();
+	for (const field of fields) {
+		const deps = manifest[field];
+		if (isJsonBlock(deps)) for (const name of Object.keys(deps)) names.add(name);
+	}
+	return [...names];
+}
+/** The source kits the application at `rootDir` declares as dependencies.
+*  A bundler serves an installed one as compiled code unless told
+*  otherwise: Next keeps it external on the server unless it is in
+*  `transpilePackages`, and Vite's optimizer prebundles it. */
+function sourceKitDependencies(rootDir) {
+	return dependencyNames(readPackageManifest(rootDir), ["dependencies", "devDependencies"]).flatMap((name) => {
+		const pkgRoot = locatePackageRoot(name, rootDir);
+		if (pkgRoot === null || readKitSourceCondition(pkgRoot) === null) return [];
+		return [{
+			name,
+			installed: isInstalledPackage(pkgRoot),
+			dependencies: dependencyNames(readPackageManifest(pkgRoot), ["dependencies"])
+		}];
+	});
+}
+/** A specifier that names a package: not relative or absolute, and no URL,
+*  scheme (`node:`, `virtual:`), subpath import or virtual id. */
+function isPackageSpecifier(specifier) {
+	return /^(?:@[^/\\:]+\/)?[^./\\#\0:][^:]*$/.test(specifier);
+}
+/**
+* An error for each kit the application's own `files` import or re-export
+* whose system the application's system does not include: a package that
+* declares the kit source condition, with no kit the system extends
+* (`systemKits`) in that package. One app build has exactly one system, and
+* every kit's system is part of it, so such a kit is not extracted against
+* a system it was not built for. One batch parse reads the imports of every
+* file the engine parses as it is; an adapted source (`.svelte`, `.mdx`)
+* reaches the engine only as its generated children.
+*/
+function importedKitDiagnostics(files, engine, rootDir, systemKits) {
+	const { extractFacts } = engine;
+	const parsed = files.filter(({ path: path$4 }) => isEngineTransformExtension(path$4));
+	if (!extractFacts || parsed.length === 0) return [];
+	let facts;
+	try {
+		facts = parseInternalWire(extractFacts(JSON.stringify(parsed.map(({ path: path$5, source }) => ({
+			path: path$5,
+			source
+		})))), "extractFacts");
+	} catch {
+		return [];
+	}
+	const seen = new Set(systemKits.filter((specifier) => !(0, path.isAbsolute)(specifier)).map(bareSpecifierPackageName));
+	const diagnostics = [];
+	for (const [path$6, file] of Object.entries(facts.files)) {
+		if (file.parsePanicked) continue;
+		const specifiers = [...file.imports.map((fact) => fact.source), ...file.exports.flatMap((fact) => fact.source === null ? [] : [fact.source])];
+		for (const specifier of specifiers) {
+			if (!isPackageSpecifier(specifier)) continue;
+			const name = bareSpecifierPackageName(specifier);
+			if (seen.has(name)) continue;
+			seen.add(name);
+			const pkgRoot = locatePackageRoot(name, (0, path.dirname)((0, path.resolve)(rootDir, path$6)));
+			if (pkgRoot && readKitSourceCondition(pkgRoot)) diagnostics.push({
+				file: path$6,
+				component: name,
+				kind: "warn",
+				message: `the application imports this kit, but its system is not included in the application's system, so its components are not extracted — include the kit's system in the application's system: createSystem().extend(<the kit's system>)`,
+				code: KIT_SYSTEM_NOT_INCLUDED,
+				severity: severityFor(KIT_SYSTEM_NOT_INCLUDED)
+			});
+		}
+	}
+	return diagnostics;
+}
+/** A kit without the source condition, warned once, or each condition entry
+*  whose target is missing or outside the package. */
+function sourceConditionDiagnostics(packageName, condition) {
+	if (condition === null) return [{
+		file: packageName,
+		component: "kit",
+		kind: "warn",
+		message: `declares no "${KIT_SOURCE_CONDITION}" export condition, so discovery guesses its source from src/ — give each public exports entry an "${KIT_SOURCE_CONDITION}" condition naming its original source`,
+		code: KIT_WITHOUT_SOURCE_CONDITION,
+		severity: severityFor(KIT_WITHOUT_SOURCE_CONDITION)
+	}];
+	return condition.invalid.map(([subpath, target]) => ({
+		file: packageName,
+		component: "kit",
+		kind: "warn",
+		message: `exports["${subpath}"].${KIT_SOURCE_CONDITION} names ${target}, which is missing or outside the package, so that entry is not read from source`,
+		code: INVALID_KIT_SOURCE_CONDITION,
+		severity: severityFor(INVALID_KIT_SOURCE_CONDITION)
+	}));
+}
 function firstOwners(dirOwnerSets) {
 	const owners = {};
 	for (const [dir, specifiers] of Object.entries(dirOwnerSets)) if (specifiers.length > 0) owners[dir] = specifiers[0];
@@ -2401,10 +3051,14 @@ function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
 		sourceEntries,
 		sourceEntrySideEffects,
 		packageDirs: collected.packageDirs.filter((dir) => !rejectedDirs.includes(dir)),
+		linkedDirs: collected.linkedDirs.filter((dir) => !rejectedDirs.includes(dir)),
+		outputDirs: collected.outputDirs.filter((dir) => !rejectedDirs.includes(dir)),
 		dirOwnerSets,
 		dirExtensions,
 		fileOwners,
-		outcomes: collected.outcomes
+		outcomes: collected.outcomes,
+		diagnostics: collected.diagnostics,
+		kitDescriptors: collected.kitDescriptors.filter((record) => !rejectedDirs.some((dir) => isPathWithinRoot((0, path.resolve)(rootDir, record.packageRoot), dir)))
 	};
 }
 function unresolvableIncludesMessage(outcomes) {
@@ -2419,48 +3073,239 @@ function staleDistIncludesMessage(outcomes) {
 	if (stale.length === 0) return null;
 	return `[animus-extract] stale dist for include specifier(s): ${stale.join(", ")} — dist entry is older than the newest src/ file; rebuild the package(s) before extracting`;
 }
-/** The engine's own parse of a module's imports, through its
+/** The engine's own parse of a module's bindings, through its
 *  `extractFacts`; undefined for an engine without one. A parse that
-*  panicked reports no imports, so it counts as no parse. */
-function engineImportParser(engine) {
+*  panicked counts as no parse. */
+function engineModuleParser(engine) {
 	const { extractFacts } = engine;
 	if (!extractFacts) return void 0;
-	return (source, path$3) => {
+	return (source, path$7) => {
 		try {
 			const facts = parseInternalWire(extractFacts(JSON.stringify([{
-				path: path$3,
+				path: path$7,
 				source
-			}])), "extractFacts").files[path$3];
-			return facts && !facts.parsePanicked ? facts.imports : null;
+			}])), "extractFacts").files[path$7];
+			return facts && !facts.parsePanicked ? {
+				imports: facts.imports,
+				exports: facts.exports,
+				unboundCreateSystemCalls: facts.unboundCreateSystemCalls ?? []
+			} : null;
 		} catch {
 			return null;
 		}
 	};
 }
+const ANIMUS_SYSTEM_SPECIFIER = /^@animus-ui\/system(?:\/.*)?$/;
+/** The file a specifier names from `importer`: a relative one by the
+*  ingestion's probe order, a bare one by the host's package resolution. */
+async function resolveModuleFile(importer, specifier, resolvePackage) {
+	if (specifier.startsWith(".")) return relativeSourceCandidates(importer, specifier).find(isFile$1) ?? null;
+	try {
+		return await resolvePackage?.(specifier) ?? null;
+	} catch {
+		return null;
+	}
+}
+const escapeRegExp$1 = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* Follows `name`, exported by the module `specifier` names from `importer`,
+* through re-exports to its declaration. It is Animus's factory only when
+* that is `createSystem` of `@animus-ui/system`, and another identity only
+* when a module is shown to declare it; anything discovery cannot follow is
+* unknown.
+*/
+async function exportIdentity(importer, specifier, name, following, seen) {
+	if (ANIMUS_SYSTEM_SPECIFIER.test(specifier)) return name === "createSystem" ? { kind: "animus" } : {
+		kind: "other",
+		what: `'${name}' of ${specifier}`
+	};
+	const file = await resolveModuleFile(importer, specifier, following.resolvePackage);
+	if (file === null) return {
+		kind: "unknown",
+		why: `'${specifier}' could not be resolved`
+	};
+	const key = `${file}#${name}`;
+	if (seen.has(key)) return {
+		kind: "unknown",
+		why: `'${specifier}' re-exports it in a cycle`
+	};
+	seen.add(key);
+	let source;
+	try {
+		source = (0, fs.readFileSync)(file, "utf-8");
+	} catch {
+		return {
+			kind: "unknown",
+			why: `'${specifier}' could not be read`
+		};
+	}
+	const record = following.parseModule(source, file);
+	if (record === null) return {
+		kind: "unknown",
+		why: `'${specifier}' could not be parsed`
+	};
+	const exported = record.exports.find((entry) => entry.exported === name);
+	if (exported?.source) return exportIdentity(file, exported.source, exported.original ?? name, following, seen);
+	const local = exported?.local ?? name;
+	const imported = record.imports.find((entry) => entry.local === local);
+	if (exported && imported) return exportIdentity(file, imported.source, imported.imported, following, seen);
+	if (exported || new RegExp(`\\bexport\\s+(?:async\\s+)?(?:function\\*?|class|const|let|var)\\s+${escapeRegExp$1(name)}\\b`).test(source)) return {
+		kind: "other",
+		what: `the '${name}' that '${specifier}' declares`
+	};
+	const stars = [];
+	for (const match of source.matchAll(/\bexport\s*\*\s*from\s*['"]([^'"]+)['"]/g)) stars.push(await exportIdentity(file, match[1], name, following, seen));
+	const definite = stars.filter((identity) => identity.kind !== "unknown");
+	if (definite.length === 1) return definite[0];
+	if (definite.length > 1) return {
+		kind: "unknown",
+		why: `more than one \`export *\` of '${specifier}' provides '${name}'`
+	};
+	return stars.find((identity) => identity.kind === "unknown") ?? {
+		kind: "unknown",
+		why: `'${specifier}' has no export '${name}' discovery can read`
+	};
+}
+/** 1-based line and column of `offset` in `source`. */
+function locationIn(source, offset) {
+	const before = source.slice(0, offset);
+	const lineStart = before.lastIndexOf("\n") + 1;
+	return {
+		line: before.split("\n").length,
+		column: offset - lineStart + 1
+	};
+}
+const NAMESPACE_IMPORT = /\bimport\s+(?:[a-zA-Z_$][a-zA-Z0-9_$]*\s*,\s*)?\*\s*as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s+from\s+['"]([^'"]+)['"]/g;
+/**
+* The callees that are Animus's `createSystem` in a parsed system file. A
+* binding counts once its identity is followed to the factory: a named
+* import, through local and package re-exports; a namespace import's
+* member; or a property destructured from a namespace import, `require` or
+* `import()` of a module. A binding named `createSystem` shown to be
+* something else is no root. One whose identity discovery cannot follow
+* keeps the admission spelling gave it, so a resolution limit never drops a
+* kit. Both are reported. A call of the bare name, which the file neither
+* imports nor declares, is no root: the system loader evaluates the file
+* without auto-imports, where the name is undefined. It is reported once.
+*/
+async function systemRoots(systemFilePath, source, record, following) {
+	const { imports } = record;
+	const roots = /* @__PURE__ */ new Set();
+	const identityOf = (specifier, name) => exportIdentity(systemFilePath, specifier, name, following, /* @__PURE__ */ new Set());
+	const called = (callee) => callOf(callee).test(source);
+	/** Admits a binding named `createSystem` by its identity: an unknown one
+	*  keeps `spellingAdmits`, and every unproven one is reported. */
+	const admit = (local, offset, identity, spellingAdmits) => {
+		if (identity.kind === "animus") {
+			roots.add(local);
+			return;
+		}
+		if (identity.kind === "unknown" && spellingAdmits) roots.add(local);
+		const shown = identity.kind === "other" ? `it is ${identity.what}, so it is not read as a system root` : `discovery cannot follow what it is bound to (${identity.why}), so it is ${spellingAdmits ? "still read" : "not read"} as a system root by its name alone`;
+		following.report?.({
+			file: systemFilePath,
+			component: local,
+			kind: "warn",
+			message: `'${local}' is not proven to be Animus's createSystem: ${shown} — import createSystem from '@animus-ui/system', directly or through a re-export discovery can follow`,
+			code: UNPROVEN_ROOT_BINDING,
+			severity: severityFor(UNPROVEN_ROOT_BINDING),
+			...locationIn(source, offset)
+		});
+	};
+	for (const binding of imports) {
+		if (binding.imported === "createSystem" || binding.local === "createSystem") {
+			const statement = new RegExp(`\\bimport\\b[^;]*?\\bfrom\\s*['"]${escapeRegExp$1(binding.source)}['"]`, "g");
+			let offset = 0;
+			for (const match of source.matchAll(statement)) {
+				const at = match[0].search(new RegExp(`(?<![a-zA-Z0-9_$])${escapeRegExp$1(binding.local)}\\b`));
+				if (at !== -1) {
+					offset = match.index + at;
+					break;
+				}
+			}
+			admit(binding.local, offset, await identityOf(binding.source, binding.imported), binding.imported === "createSystem");
+			continue;
+		}
+		if (binding.source.startsWith(".") && called(binding.local) && (await identityOf(binding.source, binding.imported)).kind === "animus") roots.add(binding.local);
+	}
+	const namespaces = /* @__PURE__ */ new Map();
+	for (const [, namespace, specifier] of source.matchAll(NAMESPACE_IMPORT)) {
+		namespaces.set(namespace, specifier);
+		const member = `${namespace}.createSystem`;
+		if (ANIMUS_SYSTEM_SPECIFIER.test(specifier) || specifier.startsWith(".") && called(member) && (await identityOf(specifier, "createSystem")).kind === "animus") roots.add(member);
+	}
+	const destructuredFrom = (initializer) => {
+		const loaded = /^\(?\s*(?:(?:await\s+)?import|require)\(\s*['"]([^'"]+)['"]\s*\)\s*\)?$/.exec(initializer);
+		if (loaded) return identityOf(loaded[1], "createSystem");
+		const namespace = namespaces.get(initializer);
+		if (namespace !== void 0) return identityOf(namespace, "createSystem");
+		return Promise.resolve({
+			kind: "unknown",
+			why: `it is destructured from '${initializer}', which is not a module namespace`
+		});
+	};
+	for (const { local, offset, initializer } of destructuredCreateSystems(source)) admit(local, offset, await destructuredFrom(initializer), local === "createSystem");
+	const unimported = unimportedCreateSystemCall(systemFilePath, record);
+	if (unimported) following.report?.(unimported);
+	return roots;
+}
+/** A call of `callee` as a whole name, not a member. */
+function callOf(callee) {
+	return new RegExp(`(?<![a-zA-Z0-9_$.])${escapeRegExp$1(callee)}\\s*\\(`);
+}
+/** Each `createSystem` property a declaration destructures: its local name,
+*  its offset in `source`, and the destructured initializer. */
+function* destructuredCreateSystems(source) {
+	for (const match of source.matchAll(/\b(?:const|let|var)\s*\{([^}]*)\}\s*=\s*([^;\n]+)/g)) {
+		const [whole, pattern, initializer] = match;
+		for (const property of pattern.split(",")) {
+			const binding = /^\s*createSystem\s*(?::\s*([a-zA-Z_$][a-zA-Z0-9_$]*))?\s*(?:=[\s\S]*)?$/.exec(property);
+			if (!binding) continue;
+			yield {
+				local: binding[1] ?? "createSystem",
+				offset: match.index + whole.indexOf("createSystem"),
+				initializer: initializer.trim()
+			};
+		}
+	}
+}
+/** The warning for a `createSystem` call that the parser's scopes leave
+*  unbound: no import, declaration or parameter names it. Null when there is
+*  none, or when the parser reports no scopes. */
+function unimportedCreateSystemCall(systemFilePath, record) {
+	const call = record.unboundCreateSystemCalls?.[0];
+	if (!call) return null;
+	return {
+		file: systemFilePath,
+		component: "createSystem",
+		kind: "warn",
+		message: `'createSystem' is called with no import or local binding, so it is not read as a system root: the system loader evaluates this file without auto-imports, where the name is undefined — import createSystem from '@animus-ui/system'`,
+		code: UNIMPORTED_CREATE_SYSTEM,
+		severity: severityFor(UNIMPORTED_CREATE_SYSTEM),
+		line: call[0],
+		column: call[1]
+	};
+}
 /** A pattern matching a call of any of `callees` as a whole name, or null
 *  when there is none to anchor on. */
 function rootCallPattern(callees) {
 	if (callees.length === 0) return null;
 	return `(?<![a-zA-Z0-9_$.])(?:${callees.map((callee) => callee.replace(/[.$]/g, "\\$&")).join("|")})`;
 }
-function extractSystemFilePackages(systemFilePath, parseImports) {
+async function extractSystemFilePackages(systemFilePath, parseModule, report, resolvePackage) {
 	let source;
 	try {
 		source = (0, fs.readFileSync)(systemFilePath, "utf-8");
 	} catch {
 		return [];
 	}
-	const parsed = parseImports?.(source, systemFilePath) ?? null;
-	const parsedImports = parsed && parsed.length > 0 ? parsed : null;
+	const parsed = parseModule?.(source, systemFilePath) ?? null;
 	let rootCall = "createSystem";
-	if (parsedImports) {
-		const shadowed = parsedImports.some((binding) => binding.local === "createSystem" && binding.imported !== "createSystem") || /\b(?:function\*?|class)\s+createSystem\b|\b(?:const|let|var)\s+createSystem\b/.test(source);
-		rootCall = rootCallPattern([.../* @__PURE__ */ new Set([
-			...parsedImports.filter((binding) => binding.imported === "createSystem").map((binding) => binding.local),
-			...Array.from(source.matchAll(/\bimport\s+(?:[a-zA-Z_$][a-zA-Z0-9_$]*\s*,\s*)?\*\s*as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s+from\s+['"]@animus-ui\/system(?:\/[^'"]*)?['"]/g), (match) => `${match[1]}.createSystem`),
-			...shadowed ? [] : ["createSystem"]
-		])]);
-	}
+	if (parseModule && parsed) rootCall = rootCallPattern([...await systemRoots(systemFilePath, source, parsed, {
+		parseModule,
+		resolvePackage,
+		report
+	})]);
 	const identifiers = /* @__PURE__ */ new Set();
 	const constructorRegex = rootCall === null ? null : new RegExp(`${rootCall}\\s*\\(\\s*\\{[^}]*?\\bincludes\\s*:\\s*\\[([^\\]]*)\\]`, "gs");
 	const chainRegex = /\.includes\s*\(\s*\[([^\]]*)\]\s*\)/gs;
@@ -2626,239 +3471,94 @@ function extractSystemFilePackages(systemFilePath, parseImports) {
 			}
 		}
 	}
-	if (identifiers.size === 0) return [];
-	const importMap = /* @__PURE__ */ new Map();
-	for (const binding of parsedImports ?? []) importMap.set(binding.local, binding.source);
-	const importRegex = /^\s*import\s+(?:([a-zA-Z_$][a-zA-Z0-9_$]*)\s*,\s*)?(?:\{([^}]*)\}|([a-zA-Z_$][a-zA-Z0-9_$]*))\s+from\s+['"]([^'"]+)['"]/gm;
-	if (!parsedImports) {
-		let importMatch;
-		while ((importMatch = importRegex.exec(source)) !== null) {
-			const [, comboDefault, namedImports, defaultImport, specifier] = importMatch;
-			if (comboDefault) importMap.set(comboDefault, specifier);
-			if (defaultImport) importMap.set(defaultImport, specifier);
-			if (namedImports) for (const binding of namedImports.split(",")) {
-				const parts = binding.trim().split(/\s+as\s+/);
-				const localName = (parts[1] || parts[0]).trim();
-				if (localName) importMap.set(localName, specifier);
-			}
-		}
-	}
-	const systemFileDir = (0, path.dirname)(systemFilePath);
-	const packages = /* @__PURE__ */ new Set();
-	/** The import a local alias chain ends at, or the identifier itself. */
-	const throughAliases = (id) => {
-		const seen = /* @__PURE__ */ new Set();
-		let current = id;
-		while (!importMap.has(current) && !seen.has(current)) {
-			seen.add(current);
-			const target = aliasOf.get(current);
-			if (!target) break;
-			current = target;
-		}
-		return current;
-	};
-	for (const id of identifiers) {
-		const specifier = importMap.get(throughAliases(id));
-		if (!specifier) continue;
-		if (specifier.startsWith(".")) packages.add((0, path.resolve)(systemFileDir, specifier));
-		else packages.add(specifier);
-	}
-	return Array.from(packages);
-}
-//#endregion
-//#region pipeline/source-corpus.ts
-function assembleRawEntries({ fileCache, externalFileOwners }) {
-	const project = [];
-	const external = [];
-	for (const [path, { hash, source }] of fileCache) (externalFileOwners[path] === void 0 ? project : external).push({
-		path,
-		source,
-		hash
-	});
-	project.sort((a, b) => compareDiscoveryOrder(a.path, b.path));
-	return [...project, ...external];
-}
-function createSourceCorpus(host, ingestor = createSourceIngestor(host)) {
-	let published = {
-		analysisEntries: /* @__PURE__ */ new Map(),
-		ownership: {}
-	};
-	return {
-		async prepare(input) {
-			const rawEntries = "fileCache" in input ? assembleRawEntries(input) : input;
-			const ingested = await ingestor.ingest(rawEntries);
-			return withoutInvalidOriginals(ingested, ingestor.surfaceDiagnostics(ingested.diagnostics));
-		},
-		rejection(prepared) {
-			const aborted = (prepared.abortedParses ?? []).filter(({ originalPath }) => prepared.ownership[originalPath] !== void 0);
-			if (aborted.length === 0) return null;
-			const files = aborted.map(({ originalPath, messages }) => `${originalPath} (${messages.join("; ")})`).join(", ");
-			const owners = aborted.length === 1 ? "this file's" : "these files'";
-			return {
-				originals: new Map(aborted.map(({ originalPath, hash }) => [originalPath, hash])),
-				message: `${host.prefix} analysis not published: the parser stopped before the end of ${files}; fix the syntax error to publish ${owners} changes`
-			};
-		},
-		publish(accepted) {
-			ingestor.markPublished(accepted);
-			published = {
-				analysisEntries: new Map(accepted.analysisEntries.map((entry) => [entry.path, {
-					hash: entry.hash,
-					source: entry.source
-				}])),
-				ownership: accepted.ownership
-			};
-		},
-		get published() {
-			return published;
-		}
-	};
-}
-//#endregion
-//#region pipeline/asset-placeholders.ts
-const ASSET_PLACEHOLDER_PREFIX = "animus-asset:";
-const URL_OPEN_RE = /url\(\s*(['"]?)/gi;
-const IMAGE_SET_OPEN_RE = /(?:-webkit-)?image-set\(/gi;
-const BARE_SPECIFIER_RE = /^[^'")\s]+/;
-/** The index of the `)` that closes the `(` at `open`, outside strings. */
-function closingParen(css, open) {
-	let depth = 0;
-	let quote = null;
-	for (let i = open; i < css.length; i += 1) {
-		const c = css[i];
-		if (quote !== null) {
-			if (c === quote) quote = null;
-		} else if (c === "\"" || c === "'") quote = c;
-		else if (c === "(") depth += 1;
-		else if (c === ")") {
-			depth -= 1;
-			if (depth === 0) return i;
-		}
-	}
-	return css.length;
-}
-function quotedReference(css, quoteAt) {
-	const start = quoteAt + 1;
-	if (!css.startsWith("animus-asset:", start)) return null;
-	const end = css.indexOf(css[quoteAt], start);
-	if (end === -1) return null;
-	return {
-		start,
-		end,
-		specifier: css.slice(start + 13, end)
-	};
-}
-function assetReferences(css) {
-	if (!css.includes("animus-asset:")) return [];
-	const references = [];
-	for (const open of css.matchAll(URL_OPEN_RE)) {
-		const at = (open.index ?? 0) + open[0].length;
-		if (open[1]) {
-			const reference = quotedReference(css, at - 1);
-			if (reference) references.push(reference);
-			continue;
-		}
-		if (!css.startsWith("animus-asset:", at)) continue;
-		const specifier = BARE_SPECIFIER_RE.exec(css.slice(at + 13))?.[0];
-		if (specifier === void 0) continue;
-		const end = at + 13 + specifier.length;
-		references.push({
-			start: at,
-			end,
-			specifier
-		});
-	}
-	for (const open of css.matchAll(IMAGE_SET_OPEN_RE)) {
-		const paren = (open.index ?? 0) + open[0].length - 1;
-		const close = closingParen(css, paren);
-		let depth = 0;
-		let candidateStart = true;
-		for (let i = paren + 1; i < close; i += 1) {
-			const c = css[i];
-			if (/\s/.test(c)) continue;
-			if (c === "\"" || c === "'") {
-				if (depth === 0 && candidateStart) {
-					const reference = quotedReference(css, i);
-					if (reference) references.push(reference);
-				}
-				const end = css.indexOf(c, i + 1);
-				i = end === -1 ? close : end;
-			} else if (c === "(") depth += 1;
-			else if (c === ")") depth -= 1;
-			else if (c === "," && depth === 0) {
-				candidateStart = true;
-				continue;
-			}
-			candidateStart = false;
-		}
-	}
-	return references.sort((a, b) => a.start - b.start);
-}
-function findAssetSpecifiers(css) {
-	return [...new Set(assetReferences(css).map((reference) => reference.specifier))];
-}
-function substituteAssetPlaceholders(css, urlBySpecifier) {
-	if (urlBySpecifier.size === 0) return css;
-	let out = css;
-	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);
+	if (identifiers.size === 0) return [];
+	const importMap = /* @__PURE__ */ new Map();
+	for (const binding of parsed?.imports ?? []) importMap.set(binding.local, binding.source);
+	const importRegex = /^\s*import\s+(?:([a-zA-Z_$][a-zA-Z0-9_$]*)\s*,\s*)?(?:\{([^}]*)\}|([a-zA-Z_$][a-zA-Z0-9_$]*))\s+from\s+['"]([^'"]+)['"]/gm;
+	if (!parsed) {
+		let importMatch;
+		while ((importMatch = importRegex.exec(source)) !== null) {
+			const [, comboDefault, namedImports, defaultImport, specifier] = importMatch;
+			if (comboDefault) importMap.set(comboDefault, specifier);
+			if (defaultImport) importMap.set(defaultImport, specifier);
+			if (namedImports) for (const binding of namedImports.split(",")) {
+				const parts = binding.trim().split(/\s+as\s+/);
+				const localName = (parts[1] || parts[0]).trim();
+				if (localName) importMap.set(localName, specifier);
+			}
+		}
 	}
-	return out;
-}
-/**
-* Specifiers of placeholder text anywhere inside a `url()` or `image-set()`
-* call, a reference or not: after substitution any of it is a broken load.
-*/
-function placeholdersInAssetCalls(css) {
-	if (!css.includes("animus-asset:")) return [];
-	const calls = [...css.matchAll(URL_OPEN_RE), ...css.matchAll(IMAGE_SET_OPEN_RE)].map((open) => {
-		const paren = css.indexOf("(", open.index ?? 0);
-		return [paren, closingParen(css, paren)];
-	});
-	const found = /* @__PURE__ */ new Set();
-	for (let at = css.indexOf(ASSET_PLACEHOLDER_PREFIX); at !== -1; at = css.indexOf(ASSET_PLACEHOLDER_PREFIX, at + 1)) {
-		if (!calls.some(([open, close]) => open < at && at < close)) continue;
-		found.add(/^[^'")\s,]*/.exec(css.slice(at + 13))[0]);
+	const systemFileDir = (0, path.dirname)(systemFilePath);
+	const packages = /* @__PURE__ */ new Set();
+	/** The import a local alias chain ends at, or the identifier itself. */
+	const throughAliases = (id) => {
+		const seen = /* @__PURE__ */ new Set();
+		let current = id;
+		while (!importMap.has(current) && !seen.has(current)) {
+			seen.add(current);
+			const target = aliasOf.get(current);
+			if (!target) break;
+			current = target;
+		}
+		return current;
+	};
+	for (const id of identifiers) {
+		const specifier = importMap.get(throughAliases(id));
+		if (!specifier) continue;
+		if (specifier.startsWith(".")) packages.add((0, path.resolve)(systemFileDir, specifier));
+		else packages.add(specifier);
 	}
-	return [...found];
+	return Array.from(packages);
 }
-function findSheetAssetSpecifiers(sheets) {
-	return [.../* @__PURE__ */ new Set([
-		...findAssetSpecifiers(sheets.variableCss),
-		...findAssetSpecifiers(sheets.globalCss),
-		...findAssetSpecifiers(sheets.componentCss)
-	])];
+//#endregion
+//#region pipeline/source-corpus.ts
+function assembleRawEntries({ fileCache, externalFileOwners }) {
+	const project = [];
+	const external = [];
+	for (const [path, { hash, source }] of fileCache) (externalFileOwners[path] === void 0 ? project : external).push({
+		path,
+		source,
+		hash
+	});
+	project.sort((a, b) => compareDiscoveryOrder(a.path, b.path));
+	return [...project, ...external];
 }
-/** The one substitution step every emitted sheet passes through. */
-function substituteSheetAssets(sheets, urlBySpecifier) {
+function createSourceCorpus(host, ingestor = createSourceIngestor(host)) {
+	let published = {
+		analysisEntries: /* @__PURE__ */ new Map(),
+		ownership: {}
+	};
 	return {
-		variableCss: substituteAssetPlaceholders(sheets.variableCss, urlBySpecifier),
-		globalCss: substituteAssetPlaceholders(sheets.globalCss, urlBySpecifier),
-		componentCss: substituteAssetPlaceholders(sheets.componentCss, urlBySpecifier)
+		async prepare(input) {
+			const rawEntries = "fileCache" in input ? assembleRawEntries(input) : input;
+			const ingested = await ingestor.ingest(rawEntries);
+			return withoutInvalidOriginals(ingested, ingestor.surfaceDiagnostics(ingested.diagnostics));
+		},
+		rejection(prepared) {
+			const aborted = (prepared.abortedParses ?? []).filter(({ originalPath }) => prepared.ownership[originalPath] !== void 0);
+			if (aborted.length === 0) return null;
+			const files = aborted.map(({ originalPath, messages }) => `${originalPath} (${messages.join("; ")})`).join(", ");
+			const owners = aborted.length === 1 ? "this file's" : "these files'";
+			return {
+				originals: new Map(aborted.map(({ originalPath, hash }) => [originalPath, hash])),
+				message: `${host.prefix} analysis not published: the parser stopped before the end of ${files}; fix the syntax error to publish ${owners} changes`
+			};
+		},
+		publish(accepted) {
+			ingestor.markPublished(accepted);
+			published = {
+				analysisEntries: new Map(accepted.analysisEntries.map((entry) => [entry.path, {
+					hash: entry.hash,
+					source: entry.source
+				}])),
+				ownership: accepted.ownership
+			};
+		},
+		get published() {
+			return published;
+		}
 	};
 }
-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
 /**
@@ -3027,8 +3727,13 @@ function enforceExternalTokenContracts(opts) {
 		sourceTokens
 	});
 	if (messages.length === 0) return;
-	if (opts.strict) throw new Error(`${opts.prefix} ${messages.join("\n")}`);
-	for (const message of messages) opts.warn(message);
+	if (!opts.strict) {
+		for (const message of messages) opts.warn(message);
+		return;
+	}
+	const message = `${opts.prefix} ${messages.join("\n")}`;
+	if (!opts.reportErrors) throw new Error(message);
+	opts.reportErrors(message);
 }
 //#endregion
 //#region pipeline/path-aliases.ts
@@ -3640,11 +4345,14 @@ function buildAnalysisInputs(opts) {
 		externalDirsJson: opts.externalDirs?.length && hasSourceThemeManifests(opts.system) ? JSON.stringify(opts.externalDirs) : null
 	};
 	if (opts.system.declarationScalesJson) inputs.declarationScalesJson = opts.system.declarationScalesJson;
+	if (opts.system.generatedNamesJson) inputs.generatedNamesJson = opts.system.generatedNamesJson;
 	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 ?? []
+		packageDirs: context.packageDirs ?? [],
+		linkedDirs: context.linkedDirs ?? [],
+		outputDirs: context.outputDirs ?? []
 	});
 	return inputs;
 }
@@ -3660,9 +4368,12 @@ function hasSourceThemeManifests(system) {
 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) {
+function systemDiagnostics(system, strict, levels) {
 	const diagnostics = [...collectSelectorAliasDiagnostics(system.selectorAliasesJson), ...systemLoadDiagnostics(system)];
-	const blocking = strict === true && diagnostics.some((d) => d.severity === "error");
+	const blocking = diagnostics.some((d) => effectiveLevel(d, {
+		strict,
+		levels
+	}) === "error");
 	if (surfacedSystems.has(system) && !blocking) return [];
 	surfacedSystems.add(system);
 	return diagnostics;
@@ -3672,7 +4383,7 @@ function systemDiagnostics(system, strict) {
 * the call site (strict-mode throw vs warn).
 */
 function runProjectAnalysis(engineApi, opts) {
-	const { analyzeProject } = engineApi();
+	const { analyzeProject, diagnosticCodes } = engineApi();
 	let t = performance.now();
 	const inputs = buildAnalysisInputs(opts);
 	const serializeMs = Math.round(performance.now() - t);
@@ -3682,7 +4393,12 @@ function runProjectAnalysis(engineApi, opts) {
 	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 kitDiagnostics = kitDescriptorDiagnostics(opts.kitDescriptors ?? [], manifest);
+	if (systemErrors.length > 0 || kitDiagnostics.length > 0) manifest.diagnostics = [
+		...systemErrors,
+		...kitDiagnostics,
+		...manifest.diagnostics ?? []
+	];
 	const componentCss = applyUnitFallback(manifest.css);
 	const propertyDiagnostics = checkCustomProperties({
 		system: opts.system,
@@ -3693,8 +4409,11 @@ function runProjectAnalysis(engineApi, opts) {
 	surfaceManifestDiagnostics(manifest, opts.warn, {
 		strict: opts.strict,
 		info: opts.info,
+		reportErrors: opts.reportErrors,
+		levels: opts.diagnostics,
+		knownCodes: opts.diagnostics ? knownDiagnosticCodes(diagnosticCodes?.()) : void 0,
 		prepend: [
-			...systemDiagnostics(opts.system, opts.strict),
+			...systemDiagnostics(opts.system, opts.strict, opts.diagnostics),
 			...propertyDiagnostics,
 			...opts.extraDiagnostics ?? []
 		]
@@ -3798,36 +4517,34 @@ function renameCustomProperties(css, names) {
 }
 //#endregion
 //#region pipeline/prefix.ts
-/** Prefix variable references without changing their matching rules. */
-function prefixVariableReferences(prefix, value) {
-	if (!prefix) return value;
-	return value.replace(/var\(--([a-zA-Z][\w-]*)\)/g, `var(--${prefix}-$1)`);
-}
-function applyPrefix(prefix, variableMapJson, variableCss, themeJson, contextualVarsJson) {
+/**
+* The prefix without `prefixContextualVars`: every name Animus generates (a
+* variable the theme's map or variable CSS defines) takes `--${prefix}-`
+* wherever it is defined, registered or read, `var()` fallbacks at any depth
+* included. Every other name stays as written: each declared contextual
+* variable, and any custom property an author writes.
+*/
+function applyPrefix(prefix, variableMapJson, variableCss, themeJson, contextualVarsJson, declarationScalesJson) {
 	if (!prefix) return {
 		variableMapJson,
 		variableCss,
 		themeJson,
-		contextualVarsJson
+		contextualVarsJson,
+		declarationScalesJson
 	};
-	const map = JSON.parse(variableMapJson);
-	const prefixed = {};
-	for (const [key, varName] of Object.entries(map)) prefixed[key] = varName.startsWith("--") ? `--${prefix}-${varName.slice(2)}` : varName;
-	let css = variableCss;
-	css = css.replace(/--([a-zA-Z][\w-]*)\s*:/g, `--${prefix}-$1:`);
-	css = prefixVariableReferences(prefix, css);
-	css = css.replace(/@property(\s+)--([a-zA-Z][\w-]*)/g, `@property$1--${prefix}-$2`);
+	const contextual = new Set(contextualVarsJson ? Object.values(parseInternalWire(contextualVarsJson, "contextualVarsJson (the theme's contextual variable names)")).flat() : []);
+	const variableMap = parseInternalWire(variableMapJson, "variableMapJson (the theme's token variables)");
+	const generated = [...Object.values(variableMap).map((name) => name.replace(/^--/, "")), ...themeDefinitions(variableCss)].filter((name) => !contextual.has(name));
+	const names = createPropertyNames([], prefix, generated);
+	const rename = (value) => renameCustomProperties(value, names);
 	const result = {
-		variableMapJson: JSON.stringify(prefixed),
-		variableCss: css
+		variableMapJson: JSON.stringify(Object.fromEntries(Object.entries(variableMap).map(([key, name]) => [key, rename(name)]))),
+		variableCss: rename(variableCss)
 	};
-	if (themeJson) result.themeJson = prefixVariableReferences(prefix, themeJson);
-	if (contextualVarsJson) {
-		const ctxVars = JSON.parse(contextualVarsJson);
-		const prefixedCtx = {};
-		for (const [scale, names] of Object.entries(ctxVars)) prefixedCtx[scale] = names.map((name) => `${prefix}-${name}`);
-		result.contextualVarsJson = JSON.stringify(prefixedCtx);
-	}
+	if (themeJson) result.themeJson = renameTokenValues(themeJson, rename);
+	if (contextualVarsJson) result.contextualVarsJson = contextualVarsJson;
+	if (generated.length > 0) result.generatedNamesJson = JSON.stringify(Object.fromEntries(generated.map((name) => [name, `${prefix}-${name}`])));
+	if (declarationScalesJson) result.declarationScalesJson = renameDeclarationRecords(declarationScalesJson, rename);
 	return result;
 }
 /** The runtime's transport variables are `--animus-<prop>`. */
@@ -3843,7 +4560,8 @@ 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 themeDefined = [...Object.values(variableMap).map((name) => name.replace(/^--/, "")), ...themeDefinitions(artifacts.variableCss)];
+	const managed = createPropertyNames(declared, prefix, themeDefined);
 	const nameConflicts = [...[...new Set(declared)].flatMap((name) => {
 		const final = managed.finalName(name) ?? name;
 		return final.startsWith(TRANSPORT_NAMESPACE) ? [{
@@ -3867,11 +4585,30 @@ function applyPropertyNames(prefix, artifacts) {
 		}))]))),
 		declarationScalesJson: artifacts.declarationScalesJson === null ? null : renameDeclarationRecords(artifacts.declarationScalesJson, rename),
 		nameConflicts,
-		contextualProperties: [...new Set(declared)].map((name) => `--${managed.finalName(name) ?? name}`)
+		contextualProperties: [...new Set(declared)].map((name) => `--${managed.finalName(name) ?? name}`),
+		generatedNamesJson: generatedNamesJson(themeDefined.filter((name) => !declared.includes(name)), managed)
 	};
 }
-/** A custom property the theme's CSS defines or registers. */
-const THEME_DEFINITION = /(?:@property\s+|(?:^|[\s;{]))--([\w-]+)(?=\s*[:{])/g;
+/** The generated names' final names, for authored component styles. */
+function generatedNamesJson(names, managed) {
+	const entries = [...new Set(names)].flatMap((name) => {
+		const final = managed.finalName(name);
+		return final === void 0 ? [] : [[name, final]];
+	});
+	return entries.length === 0 ? null : JSON.stringify(Object.fromEntries(entries));
+}
+/** The custom properties the theme's CSS declares or `@property` registers,
+*  read as CSS tokenizes it: a name in a string or comment defines nothing. */
+function themeDefinitions(variableCss) {
+	const tokens = (0, _animus_ui_properties.tokenize)(variableCss).filter((token) => token.type !== "whitespace");
+	return tokens.flatMap((token, index) => {
+		if (token.type !== "ident" || !token.value.startsWith("--")) return [];
+		const previous = tokens[index - 1];
+		const declared = (previous === void 0 || previous.type === "{" || previous.type === ";") && tokens[index + 1]?.type === ":";
+		const registered = previous?.type === "at-keyword" && previous.value.toLowerCase() === "property";
+		return declared || registered ? [token.value.slice(2)] : [];
+	});
+}
 /** Renames inside the token map's values. */
 function renameTokenValues(themeJson, rename) {
 	const tokens = parseInternalWire(themeJson, "themeJson (the theme's flattened token values)");
@@ -3887,23 +4624,40 @@ function renameDeclarationRecords(declarationScalesJson, rename) {
 }
 //#endregion
 //#region pipeline/system-config.ts
+/** The loader's evaluation of the system file. A failure on a file that
+*  calls `createSystem` with no binding leads with discovery's warning line
+*  for it, then keeps the loader's own error. */
+function evaluateSystemModule(engine, systemPath, rootDir, conditions) {
+	try {
+		return engine.loadSystemModule(systemPath, rootDir, void 0, conditions);
+	} catch (error) {
+		let source;
+		try {
+			source = (0, fs.readFileSync)(systemPath, "utf-8");
+		} catch {
+			throw error;
+		}
+		const record = engineModuleParser(engine)?.(source, systemPath);
+		const call = record && unimportedCreateSystemCall(systemPath, record);
+		if (!call) throw error;
+		throw new Error(`${warnLine(call)}\n${String(error)}`, { cause: error });
+	}
+}
 /**
 * Load and normalize a SystemInstance; `prefix` namespaces every CSS
 * variable name. Error handling stays at the call site.
 */
 function loadSystemConfig(engineApi, opts) {
-	const { loadSystemModule } = engineApi();
-	const config = loadSystemModule(opts.systemPath, opts.rootDir);
+	const config = evaluateSystemModule(engineApi(), opts.systemPath, opts.rootDir, opts.conditions);
 	let scalesJson = config.scalesJson;
 	let variableMapJson = config.variableMapJson;
 	const registrations = splitInvalidPropertyRegistrations(config.variableCss);
 	let variableCss = registrations.css;
 	let contextualVarsJson = config.contextualVarsJson || null;
 	let declarationScalesJson = config.declarationScalesJson || null;
-	const declaredNames = Object.values(parseInternalWire(contextualVarsJson ?? "{}", "contextualVarsJson (the theme's contextual variable names)")).flat();
-	let contextualProperties = declaredNames.map((name) => `--${name}`);
-	let legacyPrefixedContextualVars = [];
+	let contextualProperties = Object.values(parseInternalWire(contextualVarsJson ?? "{}", "contextualVarsJson (the theme's contextual variable names)")).flat().map((name) => `--${name}`);
 	let prefixNameConflicts = [];
+	let generatedNamesJson;
 	if (opts.prefix && opts.prefixContextualVars) {
 		const resolved = applyPropertyNames(opts.prefix, {
 			variableMapJson,
@@ -3919,15 +4673,14 @@ function loadSystemConfig(engineApi, opts) {
 		contextualProperties = resolved.contextualProperties;
 		prefixNameConflicts = resolved.nameConflicts;
 		declarationScalesJson = resolved.declarationScalesJson;
+		generatedNamesJson = resolved.generatedNamesJson;
 	} else if (opts.prefix) {
-		legacyPrefixedContextualVars = declaredNames;
-		contextualProperties = declaredNames.map((name) => `--${opts.prefix}-${name}`);
-		const prefixed = applyPrefix(opts.prefix, variableMapJson, variableCss, scalesJson, contextualVarsJson || void 0);
+		const prefixed = applyPrefix(opts.prefix, variableMapJson, variableCss, scalesJson, contextualVarsJson || void 0, declarationScalesJson || void 0);
 		variableMapJson = prefixed.variableMapJson;
 		variableCss = prefixed.variableCss;
 		if (prefixed.themeJson) scalesJson = prefixed.themeJson;
-		if (prefixed.contextualVarsJson) contextualVarsJson = prefixed.contextualVarsJson;
-		if (declarationScalesJson) declarationScalesJson = prefixVariableReferences(opts.prefix, declarationScalesJson);
+		if (prefixed.declarationScalesJson) declarationScalesJson = prefixed.declarationScalesJson;
+		generatedNamesJson = prefixed.generatedNamesJson;
 	}
 	const system = {
 		propConfigJson: config.propConfig,
@@ -3951,7 +4704,7 @@ function loadSystemConfig(engineApi, opts) {
 	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)];
+	if (generatedNamesJson) system.generatedNamesJson = generatedNamesJson;
 	return system;
 }
 //#endregion
@@ -3960,8 +4713,7 @@ function runStructuralSelfCheck(input) {
 	const failures = [];
 	if (input.componentCount === 0) failures.push("No component CSS produced — check the system file and its includes list");
 	else if (input.assembledCss !== void 0 ? !/@layer\s+anm-base\s*\{/.test(input.assembledCss) : input.componentCss.trim().length === 0) failures.push(`${input.componentCount} component(s) discovered but the emitted component CSS is empty`);
-	for (const { specifier, outcome } of input.externalOutcomes ?? []) if (outcome === "empty") failures.push(`include '${specifier}' resolved but discovered no component sources`);
-	else if (outcome === "unresolvable") failures.push(`include '${specifier}' could not be resolved`);
+	for (const { specifier, outcome } of input.externalOutcomes ?? []) if (outcome === "unresolvable") failures.push(`include '${specifier}' could not be resolved`);
 	if ((input.variableMapJson == null || Object.keys(parseInternalWire(input.variableMapJson, "variableMapJson (the theme's token → variable map)")).length > 0) && !input.variableCss.includes(":root")) failures.push("No :root variable block found in variable CSS");
 	if ((input.assembledCss ?? `${input.variableCss}\n${input.globalCss}\n${input.componentCss}`).includes("__TRANSFORM__")) failures.push("Unresolved __TRANSFORM__ placeholders found in CSS output");
 	if (input.componentCount > 0 && (input.componentCss.length > 0 || input.assembledCss !== void 0)) {
@@ -3995,7 +4747,8 @@ function buildDynamicPropConfig(dynamicProps) {
 				kind: meta.kind,
 				slotClass: meta.slotClass,
 				memberVars: meta.memberVars,
-				declarationScaleValues: meta.declarationScaleValues
+				declarationScaleValues: meta.declarationScaleValues,
+				...meta.productionConditions && { productionConditions: meta.productionConditions }
 			};
 			continue;
 		}
@@ -4013,6 +4766,7 @@ function buildDynamicPropConfig(dynamicProps) {
 		if (meta.strict) entry.strict = true;
 		if (meta.keywords?.length) entry.keywords = meta.keywords;
 		if (meta.currentVar) entry.currentVar = meta.currentVar;
+		if (meta.productionConditions) entry.productionConditions = meta.productionConditions;
 		configEntries[propName] = entry;
 	}
 	return configEntries;
@@ -4051,6 +4805,191 @@ function assertNoErrorDiagnostics(diagnostics) {
 	throw new Error(lines.join("\n"));
 }
 //#endregion
+//#region pipeline/kit-publication.ts
+/** Source a kit publishes and the loader or a bundler parses for imports. */
+const CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const isFile = (path) => {
+	try {
+		return (0, node_fs.statSync)(path).isFile();
+	} catch {
+		return false;
+	}
+};
+const posixPath = (path) => path.split(node_path.sep).join("/");
+/**
+* The package-relative files `npm pack` publishes, read with npm's own rules
+* (`files`, `.npmignore`, `.gitignore` and the files npm always includes)
+* through a dry run that runs no scripts and needs no network.
+*/
+function npmPublishedFiles(pkgRoot) {
+	const windows = process.platform === "win32";
+	const run = (0, node_child_process.spawnSync)(windows ? "npm.cmd" : "npm", [
+		"pack",
+		"--dry-run",
+		"--json",
+		"--ignore-scripts"
+	], {
+		cwd: pkgRoot,
+		encoding: "utf-8",
+		shell: windows,
+		env: {
+			...process.env,
+			npm_config_update_notifier: "false"
+		}
+	});
+	if (run.error || run.status !== 0) return {
+		kind: "failed",
+		reason: `npm pack --dry-run could not list the published files: ${String(run.error ?? run.stderr.trim())}`
+	};
+	let output;
+	try {
+		output = JSON.parse(run.stdout);
+	} catch (error) {
+		return {
+			kind: "failed",
+			reason: `npm pack --dry-run printed no JSON: ${String(error)}`
+		};
+	}
+	const pack = Array.isArray(output) ? output[0] : void 0;
+	const files = isJsonBlock(pack) ? pack.files : void 0;
+	if (!Array.isArray(files)) return {
+		kind: "failed",
+		reason: "npm pack --dry-run printed no file list"
+	};
+	return {
+		kind: "listed",
+		files: new Set(files.flatMap((file) => isJsonBlock(file) && isJsonString(file.path) ? [posixPath(file.path)] : []))
+	};
+}
+function animusTargets(manifest) {
+	const targets = [];
+	const unreadable = [];
+	const visit = (subpath, value, underAnimus) => {
+		if (isJsonString(value)) {
+			if (underAnimus) targets.push([subpath, value]);
+		} else if (Array.isArray(value)) for (const entry of value) visit(subpath, entry, underAnimus);
+		else if (isJsonBlock(value)) for (const [key, entry] of Object.entries(value)) visit(subpath, entry, underAnimus || key === "animus");
+		else if (underAnimus && value !== null) unreadable.push([subpath, JSON.stringify(value)]);
+	};
+	for (const [subpath, value] of exportsSubpaths(manifest)) visit(subpath, value, false);
+	return {
+		targets,
+		unreadable
+	};
+}
+/** Every file in the package outside `node_modules` and `.git`,
+*  package-relative. */
+function packageFiles(pkgRoot, dir = "") {
+	return (0, node_fs.readdirSync)((0, node_path.join)(pkgRoot, dir), { withFileTypes: true }).flatMap((entry) => {
+		const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+		if (entry.isDirectory()) return entry.name === "node_modules" || entry.name === ".git" ? [] : packageFiles(pkgRoot, path);
+		return entry.isFile() ? [path] : [];
+	});
+}
+/** A `*` target pattern as a matcher of package-relative files. Node puts
+*  one subpath into every `*`, so each later `*` repeats the first match. */
+function targetPattern(target) {
+	const body = posixPath(target).replace(/^\.\//, "").split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).reduce((pattern, part, index) => index === 0 ? part : `${pattern}${index === 1 ? "(.+)" : "\\1"}${part}`);
+	return new RegExp(`^${body}$`);
+}
+/**
+* Why the kit at `pkgRoot` would fail an installed consumer: each `animus`
+* source target, at any condition depth or as a pattern, and each file its
+* relative imports reach, must be in the package and among the files `npm
+* pack` publishes, and each bare package import a declared dependency.
+* Each line names the file, the import and the cause; none means the
+* published source is complete. With `artifactDir`, a build's artifact
+* directory inside the package that `npm pack` would publish is a line too.
+*/
+function kitPublicationFailures(pkgRoot, engine, artifactDir) {
+	let manifest;
+	try {
+		manifest = JSON.parse((0, node_fs.readFileSync)((0, node_path.join)(pkgRoot, "package.json"), "utf-8"));
+	} catch (error) {
+		return [`package.json: cannot be read: ${String(error)}`];
+	}
+	const { targets, unreadable } = animusTargets(manifest);
+	if (targets.length === 0 && unreadable.length === 0) return [];
+	const { moduleSpecifiers } = engine;
+	if (moduleSpecifiers === void 0) throw new Error("the native engine does not expose moduleSpecifiers, which the kit publication check needs — rebuild @animus-ui/extract");
+	const publication = npmPublishedFiles(pkgRoot);
+	if (publication.kind === "failed") return [`package.json: ${publication.reason}`];
+	const published = (packageRelative) => publication.files.has(packageRelative);
+	const declared = new Set([
+		"dependencies",
+		"peerDependencies",
+		"optionalDependencies"
+	].flatMap((field) => {
+		const block = isJsonBlock(manifest) ? manifest[field] : void 0;
+		return isJsonBlock(block) ? Object.keys(block) : [];
+	}));
+	const ownName = isJsonBlock(manifest) && isJsonString(manifest.name) ? manifest.name : null;
+	const failures = [];
+	const rel = (file) => posixPath((0, node_path.relative)(pkgRoot, file));
+	const outside = (relPath) => relPath.startsWith("../") || (0, node_path.isAbsolute)(relPath);
+	for (const [subpath, value] of unreadable) failures.push(`package.json: exports["${subpath}"] has an "animus" value, ${value}, that is no target path`);
+	const queue = [];
+	const admit = (subpath, relPath) => {
+		if (published(relPath)) queue.push((0, node_path.resolve)(pkgRoot, relPath));
+		else failures.push(`package.json: the "animus" target of exports["${subpath}"], ${relPath}, is not in the published files`);
+	};
+	let files = null;
+	for (const [subpath, target] of targets) {
+		const relPath = rel((0, node_path.resolve)(pkgRoot, target));
+		if (outside(relPath)) failures.push(`package.json: the "animus" target of exports["${subpath}"], ${target}, is outside the package`);
+		else if (target.includes("*")) {
+			files ??= packageFiles(pkgRoot);
+			const pattern = targetPattern(target);
+			const matched = files.filter((file) => pattern.test(file));
+			if (matched.length === 0) failures.push(`package.json: the "animus" target of exports["${subpath}"], ${target}, matches no file in the package`);
+			for (const file of matched) admit(subpath, file);
+		} else if (!isFile((0, node_path.resolve)(pkgRoot, target))) failures.push(`package.json: the "animus" target of exports["${subpath}"], ${target}, does not exist in the package`);
+		else admit(subpath, relPath);
+	}
+	const visited = /* @__PURE__ */ new Set();
+	while (queue.length > 0) {
+		const file = queue.shift();
+		if (visited.has(file)) continue;
+		visited.add(file);
+		const specifiers = parseInternalWire(moduleSpecifiers(JSON.stringify([{
+			path: file,
+			source: (0, node_fs.readFileSync)(file, "utf-8")
+		}])), "moduleSpecifiers").files[file] ?? [];
+		for (const specifier of specifiers) {
+			if (specifier.startsWith(".")) {
+				const target = relativeSourceCandidates(file, specifier).find(isFile);
+				if (target === void 0) failures.push(`${rel(file)}: import '${specifier}' resolves to no file in the package`);
+				else if (outside(rel(target))) failures.push(`${rel(file)}: import '${specifier}' resolves to ${rel(target)}, outside the package`);
+				else if (!published(rel(target))) failures.push(`${rel(file)}: import '${specifier}' resolves to ${rel(target)}, which is not in the published files`);
+				else if (CODE_EXTENSIONS.has((0, node_path.extname)(target))) queue.push(target);
+				continue;
+			}
+			if (specifier.startsWith("/") || /^[a-z][\w+.-]*:/i.test(specifier)) {
+				if (!(0, node_module.isBuiltin)(specifier)) failures.push(`${rel(file)}: import '${specifier}' is not a package or relative import, so an installed consumer cannot resolve it`);
+				continue;
+			}
+			const name = bareSpecifierPackageName(specifier);
+			if ((0, node_module.isBuiltin)(name) || name === ownName || declared.has(name)) continue;
+			failures.push(`${rel(file)}: import '${specifier}' names the package ${name}, which package.json does not declare in dependencies, peerDependencies or optionalDependencies`);
+		}
+	}
+	const artifacts = artifactDir === void 0 ? "" : rel(artifactDir);
+	if (artifacts !== "" && !outside(artifacts)) {
+		const shipped = [...publication.files].filter((file) => file.startsWith(`${artifacts}/`));
+		if (shipped.length > 0) failures.push(`${artifacts}/: npm pack would publish this build-artifact directory (${shipped.length} files) — add "${artifacts}/" to .npmignore or .gitignore, or list the published files in package.json "files"`);
+	}
+	return failures;
+}
+//#endregion
 //#region pipeline/replacement-plans.ts
 const snapshotByManifest = /* @__PURE__ */ new WeakMap();
 /** `null` (a context before its first analysis) snapshots to the empty plan
@@ -4157,12 +5096,24 @@ Object.defineProperty(exports, "DEFAULT_EXTENSIONS", {
 		return DEFAULT_EXTENSIONS;
 	}
 });
+Object.defineProperty(exports, "DIAGNOSTIC_LEVELS", {
+	enumerable: true,
+	get: function() {
+		return DIAGNOSTIC_LEVELS;
+	}
+});
 Object.defineProperty(exports, "DRIVER_NAMESPACES", {
 	enumerable: true,
 	get: function() {
 		return DRIVER_NAMESPACES;
 	}
 });
+Object.defineProperty(exports, "DiagnosticFailure", {
+	enumerable: true,
+	get: function() {
+		return DiagnosticFailure;
+	}
+});
 Object.defineProperty(exports, "ENGINE_TRANSFORM_EXTENSIONS", {
 	enumerable: true,
 	get: function() {
@@ -4175,6 +5126,12 @@ Object.defineProperty(exports, "INVALID_PROPERTY_REGISTRATION", {
 		return INVALID_PROPERTY_REGISTRATION;
 	}
 });
+Object.defineProperty(exports, "KIT_DESCRIPTOR_FILE", {
+	enumerable: true,
+	get: function() {
+		return KIT_DESCRIPTOR_FILE;
+	}
+});
 Object.defineProperty(exports, "REPLACEABLE_DEFAULT_EXCLUDE", {
 	enumerable: true,
 	get: function() {
@@ -4265,6 +5222,12 @@ Object.defineProperty(exports, "buildDynamicPropConfig", {
 		return buildDynamicPropConfig;
 	}
 });
+Object.defineProperty(exports, "buildKitDescriptor", {
+	enumerable: true,
+	get: function() {
+		return buildKitDescriptor;
+	}
+});
 Object.defineProperty(exports, "buildPathAliasesJson", {
 	enumerable: true,
 	get: function() {
@@ -4349,10 +5312,10 @@ Object.defineProperty(exports, "enforceExternalTokenContracts", {
 		return enforceExternalTokenContracts;
 	}
 });
-Object.defineProperty(exports, "engineImportParser", {
+Object.defineProperty(exports, "engineModuleParser", {
 	enumerable: true,
 	get: function() {
-		return engineImportParser;
+		return engineModuleParser;
 	}
 });
 Object.defineProperty(exports, "excludeCollectedPackages", {
@@ -4367,6 +5330,12 @@ Object.defineProperty(exports, "extractSystemFilePackages", {
 		return extractSystemFilePackages;
 	}
 });
+Object.defineProperty(exports, "fileSideEffects", {
+	enumerable: true,
+	get: function() {
+		return fileSideEffects;
+	}
+});
 Object.defineProperty(exports, "findAssetSpecifiers", {
 	enumerable: true,
 	get: function() {
@@ -4403,6 +5372,12 @@ Object.defineProperty(exports, "hashReplacementPlans", {
 		return hashReplacementPlans;
 	}
 });
+Object.defineProperty(exports, "importedKitDiagnostics", {
+	enumerable: true,
+	get: function() {
+		return importedKitDiagnostics;
+	}
+});
 Object.defineProperty(exports, "ingestSourceEntries", {
 	enumerable: true,
 	get: function() {
@@ -4457,6 +5432,30 @@ Object.defineProperty(exports, "isUnresolvedParentDrop", {
 		return isUnresolvedParentDrop;
 	}
 });
+Object.defineProperty(exports, "keepsKitSourceEffects", {
+	enumerable: true,
+	get: function() {
+		return keepsKitSourceEffects;
+	}
+});
+Object.defineProperty(exports, "kitDescriptorDiagnostics", {
+	enumerable: true,
+	get: function() {
+		return kitDescriptorDiagnostics;
+	}
+});
+Object.defineProperty(exports, "kitPublicationFailures", {
+	enumerable: true,
+	get: function() {
+		return kitPublicationFailures;
+	}
+});
+Object.defineProperty(exports, "kitSourceModuleSideEffects", {
+	enumerable: true,
+	get: function() {
+		return kitSourceModuleSideEffects;
+	}
+});
 Object.defineProperty(exports, "loadSystemConfig", {
 	enumerable: true,
 	get: function() {
@@ -4499,6 +5498,12 @@ Object.defineProperty(exports, "projectExternalFileOwners", {
 		return projectExternalFileOwners;
 	}
 });
+Object.defineProperty(exports, "readKitDescriptor", {
+	enumerable: true,
+	get: function() {
+		return readKitDescriptor;
+	}
+});
 Object.defineProperty(exports, "readTsconfigAliasPairs", {
 	enumerable: true,
 	get: function() {
@@ -4577,6 +5582,12 @@ Object.defineProperty(exports, "snapshotFilePlans", {
 		return snapshotFilePlans;
 	}
 });
+Object.defineProperty(exports, "sourceKitDependencies", {
+	enumerable: true,
+	get: function() {
+		return sourceKitDependencies;
+	}
+});
 Object.defineProperty(exports, "stableStringify", {
 	enumerable: true,
 	get: function() {