@animus-ui/extract 0.1.23 → 0.1.25

package/dist/{pipeline-B3JzXiSY.cjs → pipeline-DOgKR4VZ.cjs}

@@ -31,6 +31,8 @@ let browserslist = require("browserslist");
 browserslist = __toESM(browserslist);
 let lightningcss = require("lightningcss");
 let _animus_ui_properties = require("@animus-ui/properties");
+let node_child_process = require("node:child_process");
+let node_module = require("node:module");
 //#region pipeline/assemble-stylesheet.ts
 /**
 * The cascade layer order, outermost first: its one definition. The engine
@@ -110,8 +112,14 @@ 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,
+		inputs.propertyRecordsJson
+	];
+	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
@@ -257,13 +265,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
@@ -292,6 +304,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";
@@ -310,10 +331,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)) {
@@ -326,11 +356,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";
 }
@@ -349,6 +387,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));
@@ -403,9 +442,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 whose exports do not all target
+*  TypeScript source: 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";
@@ -441,6 +493,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. */
@@ -466,9 +523,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";
@@ -482,7 +536,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"],
@@ -492,7 +552,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"]
@@ -547,15 +606,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}`,
@@ -567,7 +617,6 @@ function systemLoadDiagnostics(system) {
 	return [
 		...vocabularyWitnessDiagnostics(system.vocabularyWitnessesJson),
 		...registrations,
-		...unprefixed,
 		...conflicts,
 		...tokenCollisionDiagnostics(system)
 	];
@@ -603,13 +652,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) {
@@ -618,22 +668,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
@@ -1600,7 +1656,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} `)}`);
 			}
@@ -1614,7 +1671,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;
 		},
@@ -1641,8 +1699,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, propertyRecordsJson) => {
 				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);
@@ -1670,6 +1729,8 @@ function createV2EngineApi(deps) {
 					transformProvenanceJson: transformProvenanceJson ?? void 0,
 					declarationScalesJson,
 					analysisContextJson,
+					generatedNamesJson,
+					propertyRecordsJson,
 					devMode
 				};
 				const engine = new native.ExtractEngine(config);
@@ -2005,114 +2066,6 @@ function walkFiles(dir, rootDir, exclude, extensionsSet) {
 	return results;
 }
 //#endregion
-//#region pipeline/source-identity.ts
-/**
-* One derivation of source identity for discovery, watch ingestion, ownership
-* and deletion: event paths are lookup INPUTS only and never fork identity.
-*/
-/**
-* True when `target` is `root` or a descendant, decided by `relative()`
-* shape: string prefixing would let `/ui` claim `/ui-old`.
-*/
-function isPathWithinRoot(root, target, pathApi = node_path.default) {
-	const rel = pathApi.relative(root, target);
-	return rel === "" || !pathApi.isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + pathApi.sep);
-}
-/**
-* True when two paths share a platform root (win32 drive letter or UNC
-* share; always true on posix). Drive letters compare case-insensitively.
-*/
-function sharesVolumeRoot(a, b, pathApi = node_path.default) {
-	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
-	return volumeOf(a) === volumeOf(b);
-}
-function canonicalize(p) {
-	try {
-		return (0, node_fs.realpathSync)(p);
-	} catch {
-		return null;
-	}
-}
-function createSourceIdentity(rootDir) {
-	const normalizedRootDir = node_path.default.normalize(rootDir);
-	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
-	const roots = [];
-	const aliases = /* @__PURE__ */ new Map();
-	const owningRecord = (canonicalPath) => {
-		let owner = null;
-		for (const record of roots) {
-			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
-			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-		}
-		return owner;
-	};
-	return {
-		rootDir: normalizedRootDir,
-		canonicalRootDir,
-		registerExternalRoot(root) {
-			const asRegistered = node_path.default.normalize(root);
-			const canonical = canonicalize(asRegistered) ?? asRegistered;
-			const existing = roots.find((record) => record.canonical === canonical);
-			if (existing) return existing.canonical;
-			roots.push({
-				asRegistered,
-				canonical
-			});
-			return canonical;
-		},
-		externalRoots() {
-			return roots.map((record) => record.canonical);
-		},
-		resolveSourceId(inputPath) {
-			const lexical = node_path.default.normalize(inputPath);
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			const owner = owningRecord(canonical);
-			const ownedBy = (record) => {
-				const pathInRoot = node_path.default.relative(record.canonical, canonical);
-				return {
-					sourceKey: node_path.default.relative(normalizedRootDir, node_path.default.join(record.asRegistered, pathInRoot)),
-					owningRoot: record.canonical,
-					pathInRoot
-				};
-			};
-			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
-			let resolved;
-			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
-				const key = node_path.default.relative(canonicalRootDir, canonical);
-				resolved = {
-					sourceKey: key,
-					owningRoot: null,
-					pathInRoot: key
-				};
-			} else if (owner) resolved = ownedBy(owner);
-			else return null;
-			aliases.set(lexical, resolved);
-			aliases.set(canonical, resolved);
-			return resolved;
-		},
-		resolveDeletedSourceId(inputPath) {
-			return aliases.get(node_path.default.normalize(inputPath)) ?? null;
-		},
-		containingExternalRoot(inputPath) {
-			const lexical = node_path.default.normalize(inputPath);
-			let owner = null;
-			for (const record of roots) {
-				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
-				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-			}
-			if (owner) return owner.canonical;
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			for (const record of roots) {
-				if (!isPathWithinRoot(record.canonical, canonical)) continue;
-				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-			}
-			return owner?.canonical ?? null;
-		}
-	};
-}
-//#endregion
 //#region pipeline/tsconfig-paths.ts
 /**
 * tsconfig `paths` → alias pairs, for drivers with no live bundler config.
@@ -2196,10 +2149,10 @@ function decodePaths(value) {
 function decodeExtends(value) {
 	return (Array.isArray(value) ? value : [value]).filter(isJsonString);
 }
-function readConfig(path$4) {
+function readConfig(path$8) {
 	let raw;
 	try {
-		raw = (0, fs.readFileSync)(path$4, "utf-8");
+		raw = (0, fs.readFileSync)(path$8, "utf-8");
 	} catch {
 		return null;
 	}
@@ -2212,7 +2165,7 @@ function readConfig(path$4) {
 	const root = isJsonBlock(parsed) ? parsed : {};
 	const compilerOptions = isJsonBlock(root.compilerOptions) ? root.compilerOptions : {};
 	return {
-		dir: (0, path.dirname)(path$4),
+		dir: (0, path.dirname)(path$8),
 		baseUrl: isJsonString(compilerOptions.baseUrl) ? compilerOptions.baseUrl : null,
 		paths: decodePaths(compilerOptions.paths),
 		extends: decodeExtends(root.extends)
@@ -2244,8 +2197,8 @@ function loadChain(entryPath) {
 	const visited = /* @__PURE__ */ new Set();
 	const queue = [entryPath];
 	while (queue.length > 0) {
-		const path$5 = queue.shift();
-		const key = (0, path.resolve)(path$5);
+		const path$9 = queue.shift();
+		const key = (0, path.resolve)(path$9);
 		if (visited.has(key)) continue;
 		visited.add(key);
 		const node = readConfig(key);
@@ -2295,6 +2248,216 @@ function readTsconfigAliasPairs(rootDir) {
 	return pairs;
 }
 //#endregion
+//#region pipeline/kit-descriptor.ts
+/** A kit's description, which `animus build --kit` writes at its package
+*  root and the kit exports as `./animus.json`. */
+const KIT_DESCRIPTOR_FILE = "animus.json";
+/** A path with `/` separators, as descriptors key their components. */
+function posixPath$1(path) {
+	return path.split(node_path.sep).join("/");
+}
+/** The descriptor of the kit a build analysed. */
+function buildKitDescriptor(manifest) {
+	const components = {};
+	for (const id of Object.keys(manifest.components).sort()) {
+		const component = manifest.components[id];
+		components[posixPath$1(id)] = {
+			definition: component.definition_fingerprint,
+			runtimeProps: [...new Set(component.system_prop_names)].sort()
+		};
+	}
+	return {
+		format: 1,
+		system: manifest.system_fingerprint,
+		components
+	};
+}
+/** Reads the descriptor at a kit's package root; `null` when it has none. */
+function readKitDescriptor(pkgRoot, rootDir) {
+	const path = (0, node_path.join)(pkgRoot, KIT_DESCRIPTOR_FILE);
+	if (!(0, node_fs.existsSync)(path)) return null;
+	const packageRoot = posixPath$1((0, node_path.relative)(rootDir, pkgRoot));
+	let wire;
+	try {
+		wire = JSON.parse((0, node_fs.readFileSync)(path, "utf-8"));
+	} catch {
+		return {
+			packageRoot,
+			unreadable: "is not valid JSON: rebuild it with animus build --kit"
+		};
+	}
+	const block = isJsonBlock(wire) ? wire : {};
+	if (block.format !== 1) return {
+		packageRoot,
+		unreadable: `declares descriptor format ${JSON.stringify(block.format ?? null)}, which this Animus does not read (it reads format 1): upgrade Animus, or install a kit built for this version`
+	};
+	const definitions = {};
+	const components = isJsonBlock(block.components) ? block.components : {};
+	for (const [id, component] of Object.entries(components)) {
+		const definition = isJsonBlock(component) ? component.definition : null;
+		if (isJsonString(definition)) definitions[posixPath$1(id)] = definition;
+	}
+	return {
+		packageRoot,
+		definitions
+	};
+}
+/**
+* A descriptor in a format this Animus cannot read fails the build; one
+* whose component definitions differ from the kit's shipped source, as the
+* analysis read it, or that describes a component its analysed file no
+* longer declares, was built from other source and is stale.
+*/
+function kitDescriptorDiagnostics(records, manifest) {
+	if (records.length === 0) return [];
+	const diagnostics = [];
+	const analysedById = new Map(Object.entries(manifest.components).map(([id, component]) => [posixPath$1(id), component]));
+	const analysedFiles = new Set(Object.keys(manifest.fileFacts).map(posixPath$1));
+	const declared = new Set(Object.entries(manifest.fileFacts).flatMap(([file, facts]) => facts.chains.map((chain) => `${posixPath$1(file)}::${chain.descriptor.binding}`)));
+	for (const record of records) {
+		const file = `${record.packageRoot}/${KIT_DESCRIPTOR_FILE}`;
+		if ("unreadable" in record) {
+			diagnostics.push({
+				file,
+				component: "kit",
+				kind: "error",
+				message: record.unreadable,
+				code: KIT_UNSUPPORTED_FORMAT,
+				severity: severityFor(KIT_UNSUPPORTED_FORMAT)
+			});
+			continue;
+		}
+		for (const [id, definition] of Object.entries(record.definitions)) {
+			const key = `${record.packageRoot}/${id}`;
+			const analysed = analysedById.get(key);
+			const fileAnalysed = analysedFiles.has(key.slice(0, key.lastIndexOf("::")));
+			let stale;
+			if (analysed) {
+				if (analysed.definition_fingerprint === definition) continue;
+				stale = `describes ${id} with a definition other than the one its shipped source declares`;
+			} else if (fileAnalysed && !declared.has(key)) stale = `describes ${id}, which its shipped source no longer declares`;
+			else continue;
+			diagnostics.push({
+				file,
+				component: analysed?.binding ?? id.slice(id.lastIndexOf("::") + 2),
+				kind: "warn",
+				message: `${stale}, so the descriptor is stale: rebuild it with animus build --kit`,
+				code: KIT_STALE_DESCRIPTOR,
+				severity: severityFor(KIT_STALE_DESCRIPTOR)
+			});
+		}
+	}
+	return diagnostics;
+}
+//#endregion
+//#region pipeline/source-identity.ts
+/**
+* One derivation of source identity for discovery, watch ingestion, ownership
+* and deletion: event paths are lookup INPUTS only and never fork identity.
+*/
+/**
+* True when `target` is `root` or a descendant, decided by `relative()`
+* shape: string prefixing would let `/ui` claim `/ui-old`.
+*/
+function isPathWithinRoot(root, target, pathApi = node_path.default) {
+	const rel = pathApi.relative(root, target);
+	return rel === "" || !pathApi.isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + pathApi.sep);
+}
+/**
+* True when two paths share a platform root (win32 drive letter or UNC
+* share; always true on posix). Drive letters compare case-insensitively.
+*/
+function sharesVolumeRoot(a, b, pathApi = node_path.default) {
+	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
+	return volumeOf(a) === volumeOf(b);
+}
+function canonicalize(p) {
+	try {
+		return (0, node_fs.realpathSync)(p);
+	} catch {
+		return null;
+	}
+}
+function createSourceIdentity(rootDir) {
+	const normalizedRootDir = node_path.default.normalize(rootDir);
+	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
+	const roots = [];
+	const aliases = /* @__PURE__ */ new Map();
+	const owningRecord = (canonicalPath) => {
+		let owner = null;
+		for (const record of roots) {
+			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
+			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+		}
+		return owner;
+	};
+	return {
+		rootDir: normalizedRootDir,
+		canonicalRootDir,
+		registerExternalRoot(root) {
+			const asRegistered = node_path.default.normalize(root);
+			const canonical = canonicalize(asRegistered) ?? asRegistered;
+			const existing = roots.find((record) => record.canonical === canonical);
+			if (existing) return existing.canonical;
+			roots.push({
+				asRegistered,
+				canonical
+			});
+			return canonical;
+		},
+		externalRoots() {
+			return roots.map((record) => record.canonical);
+		},
+		resolveSourceId(inputPath) {
+			const lexical = node_path.default.normalize(inputPath);
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			const owner = owningRecord(canonical);
+			const ownedBy = (record) => {
+				const pathInRoot = node_path.default.relative(record.canonical, canonical);
+				return {
+					sourceKey: node_path.default.relative(normalizedRootDir, node_path.default.join(record.asRegistered, pathInRoot)),
+					owningRoot: record.canonical,
+					pathInRoot
+				};
+			};
+			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
+			let resolved;
+			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
+				const key = node_path.default.relative(canonicalRootDir, canonical);
+				resolved = {
+					sourceKey: key,
+					owningRoot: null,
+					pathInRoot: key
+				};
+			} else if (owner) resolved = ownedBy(owner);
+			else return null;
+			aliases.set(lexical, resolved);
+			aliases.set(canonical, resolved);
+			return resolved;
+		},
+		resolveDeletedSourceId(inputPath) {
+			return aliases.get(node_path.default.normalize(inputPath)) ?? null;
+		},
+		containingExternalRoot(inputPath) {
+			const lexical = node_path.default.normalize(inputPath);
+			let owner = null;
+			for (const record of roots) {
+				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			if (owner) return owner.canonical;
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			for (const record of roots) {
+				if (!isPathWithinRoot(record.canonical, canonical)) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			return owner?.canonical ?? null;
+		}
+	};
+}
+//#endregion
 //#region pipeline/discover-packages.ts
 function findPackageRoot(absEntryPath) {
 	let pkgRoot = (0, path.dirname)(absEntryPath);
@@ -2320,7 +2483,7 @@ const PACKAGE_OUTPUT_EXCLUDES = [
 	".d.ts",
 	".map"
 ];
-const isFile = (path$2) => {
+const isFile$1 = (path$2) => {
 	try {
 		return (0, fs.statSync)(path$2).isFile();
 	} catch {
@@ -2332,8 +2495,9 @@ function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
 		absSpecifier,
 		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
 		...Array.from(extensionsSet, (ext) => (0, path.join)(absSpecifier, `index${ext}`))
-	].find(isFile) ?? null;
+	].find(isFile$1) ?? null;
 }
+/** The package a bare specifier names: `@scope/name` or `name`. */
 function bareSpecifierPackageName(specifier) {
 	const segments = specifier.split("/");
 	return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
@@ -2348,6 +2512,103 @@ function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
 	const subpath = specifier.slice(packageName.length + 1);
 	return resolveAbsolutePathSpecifier((0, path.join)(srcDir, subpath || "index"), extensionsSet);
 }
+/** The package's parsed `package.json`, or null when it cannot be read. */
+function readPackageManifest(pkgRoot) {
+	try {
+		return JSON.parse((0, fs.readFileSync)((0, path.join)(pkgRoot, "package.json"), "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/** Each `exports` subpath and its value; a bare target or condition object
+*  is the `.` entry. */
+function exportsSubpaths(manifest) {
+	const exports = isJsonBlock(manifest) ? manifest.exports : void 0;
+	if (exports === void 0 || exports === null) return [];
+	const subpaths = isJsonBlock(exports) && Object.keys(exports).some((k) => k.startsWith(".")) ? exports : { ".": exports };
+	return Object.entries(subpaths).filter(([subpath]) => subpath.startsWith("."));
+}
+/**
+* The export condition a kit gives each public entry's original source:
+* `{ "types": …, "animus": "./src/system.ts", "import": …, "default": … }`.
+* Hosts never resolve through it; discovery reads it, redirects the entry to
+* its source in every host, and the system loader prefers it.
+*/
+const KIT_SOURCE_CONDITION = "animus";
+/** The package's kit source condition, or null when no exact `exports`
+*  entry declares it: the package is no source kit. */
+function readKitSourceCondition(pkgRoot) {
+	const condition = {
+		entries: [],
+		invalid: [],
+		root: null
+	};
+	for (const [subpath, value] of exportsSubpaths(readPackageManifest(pkgRoot))) {
+		if (subpath.includes("*") || !isJsonBlock(value)) continue;
+		const target = value[KIT_SOURCE_CONDITION];
+		if (!isJsonString(target)) continue;
+		const file = (0, path.resolve)(pkgRoot, target);
+		if (isPathWithinRoot(pkgRoot, file) && isFile$1(file)) condition.entries.push([subpath, file]);
+		else condition.invalid.push([subpath, target]);
+	}
+	if (condition.entries.length === 0 && condition.invalid.length === 0) return null;
+	condition.root = sourceRoot(condition.entries);
+	return condition;
+}
+/** The deepest directory holding every entry's file. */
+function sourceRoot(entries) {
+	return entries.reduce((root, [, file]) => root === null ? (0, path.dirname)(file) : commonDirectory(root, (0, path.dirname)(file)), null);
+}
+/** A TypeScript source file; compiled output and declarations are not. */
+const TS_SOURCE = /(?<!\.d)\.[cm]?tsx?$/;
+/** A kit with no source condition whose every exact `exports` entry already
+*  targets TypeScript source in the package under `import` or `default`:
+*  those targets are its source, as the condition would name them. Null
+*  when any exact entry has no such target, such as one only `require` or
+*  `types` reaches, or there is no exact entry. */
+function sourceExportsCondition(pkgRoot) {
+	const entries = [];
+	for (const [subpath, value] of exportsSubpaths(readPackageManifest(pkgRoot))) {
+		if (subpath.includes("*")) continue;
+		const target = exportTarget(value);
+		const file = target === null ? null : (0, path.resolve)(pkgRoot, target);
+		if (file === null || !TS_SOURCE.test(file) || !isPathWithinRoot(pkgRoot, file) || !isFile$1(file)) return null;
+		entries.push([subpath, file]);
+	}
+	if (entries.length === 0) return null;
+	return {
+		entries,
+		invalid: [],
+		root: sourceRoot(entries)
+	};
+}
+function commonDirectory(a, b) {
+	let dir = a;
+	while (!isPathWithinRoot(dir, b)) dir = (0, path.dirname)(dir);
+	return dir;
+}
+/** Whether the manifest at `dir` names the package `name`. */
+function isPackageNamed(dir, name) {
+	const manifest = readPackageManifest(dir);
+	return isJsonBlock(manifest) && manifest.name === name;
+}
+function realPath(path$3) {
+	try {
+		return (0, fs.realpathSync)(path$3);
+	} catch {
+		return path$3;
+	}
+}
+/** The root of the installed package `name` as Node finds it from `fromDir`,
+*  the first `node_modules/<name>` up the directory tree, at its real path,
+*  as host resolvers report a linked package. */
+function locatePackageRoot(name, fromDir) {
+	for (let dir = fromDir;; dir = (0, path.dirname)(dir)) {
+		const candidate = (0, path.join)(dir, "node_modules", name);
+		if ((0, fs.existsSync)((0, path.join)(candidate, "package.json"))) return realPath(candidate);
+		if (dir === (0, path.dirname)(dir)) return null;
+	}
+}
 /**
 * A package's `sideEffects` field, decoded the way Vite reads it: a boolean
 * as written, or the list's globs, one with no `/` matching the basename
@@ -2356,12 +2617,7 @@ function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
 * extglobs), which leaves the bundler's side-effectful default.
 */
 function readPackageSideEffects(pkgRoot) {
-	let manifest;
-	try {
-		manifest = JSON.parse((0, fs.readFileSync)((0, path.join)(pkgRoot, "package.json"), "utf-8"));
-	} catch {
-		return;
-	}
+	const manifest = readPackageManifest(pkgRoot);
 	const field = isJsonBlock(manifest) ? manifest.sideEffects : void 0;
 	if (field === true || field === false) return field;
 	if (!Array.isArray(field)) return void 0;
@@ -2369,6 +2625,77 @@ function readPackageSideEffects(pkgRoot) {
 	if (globs.some((glob) => /[{}[\]()!+@]/.test(glob))) return void 0;
 	return globs.map((glob) => globToRegExp(glob.includes("/") ? glob.replace(/^\.?\//, "") : `**/${glob}`));
 }
+/** Whether a bundler that reads the nearest `package.json`'s `sideEffects`
+*  against the file's own path keeps `absFile`; undefined without a field
+*  it reads, which keeps the bundler's side-effectful default. */
+function fileSideEffects(absFile) {
+	const pkgRoot = findPackageRoot(absFile);
+	const field = readPackageSideEffects(pkgRoot);
+	if (field === void 0 || field === true || field === false) return field;
+	return matchesSideEffects(field, pkgRoot, [absFile]);
+}
+/** Whether a `sideEffects` glob can name a code file: a last segment with
+*  no extension can name any file, and an extension with glob syntax or of
+*  a script can name code; `*.css` cannot. Brace alternatives are each read,
+*  and braces this reading cannot expand count as naming code. */
+function globNamesCode(glob) {
+	const alternatives = expandBraces(glob);
+	if (alternatives === null) return true;
+	return alternatives.some((alternative) => {
+		const last = alternative.split("/").at(-1) ?? "";
+		const dot = last.lastIndexOf(".");
+		if (dot === -1) return true;
+		const extension = last.slice(dot + 1);
+		return /[*?[]/.test(extension) || /^[cm]?[jt]sx?$/.test(extension);
+	});
+}
+/** Every alternative a glob's `{a,b}` groups spell, nested groups included;
+*  null when its braces do not balance. */
+function expandBraces(glob) {
+	const open = glob.indexOf("{");
+	if (open === -1) return glob.includes("}") ? null : [glob];
+	let depth = 0;
+	const commas = [];
+	for (let at = open; at < glob.length; at++) if (glob[at] === "{") depth++;
+	else if (glob[at] === "," && depth === 1) commas.push(at);
+	else if (glob[at] === "}" && --depth === 0) {
+		const bounds = [
+			open,
+			...commas,
+			at
+		];
+		const rest = expandBraces(glob.slice(at + 1));
+		if (rest === null) return null;
+		const expanded = [];
+		for (let i = 0; i < bounds.length - 1; i++) {
+			const inner = expandBraces(glob.slice(bounds[i] + 1, bounds[i + 1]));
+			if (inner === null) return null;
+			for (const middle of inner) for (const tail of rest) expanded.push(glob.slice(0, open) + middle + tail);
+		}
+		return expanded;
+	}
+	return null;
+}
+/**
+* True when a source module of the package that owns `absFile` must stay
+* side-effectful: its `sideEffects` list names shipped code, and no proven
+* map takes a shipped file to its source module, so a bundler that reads
+* the list against the source path can drop a listed effect. Undefined
+* leaves the bundler's own reading, which no list naming code can mislead.
+*/
+function kitSourceModuleSideEffects(absFile) {
+	const manifest = readPackageManifest(findPackageRoot(absFile));
+	const field = isJsonBlock(manifest) ? manifest.sideEffects : void 0;
+	if (!Array.isArray(field)) return void 0;
+	return field.some((glob) => isJsonString(glob) && globNamesCode(glob)) ? true : void 0;
+}
+/** Whether a host keeps the module at `file` side-effectful: it lies under
+*  one of the discovered kit source directories, and its package's list
+*  could misread it (see `kitSourceModuleSideEffects`). A host asks this of
+*  the resolved module, never of its importer alone. */
+function keepsKitSourceEffects(file, kitDirs) {
+	return kitDirs.some((dir) => isPathWithinRoot(dir, file)) && kitSourceModuleSideEffects(file) === true;
+}
 function matchesSideEffects(globs, pkgRoot, absFiles) {
 	return absFiles.some((file) => {
 		const relPath = (0, path.relative)(pkgRoot, file).split(path.sep).join("/");
@@ -2392,18 +2719,9 @@ function exportTarget(value) {
 /** Each exact `exports` entry of the package at `pkgRoot`, as its subpath
 *  and absolute target; `*` patterns name no single file and are skipped. */
 function packageExportEntries(pkgRoot) {
-	let manifest;
-	try {
-		manifest = JSON.parse((0, fs.readFileSync)((0, path.join)(pkgRoot, "package.json"), "utf-8"));
-	} catch {
-		return [];
-	}
-	const exports = isJsonBlock(manifest) ? manifest.exports : void 0;
-	if (exports === void 0 || exports === null) return [];
-	const subpaths = isJsonBlock(exports) && Object.keys(exports).some((k) => k.startsWith(".")) ? exports : { ".": exports };
 	const entries = [];
-	for (const [subpath, value] of Object.entries(subpaths)) {
-		if (!subpath.startsWith(".") || subpath.includes("*")) continue;
+	for (const [subpath, value] of exportsSubpaths(readPackageManifest(pkgRoot))) {
+		if (subpath.includes("*")) continue;
 		const target = exportTarget(value);
 		if (target !== null) entries.push([subpath, (0, path.resolve)(pkgRoot, target)]);
 	}
@@ -2442,6 +2760,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);
@@ -2454,6 +2782,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 = {};
@@ -2462,6 +2792,31 @@ async function collectExternalPackageSources(opts) {
 		(dirOwnerSets[dir] ??= []).push(specifier);
 	};
 	const alreadyIngested = (relPath) => hasEntry(relPath) || pushed.has(relPath);
+	/** Adds `file` to the analysis set unless it is there; false when it
+	*  cannot be read. */
+	const ingest = (file, specifier) => {
+		const relPath = (0, path.relative)(rootDir, file);
+		if (alreadyIngested(relPath)) return true;
+		let source;
+		try {
+			source = (0, fs.readFileSync)(file, "utf-8");
+		} catch (err) {
+			onUnreadable(relPath, err);
+			return false;
+		}
+		onSourceRead?.(source, relPath, file);
+		entries.push({
+			path: relPath,
+			source
+		});
+		pushed.add(relPath);
+		fileOwners[relPath] ??= specifier;
+		return true;
+	};
+	const diagnostics = [];
+	const reportedPackages = /* @__PURE__ */ new Set();
+	const kitDescriptors = [];
+	const describedRoots = /* @__PURE__ */ new Set();
 	for (const specifier of specifiers) {
 		let absEntry;
 		try {
@@ -2470,7 +2825,14 @@ async function collectExternalPackageSources(opts) {
 			absEntry = null;
 		}
 		if (!absEntry && (0, path.isAbsolute)(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
-		if (!absEntry) {
+		const packageName = (0, path.isAbsolute)(specifier) ? null : bareSpecifierPackageName(specifier);
+		const resolvedRoot = absEntry ? findPackageRoot(absEntry) : null;
+		const locatedRoot = packageName && locatePackageRoot(packageName, rootDir);
+		const pkgRoot = resolvedRoot && (!locatedRoot || isPackageNamed(resolvedRoot, packageName) || realPath(resolvedRoot) === locatedRoot) ? resolvedRoot : locatedRoot || resolvedRoot;
+		const condition = packageName && pkgRoot ? readKitSourceCondition(pkgRoot) ?? sourceExportsCondition(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",
@@ -2478,12 +2840,38 @@ async function collectExternalPackageSources(opts) {
 			});
 			continue;
 		}
-		const pkgRoot = findPackageRoot(absEntry);
+		const realRoot = realPath(pkgRoot);
+		if (!describedRoots.has(realRoot)) {
+			describedRoots.add(realRoot);
+			const described = readKitDescriptor(pkgRoot, rootDir);
+			if (described) kitDescriptors.push(described);
+		}
+		const linked = !isInstalledPackage(pkgRoot);
 		const srcDir = (0, path.join)(pkgRoot, "src");
 		let fileCount = 0;
 		let staleDist = false;
-		if ((0, fs.existsSync)(srcDir)) {
+		if (packageName && !reportedPackages.has(packageName)) {
+			reportedPackages.add(packageName);
+			diagnostics.push(...sourceConditionDiagnostics(packageName, condition));
+		}
+		if (condition && packageName) {
+			for (const [entry, target] of condition.entries) {
+				const entrySpecifier = packageName + entry.slice(1);
+				packageMap[entrySpecifier] = (0, path.relative)(rootDir, target);
+				await redirect(entrySpecifier, target, pkgRoot, () => shippedEntry(entrySpecifier, pkgRoot, entry));
+			}
+			packageMap[specifier] ??= (0, path.relative)(rootDir, absEntry);
+			if (condition.root) {
+				packageDirs.push(condition.root);
+				if (linked) linkedDirs.push(condition.root);
+				claimDir(condition.root, specifier);
+				dirExtensions[condition.root] = [...extensionsSet];
+				onPackageResolved?.(specifier, condition.root);
+				for (const file of walkPackageSources(condition.root, extensionsSet)) if (ingest(file, specifier)) fileCount++;
+			}
+		} else if ((0, fs.existsSync)(srcDir)) {
 			packageDirs.push(srcDir);
+			if (linked) linkedDirs.push(srcDir);
 			claimDir(srcDir, specifier);
 			dirExtensions[srcDir] = [...extensionsSet];
 			onPackageResolved?.(specifier, srcDir);
@@ -2493,49 +2881,23 @@ async function collectExternalPackageSources(opts) {
 				const replaced = absEntry;
 				await redirect(specifier, srcEntry, pkgRoot, async () => replaced);
 			} else packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
-			if (!(0, path.isAbsolute)(specifier)) {
-				const packageName = bareSpecifierPackageName(specifier);
+			if (packageName) {
 				if (packageName !== specifier && !(packageName in packageMap)) {
 					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
 					if (rootEntry) {
 						packageMap[packageName] = (0, path.relative)(rootDir, rootEntry);
-						await redirect(packageName, rootEntry, pkgRoot, async () => {
-							try {
-								return await resolveSpecifier(packageName);
-							} catch {
-								return null;
-							}
-						});
+						await redirect(packageName, rootEntry, pkgRoot, () => shippedEntry(packageName, pkgRoot, "."));
 					}
 				}
 			}
 			const pkgFiles = walkPackageSources(srcDir, extensionsSet);
-			staleDist = !isInstalledPackage(pkgRoot) && distEntryIsStale(absEntry, srcDir, pkgFiles);
-			for (const pkgFile of pkgFiles) {
-				const relPath = (0, path.relative)(rootDir, pkgFile);
-				if (alreadyIngested(relPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = (0, fs.readFileSync)(pkgFile, "utf-8");
-				} catch (err) {
-					onUnreadable(relPath, err);
-					continue;
-				}
-				onSourceRead?.(source, relPath, pkgFile);
-				entries.push({
-					path: relPath,
-					source
-				});
-				pushed.add(relPath);
-				fileOwners[relPath] ??= specifier;
-				fileCount++;
-			}
+			staleDist = linked && distEntryIsStale(absEntry, srcDir, pkgFiles);
+			for (const pkgFile of pkgFiles) if (ingest(pkgFile, specifier)) fileCount++;
 		} else {
 			const outputDir = (0, path.dirname)(absEntry);
 			packageDirs.push(outputDir);
+			if (linked) linkedDirs.push(outputDir);
+			outputDirs.push(outputDir);
 			claimDir(outputDir, specifier);
 			onPackageResolved?.(specifier, outputDir);
 			packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
@@ -2547,37 +2909,13 @@ async function collectExternalPackageSources(opts) {
 				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
 			});
 			if (!outputFiles.includes(absEntry)) outputFiles.unshift(absEntry);
-			for (const outputFile of outputFiles) {
-				const outputRelPath = (0, path.relative)(rootDir, outputFile);
-				if (alreadyIngested(outputRelPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = (0, fs.readFileSync)(outputFile, "utf-8");
-				} catch (err) {
-					onUnreadable(outputRelPath, err);
-					continue;
-				}
-				onSourceRead?.(source, outputRelPath, outputFile);
-				entries.push({
-					path: outputRelPath,
-					source
-				});
-				pushed.add(outputRelPath);
-				fileOwners[outputRelPath] ??= specifier;
-				fileCount++;
-			}
+			for (const outputFile of outputFiles) if (ingest(outputFile, specifier)) fileCount++;
 		}
-		if (!(0, path.isAbsolute)(specifier)) {
-			const packageName = bareSpecifierPackageName(specifier);
-			for (const [subpath, target] of packageExportEntries(pkgRoot)) {
-				const entrySpecifier = packageName + subpath.slice(1);
-				const targetRelPath = (0, path.relative)(rootDir, target);
-				if (entrySpecifier in packageMap || !alreadyIngested(targetRelPath)) continue;
-				packageMap[entrySpecifier] = targetRelPath;
-			}
+		if (packageName) for (const [subpath, target] of packageExportEntries(pkgRoot)) {
+			const entrySpecifier = packageName + subpath.slice(1);
+			const targetRelPath = (0, path.relative)(rootDir, target);
+			if (entrySpecifier in packageMap || !alreadyIngested(targetRelPath)) continue;
+			packageMap[entrySpecifier] = targetRelPath;
 		}
 		outcomes.push({
 			specifier,
@@ -2591,12 +2929,112 @@ async function collectExternalPackageSources(opts) {
 		sourceEntries,
 		sourceEntrySideEffects,
 		packageDirs,
+		linkedDirs,
+		outputDirs,
 		dirOwnerSets,
 		dirExtensions,
 		fileOwners,
-		outcomes
+		outcomes,
+		diagnostics: [...diagnostics, ...noKitFilesDiagnostics(outcomes)],
+		kitDescriptors
 	};
 }
+/** The dependency names a manifest lists in `fields`. */
+function dependencyNames(manifest, fields) {
+	if (!isJsonBlock(manifest)) return [];
+	const names = /* @__PURE__ */ new Set();
+	for (const field of fields) {
+		const deps = manifest[field];
+		if (isJsonBlock(deps)) for (const name of Object.keys(deps)) names.add(name);
+	}
+	return [...names];
+}
+/** The source kits the application at `rootDir` declares as dependencies.
+*  A bundler serves an installed one as compiled code unless told
+*  otherwise: Next keeps it external on the server unless it is in
+*  `transpilePackages`, and Vite's optimizer prebundles it. */
+function sourceKitDependencies(rootDir) {
+	return dependencyNames(readPackageManifest(rootDir), ["dependencies", "devDependencies"]).flatMap((name) => {
+		const pkgRoot = locatePackageRoot(name, rootDir);
+		if (pkgRoot === null || readKitSourceCondition(pkgRoot) === null) return [];
+		return [{
+			name,
+			installed: isInstalledPackage(pkgRoot),
+			dependencies: dependencyNames(readPackageManifest(pkgRoot), ["dependencies"])
+		}];
+	});
+}
+/** A specifier that names a package: not relative or absolute, and no URL,
+*  scheme (`node:`, `virtual:`), subpath import or virtual id. */
+function isPackageSpecifier(specifier) {
+	return /^(?:@[^/\\:]+\/)?[^./\\#\0:][^:]*$/.test(specifier);
+}
+/**
+* An error for each kit the application's own `files` import or re-export
+* whose system the application's system does not include: a package that
+* declares the kit source condition, with no kit the system extends
+* (`systemKits`) in that package. One app build has exactly one system, and
+* every kit's system is part of it, so such a kit is not extracted against
+* a system it was not built for. One batch parse reads the imports of every
+* file the engine parses as it is; an adapted source (`.svelte`, `.mdx`)
+* reaches the engine only as its generated children.
+*/
+function importedKitDiagnostics(files, engine, rootDir, systemKits) {
+	const { extractFacts } = engine;
+	const parsed = files.filter(({ path: path$4 }) => isEngineTransformExtension(path$4));
+	if (!extractFacts || parsed.length === 0) return [];
+	let facts;
+	try {
+		facts = parseInternalWire(extractFacts(JSON.stringify(parsed.map(({ path: path$5, source }) => ({
+			path: path$5,
+			source
+		})))), "extractFacts");
+	} catch {
+		return [];
+	}
+	const seen = new Set(systemKits.filter((specifier) => !(0, path.isAbsolute)(specifier)).map(bareSpecifierPackageName));
+	const diagnostics = [];
+	for (const [path$6, file] of Object.entries(facts.files)) {
+		if (file.parsePanicked) continue;
+		const specifiers = [...file.imports.map((fact) => fact.source), ...file.exports.flatMap((fact) => fact.source === null ? [] : [fact.source])];
+		for (const specifier of specifiers) {
+			if (!isPackageSpecifier(specifier)) continue;
+			const name = bareSpecifierPackageName(specifier);
+			if (seen.has(name)) continue;
+			seen.add(name);
+			const pkgRoot = locatePackageRoot(name, (0, path.dirname)((0, path.resolve)(rootDir, path$6)));
+			if (pkgRoot && readKitSourceCondition(pkgRoot)) diagnostics.push({
+				file: path$6,
+				component: name,
+				kind: "warn",
+				message: `the application imports this kit, but its system is not included in the application's system, so its components are not extracted — include the kit's system in the application's system: createSystem().extend(<the kit's system>)`,
+				code: KIT_SYSTEM_NOT_INCLUDED,
+				severity: severityFor(KIT_SYSTEM_NOT_INCLUDED)
+			});
+		}
+	}
+	return diagnostics;
+}
+/** A kit without the source condition, warned once, or each condition entry
+*  whose target is missing or outside the package. */
+function sourceConditionDiagnostics(packageName, condition) {
+	if (condition === null) return [{
+		file: packageName,
+		component: "kit",
+		kind: "warn",
+		message: `declares no "${KIT_SOURCE_CONDITION}" export condition, so discovery guesses its source from src/ — give each public exports entry an "${KIT_SOURCE_CONDITION}" condition naming its original source`,
+		code: KIT_WITHOUT_SOURCE_CONDITION,
+		severity: severityFor(KIT_WITHOUT_SOURCE_CONDITION)
+	}];
+	return condition.invalid.map(([subpath, target]) => ({
+		file: packageName,
+		component: "kit",
+		kind: "warn",
+		message: `exports["${subpath}"].${KIT_SOURCE_CONDITION} names ${target}, which is missing or outside the package, so that entry is not read from source`,
+		code: INVALID_KIT_SOURCE_CONDITION,
+		severity: severityFor(INVALID_KIT_SOURCE_CONDITION)
+	}));
+}
 function firstOwners(dirOwnerSets) {
 	const owners = {};
 	for (const [dir, specifiers] of Object.entries(dirOwnerSets)) if (specifiers.length > 0) owners[dir] = specifiers[0];
@@ -2642,10 +3080,14 @@ function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
 		sourceEntries,
 		sourceEntrySideEffects,
 		packageDirs: collected.packageDirs.filter((dir) => !rejectedDirs.includes(dir)),
+		linkedDirs: collected.linkedDirs.filter((dir) => !rejectedDirs.includes(dir)),
+		outputDirs: collected.outputDirs.filter((dir) => !rejectedDirs.includes(dir)),
 		dirOwnerSets,
 		dirExtensions,
 		fileOwners,
-		outcomes: collected.outcomes
+		outcomes: collected.outcomes,
+		diagnostics: collected.diagnostics,
+		kitDescriptors: collected.kitDescriptors.filter((record) => !rejectedDirs.some((dir) => isPathWithinRoot((0, path.resolve)(rootDir, record.packageRoot), dir)))
 	};
 }
 function unresolvableIncludesMessage(outcomes) {
@@ -2666,15 +3108,16 @@ function staleDistIncludesMessage(outcomes) {
 function engineModuleParser(engine) {
 	const { extractFacts } = engine;
 	if (!extractFacts) return void 0;
-	return (source, path$3) => {
+	return (source, path$7) => {
 		try {
 			const facts = parseInternalWire(extractFacts(JSON.stringify([{
-				path: path$3,
+				path: path$7,
 				source
-			}])), "extractFacts").files[path$3];
+			}])), "extractFacts").files[path$7];
 			return facts && !facts.parsePanicked ? {
 				imports: facts.imports,
-				exports: facts.exports
+				exports: facts.exports,
+				unboundCreateSystemCalls: facts.unboundCreateSystemCalls ?? []
 			} : null;
 		} catch {
 			return null;
@@ -2685,7 +3128,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 {
@@ -2770,13 +3213,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) => {
@@ -2796,11 +3241,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)) {
@@ -2831,19 +3273,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. */
@@ -2859,9 +3329,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
@@ -3033,9 +3502,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;
@@ -3287,8 +3756,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
@@ -3900,11 +4374,15 @@ 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;
+	if (opts.system.propertyRecordsJson) inputs.propertyRecordsJson = opts.system.propertyRecordsJson;
 	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;
 }
@@ -3945,7 +4423,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,
@@ -3956,6 +4439,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: [
@@ -4063,36 +4547,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>`. */
@@ -4108,7 +4590,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) ? [{
@@ -4132,11 +4615,30 @@ function applyPropertyNames(prefix, artifacts) {
 		}))]))),
 		declarationScalesJson: artifacts.declarationScalesJson === null ? null : renameDeclarationRecords(artifacts.declarationScalesJson, rename),
 		nameConflicts,
-		contextualProperties: [...new Set(declared)].map((name) => `--${managed.finalName(name) ?? name}`)
+		contextualProperties: [...new Set(declared)].map((name) => `--${managed.finalName(name) ?? name}`),
+		generatedNamesJson: generatedNamesJson(themeDefined.filter((name) => !declared.includes(name)), managed)
 	};
 }
-/** A custom property the theme's CSS defines or registers. */
-const THEME_DEFINITION = /(?:@property\s+|(?:^|[\s;{]))--([\w-]+)(?=\s*[:{])/g;
+/** The generated names' final names, for authored component styles. */
+function generatedNamesJson(names, managed) {
+	const entries = [...new Set(names)].flatMap((name) => {
+		const final = managed.finalName(name);
+		return final === void 0 ? [] : [[name, final]];
+	});
+	return entries.length === 0 ? null : JSON.stringify(Object.fromEntries(entries));
+}
+/** The custom properties the theme's CSS declares or `@property` registers,
+*  read as CSS tokenizes it: a name in a string or comment defines nothing. */
+function themeDefinitions(variableCss) {
+	const tokens = (0, _animus_ui_properties.tokenize)(variableCss).filter((token) => token.type !== "whitespace");
+	return tokens.flatMap((token, index) => {
+		if (token.type !== "ident" || !token.value.startsWith("--")) return [];
+		const previous = tokens[index - 1];
+		const declared = (previous === void 0 || previous.type === "{" || previous.type === ";") && tokens[index + 1]?.type === ":";
+		const registered = previous?.type === "at-keyword" && previous.value.toLowerCase() === "property";
+		return declared || registered ? [token.value.slice(2)] : [];
+	});
+}
 /** Renames inside the token map's values. */
 function renameTokenValues(themeJson, rename) {
 	const tokens = parseInternalWire(themeJson, "themeJson (the theme's flattened token values)");
@@ -4152,23 +4654,40 @@ function renameDeclarationRecords(declarationScalesJson, rename) {
 }
 //#endregion
 //#region pipeline/system-config.ts
+/** The loader's evaluation of the system file. A failure on a file that
+*  calls `createSystem` with no binding leads with discovery's warning line
+*  for it, then keeps the loader's own error. */
+function evaluateSystemModule(engine, systemPath, rootDir, conditions) {
+	try {
+		return engine.loadSystemModule(systemPath, rootDir, void 0, conditions);
+	} catch (error) {
+		let source;
+		try {
+			source = (0, fs.readFileSync)(systemPath, "utf-8");
+		} catch {
+			throw error;
+		}
+		const record = engineModuleParser(engine)?.(source, systemPath);
+		const call = record && unimportedCreateSystemCall(systemPath, record);
+		if (!call) throw error;
+		throw new Error(`${warnLine(call)}\n${String(error)}`, { cause: error });
+	}
+}
 /**
 * Load and normalize a SystemInstance; `prefix` namespaces every CSS
 * variable name. Error handling stays at the call site.
 */
 function loadSystemConfig(engineApi, opts) {
-	const { loadSystemModule } = engineApi();
-	const config = loadSystemModule(opts.systemPath, opts.rootDir);
+	const config = evaluateSystemModule(engineApi(), opts.systemPath, opts.rootDir, opts.conditions);
 	let scalesJson = config.scalesJson;
 	let variableMapJson = config.variableMapJson;
 	const registrations = splitInvalidPropertyRegistrations(config.variableCss);
 	let variableCss = registrations.css;
 	let contextualVarsJson = config.contextualVarsJson || null;
 	let declarationScalesJson = config.declarationScalesJson || null;
-	const declaredNames = Object.values(parseInternalWire(contextualVarsJson ?? "{}", "contextualVarsJson (the theme's contextual variable names)")).flat();
-	let contextualProperties = declaredNames.map((name) => `--${name}`);
-	let legacyPrefixedContextualVars = [];
+	let contextualProperties = Object.values(parseInternalWire(contextualVarsJson ?? "{}", "contextualVarsJson (the theme's contextual variable names)")).flat().map((name) => `--${name}`);
 	let prefixNameConflicts = [];
+	let generatedNamesJson;
 	if (opts.prefix && opts.prefixContextualVars) {
 		const resolved = applyPropertyNames(opts.prefix, {
 			variableMapJson,
@@ -4184,15 +4703,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,
@@ -4216,7 +4734,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
@@ -4225,8 +4743,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)) {
@@ -4260,7 +4777,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;
 		}
@@ -4278,6 +4796,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;
@@ -4316,6 +4835,191 @@ function assertNoErrorDiagnostics(diagnostics) {
 	throw new Error(lines.join("\n"));
 }
 //#endregion
+//#region pipeline/kit-publication.ts
+/** Source a kit publishes and the loader or a bundler parses for imports. */
+const CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const isFile = (path) => {
+	try {
+		return (0, node_fs.statSync)(path).isFile();
+	} catch {
+		return false;
+	}
+};
+const posixPath = (path) => path.split(node_path.sep).join("/");
+/**
+* The package-relative files `npm pack` publishes, read with npm's own rules
+* (`files`, `.npmignore`, `.gitignore` and the files npm always includes)
+* through a dry run that runs no scripts and needs no network.
+*/
+function npmPublishedFiles(pkgRoot) {
+	const windows = process.platform === "win32";
+	const run = (0, node_child_process.spawnSync)(windows ? "npm.cmd" : "npm", [
+		"pack",
+		"--dry-run",
+		"--json",
+		"--ignore-scripts"
+	], {
+		cwd: pkgRoot,
+		encoding: "utf-8",
+		shell: windows,
+		env: {
+			...process.env,
+			npm_config_update_notifier: "false"
+		}
+	});
+	if (run.error || run.status !== 0) return {
+		kind: "failed",
+		reason: `npm pack --dry-run could not list the published files: ${String(run.error ?? run.stderr.trim())}`
+	};
+	let output;
+	try {
+		output = JSON.parse(run.stdout);
+	} catch (error) {
+		return {
+			kind: "failed",
+			reason: `npm pack --dry-run printed no JSON: ${String(error)}`
+		};
+	}
+	const pack = Array.isArray(output) ? output[0] : void 0;
+	const files = isJsonBlock(pack) ? pack.files : void 0;
+	if (!Array.isArray(files)) return {
+		kind: "failed",
+		reason: "npm pack --dry-run printed no file list"
+	};
+	return {
+		kind: "listed",
+		files: new Set(files.flatMap((file) => isJsonBlock(file) && isJsonString(file.path) ? [posixPath(file.path)] : []))
+	};
+}
+function animusTargets(manifest) {
+	const targets = [];
+	const unreadable = [];
+	const visit = (subpath, value, underAnimus) => {
+		if (isJsonString(value)) {
+			if (underAnimus) targets.push([subpath, value]);
+		} else if (Array.isArray(value)) for (const entry of value) visit(subpath, entry, underAnimus);
+		else if (isJsonBlock(value)) for (const [key, entry] of Object.entries(value)) visit(subpath, entry, underAnimus || key === "animus");
+		else if (underAnimus && value !== null) unreadable.push([subpath, JSON.stringify(value)]);
+	};
+	for (const [subpath, value] of exportsSubpaths(manifest)) visit(subpath, value, false);
+	return {
+		targets,
+		unreadable
+	};
+}
+/** Every file in the package outside `node_modules` and `.git`,
+*  package-relative. */
+function packageFiles(pkgRoot, dir = "") {
+	return (0, node_fs.readdirSync)((0, node_path.join)(pkgRoot, dir), { withFileTypes: true }).flatMap((entry) => {
+		const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+		if (entry.isDirectory()) return entry.name === "node_modules" || entry.name === ".git" ? [] : packageFiles(pkgRoot, path);
+		return entry.isFile() ? [path] : [];
+	});
+}
+/** A `*` target pattern as a matcher of package-relative files. Node puts
+*  one subpath into every `*`, so each later `*` repeats the first match. */
+function targetPattern(target) {
+	const body = posixPath(target).replace(/^\.\//, "").split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).reduce((pattern, part, index) => index === 0 ? part : `${pattern}${index === 1 ? "(.+)" : "\\1"}${part}`);
+	return new RegExp(`^${body}$`);
+}
+/**
+* Why the kit at `pkgRoot` would fail an installed consumer: each `animus`
+* source target, at any condition depth or as a pattern, and each file its
+* relative imports reach, must be in the package and among the files `npm
+* pack` publishes, and each bare package import a declared dependency.
+* Each line names the file, the import and the cause; none means the
+* published source is complete. With `artifactDir`, a build's artifact
+* directory inside the package that `npm pack` would publish is a line too.
+*/
+function kitPublicationFailures(pkgRoot, engine, artifactDir) {
+	let manifest;
+	try {
+		manifest = JSON.parse((0, node_fs.readFileSync)((0, node_path.join)(pkgRoot, "package.json"), "utf-8"));
+	} catch (error) {
+		return [`package.json: cannot be read: ${String(error)}`];
+	}
+	const { targets, unreadable } = animusTargets(manifest);
+	if (targets.length === 0 && unreadable.length === 0) return [];
+	const { moduleSpecifiers } = engine;
+	if (moduleSpecifiers === void 0) throw new Error("the native engine does not expose moduleSpecifiers, which the kit publication check needs — rebuild @animus-ui/extract");
+	const publication = npmPublishedFiles(pkgRoot);
+	if (publication.kind === "failed") return [`package.json: ${publication.reason}`];
+	const published = (packageRelative) => publication.files.has(packageRelative);
+	const declared = new Set([
+		"dependencies",
+		"peerDependencies",
+		"optionalDependencies"
+	].flatMap((field) => {
+		const block = isJsonBlock(manifest) ? manifest[field] : void 0;
+		return isJsonBlock(block) ? Object.keys(block) : [];
+	}));
+	const ownName = isJsonBlock(manifest) && isJsonString(manifest.name) ? manifest.name : null;
+	const failures = [];
+	const rel = (file) => posixPath((0, node_path.relative)(pkgRoot, file));
+	const outside = (relPath) => relPath.startsWith("../") || (0, node_path.isAbsolute)(relPath);
+	for (const [subpath, value] of unreadable) failures.push(`package.json: exports["${subpath}"] has an "animus" value, ${value}, that is no target path`);
+	const queue = [];
+	const admit = (subpath, relPath) => {
+		if (published(relPath)) queue.push((0, node_path.resolve)(pkgRoot, relPath));
+		else failures.push(`package.json: the "animus" target of exports["${subpath}"], ${relPath}, is not in the published files`);
+	};
+	let files = null;
+	for (const [subpath, target] of targets) {
+		const relPath = rel((0, node_path.resolve)(pkgRoot, target));
+		if (outside(relPath)) failures.push(`package.json: the "animus" target of exports["${subpath}"], ${target}, is outside the package`);
+		else if (target.includes("*")) {
+			files ??= packageFiles(pkgRoot);
+			const pattern = targetPattern(target);
+			const matched = files.filter((file) => pattern.test(file));
+			if (matched.length === 0) failures.push(`package.json: the "animus" target of exports["${subpath}"], ${target}, matches no file in the package`);
+			for (const file of matched) admit(subpath, file);
+		} else if (!isFile((0, node_path.resolve)(pkgRoot, target))) failures.push(`package.json: the "animus" target of exports["${subpath}"], ${target}, does not exist in the package`);
+		else admit(subpath, relPath);
+	}
+	const visited = /* @__PURE__ */ new Set();
+	while (queue.length > 0) {
+		const file = queue.shift();
+		if (visited.has(file)) continue;
+		visited.add(file);
+		const specifiers = parseInternalWire(moduleSpecifiers(JSON.stringify([{
+			path: file,
+			source: (0, node_fs.readFileSync)(file, "utf-8")
+		}])), "moduleSpecifiers").files[file] ?? [];
+		for (const specifier of specifiers) {
+			if (specifier.startsWith(".")) {
+				const target = relativeSourceCandidates(file, specifier).find(isFile);
+				if (target === void 0) failures.push(`${rel(file)}: import '${specifier}' resolves to no file in the package`);
+				else if (outside(rel(target))) failures.push(`${rel(file)}: import '${specifier}' resolves to ${rel(target)}, outside the package`);
+				else if (!published(rel(target))) failures.push(`${rel(file)}: import '${specifier}' resolves to ${rel(target)}, which is not in the published files`);
+				else if (CODE_EXTENSIONS.has((0, node_path.extname)(target))) queue.push(target);
+				continue;
+			}
+			if (specifier.startsWith("/") || /^[a-z][\w+.-]*:/i.test(specifier)) {
+				if (!(0, node_module.isBuiltin)(specifier)) failures.push(`${rel(file)}: import '${specifier}' is not a package or relative import, so an installed consumer cannot resolve it`);
+				continue;
+			}
+			const name = bareSpecifierPackageName(specifier);
+			if ((0, node_module.isBuiltin)(name) || name === ownName || declared.has(name)) continue;
+			failures.push(`${rel(file)}: import '${specifier}' names the package ${name}, which package.json does not declare in dependencies, peerDependencies or optionalDependencies`);
+		}
+	}
+	const artifacts = artifactDir === void 0 ? "" : rel(artifactDir);
+	if (artifacts !== "" && !outside(artifacts)) {
+		const shipped = [...publication.files].filter((file) => file.startsWith(`${artifacts}/`));
+		if (shipped.length > 0) failures.push(`${artifacts}/: npm pack would publish this build-artifact directory (${shipped.length} files) — add "${artifacts}/" to .npmignore or .gitignore, or list the published files in package.json "files"`);
+	}
+	return failures;
+}
+//#endregion
 //#region pipeline/replacement-plans.ts
 const snapshotByManifest = /* @__PURE__ */ new WeakMap();
 /** `null` (a context before its first analysis) snapshots to the empty plan
@@ -4452,6 +5156,12 @@ Object.defineProperty(exports, "INVALID_PROPERTY_REGISTRATION", {
 		return INVALID_PROPERTY_REGISTRATION;
 	}
 });
+Object.defineProperty(exports, "KIT_DESCRIPTOR_FILE", {
+	enumerable: true,
+	get: function() {
+		return KIT_DESCRIPTOR_FILE;
+	}
+});
 Object.defineProperty(exports, "REPLACEABLE_DEFAULT_EXCLUDE", {
 	enumerable: true,
 	get: function() {
@@ -4542,6 +5252,12 @@ Object.defineProperty(exports, "buildDynamicPropConfig", {
 		return buildDynamicPropConfig;
 	}
 });
+Object.defineProperty(exports, "buildKitDescriptor", {
+	enumerable: true,
+	get: function() {
+		return buildKitDescriptor;
+	}
+});
 Object.defineProperty(exports, "buildPathAliasesJson", {
 	enumerable: true,
 	get: function() {
@@ -4644,6 +5360,12 @@ Object.defineProperty(exports, "extractSystemFilePackages", {
 		return extractSystemFilePackages;
 	}
 });
+Object.defineProperty(exports, "fileSideEffects", {
+	enumerable: true,
+	get: function() {
+		return fileSideEffects;
+	}
+});
 Object.defineProperty(exports, "findAssetSpecifiers", {
 	enumerable: true,
 	get: function() {
@@ -4680,6 +5402,12 @@ Object.defineProperty(exports, "hashReplacementPlans", {
 		return hashReplacementPlans;
 	}
 });
+Object.defineProperty(exports, "importedKitDiagnostics", {
+	enumerable: true,
+	get: function() {
+		return importedKitDiagnostics;
+	}
+});
 Object.defineProperty(exports, "ingestSourceEntries", {
 	enumerable: true,
 	get: function() {
@@ -4734,6 +5462,30 @@ Object.defineProperty(exports, "isUnresolvedParentDrop", {
 		return isUnresolvedParentDrop;
 	}
 });
+Object.defineProperty(exports, "keepsKitSourceEffects", {
+	enumerable: true,
+	get: function() {
+		return keepsKitSourceEffects;
+	}
+});
+Object.defineProperty(exports, "kitDescriptorDiagnostics", {
+	enumerable: true,
+	get: function() {
+		return kitDescriptorDiagnostics;
+	}
+});
+Object.defineProperty(exports, "kitPublicationFailures", {
+	enumerable: true,
+	get: function() {
+		return kitPublicationFailures;
+	}
+});
+Object.defineProperty(exports, "kitSourceModuleSideEffects", {
+	enumerable: true,
+	get: function() {
+		return kitSourceModuleSideEffects;
+	}
+});
 Object.defineProperty(exports, "loadSystemConfig", {
 	enumerable: true,
 	get: function() {
@@ -4776,6 +5528,12 @@ Object.defineProperty(exports, "projectExternalFileOwners", {
 		return projectExternalFileOwners;
 	}
 });
+Object.defineProperty(exports, "readKitDescriptor", {
+	enumerable: true,
+	get: function() {
+		return readKitDescriptor;
+	}
+});
 Object.defineProperty(exports, "readTsconfigAliasPairs", {
 	enumerable: true,
 	get: function() {
@@ -4854,6 +5612,12 @@ Object.defineProperty(exports, "snapshotFilePlans", {
 		return snapshotFilePlans;
 	}
 });
+Object.defineProperty(exports, "sourceKitDependencies", {
+	enumerable: true,
+	get: function() {
+		return sourceKitDependencies;
+	}
+});
 Object.defineProperty(exports, "stableStringify", {
 	enumerable: true,
 	get: function() {