@animus-ui/extract 0.1.23 → 0.1.24

package/dist/{pipeline-kA3VEMgt.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
@@ -237,13 +243,17 @@ function substituteSheetAssets(sheets, 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. */
+*  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) throw new Error(message);
-	report.warn(message);
+	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
@@ -272,6 +282,15 @@ function locatedPrefix(diagnostic) {
 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";
@@ -290,10 +309,19 @@ const DIAGNOSTIC_LEVELS = /* @__PURE__ */ new Set([
 	"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 levelFor(code, levels) {
-	if (code === void 0 || levels === void 0) return void 0;
+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)) {
@@ -306,11 +334,19 @@ function levelFor(code, levels) {
 	}
 	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 an error-severity record under `strict`, else its own. */
+*  `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.code, policy.levels);
+	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";
 }
@@ -329,6 +365,7 @@ function knownDiagnosticCodes(engineCodesJson) {
 /** 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));
@@ -383,9 +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";
@@ -421,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. */
@@ -446,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";
@@ -462,7 +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"],
@@ -472,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"]
@@ -527,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}`,
@@ -547,7 +595,6 @@ function systemLoadDiagnostics(system) {
 	return [
 		...vocabularyWitnessDiagnostics(system.vocabularyWitnessesJson),
 		...registrations,
-		...unprefixed,
 		...conflicts,
 		...tokenCollisionDiagnostics(system)
 	];
@@ -583,13 +630,14 @@ 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(`⚠ 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)`);
+		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) {
@@ -598,22 +646,28 @@ function surfaceManifestDiagnostics(manifest, warn, policy = {}) {
 		let line = null;
 		const mark = level === "info" ? "ℹ" : "⚠";
 		const message = `${diagnostic.message}${droppedSuffix(diagnostic)}`;
-		if (diagnostic.kind === "bail") line = `${mark} ${locatedPrefix(diagnostic)}${diagnostic.component} not extracted: ${message}`;
-		else if (diagnostic.kind === "skip") line = `${mark} ${locatedPrefix(diagnostic)}${diagnostic.component}: skipped ${message}`;
-		else if (diagnostic.kind === "warn") line = `${mark} ${locationOf(diagnostic)}: ${diagnostic.component}: ${message}`;
+		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 (level === "info") {
 			policy.info?.(line);
 			continue;
 		}
 		if (level === "error") {
-			errors.push(`${diagnostic.code ?? "error"} — ${locatedPrefix(diagnostic)}${diagnostic.component}: ${message}`);
+			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 DiagnosticFailure(`[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
@@ -1580,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} `)}`);
 			}
@@ -1594,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;
 		},
@@ -1621,8 +1677,9 @@ function createV2EngineApi(deps) {
 		return {
 			loadSystemModule: (...args) => native.loadSystemModule(...args),
 			extractFacts: (filesJson) => native.extractFacts(filesJson),
+			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) => {
+			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);
@@ -1650,6 +1707,7 @@ function createV2EngineApi(deps) {
 					transformProvenanceJson: transformProvenanceJson ?? void 0,
 					declarationScalesJson,
 					analysisContextJson,
+					generatedNamesJson,
 					devMode
 				};
 				const engine = new native.ExtractEngine(config);
@@ -1972,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);
@@ -1980,119 +2038,11 @@ 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.
-*/
-/**
-* 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/tsconfig-paths.ts
 /**
 * tsconfig `paths` → alias pairs, for drivers with no live bundler config.
@@ -2199,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`,
@@ -2225,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);
@@ -2250,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;
@@ -2260,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;
@@ -2268,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);
@@ -2291,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",
@@ -2300,7 +2460,7 @@ const PACKAGE_OUTPUT_EXCLUDES = [
 	".d.ts",
 	".map"
 ];
-const isFile = (path) => {
+const isFile$1 = (path) => {
 	try {
 		return statSync(path).isFile();
 	} catch {
@@ -2312,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;
@@ -2328,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
@@ -2336,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;
@@ -2349,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));
 	});
 }
@@ -2372,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;
 }
@@ -2422,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);
@@ -2434,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 = {};
@@ -2442,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 {
@@ -2449,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",
@@ -2458,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,
@@ -2571,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];
@@ -2589,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();
@@ -2622,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) {
@@ -2654,7 +3066,8 @@ function engineModuleParser(engine) {
 			}])), "extractFacts").files[path];
 			return facts && !facts.parsePanicked ? {
 				imports: facts.imports,
-				exports: facts.exports
+				exports: facts.exports,
+				unboundCreateSystemCalls: facts.unboundCreateSystemCalls ?? []
 			} : null;
 		} catch {
 			return null;
@@ -2665,7 +3078,7 @@ 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) ?? null;
+	if (specifier.startsWith(".")) return relativeSourceCandidates(importer, specifier).find(isFile$1) ?? null;
 	try {
 		return await resolvePackage?.(specifier) ?? null;
 	} catch {
@@ -2750,13 +3163,15 @@ const NAMESPACE_IMPORT = /\bimport\s+(?:[a-zA-Z_$][a-zA-Z0-9_$]*\s*,\s*)?\*\s*as
 * `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. The bare name also anchors, as a global, unless
-* the file binds it.
+* 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, imports, following) {
+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) => new RegExp(`(?<![a-zA-Z0-9_$.])${escapeRegExp$1(callee)}\\s*\\(`).test(source);
+	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) => {
@@ -2776,11 +3191,8 @@ async function systemRoots(systemFilePath, source, imports, following) {
 			...locationIn(source, offset)
 		});
 	};
-	let bindsName = false;
 	for (const binding of imports) {
-		const named = binding.imported === "createSystem" || binding.local === "createSystem";
-		if (binding.local === "createSystem") bindsName = true;
-		if (named) {
+		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)) {
@@ -2811,19 +3223,47 @@ async function systemRoots(systemFilePath, source, imports, following) {
 			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;
-			const local = binding[1] ?? "createSystem";
-			if (local === "createSystem") bindsName = true;
-			admit(local, match.index + whole.indexOf("createSystem"), await destructuredFrom(initializer.trim()), local === "createSystem");
+			yield {
+				local: binding[1] ?? "createSystem",
+				offset: match.index + whole.indexOf("createSystem"),
+				initializer: initializer.trim()
+			};
 		}
 	}
-	const declaresName = /\b(?:function\*?|class)\s+createSystem\b|\b(?:const|let|var)\s+createSystem\b/.test(source);
-	if (!bindsName && !declaresName) roots.add("createSystem");
-	return roots;
+}
+/** The warning for a `createSystem` call that the parser's scopes leave
+*  unbound: no import, declaration or parameter names it. Null when there is
+*  none, or when the parser reports no scopes. */
+function unimportedCreateSystemCall(systemFilePath, record) {
+	const call = record.unboundCreateSystemCalls?.[0];
+	if (!call) return null;
+	return {
+		file: systemFilePath,
+		component: "createSystem",
+		kind: "warn",
+		message: `'createSystem' is called with no import or local binding, so it is not read as a system root: the system loader evaluates this file without auto-imports, where the name is undefined — import createSystem from '@animus-ui/system'`,
+		code: UNIMPORTED_CREATE_SYSTEM,
+		severity: severityFor(UNIMPORTED_CREATE_SYSTEM),
+		line: call[0],
+		column: call[1]
+	};
 }
 /** A pattern matching a call of any of `callees` as a whole name, or null
 *  when there is none to anchor on. */
@@ -2839,9 +3279,8 @@ async function extractSystemFilePackages(systemFilePath, parseModule, report, re
 		return [];
 	}
 	const parsed = parseModule?.(source, systemFilePath) ?? null;
-	const parsedImports = parsed && parsed.imports.length > 0 ? parsed.imports : null;
 	let rootCall = "createSystem";
-	if (parseModule && parsedImports) rootCall = rootCallPattern([...await systemRoots(systemFilePath, source, parsedImports, {
+	if (parseModule && parsed) rootCall = rootCallPattern([...await systemRoots(systemFilePath, source, parsed, {
 		parseModule,
 		resolvePackage,
 		report
@@ -3013,9 +3452,9 @@ async function extractSystemFilePackages(systemFilePath, parseModule, report, re
 	}
 	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;
@@ -3045,7 +3484,7 @@ async function extractSystemFilePackages(systemFilePath, parseModule, report, re
 	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);
@@ -3148,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;
@@ -3267,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
@@ -3880,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;
 }
@@ -3925,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,
@@ -3936,6 +4388,7 @@ 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: [
@@ -4043,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>`. */
@@ -4088,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) ? [{
@@ -4112,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)");
@@ -4132,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,
@@ -4164,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,
@@ -4196,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
@@ -4205,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 [${NO_KIT_FILES}]`);
-	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)) {
@@ -4240,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;
 		}
@@ -4258,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;
@@ -4296,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
@@ -4372,4 +5045,4 @@ function realpathThroughNearestExistingAncestor(path) {
 	}
 }
 //#endregion
-export { resolveVerbosity as $, firstOwners as A, substituteSheetAssets as At, isPathWithinRoot as B, resolveThroughPathAliases as C, unresolvedParentName as Ct, excludeCollectedPackages as D, generatedModuleCode as Dt, engineModuleParser as E, findSheetAssetSpecifiers as Et, walkPackageSources as F, assembleStylesheet as Ft, CORE_OPTION_KEYS as G, compareDiscoveryOrder as H, isJsonBlock as I, stripLeadingLayerDeclaration as It, REPLACEABLE_DEFAULT_EXCLUDE as J, DEFAULT_EXCLUDE as K, isJsonString as L, validateLayerOrder as Lt, resolveAbsolutePathSpecifier as M, contentHash as Mt, staleDistIncludesMessage as N, buildAnalyzeProjectArgs as Nt, extractSystemFilePackages as O, reportSurvivingAssetPlaceholders as Ot, unresolvableIncludesMessage as P, ANIMUS_LAYERS as Pt, resolveMode as Q, readTsconfigAliasPairs as R, __require as Rt, resolveAssetFile as S, unreadableSourceDiagnostic as St, collectExternalPackageSources as T, findAssetSpecifiers as Tt, discoverFiles as U, sharesVolumeRoot as V, AnimusConfigError as W, assertKnownOptionKeys as X, STRUCTURAL_EXCLUDE as Y, createExcludeMatcher as Z, applyUnitFallback as _, isDeletedSource as _t, assertNoErrorDiagnostics as a, parseFilesJson as at, buildPathAliasesJson as b, surfaceManifestDiagnostics as bt, runStructuralSelfCheck as c, DEFAULT_EXTENSIONS as ct, serializeStaticCss as d, preprocessMdx as dt, RETIRED_ENGINE_MESSAGE as et, camelToKebab as f, DIAGNOSTIC_LEVELS as ft, runProjectAnalysis as g, VOCABULARY_LEGACY_VERB as gt, clearEngineCache as h, VOCABULARY_COLLISION as ht, snapshotFilePlans as i, isAdvisorySourceDiagnostic as it, isExcludedPackageRelativePath as j, parseInternalWire as jt, findPackageRoot as k, substituteAssetPlaceholders as kt, loadSystemConfig as l, ENGINE_TRANSFORM_EXTENSIONS as lt, buildAnalysisInputs as m, INVALID_PROPERTY_REGISTRATION as mt, diffFilePlans as n, createV2EngineApi as nt, buildSystemPropsModule as o, projectExternalFileOwners as ot, stableStringify as p, DiagnosticFailure as pt, DRIVER_NAMESPACES as q, hashReplacementPlans as r, ingestSourceEntries as rt, buildDynamicPropConfig as s, adaptSvelteSource as st, toWatchKeys as t, assertNoRetiredEngineSelection as tt, applyPrefix as u, isEngineTransformExtension as ut, postProcessCss as v, isUnresolvedParentDrop as vt, createSourceCorpus as w, vocabularyWitnessDiagnostics as wt, enforceExternalTokenContracts as x, systemLoadDiagnostics as xt, resolveLightningTargets as y, noKitFilesDiagnostics as yt, createSourceIdentity 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 };