@animus-ui/extract 0.1.22 → 0.1.24

package/dist/{pipeline-BXY7Pf_D.mjs → pipeline-Bl20tbu_.mjs}

@@ -1,13 +1,14 @@
-import { createRequire } from "node:module";
-import path, { basename, dirname, join, normalize, posix } from "node:path";
+import { createRequire, isBuiltin } from "node:module";
+import path, { basename, dirname, extname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "node:path";
 import { createHash } from "crypto";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "fs";
-import { dirname as dirname$1, extname, isAbsolute, join as join$1, relative, resolve, sep } from "path";
-import { realpathSync as realpathSync$1 } from "node:fs";
+import { dirname as dirname$1, extname as extname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, statSync as statSync$1 } from "node:fs";
 import { createRequire as createRequire$1 } from "module";
 import browserslist from "browserslist";
 import { browserslistToTargets, transform } from "lightningcss";
 import { componentValues, dependsOnContext, foldInitialValue, identifierAt, isSpace, isUnitlessProperty, someValue, substitutesValue, tokenize, variableReads } from "@animus-ui/properties";
+import { spawnSync } from "node:child_process";
 //#region \0rolldown/runtime.js
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
@@ -90,8 +91,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
@@ -111,7 +117,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";
@@ -124,6 +303,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) {
@@ -166,6 +420,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";
@@ -201,6 +471,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. */
@@ -226,9 +501,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";
@@ -242,6 +514,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"],
@@ -251,7 +530,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"]
@@ -306,15 +584,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}`,
@@ -326,7 +595,6 @@ function systemLoadDiagnostics(system) {
 	return [
 		...vocabularyWitnessDiagnostics(system.vocabularyWitnessesJson),
 		...registrations,
-		...unprefixed,
 		...conflicts,
 		...tokenCollisionDiagnostics(system)
 	];
@@ -362,29 +630,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
@@ -1036,17 +1319,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 = posix.normalize(posix.join(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;
 	}
@@ -1351,7 +1634,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} `)}`);
 			}
@@ -1365,7 +1649,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;
 		},
@@ -1392,7 +1677,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);
@@ -1420,6 +1707,7 @@ function createV2EngineApi(deps) {
 					transformProvenanceJson: transformProvenanceJson ?? void 0,
 					declarationScalesJson,
 					analysisContextJson,
+					generatedNamesJson,
 					devMode
 				};
 				const engine = new native.ExtractEngine(config);
@@ -1457,6 +1745,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",
@@ -1490,6 +1782,7 @@ const CORE_OPTION_KEYS = /* @__PURE__ */ new Set([
 	"exclude",
 	"extensions",
 	"strict",
+	"diagnostics",
 	"verbose",
 	"prefix",
 	"prefixContextualVars",
@@ -1549,6 +1842,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 = [
 	{
@@ -1571,6 +1865,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,
@@ -1731,7 +2030,7 @@ function walkFiles(dir, rootDir, exclude, extensionsSet) {
 	const isExcluded = exclude ? (full, rel) => exclude.matches(full, rel) : () => false;
 	for (const entry of entries) {
 		const fullPath = join$1(dir, entry);
-		if (isExcluded(fullPath, relative(rootDir, fullPath))) continue;
+		if (isExcluded(fullPath, relative$1(rootDir, fullPath))) continue;
 		let stat;
 		try {
 			stat = statSync(fullPath);
@@ -1739,182 +2038,74 @@ function walkFiles(dir, rootDir, exclude, extensionsSet) {
 			continue;
 		}
 		if (stat.isDirectory()) results.push(...walkFiles(fullPath, rootDir, exclude, extensionsSet));
-		else if (extensionsSet.has(extname(entry))) results.push(fullPath);
+		else if (extensionsSet.has(extname$1(entry))) results.push(fullPath);
 	}
 	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 = path) {
-	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 = path) {
-	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 realpathSync$1(p);
-	} catch {
-		return null;
-	}
-}
-function createSourceIdentity(rootDir) {
-	const normalizedRootDir = path.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 = path.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 = path.normalize(inputPath);
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			const owner = owningRecord(canonical);
-			const ownedBy = (record) => {
-				const pathInRoot = path.relative(record.canonical, canonical);
-				return {
-					sourceKey: path.relative(normalizedRootDir, path.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 = path.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(path.normalize(inputPath)) ?? null;
-		},
-		containingExternalRoot(inputPath) {
-			const lexical = path.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. */
@@ -1958,8 +2149,8 @@ function readConfig(path) {
 	};
 }
 function resolveExtendsTarget(specifier, fromDir) {
-	if (specifier.startsWith(".") || isAbsolute(specifier)) {
-		const base = resolve(fromDir, specifier);
+	if (specifier.startsWith(".") || isAbsolute$1(specifier)) {
+		const base = resolve$1(fromDir, specifier);
 		for (const candidate of [
 			base,
 			`${base}.json`,
@@ -1984,7 +2175,7 @@ function loadChain(entryPath) {
 	const queue = [entryPath];
 	while (queue.length > 0) {
 		const path = queue.shift();
-		const key = resolve(path);
+		const key = resolve$1(path);
 		if (visited.has(key)) continue;
 		visited.add(key);
 		const node = readConfig(key);
@@ -2009,7 +2200,7 @@ function readTsconfigAliasPairs(rootDir) {
 	if (pathsOwner === void 0 || paths === null) return [];
 	const baseOwner = chain.find((node) => node.baseUrl !== null);
 	const baseUrl = baseOwner?.baseUrl ?? null;
-	const base = baseOwner !== void 0 && baseUrl !== null ? resolve(baseOwner.dir, baseUrl) : pathsOwner.dir;
+	const base = baseOwner !== void 0 && baseUrl !== null ? resolve$1(baseOwner.dir, baseUrl) : pathsOwner.dir;
 	const pairs = [];
 	for (const [pattern, target] of paths) {
 		const patternStars = pattern.split("*").length - 1;
@@ -2019,7 +2210,7 @@ function readTsconfigAliasPairs(rootDir) {
 			if (!target.endsWith("/*")) continue;
 			pairs.push({
 				pattern: pattern.slice(0, -2),
-				target: resolve(base, target.slice(0, -2)),
+				target: resolve$1(base, target.slice(0, -2)),
 				kind: "prefix"
 			});
 			continue;
@@ -2027,13 +2218,223 @@ function readTsconfigAliasPairs(rootDir) {
 		if (patternStars > 0 || targetStars > 0) continue;
 		pairs.push({
 			pattern,
-			target: resolve(base, target),
+			target: resolve$1(base, target),
 			kind: "exact"
 		});
 	}
 	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(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 = join(pkgRoot, KIT_DESCRIPTOR_FILE);
+	if (!existsSync$1(path)) return null;
+	const packageRoot = posixPath$1(relative(rootDir, pkgRoot));
+	let wire;
+	try {
+		wire = JSON.parse(readFileSync$1(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 = path) {
+	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 = path) {
+	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
+	return volumeOf(a) === volumeOf(b);
+}
+function canonicalize(p) {
+	try {
+		return realpathSync$1(p);
+	} catch {
+		return null;
+	}
+}
+function createSourceIdentity(rootDir) {
+	const normalizedRootDir = path.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 = path.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 = path.normalize(inputPath);
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			const owner = owningRecord(canonical);
+			const ownedBy = (record) => {
+				const pathInRoot = path.relative(record.canonical, canonical);
+				return {
+					sourceKey: path.relative(normalizedRootDir, path.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 = path.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(path.normalize(inputPath)) ?? null;
+		},
+		containingExternalRoot(inputPath) {
+			const lexical = path.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 = dirname$1(absEntryPath);
@@ -2050,7 +2451,7 @@ function isExcludedPackageRelativePath(rel) {
 	return PACKAGE_SRC_EXCLUDES.some((pattern) => rel.includes(pattern));
 }
 function walkPackageSources(packageDir, extensionsSet) {
-	return discoverFiles(packageDir, packageDir, void 0, extensionsSet).filter((absPath) => !isExcludedPackageRelativePath(relative(packageDir, absPath)));
+	return discoverFiles(packageDir, packageDir, void 0, extensionsSet).filter((absPath) => !isExcludedPackageRelativePath(relative$1(packageDir, absPath)));
 }
 const PACKAGE_OUTPUT_EXCLUDES = [
 	"node_modules",
@@ -2059,7 +2460,7 @@ const PACKAGE_OUTPUT_EXCLUDES = [
 	".d.ts",
 	".map"
 ];
-const isFile = (path) => {
+const isFile$1 = (path) => {
 	try {
 		return statSync(path).isFile();
 	} catch {
@@ -2071,14 +2472,15 @@ function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
 		absSpecifier,
 		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
 		...Array.from(extensionsSet, (ext) => join$1(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];
 }
 function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
-	if (isAbsolute(specifier)) {
+	if (isAbsolute$1(specifier)) {
 		const resolved = resolveAbsolutePathSpecifier(specifier, extensionsSet);
 		if (!resolved) return null;
 		return isPathWithinRoot(srcDir, resolved) ? resolved : null;
@@ -2087,6 +2489,76 @@ function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
 	const subpath = specifier.slice(packageName.length + 1);
 	return resolveAbsolutePathSpecifier(join$1(srcDir, subpath || "index"), extensionsSet);
 }
+/** The package's parsed `package.json`, or null when it cannot be read. */
+function readPackageManifest(pkgRoot) {
+	try {
+		return JSON.parse(readFileSync(join$1(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 = resolve$1(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 ? dirname$1(file) : commonDirectory(root, dirname$1(file)), null);
+	return condition;
+}
+function commonDirectory(a, b) {
+	let dir = a;
+	while (!isPathWithinRoot(dir, b)) dir = dirname$1(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) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+/** 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 = dirname$1(dir)) {
+		const candidate = join$1(dir, "node_modules", name);
+		if (existsSync(join$1(candidate, "package.json"))) return realPath(candidate);
+		if (dir === dirname$1(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
@@ -2095,12 +2567,7 @@ function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
 * extglobs), which leaves the bundler's side-effectful default.
 */
 function readPackageSideEffects(pkgRoot) {
-	let manifest;
-	try {
-		manifest = JSON.parse(readFileSync(join$1(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;
@@ -2108,9 +2575,80 @@ 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 = relative(pkgRoot, file).split(sep).join("/");
+		const relPath = relative$1(pkgRoot, file).split(sep$1).join("/");
 		return globs.some((glob) => glob.test(relPath));
 	});
 }
@@ -2131,20 +2669,11 @@ 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(readFileSync(join$1(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, resolve(pkgRoot, target)]);
+		if (target !== null) entries.push([subpath, resolve$1(pkgRoot, target)]);
 	}
 	return entries;
 }
@@ -2181,6 +2710,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);
@@ -2193,6 +2732,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 = {};
@@ -2201,6 +2742,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 = relative$1(rootDir, file);
+		if (alreadyIngested(relPath)) return true;
+		let source;
+		try {
+			source = 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 {
@@ -2208,8 +2774,15 @@ async function collectExternalPackageSources(opts) {
 		} catch {
 			absEntry = null;
 		}
-		if (!absEntry && isAbsolute(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
-		if (!absEntry) {
+		if (!absEntry && isAbsolute$1(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		const packageName = isAbsolute$1(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",
@@ -2217,106 +2790,82 @@ 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 = join$1(pkgRoot, "src");
 		let fileCount = 0;
 		let staleDist = false;
-		if (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] = relative$1(rootDir, target);
+				await redirect(entrySpecifier, target, pkgRoot, () => shippedEntry(entrySpecifier, pkgRoot, entry));
+			}
+			packageMap[specifier] ??= relative$1(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 (existsSync(srcDir)) {
 			packageDirs.push(srcDir);
+			if (linked) linkedDirs.push(srcDir);
 			claimDir(srcDir, specifier);
 			dirExtensions[srcDir] = [...extensionsSet];
 			onPackageResolved?.(specifier, srcDir);
 			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
 			if (srcEntry) {
-				packageMap[specifier] = relative(rootDir, srcEntry);
+				packageMap[specifier] = relative$1(rootDir, srcEntry);
 				const replaced = absEntry;
 				await redirect(specifier, srcEntry, pkgRoot, async () => replaced);
-			} else packageMap[specifier] = relative(rootDir, absEntry);
-			if (!isAbsolute(specifier)) {
-				const packageName = bareSpecifierPackageName(specifier);
+			} else packageMap[specifier] = relative$1(rootDir, absEntry);
+			if (packageName) {
 				if (packageName !== specifier && !(packageName in packageMap)) {
 					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
 					if (rootEntry) {
-						packageMap[packageName] = relative(rootDir, rootEntry);
-						await redirect(packageName, rootEntry, pkgRoot, async () => {
-							try {
-								return await resolveSpecifier(packageName);
-							} catch {
-								return null;
-							}
-						});
+						packageMap[packageName] = relative$1(rootDir, rootEntry);
+						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 = relative(rootDir, pkgFile);
-				if (alreadyIngested(relPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = 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 = dirname$1(absEntry);
 			packageDirs.push(outputDir);
+			if (linked) linkedDirs.push(outputDir);
+			outputDirs.push(outputDir);
 			claimDir(outputDir, specifier);
 			onPackageResolved?.(specifier, outputDir);
-			packageMap[specifier] = relative(rootDir, absEntry);
+			packageMap[specifier] = relative$1(rootDir, absEntry);
 			const outputExtensions = new Set(extensionsSet);
-			outputExtensions.add(extname(absEntry));
+			outputExtensions.add(extname$1(absEntry));
 			dirExtensions[outputDir] = [...outputExtensions];
 			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
-				const relToOutput = relative(outputDir, file);
+				const relToOutput = relative$1(outputDir, file);
 				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
 			});
 			if (!outputFiles.includes(absEntry)) outputFiles.unshift(absEntry);
-			for (const outputFile of outputFiles) {
-				const outputRelPath = relative(rootDir, outputFile);
-				if (alreadyIngested(outputRelPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = 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 (!isAbsolute(specifier)) {
-			const packageName = bareSpecifierPackageName(specifier);
-			for (const [subpath, target] of packageExportEntries(pkgRoot)) {
-				const entrySpecifier = packageName + subpath.slice(1);
-				const targetRelPath = 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 = relative$1(rootDir, target);
+			if (entrySpecifier in packageMap || !alreadyIngested(targetRelPath)) continue;
+			packageMap[entrySpecifier] = targetRelPath;
 		}
 		outcomes.push({
 			specifier,
@@ -2330,12 +2879,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 }) => isEngineTransformExtension(path));
+	if (!extractFacts || parsed.length === 0) return [];
+	let facts;
+	try {
+		facts = parseInternalWire(extractFacts(JSON.stringify(parsed.map(({ path, source }) => ({
+			path,
+			source
+		})))), "extractFacts");
+	} catch {
+		return [];
+	}
+	const seen = new Set(systemKits.filter((specifier) => !isAbsolute$1(specifier)).map(bareSpecifierPackageName));
+	const diagnostics = [];
+	for (const [path, 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, dirname$1(resolve$1(rootDir, path)));
+			if (pkgRoot && readKitSourceCondition(pkgRoot)) diagnostics.push({
+				file: path,
+				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];
@@ -2348,7 +2997,7 @@ function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
 	const targetRejected = (specifier, absTarget) => rejectedSpecifiers.has(specifier) || underRejectedDir(absTarget);
 	const packageMap = {};
 	for (const [specifier, relTarget] of Object.entries(collected.packageMap)) {
-		if (targetRejected(specifier, resolve(rootDir, relTarget))) continue;
+		if (targetRejected(specifier, resolve$1(rootDir, relTarget))) continue;
 		packageMap[specifier] = relTarget;
 	}
 	const sourceEntries = /* @__PURE__ */ new Map();
@@ -2381,10 +3030,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(resolve$1(rootDir, record.packageRoot), dir)))
 	};
 }
 function unresolvableIncludesMessage(outcomes) {
@@ -2392,29 +3045,224 @@ function unresolvableIncludesMessage(outcomes) {
 	if (unresolvable.length === 0) return null;
 	return `[animus-extract] unresolvable include specifier(s): ${unresolvable.join(", ")}`;
 }
-/** A stale dist silently skews merged registry content while discovery
-*  compiles the fresh sources; null when no specifier is stale. */
-function staleDistIncludesMessage(outcomes) {
-	const stale = outcomes.filter((record) => record.outcome === "stale-dist").map((record) => record.specifier);
-	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`;
+/** A stale dist silently skews merged registry content while discovery
+*  compiles the fresh sources; null when no specifier is stale. */
+function staleDistIncludesMessage(outcomes) {
+	const stale = outcomes.filter((record) => record.outcome === "stale-dist").map((record) => record.specifier);
+	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 bindings, through its
+*  `extractFacts`; undefined for an engine without one. A parse that
+*  panicked counts as no parse. */
+function engineModuleParser(engine) {
+	const { extractFacts } = engine;
+	if (!extractFacts) return void 0;
+	return (source, path) => {
+		try {
+			const facts = parseInternalWire(extractFacts(JSON.stringify([{
+				path,
+				source
+			}])), "extractFacts").files[path];
+			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 = 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
+	};
 }
-/** The engine's own parse of a module's imports, through its
-*  `extractFacts`; undefined for an engine without one. A parse that
-*  panicked reports no imports, so it counts as no parse. */
-function engineImportParser(engine) {
-	const { extractFacts } = engine;
-	if (!extractFacts) return void 0;
-	return (source, path) => {
-		try {
-			const facts = parseInternalWire(extractFacts(JSON.stringify([{
-				path,
-				source
-			}])), "extractFacts").files[path];
-			return facts && !facts.parsePanicked ? facts.imports : null;
-		} catch {
-			return null;
+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
@@ -2423,24 +3271,20 @@ 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 = 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;
@@ -2608,9 +3452,9 @@ 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);
+	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 (!parsedImports) {
+	if (!parsed) {
 		let importMatch;
 		while ((importMatch = importRegex.exec(source)) !== null) {
 			const [, comboDefault, namedImports, defaultImport, specifier] = importMatch;
@@ -2640,7 +3484,7 @@ function extractSystemFilePackages(systemFilePath, parseImports) {
 	for (const id of identifiers) {
 		const specifier = importMap.get(throughAliases(id));
 		if (!specifier) continue;
-		if (specifier.startsWith(".")) packages.add(resolve(systemFileDir, specifier));
+		if (specifier.startsWith(".")) packages.add(resolve$1(systemFileDir, specifier));
 		else packages.add(specifier);
 	}
 	return Array.from(packages);
@@ -2695,151 +3539,6 @@ function createSourceCorpus(host, ingestor = createSourceIngestor(host)) {
 	};
 }
 //#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 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
 /**
 * Asset resolution for hosts with no bundler hook. Host path aliases apply
@@ -2888,7 +3587,7 @@ function resolveThroughPathAliases(specifier, rootDir, pathAliasesJson) {
 			if (alias.pattern === specifier) mapped = alias.replacement;
 		} else if (specifier.startsWith(alias.pattern)) mapped = alias.replacement + specifier.slice(alias.pattern.length);
 		if (mapped === null) continue;
-		const absolute = isAbsolute(mapped) ? mapped : join$1(rootDir, mapped);
+		const absolute = isAbsolute$1(mapped) ? mapped : join$1(rootDir, mapped);
 		if (existsSync(absolute)) return absolute;
 	}
 	return null;
@@ -3007,8 +3706,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
@@ -3620,11 +4324,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;
 }
@@ -3640,9 +4347,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;
@@ -3652,7 +4362,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);
@@ -3662,7 +4372,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,
@@ -3673,8 +4388,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 ?? []
 		]
@@ -3778,36 +4496,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>`. */
@@ -3823,7 +4539,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) ? [{
@@ -3847,11 +4564,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 = 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)");
@@ -3867,23 +4603,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 = 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,
@@ -3899,15 +4652,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,
@@ -3931,7 +4683,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
@@ -3940,8 +4692,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)) {
@@ -3975,7 +4726,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;
 		}
@@ -3993,6 +4745,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;
@@ -4031,6 +4784,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 statSync$1(path).isFile();
+	} catch {
+		return false;
+	}
+};
+const posixPath = (path) => path.split(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 = 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 readdirSync$1(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(readFileSync$1(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(relative(pkgRoot, file));
+	const outside = (relPath) => relPath.startsWith("../") || 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(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(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(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: readFileSync$1(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(extname(target))) queue.push(target);
+				continue;
+			}
+			if (specifier.startsWith("/") || /^[a-z][\w+.-]*:/i.test(specifier)) {
+				if (!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 (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
@@ -4107,4 +5045,4 @@ function realpathThroughNearestExistingAncestor(path) {
 	}
 }
 //#endregion
-export { DRIVER_NAMESPACES as $, createSourceCorpus as A, contentHash as At, unresolvableIncludesMessage as B, resolveThroughPathAliases as C, noKitFilesDiagnostics as Ct, reportSurvivingAssetPlaceholders as D, unresolvedParentName as Dt, generatedModuleCode as E, unreadableSourceDiagnostic as Et, findPackageRoot as F, validateLayerOrder as Ft, createSourceIdentity as G, isJsonBlock as H, firstOwners as I, __require as It, compareDiscoveryOrder as J, isPathWithinRoot as K, isExcludedPackageRelativePath as L, engineImportParser as M, ANIMUS_LAYERS as Mt, excludeCollectedPackages as N, assembleStylesheet as Nt, substituteAssetPlaceholders as O, vocabularyWitnessDiagnostics as Ot, extractSystemFilePackages as P, stripLeadingLayerDeclaration as Pt, DEFAULT_EXCLUDE as Q, resolveAbsolutePathSpecifier as R, resolveAssetFile as S, isUnresolvedParentDrop as St, findSheetAssetSpecifiers as T, systemLoadDiagnostics as Tt, isJsonString as U, walkPackageSources as V, readTsconfigAliasPairs as W, AnimusConfigError as X, discoverFiles as Y, CORE_OPTION_KEYS as Z, applyUnitFallback as _, preprocessMdx as _t, assertNoErrorDiagnostics as a, resolveVerbosity as at, buildPathAliasesJson as b, VOCABULARY_LEGACY_VERB as bt, runStructuralSelfCheck as c, createV2EngineApi as ct, serializeStaticCss as d, parseFilesJson as dt, REPLACEABLE_DEFAULT_EXCLUDE as et, camelToKebab as f, projectExternalFileOwners as ft, runProjectAnalysis as g, isEngineTransformExtension as gt, clearEngineCache as h, ENGINE_TRANSFORM_EXTENSIONS as ht, snapshotFilePlans as i, resolveMode as it, collectExternalPackageSources as j, buildAnalyzeProjectArgs as jt, substituteSheetAssets as k, parseInternalWire as kt, loadSystemConfig as l, ingestSourceEntries as lt, buildAnalysisInputs as m, DEFAULT_EXTENSIONS as mt, diffFilePlans as n, assertKnownOptionKeys as nt, buildSystemPropsModule as o, RETIRED_ENGINE_MESSAGE as ot, stableStringify as p, adaptSvelteSource as pt, sharesVolumeRoot as q, hashReplacementPlans as r, createExcludeMatcher as rt, buildDynamicPropConfig as s, assertNoRetiredEngineSelection as st, toWatchKeys as t, STRUCTURAL_EXCLUDE as tt, applyPrefix as u, isAdvisorySourceDiagnostic as ut, postProcessCss as v, INVALID_PROPERTY_REGISTRATION as vt, findAssetSpecifiers as w, surfaceManifestDiagnostics as wt, enforceExternalTokenContracts as x, isDeletedSource as xt, resolveLightningTargets as y, VOCABULARY_COLLISION as yt, staleDistIncludesMessage as z };
+export { discoverFiles as $, fileSideEffects as A, surfaceManifestDiagnostics as At, unresolvableIncludesMessage as B, substituteSheetAssets as Bt, resolveAssetFile as C, DiagnosticFailure as Ct, engineModuleParser as D, isDeletedSource as Dt, collectExternalPackageSources as E, VOCABULARY_LEGACY_VERB as Et, keepsKitSourceEffects as F, findAssetSpecifiers as Ft, KIT_DESCRIPTOR_FILE as G, assembleStylesheet as Gt, createSourceIdentity as H, contentHash as Ht, kitSourceModuleSideEffects as I, findSheetAssetSpecifiers as It, readKitDescriptor as J, __require as Jt, buildKitDescriptor as K, stripLeadingLayerDeclaration as Kt, resolveAbsolutePathSpecifier as L, generatedModuleCode as Lt, firstOwners as M, unreadableSourceDiagnostic as Mt, importedKitDiagnostics as N, unresolvedParentName as Nt, excludeCollectedPackages as O, isUnresolvedParentDrop as Ot, isExcludedPackageRelativePath as P, vocabularyWitnessDiagnostics as Pt, compareDiscoveryOrder as Q, sourceKitDependencies as R, reportSurvivingAssetPlaceholders as Rt, enforceExternalTokenContracts as S, DIAGNOSTIC_LEVELS as St, createSourceCorpus as T, VOCABULARY_COLLISION as Tt, isPathWithinRoot as U, buildAnalyzeProjectArgs as Ut, walkPackageSources as V, parseInternalWire as Vt, sharesVolumeRoot as W, ANIMUS_LAYERS as Wt, isJsonString as X, isJsonBlock as Y, readTsconfigAliasPairs as Z, runProjectAnalysis as _, adaptSvelteSource as _t, kitPublicationFailures as a, STRUCTURAL_EXCLUDE as at, resolveLightningTargets as b, isEngineTransformExtension as bt, buildDynamicPropConfig as c, resolveMode as ct, applyPrefix as d, assertNoRetiredEngineSelection as dt, AnimusConfigError as et, serializeStaticCss as f, createV2EngineApi as ft, clearEngineCache as g, projectExternalFileOwners as gt, buildAnalysisInputs as h, parseFilesJson as ht, snapshotFilePlans as i, REPLACEABLE_DEFAULT_EXCLUDE as it, findPackageRoot as j, systemLoadDiagnostics as jt, extractSystemFilePackages as k, noKitFilesDiagnostics as kt, runStructuralSelfCheck as l, resolveVerbosity as lt, stableStringify as m, isAdvisorySourceDiagnostic as mt, diffFilePlans as n, DEFAULT_EXCLUDE as nt, assertNoErrorDiagnostics as o, assertKnownOptionKeys as ot, camelToKebab as p, ingestSourceEntries as pt, kitDescriptorDiagnostics as q, validateLayerOrder as qt, hashReplacementPlans as r, DRIVER_NAMESPACES as rt, buildSystemPropsModule as s, createExcludeMatcher as st, toWatchKeys as t, CORE_OPTION_KEYS as tt, loadSystemConfig as u, RETIRED_ENGINE_MESSAGE as ut, applyUnitFallback as v, DEFAULT_EXTENSIONS as vt, resolveThroughPathAliases as w, INVALID_PROPERTY_REGISTRATION as wt, buildPathAliasesJson as x, preprocessMdx as xt, postProcessCss as y, ENGINE_TRANSFORM_EXTENSIONS as yt, staleDistIncludesMessage as z, substituteAssetPlaceholders as zt };