@animus-ui/extract 0.1.9 → 0.1.12

package/dist/pipeline-DeEENy5C.mjs

@@ -0,0 +1,2905 @@
+import { createRequire } from "node:module";
+import path, { basename, dirname, join, normalize, posix } 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 } from "path";
+import { realpathSync as realpathSync$1 } from "node:fs";
+import { createRequire as createRequire$1 } from "module";
+import browserslist from "browserslist";
+import { browserslistToTargets, transform } from "lightningcss";
+import { isUnitlessProperty } from "@animus-ui/properties";
+//#region \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region pipeline/assemble-stylesheet.ts
+const ANIMUS_LAYERS = [
+	"anm-global",
+	"anm-base",
+	"anm-variants",
+	"anm-compounds",
+	"anm-states",
+	"anm-system",
+	"anm-custom"
+];
+function buildLayerDeclaration(layers, isCustom) {
+	return `@layer ${(isCustom ? layers : [...ANIMUS_LAYERS]).join(", ")};\n`;
+}
+function validateLayerOrder(layers) {
+	const expected = [...ANIMUS_LAYERS];
+	let cursor = 0;
+	for (const layer of layers) if (cursor < expected.length && layer === expected[cursor]) cursor++;
+	if (cursor < expected.length) {
+		const missing = expected.slice(cursor);
+		const found = expected.slice(0, cursor);
+		if (!expected.every((l) => layers.includes(l))) {
+			const absent = expected.filter((l) => !layers.includes(l));
+			throw new Error(`[animus-extract] Custom layers missing required layers: ${absent.join(", ")}. All 7 Animus layers must be present: ${expected.join(", ")}`);
+		}
+		throw new Error(`[animus-extract] Custom layers have wrong order. Found ${found.join(", ")} but then expected ${missing[0]}. Required order: (${expected.join(" < ")}). You may interleave custom layers but must preserve this subsequence.`);
+	}
+}
+function stripLeadingLayerDeclaration(css) {
+	return css.replace(/^@layer\s+[^;{]+;\s*\n?/, "");
+}
+function assembleStylesheet(options) {
+	const hasCustomLayers = !!options.layers;
+	const layers = options.layers ?? ANIMUS_LAYERS;
+	if (options.layers) validateLayerOrder(options.layers);
+	const declaration = buildLayerDeclaration(layers, hasCustomLayers);
+	const variables = options.variableCss || "";
+	const componentCss = options.componentCss ? stripLeadingLayerDeclaration(options.componentCss) : "";
+	const body = [options.globalCss || "", componentCss].filter(Boolean).join("\n");
+	if (options.split) return {
+		declaration,
+		variables,
+		body
+	};
+	return [
+		declaration,
+		variables,
+		body
+	].filter(Boolean).join("\n");
+}
+//#endregion
+//#region pipeline/analyze-project-args.ts
+/** @internal */
+function buildAnalyzeProjectArgs(inputs) {
+	return [
+		inputs.filesJson,
+		inputs.scalesJson,
+		inputs.variableMapJson,
+		inputs.contextualVarsJson,
+		inputs.propConfigJson,
+		inputs.groupRegistryJson,
+		inputs.packageResolutionJson,
+		inputs.devMode,
+		inputs.emitterConfigJson,
+		inputs.selectorAliasesJson,
+		null,
+		inputs.globalStyleBlocksJson,
+		inputs.pathAliasesJson,
+		inputs.keyframesJson,
+		inputs.staticCssJson,
+		inputs.conditionAliasesJson,
+		inputs.externalDirsJson,
+		inputs.transformSourcesJson
+	];
+}
+//#endregion
+//#region pipeline/content-hash.ts
+function contentHash(source) {
+	return createHash("md5").update(source).digest("hex");
+}
+//#endregion
+//#region pipeline/internal-wire.ts
+function parseInternalWire(json, wire) {
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch (error) {
+		throw new TypeError(`[animus] ${wire} is not valid JSON. animus produces this wire, so this is an engine bug rather than a configuration error: ${String(error)}`, { cause: error });
+	}
+	return parsed;
+}
+//#endregion
+//#region pipeline/mdx-preprocessor.ts
+/**
+* MDX compiled to scanner-consumable JSX, plus the extension sets every
+* driver imports. `@mdx-js/mdx` is an optional peer, so its import is lazy.
+*/
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mdx"
+];
+/**
+* The one engine-transform file gate every driver imports — the suffixes the
+* engine's parser accepts. `.mdx` is preprocessed to `.tsx` before it.
+*/
+const ENGINE_TRANSFORM_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"jsx",
+	"mjs"
+];
+const ENGINE_TRANSFORM_RE = new RegExp(`\\.(?:${ENGINE_TRANSFORM_EXTENSIONS.join("|")})$`);
+function isEngineTransformExtension(path) {
+	return ENGINE_TRANSFORM_RE.test(path);
+}
+/**
+* Compile MDX to scanner-consumable JSX. `missing-dep` means the consumer
+* must install `@mdx-js/mdx`; hosts warn and skip the file on `error`.
+*/
+async function preprocessMdx(source, filename) {
+	const mdxMod = await import("@mdx-js/mdx").catch(() => null);
+	if (mdxMod === null) return { kind: "missing-dep" };
+	try {
+		const vfile = await mdxMod.compile(source, {
+			outputFormat: "program",
+			development: false,
+			jsx: true
+		});
+		return {
+			kind: "ok",
+			source: `/* @mdx-source: ${filename} */\n${String(vfile)}`
+		};
+	} catch (err) {
+		return {
+			kind: "error",
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+//#endregion
+//#region pipeline/svelte-source-adapter.ts
+const isCompilerReference = (value) => Object(value) === value;
+const isCompilerCallable = (value) => {
+	if (!isCompilerReference(value)) return false;
+	try {
+		Function.prototype.toString.call(value);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const isCompilerRecord = (value) => isCompilerReference(value) && !isCompilerCallable(value);
+const acceptsCompilerPrimitive = (value, read) => {
+	if (isCompilerReference(value)) return false;
+	try {
+		read();
+		return true;
+	} catch {
+		return false;
+	}
+};
+const isCompilerString = (value) => acceptsCompilerPrimitive(value, () => String.prototype.valueOf.call(value));
+const isCompilerNumber = (value) => acceptsCompilerPrimitive(value, () => Number.prototype.valueOf.call(value));
+function isNode(value) {
+	return isCompilerRecord(value) && isCompilerString(value.type) && isCompilerNumber(value.start) && isCompilerNumber(value.end);
+}
+function childNode(value) {
+	return isNode(value) ? value : null;
+}
+function isProgramNode(value) {
+	return isNode(value) && Array.isArray(value.body) && value.body.every((child) => isNode(child));
+}
+function isScriptNode(value) {
+	return isNode(value) && isProgramNode(value.content);
+}
+function parseSvelteAst(value) {
+	if (value.module !== void 0 && value.module !== null && !isScriptNode(value.module)) throw new TypeError("svelte/compiler returned an invalid module script");
+	if (value.instance !== void 0 && value.instance !== null && !isScriptNode(value.instance)) throw new TypeError("svelte/compiler returned an invalid instance script");
+	if (!isCompilerRecord(value.fragment)) throw new TypeError("svelte/compiler returned an invalid fragment");
+	return {
+		module: value.module,
+		instance: value.instance,
+		fragment: value.fragment
+	};
+}
+function nodeName(node) {
+	return node?.type === "Identifier" && isCompilerString(node.name) ? node.name : null;
+}
+/** Adaptation touches one source at a time, so a last-value memo runs the
+*  all-ASCII check once per file rather than per span endpoint. */
+let asciiMemoSource = null;
+let asciiMemoValue = false;
+function isAsciiOnly(source) {
+	if (asciiMemoSource !== source) {
+		asciiMemoSource = source;
+		asciiMemoValue = Buffer.byteLength(source) === source.length;
+	}
+	return asciiMemoValue;
+}
+function byteOffset(source, characterOffset) {
+	if (isAsciiOnly(source)) return characterOffset;
+	return Buffer.byteLength(source.slice(0, characterOffset));
+}
+function byteSpan(source, node) {
+	return {
+		start: byteOffset(source, node.start),
+		end: byteOffset(source, node.end)
+	};
+}
+function sourcePosition(source, characterOffset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let index = 0; index < characterOffset; index += 1) {
+		const code = source.charCodeAt(index);
+		if (code === 13) {
+			if (index + 1 < characterOffset && source.charCodeAt(index + 1) === 10) index += 1;
+			line += 1;
+			lineStart = index + 1;
+		} else if (code === 10 || code === 8232 || code === 8233) {
+			line += 1;
+			lineStart = index + 1;
+		}
+	}
+	return {
+		line,
+		column: characterOffset - lineStart
+	};
+}
+function sourceLocation(source, node) {
+	return {
+		start: sourcePosition(source, node.start),
+		end: sourcePosition(source, node.end)
+	};
+}
+function createsNestedBindingScope(node) {
+	return node.type === "BlockStatement" || node.type === "CatchClause" || node.type === "ClassBody" || node.type === "ClassDeclaration" || node.type === "ClassExpression" || node.type === "ForInStatement" || node.type === "ForOfStatement" || node.type === "ForStatement" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "StaticBlock" || node.type === "SwitchStatement" || node.type === "TSModuleBlock";
+}
+function walk(node, visit, nestedScopeDepth = 0) {
+	visit(node, nestedScopeDepth);
+	const childScopeDepth = nestedScopeDepth + (createsNestedBindingScope(node) ? 1 : 0);
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "loc" || key === "start" || key === "end") continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) walk(item, visit, childScopeDepth);
+		} else if (isNode(value)) walk(value, visit, childScopeDepth);
+	}
+}
+/**
+* Svelte `Fragment` containers carry no `start`/`end`, so the `isNode` gate
+* would stop at each one: descend plain objects, visit span-carrying nodes.
+*/
+function walkFragment(value, visit) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const descend = (current) => {
+		if (Array.isArray(current)) {
+			for (const item of current) descend(item);
+			return;
+		}
+		if (!isCompilerRecord(current)) return;
+		if (seen.has(current)) return;
+		seen.add(current);
+		if (isNode(current)) visit(current);
+		for (const [key, child] of Object.entries(current)) {
+			if (key === "loc" || key === "start" || key === "end" || key === "metadata" || key === "parent") continue;
+			descend(child);
+		}
+	};
+	descend(value);
+}
+function importBindings(program) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const declaration of program.body) {
+		if (declaration.type !== "ImportDeclaration" || declaration.importKind === "type" || !Array.isArray(declaration.specifiers)) continue;
+		for (const value of declaration.specifiers) {
+			if (!isNode(value) || value.importKind === "type") continue;
+			const local = childNode(value.local);
+			const localName = nodeName(local);
+			if (!local || !localName) continue;
+			const sourceNode = childNode(declaration.source);
+			const importSource = sourceNode && isCompilerString(sourceNode.value) ? sourceNode.value : null;
+			if (!importSource) continue;
+			const namedImported = importedName(value);
+			if (value.type === "ImportSpecifier" && namedImported === null) continue;
+			const importedNode = childNode(value.imported);
+			const kind = value.type === "ImportSpecifier" ? importedNode?.type === "Literal" ? "string-named" : namedImported === "default" ? "named-default" : "named" : value.type === "ImportDefaultSpecifier" ? "default" : value.type === "ImportNamespaceSpecifier" ? "namespace" : null;
+			if (kind) bindings.set(localName, {
+				kind,
+				source: importSource,
+				imported: kind === "default" || kind === "named-default" ? "default" : kind === "namespace" ? "*" : namedImported,
+				declaration,
+				specifier: value,
+				local
+			});
+		}
+	}
+	return bindings;
+}
+function diagnostic(code, message, originalPath, source, node, location) {
+	const result = {
+		code,
+		message,
+		originalPath
+	};
+	if (node) {
+		result.span = byteSpan(source, node);
+		result.location = location ?? sourceLocation(source, node);
+	}
+	return result;
+}
+function parseCompilerError(value) {
+	if (!isCompilerRecord(value)) return null;
+	const parsed = { positions: Array.isArray(value.position) ? value.position : [] };
+	if (isCompilerRecord(value.start)) parsed.start = value.start;
+	if (isCompilerRecord(value.end)) parsed.end = value.end;
+	return parsed;
+}
+function compilerParseErrorRange(error, source) {
+	const candidate = parseCompilerError(error);
+	if (candidate === null) return null;
+	const positions = candidate.positions;
+	const startCharacter = isCompilerNumber(candidate.start?.character) ? candidate.start.character : isCompilerNumber(positions[0]) ? positions[0] : null;
+	const endCharacter = isCompilerNumber(candidate.end?.character) ? candidate.end.character : isCompilerNumber(positions[1]) ? positions[1] : startCharacter;
+	if (startCharacter === null || endCharacter === null || startCharacter < 0 || endCharacter < startCharacter || endCharacter > source.length) return null;
+	const node = {
+		type: "SvelteParseError",
+		start: startCharacter,
+		end: endCharacter
+	};
+	const fallback = sourceLocation(source, node);
+	const point = (value, fallbackPoint) => ({
+		line: isCompilerNumber(value?.line) ? value.line : fallbackPoint.line,
+		column: isCompilerNumber(value?.column) ? value.column : fallbackPoint.column
+	});
+	return {
+		node,
+		location: {
+			start: point(candidate.start, fallback.start),
+			end: point(candidate.end, fallback.end)
+		}
+	};
+}
+function calleeParts(node) {
+	if (node.type !== "CallExpression") return null;
+	const callee = childNode(node.callee);
+	if (!callee || callee.type !== "MemberExpression") return null;
+	const object = childNode(callee.object);
+	const property = childNode(callee.property);
+	if (!object || !property) return null;
+	if ((nodeName(property) ?? (property.type === "Literal" && property.value === "attrs" ? "attrs" : null)) !== "attrs") return null;
+	return {
+		object,
+		property,
+		computed: callee.computed === true,
+		optional: callee.optional === true || node.optional === true
+	};
+}
+function resolverImportAccess(receiver, bindings) {
+	const directName = nodeName(receiver);
+	if (directName) {
+		const binding = bindings.get(directName);
+		if (!binding) return null;
+		return {
+			binding,
+			resolver: receiver,
+			displayName: directName,
+			request: {
+				source: binding.source,
+				imported: binding.imported,
+				local: directName,
+				access: {
+					kind: "direct",
+					importKind: binding.kind
+				}
+			}
+		};
+	}
+	if (receiver.type !== "MemberExpression" || receiver.computed === true || receiver.optional === true) return null;
+	const namespaceNode = childNode(receiver.object);
+	const memberNode = childNode(receiver.property);
+	const namespaceName = nodeName(namespaceNode);
+	const memberName = nodeName(memberNode) ?? (memberNode?.type === "Literal" && isCompilerString(memberNode.value) ? memberNode.value : null);
+	if (!namespaceNode || !namespaceName || !memberName) return null;
+	const binding = bindings.get(namespaceName);
+	if (!binding || binding.kind !== "namespace") return null;
+	return {
+		binding,
+		resolver: receiver,
+		displayName: `${namespaceName}.${memberName}`,
+		request: {
+			source: binding.source,
+			imported: memberName,
+			local: namespaceName,
+			access: {
+				kind: "namespace-member",
+				importKind: "namespace"
+			}
+		}
+	};
+}
+function isSupportedResolverAccess(access) {
+	return access.binding.kind === "named" && access.request.access.kind === "direct";
+}
+function resolverCallSite(node, bindings) {
+	if (node.type !== "CallExpression") return null;
+	const parts = calleeParts(node);
+	if (parts) {
+		const access = resolverImportAccess(parts.object, bindings);
+		if (!access) return null;
+		return {
+			access,
+			form: "attrs",
+			computed: parts.computed,
+			optional: parts.optional
+		};
+	}
+	const callee = childNode(node.callee);
+	if (!callee) return null;
+	const access = resolverImportAccess(callee, bindings);
+	if (!access) return null;
+	return {
+		access,
+		form: "callable",
+		computed: callee.type === "MemberExpression" && callee.computed === true,
+		optional: node.optional === true || callee.type === "MemberExpression" && callee.optional === true
+	};
+}
+function argumentSpan(argumentsList, fallback) {
+	if (argumentsList.length === 0) return fallback;
+	return {
+		type: "ArgumentRange",
+		start: argumentsList[0].start,
+		end: argumentsList[argumentsList.length - 1].end
+	};
+}
+function propertyName(node) {
+	const key = childNode(node.key);
+	if (!key) return null;
+	if (key.type === "Identifier" && isCompilerString(key.name)) return key.name;
+	if (key.type === "Literal" && isCompilerString(key.value)) return key.value;
+	return null;
+}
+function isJsxAttributeName(name) {
+	return /^[A-Za-z_$][A-Za-z0-9_$-]*$/.test(name);
+}
+function tsxIncompatibleValue(value) {
+	let incompatible = null;
+	walk(value, (node) => {
+		if (incompatible) return;
+		if (node.type === "TSTypeAssertion" || node.type === "ArrowFunctionExpression" && childNode(node.typeParameters) !== null) incompatible = node;
+	});
+	return incompatible;
+}
+function readProperties(argument, source, originalPath) {
+	if (!Array.isArray(argument.properties)) return diagnostic("SVELTE_ATTRS_ARGUMENT_UNRESOLVED", "Resolver .attrs() requires an object literal with statically named properties.", originalPath, source, argument);
+	const properties = [];
+	for (const value of argument.properties) {
+		if (!isNode(value)) continue;
+		if (value.type === "SpreadElement") return diagnostic("SVELTE_ATTRS_SPREAD_UNRESOLVED", "Resolver .attrs() object spreads are unresolved; enumerate properties explicitly.", originalPath, source, value);
+		if (value.type !== "Property") return diagnostic("SVELTE_ATTRS_PROPERTY_UNSUPPORTED", "Resolver .attrs() accepts ordinary object properties only.", originalPath, source, value);
+		if (value.computed === true) return diagnostic("SVELTE_ATTRS_COMPUTED_KEY", "Resolver .attrs() computed property names cannot be attributed safely.", originalPath, source, value);
+		if (value.method === true || value.kind !== "init") return diagnostic("SVELTE_ATTRS_PROPERTY_UNSUPPORTED", "Resolver .attrs() methods and accessors cannot be projected as attributes.", originalPath, source, value);
+		const key = childNode(value.key);
+		const propertyValue = childNode(value.value);
+		const name = propertyName(value);
+		if (!key || !propertyValue || !name || !isJsxAttributeName(name)) return diagnostic("SVELTE_ATTRS_PROPERTY_UNSUPPORTED", "Resolver .attrs() property names must be JSX-compatible identifier or string names.", originalPath, source, value);
+		const incompatibleValue = tsxIncompatibleValue(propertyValue);
+		if (incompatibleValue) return diagnostic("SVELTE_ATTRS_VALUE_UNSUPPORTED", "Resolver .attrs() values using angle-bracket type assertions or generic arrow parameters cannot be projected into TSX safely.", originalPath, source, incompatibleValue);
+		properties.push({
+			name,
+			property: value,
+			key,
+			value: propertyValue
+		});
+	}
+	return properties;
+}
+var VirtualSourceBuilder = class {
+	originalSource;
+	chunks = [];
+	bytes = 0;
+	mappings = [];
+	constructor(originalSource) {
+		this.originalSource = originalSource;
+	}
+	append(text) {
+		this.chunks.push(text);
+		this.bytes += Buffer.byteLength(text);
+	}
+	appendMapped(text, kind, original) {
+		const start = this.bytes;
+		this.append(text);
+		this.mappings.push({
+			kind,
+			generated: {
+				start,
+				end: this.bytes
+			},
+			original: byteSpan(this.originalSource, original)
+		});
+	}
+	toString() {
+		return this.chunks.join("");
+	}
+};
+function importedName(specifier) {
+	const imported = childNode(specifier.imported);
+	if (!imported) return null;
+	if (imported.type === "Identifier" && isCompilerString(imported.name)) return imported.name;
+	if (imported.type === "Literal" && isCompilerString(imported.value)) return imported.value;
+	return null;
+}
+function renderImport(declaration, witnessedBindings, source) {
+	if (!Array.isArray(declaration.specifiers)) return null;
+	const names = [];
+	const locals = [];
+	for (const value of declaration.specifiers) {
+		if (!isNode(value) || value.type !== "ImportSpecifier") continue;
+		const localName = nodeName(childNode(value.local));
+		if (!localName || !witnessedBindings.has(localName)) continue;
+		names.push(source.slice(value.start, value.end));
+		locals.push(localName);
+	}
+	if (names.length === 0) return null;
+	const sourceNode = childNode(declaration.source);
+	const sourceText = sourceNode && isCompilerString(sourceNode.raw) ? sourceNode.raw : sourceNode && isCompilerString(sourceNode.value) ? JSON.stringify(sourceNode.value) : null;
+	return sourceText ? {
+		text: `import { ${names.join(", ")} } from ${sourceText};\n`,
+		locals
+	} : null;
+}
+/** Memoizes success only: a missing optional peer retries per file, so
+*  installing `svelte` mid-session recovers without a restart. */
+let compilerMemo = null;
+async function loadCompiler() {
+	if (compilerMemo) return compilerMemo;
+	compilerMemo = await import("svelte/compiler").catch(() => null);
+	return compilerMemo;
+}
+function projectScope(script, scope, source, originalPath, options, inherited, precomputedOwnBindings) {
+	const ownBindings = precomputedOwnBindings ?? importBindings(script.content);
+	const bindings = inherited ? new Map([...inherited.bindings, ...ownBindings]) : ownBindings;
+	const witnesses = [];
+	const diagnostics = [];
+	if (bindings.size > 0) walk(script.content, (node, nestedScopeDepth) => {
+		const site = resolverCallSite(node, bindings);
+		if (!site) return;
+		const { access, form } = site;
+		const attribution = options.attributeResolver(access.request);
+		if (attribution === "other") return;
+		const resolverName = access.displayName;
+		const callDisplay = form === "attrs" ? `${resolverName}.attrs()` : `${resolverName}()`;
+		if (attribution === "unsupported-resolver-form" || !isSupportedResolverAccess(access)) {
+			diagnostics.push(diagnostic("SVELTE_ATTRS_IMPORT_UNSUPPORTED", `Resolver '${resolverName}' uses an import/access form that the extraction engine cannot attribute to its exported .asClass() binding.`, originalPath, source, access.resolver));
+			return;
+		}
+		if (nestedScopeDepth > 0) {
+			diagnostics.push(diagnostic("SVELTE_ATTRS_SCOPE_UNSUPPORTED", `Resolver '${callDisplay}' is inside a nested binding scope; move the call to the top-level script scope so its import identity is unambiguous.`, originalPath, source, access.resolver));
+			return;
+		}
+		if (site.computed || site.optional) {
+			diagnostics.push(diagnostic("SVELTE_ATTRS_CALLEE_UNSUPPORTED", `Resolver '${resolverName}' must be called directly as ${resolverName}(...) or ${resolverName}.attrs(...).`, originalPath, source, node));
+			return;
+		}
+		const argumentsList = Array.isArray(node.arguments) ? node.arguments.filter(isNode) : [];
+		if (argumentsList.length === 0) {
+			witnesses.push({
+				binding: access.binding,
+				resolver: access.resolver,
+				properties: []
+			});
+			return;
+		}
+		if (argumentsList.length !== 1 || argumentsList[0].type !== "ObjectExpression") {
+			diagnostics.push(diagnostic("SVELTE_ATTRS_ARGUMENT_UNRESOLVED", `Resolver '${callDisplay}' accepts no argument or one object literal in Svelte projection.`, originalPath, source, argumentSpan(argumentsList, node)));
+			return;
+		}
+		const properties = readProperties(argumentsList[0], source, originalPath);
+		if (!Array.isArray(properties)) {
+			diagnostics.push(properties);
+			return;
+		}
+		witnesses.push({
+			binding: access.binding,
+			resolver: access.resolver,
+			properties
+		});
+	});
+	if (diagnostics.length > 0 || witnesses.length === 0) return { diagnostics };
+	const witnessedBindings = new Set(witnesses.map((witness) => nodeName(witness.binding.local)));
+	const builder = new VirtualSourceBuilder(source);
+	const pendingNames = new Set(witnessedBindings);
+	const renderDeclarations = (declarations) => {
+		for (const declaration of declarations) {
+			if (declaration.type !== "ImportDeclaration") continue;
+			const rendered = renderImport(declaration, pendingNames, source);
+			if (!rendered) continue;
+			builder.append(rendered.text);
+			for (const local of rendered.locals) pendingNames.delete(local);
+		}
+	};
+	renderDeclarations(script.content.body);
+	if (inherited) renderDeclarations(inherited.importDeclarations);
+	for (const witness of witnesses) {
+		const resolverName = nodeName(witness.resolver);
+		builder.append("<");
+		builder.appendMapped(resolverName, "resolver", witness.resolver);
+		for (const property of witness.properties) {
+			builder.append(" ");
+			builder.appendMapped(property.name, "attribute", property.key);
+			builder.append("={");
+			builder.appendMapped(source.slice(property.value.start, property.value.end), "value", property.value);
+			builder.append("}");
+		}
+		builder.append(" />;\n");
+	}
+	return {
+		diagnostics: [],
+		entry: {
+			scope,
+			path: `${originalPath}.${scope}.tsx`,
+			source: builder.toString(),
+			mappings: builder.mappings
+		}
+	};
+}
+/**
+* Project Svelte script scopes into parser-only TSX witnesses from SOURCE,
+* never compiler output. Unsupported call shapes fail the whole source closed.
+*/
+async function adaptSvelteSource(source, originalPath, options) {
+	const original = {
+		path: originalPath,
+		hash: contentHash(source)
+	};
+	const compiler = await loadCompiler();
+	if (!compiler) return {
+		kind: "missing-dep",
+		original,
+		dependency: "svelte/compiler"
+	};
+	let compilerAst;
+	try {
+		compilerAst = compiler.parse(source, {
+			filename: originalPath,
+			modern: true
+		});
+	} catch (error) {
+		const range = compilerParseErrorRange(error, source);
+		return {
+			kind: "error",
+			original,
+			diagnostics: [diagnostic("SVELTE_PARSE_ERROR", error instanceof Error ? error.message : String(error), originalPath, source, range?.node, range?.location)]
+		};
+	}
+	const ast = parseSvelteAst(compilerAst);
+	const projections = [];
+	const moduleBindings = ast.module ? importBindings(ast.module.content) : void 0;
+	const instanceBindings = ast.instance ? importBindings(ast.instance.content) : void 0;
+	const moduleScope = ast.module && moduleBindings ? {
+		bindings: moduleBindings,
+		importDeclarations: ast.module.content.body.filter((declaration) => declaration.type === "ImportDeclaration")
+	} : void 0;
+	if (ast.module) projections.push(projectScope(ast.module, "module", source, originalPath, options, void 0, moduleBindings));
+	if (ast.instance) projections.push(projectScope(ast.instance, "instance", source, originalPath, options, moduleScope, instanceBindings));
+	const diagnostics = projections.flatMap((projection) => projection.diagnostics);
+	if (ast.fragment) {
+		const scriptBindings = instanceBindings ?? /* @__PURE__ */ new Map();
+		const fragmentBindings = moduleScope ? new Map([...moduleScope.bindings, ...scriptBindings]) : scriptBindings;
+		if (fragmentBindings.size > 0) walkFragment(ast.fragment, (node) => {
+			const site = resolverCallSite(node, fragmentBindings);
+			if (!site) return;
+			if (options.attributeResolver(site.access.request) === "other") return;
+			diagnostics.push(diagnostic("SVELTE_ATTRS_TEMPLATE_UNSUPPORTED", `Resolver '${site.access.displayName}' is called inside the template; assign the result to a const in the instance script and spread that instead.`, originalPath, source, node));
+		});
+	}
+	if (diagnostics.length > 0) return {
+		kind: "error",
+		original,
+		diagnostics
+	};
+	return {
+		kind: "ok",
+		original,
+		entries: projections.flatMap((projection) => projection.entry ? [projection.entry] : [])
+	};
+}
+//#endregion
+//#region pipeline/source-ingestion.ts
+function isSerializedSourceEntry(value) {
+	if (!(value instanceof Object) || Array.isArray(value)) return false;
+	return String(value.path) === value.path && String(value.source) === value.source && (value.hash === void 0 || String(value.hash) === value.hash);
+}
+/**
+* Throws on a payload that is not a corpus: an empty corpus is
+* indistinguishable from "no files" and would publish an empty stylesheet.
+*/
+function parseFilesJson(filesJson, context) {
+	const candidate = parseInternalWire(filesJson, `${context} filesJson`);
+	if (!Array.isArray(candidate) || !candidate.every(isSerializedSourceEntry)) throw new TypeError(`[${context}] analysis files JSON must be an array of {path, source} entries`);
+	return candidate;
+}
+/**
+* Advisory diagnostics warn in every mode and never quarantine their file:
+* OXC recovers parse errors the host bundler itself accepts. All else is fatal.
+*/
+function isAdvisorySourceDiagnostic(diagnostic) {
+	return diagnostic.code === "SOURCE_NATIVE_PARSE_ERROR";
+}
+const RELATIVE_PROBE_SUFFIXES = [
+	"",
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	"/index.ts",
+	"/index.tsx",
+	"/index.js",
+	"/index.jsx"
+];
+function extension(path) {
+	const basename = posix.basename(path);
+	const dot = basename.lastIndexOf(".");
+	return dot === -1 ? "" : basename.slice(dot).toLowerCase();
+}
+function canonicalResolverPath(path) {
+	return posix.normalize(path.replaceAll("\\", "/"));
+}
+const NODE_NEXT_EXTENSION_MAP = {
+	".js": [
+		".ts",
+		".tsx",
+		".jsx"
+	],
+	".mjs": [".mts"],
+	".cjs": [".cts"]
+};
+function resolveRelativeSource(importerPath, specifier, files) {
+	if (!specifier.startsWith(".")) return null;
+	const base = posix.normalize(posix.join(posix.dirname(canonicalResolverPath(importerPath)), specifier));
+	for (const suffix of RELATIVE_PROBE_SUFFIXES) {
+		const candidate = `${base}${suffix}`;
+		const actualPath = files.get(candidate);
+		if (actualPath !== void 0) return actualPath;
+	}
+	const explicitExtension = extension(base);
+	for (const sourceExtension of NODE_NEXT_EXTENSION_MAP[explicitExtension] ?? []) {
+		const candidate = `${base.slice(0, -explicitExtension.length)}${sourceExtension}`;
+		const actualPath = files.get(candidate);
+		if (actualPath !== void 0) return actualPath;
+	}
+	return null;
+}
+var ResolverExportIndex = class {
+	facts;
+	collisions;
+	files;
+	resolverBindings = /* @__PURE__ */ new Map();
+	/** Both memos live for one ingest only — the index is rebuilt per call,
+	*  so neither needs invalidation. */
+	attributionMemo = /* @__PURE__ */ new Map();
+	resolveMemo = /* @__PURE__ */ new Map();
+	constructor(facts, analysisPaths) {
+		this.facts = facts;
+		const pathsByCanonical = /* @__PURE__ */ new Map();
+		for (const path of analysisPaths) {
+			const canonicalPath = canonicalResolverPath(path);
+			const paths = pathsByCanonical.get(canonicalPath) ?? [];
+			paths.push(path);
+			pathsByCanonical.set(canonicalPath, paths);
+		}
+		this.collisions = [...pathsByCanonical].filter(([, paths]) => paths.length > 1).map(([canonicalPath, paths]) => ({
+			canonicalPath,
+			paths
+		}));
+		const factPathsByCanonical = /* @__PURE__ */ new Map();
+		for (const path of Object.keys(facts.files)) {
+			const canonicalPath = canonicalResolverPath(path);
+			const paths = factPathsByCanonical.get(canonicalPath) ?? [];
+			paths.push(path);
+			factPathsByCanonical.set(canonicalPath, paths);
+		}
+		const files = /* @__PURE__ */ new Map();
+		for (const [canonicalPath, paths] of pathsByCanonical) {
+			const factPaths = factPathsByCanonical.get(canonicalPath) ?? [];
+			if (paths.length === 1 && factPaths.length === 1) files.set(canonicalPath, factPaths[0]);
+		}
+		this.files = files;
+		for (const [path, file] of Object.entries(facts.files)) this.resolverBindings.set(path, new Set(file.chains.filter((chain) => chain.descriptor.terminal === "asClass" && chain.descriptor.extractable && chain.fatalError === null).map((chain) => chain.descriptor.binding)));
+	}
+	attribute(importerPath, request) {
+		const memoKey = `${importerPath}\0${request.source}\0${request.imported}\0${request.access.kind}\0${request.access.importKind}`;
+		const memoized = this.attributionMemo.get(memoKey);
+		if (memoized !== void 0) return memoized;
+		const attribution = this.attributeUncached(importerPath, request);
+		this.attributionMemo.set(memoKey, attribution);
+		return attribution;
+	}
+	attributeUncached(importerPath, request) {
+		const importedFile = this.resolveSource(importerPath, request.source);
+		if (!importedFile) return "other";
+		if (this.resolveClassExport(importedFile, request.imported, /* @__PURE__ */ new Set()) === null) return "other";
+		return request.access.kind === "direct" && request.access.importKind === "named" ? "resolver" : "unsupported-resolver-form";
+	}
+	resolveSource(importerPath, specifier) {
+		const key = `${importerPath}\0${specifier}`;
+		let resolved = this.resolveMemo.get(key);
+		if (resolved === void 0) {
+			resolved = resolveRelativeSource(importerPath, specifier, this.files);
+			this.resolveMemo.set(key, resolved);
+		}
+		return resolved;
+	}
+	resolveClassExport(path, exportedName, seen) {
+		const identity = `${path}\0${exportedName}`;
+		if (seen.has(identity)) return null;
+		seen.add(identity);
+		const file = this.facts.files[path];
+		const exported = file?.exports.find((candidate) => candidate.exported === exportedName);
+		if (!file || !exported) return null;
+		if (exported.source === null) {
+			if (exported.local === null) return null;
+			if (this.resolverBindings.get(path)?.has(exported.local)) return exported.local;
+			const imported = file.imports.find((candidate) => candidate.local === exported.local);
+			if (!imported) return null;
+			const importedFile = this.resolveSource(path, imported.source);
+			return importedFile ? this.resolveClassExport(importedFile, imported.imported, seen) : null;
+		}
+		if (exported.original === null) return null;
+		const nextFile = this.resolveSource(path, exported.source);
+		return nextFile ? this.resolveClassExport(nextFile, exported.original, seen) : null;
+	}
+};
+/**
+* Native and MDX entries must establish the resolver index before any Svelte
+* projection; bare-package and aliased sources stay unattributed by design.
+*/
+async function ingestSourceEntries(rawEntries, options) {
+	const mdxAdapter = options.preprocessMdx ?? preprocessMdx;
+	const svelteAdapter = options.adaptSvelte ?? adaptSvelteSource;
+	const originalEntries = rawEntries.map((entry) => ({
+		...entry,
+		hash: entry.hash ?? contentHash(entry.source)
+	}));
+	const rawOriginalPaths = new Set(originalEntries.map((entry) => entry.path));
+	const analysisEntries = [];
+	const ownership = {};
+	const analysisOwner = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	const svelteEntries = [];
+	const addAnalysisEntry = (originalPath, path, source, hash) => {
+		analysisEntries.push({
+			path,
+			source,
+			hash: hash ?? contentHash(source)
+		});
+		ownership[originalPath].analysisPaths.push(path);
+		analysisOwner.set(path, originalPath);
+	};
+	const addAdaptedEntries = (originalPath, entries) => {
+		const pendingPaths = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			const conflictingOriginalPath = rawOriginalPaths.has(entry.path) ? entry.path : analysisOwner.get(entry.path) ?? (pendingPaths.has(entry.path) ? originalPath : null);
+			if (conflictingOriginalPath !== null) {
+				diagnostics.push({
+					code: "SOURCE_ANALYSIS_PATH_COLLISION",
+					message: `Generated analysis path '${entry.path}' collides with '${conflictingOriginalPath}'. Rename one of the source files so adapted analysis paths remain unique.`,
+					originalPath,
+					analysisPath: entry.path,
+					conflictingOriginalPath
+				});
+				return;
+			}
+			pendingPaths.add(entry.path);
+		}
+		for (const entry of entries) addAnalysisEntry(originalPath, entry.path, entry.source);
+	};
+	for (const original of originalEntries) {
+		ownership[original.path] = {
+			originalPath: original.path,
+			originalHash: original.hash,
+			analysisPaths: []
+		};
+		const kind = extension(original.path);
+		if (kind === ".svelte") {
+			svelteEntries.push(original);
+			continue;
+		}
+		if (kind !== ".mdx") {
+			addAnalysisEntry(original.path, original.path, original.source, original.hash);
+			continue;
+		}
+		const result = await mdxAdapter(original.source, original.path);
+		if (result.kind === "missing-dep") {
+			diagnostics.push({
+				code: "SOURCE_MDX_DEPENDENCY_MISSING",
+				message: "Install optional peer dependency '@mdx-js/mdx' to analyze opted-in MDX source.",
+				originalPath: original.path
+			});
+			continue;
+		}
+		if (result.kind === "error" || result.source === void 0) {
+			diagnostics.push({
+				code: "SOURCE_MDX_PARSE_ERROR",
+				message: result.error ?? "MDX preprocessing produced no source.",
+				originalPath: original.path
+			});
+			continue;
+		}
+		addAdaptedEntries(original.path, [{
+			path: `${original.path}.tsx`,
+			source: result.source
+		}]);
+	}
+	const facts = collectFileFacts(analysisEntries, options);
+	for (const [analysisPath, file] of Object.entries(facts.files)) {
+		const originalPath = analysisOwner.get(analysisPath) ?? analysisPath;
+		for (const message of file.parseDiagnostics) diagnostics.push({
+			code: "SOURCE_NATIVE_PARSE_ERROR",
+			message,
+			originalPath,
+			analysisPath
+		});
+	}
+	const resolvers = new ResolverExportIndex(facts, analysisEntries.map((entry) => entry.path));
+	for (const { canonicalPath, paths } of resolvers.collisions) for (let index = 0; index < paths.length; index += 1) {
+		const path = paths[index];
+		const conflictingPath = paths[(index + 1) % paths.length];
+		diagnostics.push({
+			code: "SOURCE_RESOLVER_IDENTITY_COLLISION",
+			message: `Resolver lookup paths '${path}' and '${conflictingPath}' normalize to the same private identity '${canonicalPath}'. Rename one of the source files so resolver identities remain unique.`,
+			originalPath: analysisOwner.get(path) ?? path,
+			canonicalPath,
+			conflictingOriginalPath: analysisOwner.get(conflictingPath) ?? conflictingPath
+		});
+	}
+	for (const original of svelteEntries) {
+		const result = await svelteAdapter(original.source, original.path, { attributeResolver: (request) => resolvers.attribute(original.path, request) });
+		if (result.kind === "missing-dep") {
+			diagnostics.push({
+				code: "SOURCE_SVELTE_DEPENDENCY_MISSING",
+				message: "Install optional peer dependency 'svelte' to analyze opted-in Svelte source.",
+				originalPath: original.path
+			});
+			continue;
+		}
+		if (result.kind === "error") {
+			diagnostics.push(...result.diagnostics);
+			continue;
+		}
+		addAdaptedEntries(original.path, result.entries);
+	}
+	return {
+		originalEntries,
+		analysisEntries,
+		ownership,
+		diagnostics
+	};
+}
+/**
+* `parseCount` counts the parses performed by THIS call, so a fully-memoized
+* pass reports zero.
+*/
+function collectFileFacts(analysisEntries, options) {
+	const cache = options.factsCache;
+	if (!cache) return JSON.parse(options.extractFacts(JSON.stringify(analysisEntries)));
+	const pending = analysisEntries.filter((entry) => cache.get(entry.path)?.hash !== entry.hash);
+	let parseCount = 0;
+	if (pending.length > 0) {
+		const fresh = JSON.parse(options.extractFacts(JSON.stringify(pending)));
+		parseCount = fresh.parseCount;
+		for (const entry of pending) {
+			const facts = fresh.files[entry.path];
+			if (facts) cache.set(entry.path, {
+				hash: entry.hash,
+				facts
+			});
+			else cache.delete(entry.path);
+		}
+	}
+	const currentPaths = new Set(analysisEntries.map((entry) => entry.path));
+	for (const path of [...cache.keys()]) if (!currentPaths.has(path)) cache.delete(path);
+	const files = {};
+	for (const entry of analysisEntries) {
+		const cached = cache.get(entry.path);
+		if (cached) files[entry.path] = cached.facts;
+	}
+	return {
+		files,
+		parseCount
+	};
+}
+/**
+* Drops each named original and the analysis children it owns. Every corpus
+* path applies it — skipping it on incremental passes freezes re-analysis.
+*/
+function withoutInvalidOriginals(result, invalidOriginals) {
+	if (invalidOriginals.size === 0) return result;
+	const ownership = Object.fromEntries(Object.entries(result.ownership).filter(([originalPath]) => !invalidOriginals.has(originalPath)));
+	const analysisPaths = new Set(Object.values(ownership).flatMap((owner) => owner.analysisPaths));
+	return {
+		...result,
+		originalEntries: result.originalEntries.filter((entry) => !invalidOriginals.has(entry.path)),
+		analysisEntries: result.analysisEntries.filter((entry) => analysisPaths.has(entry.path)),
+		ownership
+	};
+}
+/**
+* Diagnostics name ANALYSIS paths while ownership is recorded for originals,
+* so projection is required; the result REPLACES the caller's owner map.
+*/
+function projectExternalFileOwners(result, rawOwners) {
+	const projected = {};
+	for (const owner of Object.values(result.ownership)) {
+		const packageOwner = rawOwners[owner.originalPath];
+		if (!packageOwner) continue;
+		projected[owner.originalPath] = packageOwner;
+		for (const analysisPath of owner.analysisPaths) projected[analysisPath] = packageOwner;
+	}
+	return projected;
+}
+/**
+* One ingestion policy point for every host: a host supplies only a prefix, a
+* strict flag, and a warn sink; policy and per-host memos stay here.
+*/
+function createSourceIngestor(host) {
+	const factsCache = /* @__PURE__ */ new Map();
+	/** Non-strict dedupe: a quarantined original re-ingests on every later
+	*  corpus pass, so re-warning it on each save is noise. */
+	const warnedByOriginal = /* @__PURE__ */ new Map();
+	return {
+		async ingest(entries) {
+			const extractFacts = host.engineApi().extractFacts;
+			if (extractFacts === void 0) throw new Error(`${host.prefix} native engine does not expose extractFacts required for source adaptation`);
+			return ingestSourceEntries(entries, {
+				extractFacts,
+				factsCache
+			});
+		},
+		surfaceDiagnostics(diagnostics) {
+			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 lines = fatal.map((diagnostic) => `${diagnostic.code} ${diagnostic.originalPath}: ${diagnostic.message}`);
+				throw new Error(`${host.prefix} ${lines.join(`\n${host.prefix} `)}`);
+			}
+			for (const diagnostic of diagnostics) {
+				const line = `${diagnostic.code} ${diagnostic.originalPath}: ${diagnostic.message}`;
+				let warned = warnedByOriginal.get(diagnostic.originalPath);
+				if (!warned) {
+					warned = /* @__PURE__ */ new Set();
+					warnedByOriginal.set(diagnostic.originalPath, warned);
+				}
+				if (warned.has(line)) continue;
+				warned.add(line);
+				host.warn(`${host.prefix} ${line}`);
+			}
+			return invalidOriginals;
+		},
+		markPublished(result) {
+			for (const originalPath of Object.keys(result.ownership)) warnedByOriginal.delete(originalPath);
+		}
+	};
+}
+//#endregion
+//#region pipeline/engine-adapter.ts
+/**
+* One engine API for both plugins. Imports neither the native binding nor any
+* plugin or bundler — every such dependency arrives injected.
+*/
+/**
+* Returns a function, invoked per call site, so `isV2()` and
+* `loadNativeEngine()` re-evaluate each time instead of being captured.
+*/
+function createV2EngineApi(deps) {
+	const { label, isV2, loadNativeEngine, store } = deps;
+	return () => {
+		if (!isV2()) return loadNativeEngine();
+		const native = loadNativeEngine();
+		return {
+			loadSystemModule: (...args) => native.loadSystemModule(...args),
+			extractFacts: (filesJson) => native.extractFacts(filesJson),
+			analyzeProject: (filesJsonRaw, scalesJson, variableMapJson, contextualVarsJson, propConfigJson, groupRegistryJson, packageResolutionJson, devMode, emitterConfigJson, selectorAliasesJson, _selectorOrderJson, globalStyleBlocksJson, pathAliasesJson, keyframesJson, staticCssJson, conditionAliasesJson, externalDirsJson, transformSourcesJson) => {
+				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);
+				store.setSentSources(sent);
+				const emitterConfig = emitterConfigJson ? JSON.parse(emitterConfigJson) : {};
+				store.setEngine(null);
+				const config = {
+					runtimeImport: emitterConfig.runtime_import ?? void 0,
+					cssModuleId: emitterConfig.css_module_id ?? void 0,
+					systemPropsModuleId: emitterConfig.system_props_module_id ?? void 0,
+					themeJson: scalesJson,
+					variableMapJson,
+					contextualVarsJson: contextualVarsJson ?? void 0,
+					configJson: propConfigJson,
+					groupRegistryJson,
+					selectorAliasesJson: selectorAliasesJson ?? void 0,
+					conditionAliasesJson: conditionAliasesJson ?? void 0,
+					globalStyleBlocksJson: globalStyleBlocksJson ?? void 0,
+					keyframesJson: keyframesJson ?? void 0,
+					packageResolutionJson: packageResolutionJson ?? void 0,
+					pathAliasesJson: pathAliasesJson ?? void 0,
+					staticCssJson: staticCssJson ?? void 0,
+					externalDirsJson: externalDirsJson ?? void 0,
+					transformSourcesJson: transformSourcesJson ?? void 0,
+					devMode
+				};
+				const engine = new native.ExtractEngine(config);
+				store.setEngine(engine);
+				return engine.analyze(filesJson);
+			},
+			transformFile: (source, path, _manifest) => {
+				const engine = store.getEngine();
+				if (!engine) throw new Error(`[${label}] v2 transform before analyze — engine instance not initialized`);
+				const sentMap = store.getSentSources();
+				if (deps.passThroughUnknownPaths && sentMap && !sentMap.has(path)) return {
+					code: source,
+					hasComponents: false
+				};
+				const sent = sentMap?.get(path);
+				if (sent !== void 0 && sent !== source && !store.getDriftWarned()) {
+					store.setDriftWarned(true);
+					console.warn(`[${label}] v2: transform-time source for ${path} differs from analyze-time source — an upstream transform may be reverted`);
+				}
+				return JSON.parse(engine.transformFile(path));
+			},
+			clearAnalysisCache: () => {
+				const engine = store.getEngine();
+				if (engine) engine.clearCache();
+				store.setEngine(null);
+			}
+		};
+	};
+}
+//#endregion
+//#region pipeline/engine-retirement.ts
+const RETIRED_ENGINE_MESSAGE = "animus: extraction engine 'v1' was retired (openspec: retire-extract-v1) — v2 is the only engine; remove the engine option / ANIMUS_ENGINE override";
+function assertNoRetiredEngineSelection(engineOption) {
+	if (engineOption === "v1" || process.env.ANIMUS_ENGINE === "v1") throw new Error(RETIRED_ENGINE_MESSAGE);
+}
+//#endregion
+//#region pipeline/core-options.ts
+const DRIVER_NAMESPACES = [
+	"vite",
+	"next",
+	"cli"
+];
+const DRIVER_NAMESPACE_KEYS = new Set(DRIVER_NAMESPACES);
+/**
+* Applied unconditionally: `node_modules` belongs to external-package
+* collection, and `.next`/`.animus` hold output, never source.
+*/
+const STRUCTURAL_EXCLUDE = [
+	"node_modules",
+	".next",
+	".animus"
+];
+/** Defaults a user `exclude` list replaces; the structural set it cannot. */
+const REPLACEABLE_DEFAULT_EXCLUDE = [
+	"dist",
+	".test.",
+	".spec."
+];
+const DEFAULT_EXCLUDE = [...STRUCTURAL_EXCLUDE, ...REPLACEABLE_DEFAULT_EXCLUDE];
+const CORE_OPTION_KEYS = /* @__PURE__ */ new Set([
+	"system",
+	"exclude",
+	"extensions",
+	"strict",
+	"verbose",
+	"prefix",
+	"targets",
+	"minify",
+	"staticCss",
+	"layers",
+	"engine",
+	"mode",
+	"root"
+]);
+/** Carries a stable `name` so drivers can map it to their own config-error
+*  surface (the CLI's exit code 2). */
+var AnimusConfigError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AnimusConfigError";
+	}
+};
+/**
+* `ownKeys` is the caller's own top-level surface; `rejectKeys` names core
+* keys it does not honor, which must fail rather than be silently ignored.
+*/
+function assertKnownOptionKeys(raw, ownKeys = [], rejectKeys = [], opts = {}) {
+	const surface = (message) => {
+		if (opts.onUnknownKey === "warn") {
+			opts.warn(message);
+			return;
+		}
+		throw new AnimusConfigError(message);
+	};
+	const own = new Set(ownKeys);
+	for (const key of Object.keys(raw)) {
+		if (raw[key] === void 0) continue;
+		const rejected = rejectKeys.find((entry) => entry.key === key);
+		if (rejected) {
+			surface(`Option "${key}" is not supported by this driver: ${rejected.reason}`);
+			continue;
+		}
+		if (CORE_OPTION_KEYS.has(key) || DRIVER_NAMESPACE_KEYS.has(key) || own.has(key)) continue;
+		const nearest = suggestNearest(key);
+		surface(`Unknown option "${key}".${nearest ? ` Did you mean "${nearest}"?` : ""} Core keys: ${[...CORE_OPTION_KEYS].join(", ")}. Driver namespaces: ${DRIVER_NAMESPACES.join(", ")}.`);
+	}
+	const mode = raw["mode"];
+	if (mode !== void 0 && mode !== "development" && mode !== "production") throw new AnimusConfigError(`Invalid mode "${String(mode)}" — expected "development" or "production".`);
+	for (const { key, ok, expected } of CORE_VALUE_GATES) {
+		const value = raw[key];
+		if (value === void 0 || ok(value)) continue;
+		throw new AnimusConfigError(`Invalid value for "${key}" — expected ${expected}, got ${JSON.stringify(value)}.`);
+	}
+}
+/**
+* Options are foreign JS, so a boxed `String`/`Boolean` must not pass: a
+* boxed value never behaves as the primitive its consumers expect.
+*/
+const isString = (value) => Object(value) !== value && Object.prototype.toString.call(value) === "[object String]";
+const isBoolean = (value) => Object(value) !== value && Object.prototype.toString.call(value) === "[object Boolean]";
+const isStringArray = (value) => Array.isArray(value) && value.every(isString);
+const isStringOrStringArray = (value) => isString(value) || isStringArray(value);
+const CORE_VALUE_GATES = [
+	{
+		key: "system",
+		ok: isString,
+		expected: "a string path"
+	},
+	{
+		key: "exclude",
+		ok: isStringArray,
+		expected: "an array of string patterns"
+	},
+	{
+		key: "extensions",
+		ok: isStringArray,
+		expected: "an array of string extensions"
+	},
+	{
+		key: "strict",
+		ok: isBoolean,
+		expected: "a boolean"
+	},
+	{
+		key: "verbose",
+		ok: isBoolean,
+		expected: "a boolean"
+	},
+	{
+		key: "minify",
+		ok: isBoolean,
+		expected: "a boolean"
+	},
+	{
+		key: "prefix",
+		ok: isString,
+		expected: "a string"
+	},
+	{
+		key: "targets",
+		ok: isStringOrStringArray,
+		expected: "a string or an array of strings"
+	},
+	{
+		key: "layers",
+		ok: isStringArray,
+		expected: "an array of layer names"
+	}
+];
+function suggestNearest(key) {
+	const lower = key.toLowerCase();
+	let best = null;
+	let bestScore = 3;
+	for (const candidate of CORE_OPTION_KEYS) {
+		const score = editDistance(lower, candidate.toLowerCase());
+		if (score < bestScore) {
+			bestScore = score;
+			best = candidate;
+		}
+	}
+	return best;
+}
+function editDistance(a, b) {
+	const dp = Array.from({ length: a.length + 1 }, (_, i) => [i]);
+	for (let j = 1; j <= b.length; j++) dp[0][j] = j;
+	for (let i = 1; i <= a.length; i++) for (let j = 1; j <= b.length; j++) dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+	return dp[a.length][b.length];
+}
+const GLOB_META = /[*?]/;
+/**
+* Globs compile to a RegExp over the root-relative path, matching the path or
+* any ancestor directory; plain patterns are substrings. `./` is stripped.
+*/
+function compilePattern(raw) {
+	let pattern = raw.split("\\").join("/");
+	while (pattern.startsWith("./")) pattern = pattern.slice(2);
+	if (pattern === "") return () => false;
+	if (!GLOB_META.test(pattern)) return (full, rel) => full.includes(pattern) || rel.includes(pattern);
+	const regex = globToRegExp(pattern);
+	return (_full, rel) => {
+		const normalized = rel.split("\\").join("/");
+		if (regex.test(normalized)) return true;
+		for (let slash = normalized.indexOf("/"); slash !== -1; slash = normalized.indexOf("/", slash + 1)) if (regex.test(normalized.slice(0, slash))) return true;
+		return false;
+	};
+}
+/** Minimal glob → RegExp: `**` spans segments, `*`/`?` stay within one. */
+function globToRegExp(glob) {
+	let out = "";
+	let i = 0;
+	const normalized = glob.split("\\").join("/");
+	while (i < normalized.length) {
+		const ch = normalized[i];
+		if (ch === "*") {
+			if (normalized[i + 1] === "*") {
+				if (normalized[i + 2] === "/") {
+					out += "(?:[^/]+/)*";
+					i += 3;
+				} else {
+					out += ".*";
+					i += 2;
+				}
+			} else {
+				out += "[^/]*";
+				i += 1;
+			}
+		} else if (ch === "?") {
+			out += "[^/]";
+			i += 1;
+		} else {
+			out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+			i += 1;
+		}
+	}
+	return new RegExp(`^${out}$`);
+}
+/**
+* A user list replaces only the replaceable defaults. Driver-owned
+* invariants belong in `extraStructural`; a user list would replace those.
+*/
+function createExcludeMatcher(userPatterns, extraStructural = []) {
+	const merged = [...STRUCTURAL_EXCLUDE];
+	for (const pattern of extraStructural) if (!merged.includes(pattern)) merged.push(pattern);
+	for (const pattern of userPatterns ?? REPLACEABLE_DEFAULT_EXCLUDE) if (!merged.includes(pattern)) merged.push(pattern);
+	const compiled = merged.map((pattern) => [pattern, compilePattern(pattern)]);
+	const hits = new Map(merged.map((p) => [p, 0]));
+	const explain = (full, rel) => {
+		for (const [pattern, test] of compiled) if (test(full, rel)) {
+			hits.set(pattern, (hits.get(pattern) ?? 0) + 1);
+			return pattern;
+		}
+		return null;
+	};
+	return {
+		patterns: merged,
+		matches: (full, rel) => explain(full, rel) !== null,
+		explain,
+		stats: () => hits
+	};
+}
+function resolveMode(explicit, driverDefault) {
+	if (explicit === "development" || explicit === "production") return {
+		mode: explicit,
+		provenance: "explicit"
+	};
+	return {
+		mode: driverDefault(),
+		provenance: "driver-default"
+	};
+}
+//#endregion
+//#region pipeline/discover-files.ts
+function pathCharRank(code) {
+	return code === 47 || code === 92 ? -1 : code;
+}
+function compareDiscoveryOrder(a, b) {
+	const shared = Math.min(a.length, b.length);
+	for (let i = 0; i < shared; i++) {
+		const left = pathCharRank(a.charCodeAt(i));
+		const right = pathCharRank(b.charCodeAt(i));
+		if (left !== right) return left - right;
+	}
+	return a.length - b.length;
+}
+function discoverFiles(dir, rootDir, exclude, extensionsSet) {
+	return walkFiles(dir, rootDir, exclude, extensionsSet).sort(compareDiscoveryOrder);
+}
+function walkFiles(dir, rootDir, exclude, extensionsSet) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir, { encoding: "utf8" });
+	} catch {
+		return results;
+	}
+	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;
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) results.push(...walkFiles(fullPath, rootDir, exclude, extensionsSet));
+		else if (extensionsSet.has(extname(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/discover-packages.ts
+function findPackageRoot(absEntryPath) {
+	let pkgRoot = dirname$1(absEntryPath);
+	while (pkgRoot !== dirname$1(pkgRoot) && !existsSync(join$1(pkgRoot, "package.json"))) pkgRoot = dirname$1(pkgRoot);
+	return pkgRoot;
+}
+const PACKAGE_SRC_EXCLUDES = [
+	"dist",
+	"node_modules",
+	".test.",
+	".spec."
+];
+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)));
+}
+const PACKAGE_OUTPUT_EXCLUDES = [
+	"node_modules",
+	".test.",
+	".spec.",
+	".d.ts",
+	".map"
+];
+const isFile = (path) => {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+};
+function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
+	return [
+		absSpecifier,
+		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
+		...Array.from(extensionsSet, (ext) => join$1(absSpecifier, `index${ext}`))
+	].find(isFile) ?? null;
+}
+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)) {
+		const resolved = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		if (!resolved) return null;
+		return isPathWithinRoot(srcDir, resolved) ? resolved : null;
+	}
+	const packageName = bareSpecifierPackageName(specifier);
+	const subpath = specifier.slice(packageName.length + 1);
+	return resolveAbsolutePathSpecifier(join$1(srcDir, subpath || "index"), extensionsSet);
+}
+function distEntryIsStale(absEntry, srcDir, srcFiles) {
+	if (isPathWithinRoot(srcDir, absEntry)) return false;
+	let distMtime;
+	try {
+		distMtime = statSync(absEntry).mtimeMs;
+	} catch {
+		return false;
+	}
+	let newestSrcMtime = -Infinity;
+	for (const srcFile of srcFiles) try {
+		newestSrcMtime = Math.max(newestSrcMtime, statSync(srcFile).mtimeMs);
+	} catch {}
+	return distMtime < newestSrcMtime;
+}
+async function collectExternalPackageSources(opts) {
+	const { specifiers, resolveSpecifier, rootDir, extensionsSet, hasEntry, onSourceRead, onUnreadable, onPackageResolved } = opts;
+	const entries = [];
+	const pushed = /* @__PURE__ */ new Set();
+	const packageMap = {};
+	const sourceEntries = /* @__PURE__ */ new Map();
+	const packageDirs = [];
+	const dirOwnerSets = {};
+	const dirExtensions = {};
+	const fileOwners = {};
+	const outcomes = [];
+	const claimDir = (dir, specifier) => {
+		(dirOwnerSets[dir] ??= []).push(specifier);
+	};
+	const alreadyIngested = (relPath) => hasEntry(relPath) || pushed.has(relPath);
+	for (const specifier of specifiers) {
+		let absEntry;
+		try {
+			absEntry = await resolveSpecifier(specifier);
+		} catch {
+			absEntry = null;
+		}
+		if (!absEntry && isAbsolute(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		if (!absEntry) {
+			outcomes.push({
+				specifier,
+				outcome: "unresolvable",
+				fileCount: 0
+			});
+			continue;
+		}
+		const pkgRoot = findPackageRoot(absEntry);
+		const srcDir = join$1(pkgRoot, "src");
+		let fileCount = 0;
+		let staleDist = false;
+		if (existsSync(srcDir)) {
+			packageDirs.push(srcDir);
+			claimDir(srcDir, specifier);
+			dirExtensions[srcDir] = [...extensionsSet];
+			onPackageResolved?.(specifier, srcDir);
+			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
+			if (srcEntry) {
+				packageMap[specifier] = relative(rootDir, srcEntry);
+				sourceEntries.set(specifier, srcEntry);
+			} else packageMap[specifier] = relative(rootDir, absEntry);
+			if (!isAbsolute(specifier)) {
+				const packageName = bareSpecifierPackageName(specifier);
+				if (packageName !== specifier && !(packageName in packageMap)) {
+					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
+					if (rootEntry) {
+						packageMap[packageName] = relative(rootDir, rootEntry);
+						sourceEntries.set(packageName, rootEntry);
+					}
+				}
+			}
+			const pkgFiles = walkPackageSources(srcDir, extensionsSet);
+			staleDist = 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++;
+			}
+		} else {
+			const outputDir = dirname$1(absEntry);
+			packageDirs.push(outputDir);
+			claimDir(outputDir, specifier);
+			onPackageResolved?.(specifier, outputDir);
+			packageMap[specifier] = relative(rootDir, absEntry);
+			const outputExtensions = new Set(extensionsSet);
+			outputExtensions.add(extname(absEntry));
+			dirExtensions[outputDir] = [...outputExtensions];
+			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
+				const relToOutput = relative(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++;
+			}
+		}
+		outcomes.push({
+			specifier,
+			outcome: staleDist ? "stale-dist" : fileCount > 0 ? "resolved" : "empty",
+			fileCount
+		});
+	}
+	return {
+		entries,
+		packageMap,
+		sourceEntries,
+		packageDirs,
+		dirOwnerSets,
+		dirExtensions,
+		fileOwners,
+		outcomes
+	};
+}
+function firstOwners(dirOwnerSets) {
+	const owners = {};
+	for (const [dir, specifiers] of Object.entries(dirOwnerSets)) if (specifiers.length > 0) owners[dir] = specifiers[0];
+	return owners;
+}
+function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
+	if (rejectedSpecifiers.size === 0) return collected;
+	const rejectedDirs = Object.entries(collected.dirOwnerSets).filter(([, specs]) => specs.every((s) => rejectedSpecifiers.has(s))).map(([dir]) => dir);
+	const underRejectedDir = (absPath) => rejectedDirs.some((dir) => isPathWithinRoot(dir, absPath));
+	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;
+		packageMap[specifier] = relTarget;
+	}
+	const sourceEntries = /* @__PURE__ */ new Map();
+	for (const [specifier, absEntry] of collected.sourceEntries) {
+		if (targetRejected(specifier, absEntry)) continue;
+		sourceEntries.set(specifier, absEntry);
+	}
+	const dirOwnerSets = {};
+	for (const [dir, specs] of Object.entries(collected.dirOwnerSets)) {
+		const kept = specs.filter((s) => !rejectedSpecifiers.has(s));
+		if (kept.length === 0) continue;
+		dirOwnerSets[dir] = kept;
+	}
+	const dirExtensions = {};
+	for (const [dir, exts] of Object.entries(collected.dirExtensions)) {
+		if (rejectedDirs.includes(dir)) continue;
+		dirExtensions[dir] = exts;
+	}
+	const fileOwners = {};
+	for (const [relPath, owner] of Object.entries(collected.fileOwners)) {
+		if (rejectedSpecifiers.has(owner)) continue;
+		fileOwners[relPath] = owner;
+	}
+	return {
+		entries: collected.entries.filter((entry) => !rejectedSpecifiers.has(collected.fileOwners[entry.path])),
+		packageMap,
+		sourceEntries,
+		packageDirs: collected.packageDirs.filter((dir) => !rejectedDirs.includes(dir)),
+		dirOwnerSets,
+		dirExtensions,
+		fileOwners,
+		outcomes: collected.outcomes
+	};
+}
+function unresolvableIncludesMessage(outcomes) {
+	const unresolvable = outcomes.filter((record) => record.outcome === "unresolvable").map((record) => record.specifier);
+	if (unresolvable.length === 0) return null;
+	return `[animus-extract] unresolvable include specifier(s): ${unresolvable.join(", ")}`;
+}
+/** A stale dist silently skews merged registry content while discovery
+*  compiles the fresh sources; null when no specifier is stale. */
+function staleDistIncludesMessage(outcomes) {
+	const stale = outcomes.filter((record) => record.outcome === "stale-dist").map((record) => record.specifier);
+	if (stale.length === 0) return null;
+	return `[animus-extract] stale dist for include specifier(s): ${stale.join(", ")} — dist entry is older than the newest src/ file; rebuild the package(s) before extracting`;
+}
+function extractSystemFilePackages(systemFilePath) {
+	let source;
+	try {
+		source = readFileSync(systemFilePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const identifiers = /* @__PURE__ */ new Set();
+	const constructorRegex = /createSystem\s*\(\s*\{[^}]*?\bincludes\s*:\s*\[([^\]]*)\]/gs;
+	const chainRegex = /\.includes\s*\(\s*\[([^\]]*)\]\s*\)/gs;
+	const collectIdentifiers = (regex) => {
+		let match;
+		while ((match = regex.exec(source)) !== null) {
+			const inner = match[1];
+			for (const token of inner.split(",")) {
+				const id = token.trim();
+				if (id && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(id)) identifiers.add(id);
+			}
+		}
+	};
+	collectIdentifiers(constructorRegex);
+	collectIdentifiers(chainRegex);
+	const IDENT_START_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*/;
+	const skipTrivia = (from) => {
+		let pos = from;
+		for (;;) {
+			while (pos < source.length && /\s/.test(source[pos])) pos++;
+			if (source.startsWith("//", pos)) {
+				const newline = source.indexOf("\n", pos);
+				pos = newline === -1 ? source.length : newline + 1;
+				continue;
+			}
+			if (source.startsWith("/*", pos)) {
+				const close = source.indexOf("*/", pos + 2);
+				pos = close === -1 ? source.length : close + 2;
+				continue;
+			}
+			return pos;
+		}
+	};
+	const consumeChainLinks = (from) => {
+		let pos = from;
+		for (;;) {
+			let cursor = skipTrivia(pos);
+			if (source[cursor] !== ".") return pos;
+			cursor = skipTrivia(cursor + 1);
+			const method = IDENT_START_RE.exec(source.slice(cursor))?.[0];
+			if (method !== "extend" && method !== "from") return pos;
+			cursor = skipTrivia(cursor + method.length);
+			if (source[cursor] !== "(") return pos;
+			cursor = skipTrivia(cursor + 1);
+			const base = IDENT_START_RE.exec(source.slice(cursor))?.[0];
+			if (!base) return pos;
+			cursor = skipTrivia(cursor + base.length);
+			while (source[cursor] === ".") {
+				const afterDot = skipTrivia(cursor + 1);
+				const segment = IDENT_START_RE.exec(source.slice(afterDot))?.[0];
+				if (!segment) break;
+				cursor = skipTrivia(afterDot + segment.length);
+			}
+			if (source[cursor] === ",") cursor = skipTrivia(cursor + 1);
+			if (source[cursor] !== ")") return pos;
+			identifiers.add(base);
+			pos = cursor + 1;
+		}
+	};
+	const boundIdentifierBefore = (index) => {
+		const match = /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*$/.exec(source.slice(0, index));
+		return match ? match[1] : null;
+	};
+	const chainRootIdentifiers = /* @__PURE__ */ new Set();
+	const createSystemAnchor = /createSystem\s*\(/g;
+	let anchorMatch;
+	while ((anchorMatch = createSystemAnchor.exec(source)) !== null) {
+		let pos = anchorMatch.index + anchorMatch[0].length;
+		let depth = 1;
+		while (pos < source.length && depth > 0) {
+			const ch = source[pos];
+			if (ch === "(") depth++;
+			else if (ch === ")") depth--;
+			pos++;
+		}
+		consumeChainLinks(pos);
+		const bound = boundIdentifierBefore(anchorMatch.index);
+		if (bound) chainRootIdentifiers.add(bound);
+	}
+	const scannedRoots = /* @__PURE__ */ new Set();
+	for (;;) {
+		const pendingRoots = [...chainRootIdentifiers].filter((root) => !scannedRoots.has(root));
+		if (pendingRoots.length === 0) break;
+		for (const root of pendingRoots) {
+			scannedRoots.add(root);
+			const rootUse = new RegExp(`(?<![a-zA-Z0-9_$])${root.replace(/\$/g, "\\$")}(?![a-zA-Z0-9_$])`, "g");
+			let useMatch;
+			while ((useMatch = rootUse.exec(source)) !== null) {
+				const afterIdentifier = useMatch.index + useMatch[0].length;
+				if (consumeChainLinks(afterIdentifier) === afterIdentifier) continue;
+				const bound = boundIdentifierBefore(useMatch.index);
+				if (bound) chainRootIdentifiers.add(bound);
+			}
+		}
+	}
+	if (identifiers.size === 0) return [];
+	const importMap = /* @__PURE__ */ new Map();
+	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;
+	let importMatch;
+	while ((importMatch = importRegex.exec(source)) !== null) {
+		const [, comboDefault, namedImports, defaultImport, specifier] = importMatch;
+		if (comboDefault) importMap.set(comboDefault, specifier);
+		if (defaultImport) importMap.set(defaultImport, specifier);
+		if (namedImports) for (const binding of namedImports.split(",")) {
+			const parts = binding.trim().split(/\s+as\s+/);
+			const localName = (parts[1] || parts[0]).trim();
+			if (localName) importMap.set(localName, specifier);
+		}
+	}
+	const systemFileDir = dirname$1(systemFilePath);
+	const packages = /* @__PURE__ */ new Set();
+	for (const id of identifiers) {
+		const specifier = importMap.get(id);
+		if (!specifier) continue;
+		if (specifier.startsWith(".")) packages.add(resolve(systemFileDir, specifier));
+		else packages.add(specifier);
+	}
+	return Array.from(packages);
+}
+//#endregion
+//#region pipeline/source-corpus.ts
+function assembleRawEntries({ fileCache, externalFileOwners }) {
+	const project = [];
+	const external = [];
+	for (const [path, { hash, source }] of fileCache) (externalFileOwners[path] === void 0 ? project : external).push({
+		path,
+		source,
+		hash
+	});
+	project.sort((a, b) => compareDiscoveryOrder(a.path, b.path));
+	return [...project, ...external];
+}
+function createSourceCorpus(host, ingestor = createSourceIngestor(host)) {
+	let published = {
+		analysisEntries: /* @__PURE__ */ new Map(),
+		ownership: {}
+	};
+	return {
+		async prepare(input) {
+			const rawEntries = "fileCache" in input ? assembleRawEntries(input) : input;
+			const ingested = await ingestor.ingest(rawEntries);
+			return withoutInvalidOriginals(ingested, ingestor.surfaceDiagnostics(ingested.diagnostics));
+		},
+		publish(accepted) {
+			ingestor.markPublished(accepted);
+			published = {
+				analysisEntries: new Map(accepted.analysisEntries.map((entry) => [entry.path, {
+					hash: entry.hash,
+					source: entry.source
+				}])),
+				ownership: accepted.ownership
+			};
+		},
+		get published() {
+			return published;
+		}
+	};
+}
+//#endregion
+//#region pipeline/asset-placeholders.ts
+const ASSET_PLACEHOLDER_PREFIX = "animus-asset:";
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const PREFIX_RE = escapeRegExp(ASSET_PLACEHOLDER_PREFIX);
+const QUOTED_PLACEHOLDER_RE = new RegExp(`(['"])${PREFIX_RE}([^'"]*?)\\1`, "g");
+const BARE_PLACEHOLDER_RE = new RegExp(`${PREFIX_RE}([^'")\\s]+)`, "g");
+function findAssetSpecifiers(css) {
+	if (!css.includes("animus-asset:")) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const remainder = css.replace(QUOTED_PLACEHOLDER_RE, (_match, _quote, specifier) => {
+		seen.add(specifier);
+		return "";
+	});
+	for (const match of remainder.matchAll(BARE_PLACEHOLDER_RE)) seen.add(match[1]);
+	return [...seen];
+}
+function substituteAssetPlaceholders(css, urlBySpecifier) {
+	if (urlBySpecifier.size === 0) return css;
+	if (!css.includes("animus-asset:")) return css;
+	const specifiers = [...urlBySpecifier.keys()].sort((a, b) => b.length - a.length);
+	let out = css;
+	for (const specifier of specifiers) {
+		const placeholder = new RegExp(escapeRegExp(ASSET_PLACEHOLDER_PREFIX + specifier) + String.raw`(?=['")\s]|$)`, "g");
+		out = out.replace(placeholder, () => urlBySpecifier.get(specifier));
+	}
+	return out;
+}
+//#endregion
+//#region pipeline/resolve-asset.ts
+/**
+* Asset resolution for hosts with no bundler hook. Host path aliases apply
+* FIRST, so `asset('@fonts/x')` resolves as the alias does in app modules.
+*/
+const requireByRoot = /* @__PURE__ */ new Map();
+function requireAnchoredAt(rootDir) {
+	let req = requireByRoot.get(rootDir);
+	if (!req) {
+		req = createRequire$1(join$1(rootDir, "package.json"));
+		requireByRoot.set(rootDir, req);
+	}
+	return req;
+}
+function packageRootFromEntry(entry) {
+	let current = dirname$1(entry);
+	while (true) {
+		if (existsSync(join$1(current, "package.json"))) return current;
+		const parent = dirname$1(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+const aliasTableCache = /* @__PURE__ */ new Map();
+/**
+* A parse failure throws: an empty table would disable every alias-based
+* `asset()` and ship dangling `url()`s as a successful build.
+*/
+function parseAliasTable(pathAliasesJson) {
+	const cached = aliasTableCache.get(pathAliasesJson);
+	if (cached) return cached;
+	const aliases = parseInternalWire(pathAliasesJson, "pathAliasesJson (the host alias table from buildPathAliasesJson)").aliases ?? [];
+	aliasTableCache.set(pathAliasesJson, aliases);
+	return aliases;
+}
+/**
+* Map a specifier through the host alias table, whose entries arrive sorted
+* longest-pattern-first. Returns an absolute path to an EXISTING file.
+*/
+function resolveThroughPathAliases(specifier, rootDir, pathAliasesJson) {
+	if (!pathAliasesJson) return null;
+	const aliases = parseAliasTable(pathAliasesJson);
+	for (const alias of aliases) {
+		let mapped = null;
+		if (alias.type === "exact") {
+			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);
+		if (existsSync(absolute)) return absolute;
+	}
+	return null;
+}
+/**
+* Resolve an asset specifier: host aliases, then Node resolution anchored at
+* `rootDir`, then the package root. Strict gating stays at the caller.
+*/
+function resolveAssetFile(specifier, rootDir, pathAliasesJson) {
+	const aliased = resolveThroughPathAliases(specifier, rootDir, pathAliasesJson);
+	if (aliased) return aliased;
+	const requireFromRoot = requireAnchoredAt(rootDir);
+	try {
+		return requireFromRoot.resolve(specifier);
+	} catch {}
+	const segments = specifier.split("/");
+	const packageName = specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+	const subpath = specifier.slice(packageName.length + 1);
+	if (!subpath) return null;
+	for (const modulesDir of requireFromRoot.resolve.paths(packageName) ?? []) {
+		const packageRoot = join$1(modulesDir, packageName);
+		if (!existsSync(join$1(packageRoot, "package.json"))) continue;
+		const candidate = join$1(packageRoot, subpath);
+		if (existsSync(candidate)) return candidate;
+	}
+	try {
+		const packageRoot = packageRootFromEntry(requireFromRoot.resolve(packageName));
+		if (!packageRoot) return null;
+		const candidate = join$1(packageRoot, subpath);
+		return existsSync(candidate) ? candidate : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region pipeline/correlate-external-tokens.ts
+/**
+* Index the loader-captured theme manifests by owning specifier. An
+* unparseable capture throws: an empty index reads as "no source defines it".
+*/
+function buildSourceTokenIndex(opts) {
+	const index = /* @__PURE__ */ new Map();
+	if (!opts.sourceThemeManifestsJson) return index;
+	const manifests = parseInternalWire(opts.sourceThemeManifestsJson, "sourceThemeManifestsJson (the system loader's built-theme capture)");
+	const realDirOwners = [];
+	const addOwnerDir = (dir, specifier) => {
+		if (!realDirOwners.some((entry) => entry.dir === dir)) realDirOwners.push({
+			dir,
+			specifier
+		});
+	};
+	for (const [dir, specifier] of Object.entries(opts.dirOwners)) {
+		let real = dir;
+		try {
+			real = realpathSync(dir);
+		} catch {}
+		addOwnerDir(real, specifier);
+		let packageRoot = real;
+		while (packageRoot !== dirname$1(packageRoot) && !existsSync(join$1(packageRoot, "package.json"))) packageRoot = dirname$1(packageRoot);
+		if (existsSync(join$1(packageRoot, "package.json"))) addOwnerDir(packageRoot, specifier);
+	}
+	for (const [modulePath, exports] of Object.entries(manifests)) {
+		const owner = realDirOwners.find(({ dir }) => isPathWithinRoot(dir, modulePath));
+		if (!owner) continue;
+		let tokens = index.get(owner.specifier);
+		if (!tokens) {
+			tokens = /* @__PURE__ */ new Set();
+			index.set(owner.specifier, tokens);
+		}
+		for (const paths of Object.values(exports)) for (const token of paths) tokens.add(token);
+	}
+	return index;
+}
+/**
+* One message per distinct (component, token, specifier) whose source
+* defines the token. Severity routing stays at the caller.
+*/
+function correlateExternalTokenDiagnostics(opts) {
+	const messages = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const diagnostic of opts.diagnostics ?? []) {
+		if (diagnostic.kind !== "external-token-candidate" || !diagnostic.token) continue;
+		const specifier = opts.fileOwners[diagnostic.file];
+		if (!specifier) continue;
+		if (!opts.sourceTokens.get(specifier)?.has(diagnostic.token)) continue;
+		const key = `${diagnostic.component}\u0000${diagnostic.token}\u0000${specifier}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		messages.push(`${diagnostic.component} (from '${specifier}') references token '${diagnostic.token}', which the consumer theme does not define — inherit the source's tokens with createTheme().extend(...) using the tokens (or bundle) export of '${specifier}'`);
+	}
+	return messages;
+}
+const indexCache = /* @__PURE__ */ new WeakMap();
+/**
+* The one cross-source token-contract gate both plugins share, so the hosts
+* cannot drift on wiring or severity.
+*/
+function enforceExternalTokenContracts(opts) {
+	const manifestsJson = opts.sourceThemeManifestsJson ?? "";
+	const cached = indexCache.get(opts.dirOwners);
+	let sourceTokens;
+	if (cached && cached.manifestsJson === manifestsJson) sourceTokens = cached.index;
+	else {
+		sourceTokens = buildSourceTokenIndex({
+			sourceThemeManifestsJson: opts.sourceThemeManifestsJson,
+			dirOwners: opts.dirOwners
+		});
+		indexCache.set(opts.dirOwners, {
+			manifestsJson,
+			index: sourceTokens
+		});
+	}
+	const messages = correlateExternalTokenDiagnostics({
+		diagnostics: opts.diagnostics,
+		fileOwners: opts.fileOwners,
+		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);
+}
+//#endregion
+//#region pipeline/path-aliases.ts
+function buildPathAliasesJson(pairs, rootDir) {
+	const entries = [];
+	for (const { pattern, target, kind } of pairs) {
+		const replacement = target.startsWith(rootDir) ? target.slice(rootDir.length + 1) : target;
+		if (kind ? kind === "exact" : /\.\w+$/.test(replacement)) entries.push({
+			pattern,
+			replacement,
+			type: "exact"
+		});
+		else entries.push({
+			pattern: pattern.endsWith("/") ? pattern : pattern + "/",
+			replacement: replacement.endsWith("/") ? replacement : replacement + "/",
+			type: "prefix"
+		});
+	}
+	entries.sort((a, b) => b.pattern.length - a.pattern.length);
+	if (entries.length === 0) return null;
+	return {
+		json: JSON.stringify({ aliases: entries }),
+		count: entries.length
+	};
+}
+//#endregion
+//#region pipeline/post-process-css.ts
+function resolveLightningTargets(explicitTargets, rootDir) {
+	let queries;
+	if (explicitTargets) queries = Array.isArray(explicitTargets) ? explicitTargets : [explicitTargets];
+	else {
+		const detected = browserslist(void 0, { path: rootDir });
+		queries = detected.length > 0 ? detected : browserslist("defaults");
+	}
+	const [firstQuery] = queries;
+	return browserslistToTargets(firstQuery !== void 0 && firstQuery.includes(" ") ? browserslist(queries) : queries);
+}
+function postProcessCss(css, opts) {
+	if (!css) return css;
+	try {
+		return transform({
+			filename: "animus-extracted.css",
+			code: Buffer.from(css),
+			minify: opts.minify,
+			targets: opts.targets
+		}).code.toString();
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		(opts.warnFn ?? console.warn)(`[animus] Lightning CSS post-processing failed: ${msg}`);
+		return css;
+	}
+}
+//#endregion
+//#region pipeline/manifest-diagnostics.ts
+/** Stable code for selector forms with no substitutable subject; the
+*  extraction engine mints the same string. */
+const SELECTOR_UNSUPPORTED_SUBJECT = "animus.selector.unsupported-subject";
+/** The one matcher for the engine's unresolved-parent chain-drop message;
+*  consumers match through the exported helpers, never their own copy. */
+const UNRESOLVED_PARENT_RE = /chain dropped: could not resolve parent component '([^']+)'/;
+function isUnresolvedParentDrop(diagnostic) {
+	return UNRESOLVED_PARENT_RE.test(diagnostic.message);
+}
+function unresolvedParentName(diagnostic) {
+	return UNRESOLVED_PARENT_RE.exec(diagnostic.message)?.[1] ?? null;
+}
+/** True when the selector carries at least one substitutable `&` subject
+*  outside quoted text. */
+function hasSelectorSubject(value) {
+	let quote = null;
+	let escaped = false;
+	for (const c of value) {
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (c === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote !== null) {
+			if (c === quote) quote = null;
+		} else if (c === "\"" || c === "'") quote = c;
+		else if (c === "&") return true;
+	}
+	return false;
+}
+/**
+* Coded diagnostics for selector-shaped alias values with no substitutable
+* subject; alias values never reach the evaluator's own key guard.
+*/
+function collectSelectorAliasDiagnostics(selectorAliasesJson) {
+	if (!selectorAliasesJson) return [];
+	const aliases = parseInternalWire(selectorAliasesJson, "selectorAliasesJson (the system loader's selector-alias registry)");
+	const diagnostics = [];
+	for (const [name, value] of Object.entries(aliases)) if (value.includes("&") && !hasSelectorSubject(value)) diagnostics.push({
+		file: "system",
+		component: name,
+		kind: "warn",
+		message: `selector alias '${name}' value '${value}' has no substitutable '&' subject outside quoted text (${SELECTOR_UNSUPPORTED_SUBJECT})`,
+		code: SELECTOR_UNSUPPORTED_SUBJECT,
+		severity: severityFor(SELECTOR_UNSUPPORTED_SUBJECT)
+	});
+	return diagnostics;
+}
+const UNREADABLE_SOURCE_FILE = "animus.ingestion.unreadable-source-file";
+/**
+* A configured source file that could not be read is a LOST INPUT: the
+* emitted artifacts silently lack whatever that file declared.
+*/
+function unreadableSourceDiagnostic(relPath, error) {
+	return {
+		file: relPath,
+		component: "source",
+		kind: "warn",
+		message: `configured source file ${relPath} could not be read and was skipped: ${String(error)}`,
+		code: UNREADABLE_SOURCE_FILE,
+		severity: severityFor(UNREADABLE_SOURCE_FILE)
+	};
+}
+/** The collision entry code minted by the system package's merge. */
+const VOCABULARY_COLLISION = "animus.vocabulary.collision";
+/** Minted when a sealed kit with registered vocabulary is consumed through
+*  the deprecated `from()`/`includes:` verbs. */
+const VOCABULARY_LEGACY_VERB = "animus.vocabulary.legacy-verb";
+const DIAGNOSTIC_SEVERITY = /* @__PURE__ */ new Map([
+	[SELECTOR_UNSUPPORTED_SUBJECT, "error"],
+	[UNREADABLE_SOURCE_FILE, "error"],
+	[VOCABULARY_COLLISION, "warn"],
+	[VOCABULARY_LEGACY_VERB, "warn"]
+]);
+/** An unlisted code is `warn`: a witness kind from a newer system package
+*  must not fail the strict build of a host that predates its writer. */
+function severityFor(code) {
+	return (code === void 0 ? void 0 : DIAGNOSTIC_SEVERITY.get(code)) ?? "warn";
+}
+/**
+* The one mapper of a sealed system's witness entries for every host: the
+* loader's evaluation host shims `console`, so the record is the channel.
+*/
+function vocabularyWitnessDiagnostics(vocabularyWitnessesJson) {
+	if (!vocabularyWitnessesJson) return [];
+	const entries = parseInternalWire(vocabularyWitnessesJson, "vocabularyWitnessesJson (the sealed system's vocabulary witness record)");
+	const diagnostics = [];
+	for (const entry of entries) if (entry.code === "animus.vocabulary.collision") diagnostics.push({
+		file: "system",
+		component: entry.name ?? "keyframes",
+		kind: "warn",
+		message: `keyframes vocabulary "${entry.name}" is registered by both ${entry.loser} and ${entry.winner} — ${entry.winner} wins; rename one collection (${entry.code})`,
+		code: entry.code,
+		severity: severityFor(entry.code)
+	});
+	else if (entry.code === "animus.vocabulary.legacy-verb") diagnostics.push({
+		file: "system",
+		component: "keyframes",
+		kind: "warn",
+		message: `a sealed system (${entry.source ?? `'${entry.verb}' source`}) with registered vocabulary [${(entry.names ?? []).join(", ")}] was consumed through the deprecated '${entry.verb}' verb, which cannot carry it — those collections do NOT reach this consumer; use createSystem().extend(source) (${entry.code})`,
+		code: entry.code,
+		severity: severityFor(entry.code)
+	});
+	else diagnostics.push({
+		file: "system",
+		component: "vocabulary",
+		kind: "warn",
+		message: `unrecognized vocabulary witness entry ${JSON.stringify(entry)} — a newer @animus-ui/system may have recorded a witness kind this host predates${entry.code ? ` (${entry.code})` : ""}`,
+		code: entry.code,
+		severity: severityFor(entry.code)
+	});
+	return diagnostics;
+}
+/**
+* The single strict-escalation policy point for both extraction plugins:
+* error-severity diagnostics throw together under `strict`, else warn.
+*/
+function surfaceManifestDiagnostics(manifest, warn, policy = {}) {
+	const errors = [];
+	const diagnostics = policy.prepend?.length ? [...policy.prepend, ...manifest.diagnostics ?? []] : manifest.diagnostics ?? [];
+	for (const diagnostic of diagnostics) {
+		let line = null;
+		if (diagnostic.kind === "bail") line = `⚠ ${diagnostic.component} not extracted: ${diagnostic.message}`;
+		else if (diagnostic.kind === "skip") line = `⚠ ${diagnostic.component}: skipped ${diagnostic.message}`;
+		else if (diagnostic.kind === "warn") line = `⚠ ${diagnostic.file}: ${diagnostic.component}: ${diagnostic.message}`;
+		if (line === null) continue;
+		if (diagnostic.code && !diagnostic.message.includes(diagnostic.code)) line += ` [${diagnostic.code}]`;
+		if (policy.strict && diagnostic.severity === "error") {
+			errors.push(`${diagnostic.code ?? "error"} — ${diagnostic.component}: ${diagnostic.message}`);
+			continue;
+		}
+		warn(line);
+	}
+	if (errors.length > 0) throw new Error(`[animus] strict: ${errors.length} error diagnostic(s):\n${errors.join("\n")}`);
+}
+//#endregion
+//#region pipeline/unit-fallback.ts
+function applyUnitFallback(css) {
+	return css.replace(/([a-z-]+)\s*:\s*([^;{}]+);/g, (match, prop, value) => {
+		if (isUnitlessProperty(prop)) return match;
+		let depth = 0;
+		let fixed = "";
+		let i = 0;
+		while (i < value.length) if (value[i] === "(") {
+			depth++;
+			fixed += value[i];
+			i++;
+		} else if (value[i] === ")") {
+			depth--;
+			fixed += value[i];
+			i++;
+		} else if (depth > 0) {
+			fixed += value[i];
+			i++;
+		} else {
+			const numMatch = value.slice(i).match(/^(-?\d+\.?\d*)/);
+			if (numMatch) {
+				const num = numMatch[1];
+				const after = value[i + num.length];
+				if (after && /[a-z%]/i.test(after)) fixed += num;
+				else fixed += num + "px";
+				i += num.length;
+			} else {
+				fixed += value[i];
+				i++;
+			}
+		}
+		return fixed !== value ? `${prop}:${fixed};` : match;
+	});
+}
+//#endregion
+//#region pipeline/run-analysis.ts
+/** The named `analyzeProject` input set, and the persistence shape an
+*  isolated process replays the analysis from. */
+function buildAnalysisInputs(opts) {
+	const emitterConfig = {
+		runtime_import: opts.emitter.runtimeImport,
+		css_module_id: opts.emitter.cssModuleId
+	};
+	if (opts.emitter.systemPropsModuleId) emitterConfig.system_props_module_id = opts.emitter.systemPropsModuleId;
+	return {
+		filesJson: JSON.stringify(opts.fileEntries),
+		scalesJson: opts.system.scalesJson,
+		variableMapJson: opts.system.variableMapJson,
+		contextualVarsJson: opts.system.contextualVarsJson,
+		propConfigJson: opts.system.propConfigJson,
+		groupRegistryJson: opts.system.groupRegistryJson,
+		packageResolutionJson: JSON.stringify(opts.packageMap),
+		devMode: opts.devMode,
+		emitterConfigJson: JSON.stringify(emitterConfig),
+		selectorAliasesJson: opts.system.selectorAliasesJson,
+		globalStyleBlocksJson: opts.system.globalStyleBlocksJson,
+		pathAliasesJson: opts.pathAliasesJson,
+		keyframesJson: opts.system.keyframesJson,
+		staticCssJson: opts.staticCssJson ?? null,
+		conditionAliasesJson: opts.system.conditionAliasesJson ?? null,
+		transformSourcesJson: opts.system.transformSourcesJson ?? null,
+		externalDirsJson: opts.externalDirs?.length && hasSourceThemeManifests(opts.system) ? JSON.stringify(opts.externalDirs) : null
+	};
+}
+function hasSourceThemeManifests(system) {
+	const json = system.sourceThemeManifestsJson ?? "";
+	return json.length > 0 && json !== "{}";
+}
+/**
+* The one analysis invocation both plugins share. Error handling stays at
+* the call site (strict-mode throw vs warn).
+*/
+function runProjectAnalysis(engineApi, opts) {
+	const { analyzeProject } = engineApi();
+	let t = performance.now();
+	const inputs = buildAnalysisInputs(opts);
+	const serializeMs = Math.round(performance.now() - t);
+	t = performance.now();
+	const manifestJson = analyzeProject(...buildAnalyzeProjectArgs(inputs));
+	const extractMs = Math.round(performance.now() - t);
+	t = performance.now();
+	const manifest = JSON.parse(manifestJson);
+	surfaceManifestDiagnostics(manifest, opts.warn, {
+		strict: opts.strict,
+		prepend: [...collectSelectorAliasDiagnostics(opts.system.selectorAliasesJson), ...opts.extraDiagnostics ?? []]
+	});
+	const parseMs = Math.round(performance.now() - t);
+	return {
+		manifest,
+		manifestJson,
+		globalCss: manifest.sheets.global,
+		componentCss: applyUnitFallback(manifest.css),
+		inputs,
+		timings: {
+			serializeMs,
+			extractMs,
+			parseMs
+		}
+	};
+}
+/**
+* Clear the engine's per-file analysis cache so stale results never bleed
+* into a fresh run. Engines without the capability are tolerated.
+*/
+function clearEngineCache(engineApi) {
+	try {
+		const { clearAnalysisCache } = engineApi();
+		clearAnalysisCache();
+	} catch {}
+}
+//#endregion
+//#region pipeline/utils.ts
+function camelToKebab(str) {
+	return str.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (isKeyedReference(value)) return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+/** Decided by an intrinsic only functions accept, so a spoofed
+*  `Symbol.toStringTag` cannot pass a plain object off as a function. */
+function isCallable(value) {
+	try {
+		Function.prototype.toString.call(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isKeyedReference(value) {
+	return Object(value) === value && !isCallable(value);
+}
+//#endregion
+//#region pipeline/static-css.ts
+/** The `staticCss` option declares emission the JSX scanner cannot observe
+*  (config-driven variants, spread props); the engine applies it as usage. */
+function serializeStaticCss(config) {
+	if (!config) return null;
+	const json = stableStringify(config);
+	return json === "{}" ? null : json;
+}
+//#endregion
+//#region pipeline/prefix.ts
+function applyPrefix(prefix, variableMapJson, variableCss, themeJson, contextualVarsJson) {
+	if (!prefix) return {
+		variableMapJson,
+		variableCss,
+		themeJson,
+		contextualVarsJson
+	};
+	const varRefRe = /var\(--([a-zA-Z][\w-]*)\)/g;
+	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 = css.replace(varRefRe, `var(--${prefix}-$1)`);
+	const result = {
+		variableMapJson: JSON.stringify(prefixed),
+		variableCss: css
+	};
+	if (themeJson) result.themeJson = themeJson.replace(varRefRe, `var(--${prefix}-$1)`);
+	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);
+	}
+	return result;
+}
+//#endregion
+//#region pipeline/system-config.ts
+/**
+* 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);
+	let scalesJson = config.scalesJson;
+	let variableMapJson = config.variableMapJson;
+	let variableCss = config.variableCss;
+	let contextualVarsJson = config.contextualVarsJson || null;
+	if (opts.prefix) {
+		const prefixed = applyPrefix(opts.prefix, variableMapJson, variableCss, scalesJson, contextualVarsJson || void 0);
+		variableMapJson = prefixed.variableMapJson;
+		variableCss = prefixed.variableCss;
+		if (prefixed.themeJson) scalesJson = prefixed.themeJson;
+		if (prefixed.contextualVarsJson) contextualVarsJson = prefixed.contextualVarsJson;
+	}
+	return {
+		propConfigJson: config.propConfig,
+		groupRegistryJson: config.groupRegistry,
+		scalesJson,
+		variableMapJson,
+		variableCss,
+		contextualVarsJson,
+		selectorAliasesJson: config.selectorAliases || null,
+		conditionAliasesJson: config.conditionAliases || null,
+		transformSourcesJson: config.transformSources || null,
+		globalStyleBlocksJson: config.globalStyleBlocks || null,
+		keyframesJson: config.keyframesBlocks || null,
+		vocabularyWitnessesJson: config.vocabularyWitnesses || null,
+		dependencies: config.dependencies ?? [],
+		sourceThemeManifestsJson: config.sourceThemeManifests || null
+	};
+}
+//#endregion
+//#region pipeline/structural-self-check.ts
+function runStructuralSelfCheck(input) {
+	const failures = [];
+	if (input.componentCount === 0) failures.push("No component CSS produced — check the system file and its includes list");
+	else if (input.assembledCss !== void 0 ? !/@layer\s+anm-base\s*\{/.test(input.assembledCss) : input.componentCss.trim().length === 0) failures.push(`${input.componentCount} component(s) discovered but the emitted component CSS is empty`);
+	for (const { specifier, outcome } of input.externalOutcomes ?? []) if (outcome === "empty") failures.push(`include '${specifier}' resolved but discovered no component sources`);
+	else if (outcome === "unresolvable") failures.push(`include '${specifier}' could not be resolved`);
+	if (!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)) {
+		const assembled = input.assembledCss ?? assembleStylesheet({
+			layers: input.layers,
+			variableCss: input.variableCss,
+			globalCss: input.globalCss,
+			componentCss: input.componentCss
+		});
+		const baseIdx = assembled.search(/@layer\s+anm-base\s*\{/);
+		const variantsIdx = assembled.search(/@layer\s+anm-variants\s*\{/);
+		if (baseIdx !== -1 && variantsIdx !== -1 && baseIdx >= variantsIdx) failures.push(`CSS layer ordering violated — @layer anm-base (offset ${baseIdx}) must precede @layer anm-variants (offset ${variantsIdx})`);
+	}
+	return failures;
+}
+//#endregion
+//#region pipeline/dynamic-prop-config.ts
+function buildDynamicPropConfig(dynamicProps) {
+	const configEntries = {};
+	for (const [propName, meta] of Object.entries(dynamicProps)) {
+		if (!meta.varName || !meta.slotClass) throw new Error(`buildDynamicPropConfig: dynamic prop '${propName}' carries no slot metadata — expected varName and slotClass, got keys [${Object.keys(meta).join(", ")}].`);
+		const entry = {
+			varName: meta.varName,
+			slotClass: meta.slotClass
+		};
+		if (meta.property) entry.property = meta.property;
+		if (meta.properties && meta.properties.length > 0) entry.properties = meta.properties;
+		if (meta.transformName) entry.transformName = meta.transformName;
+		if (meta.scaleValues && Object.keys(meta.scaleValues).length > 0) entry.scaleValues = meta.scaleValues;
+		configEntries[propName] = entry;
+	}
+	return configEntries;
+}
+//#endregion
+//#region pipeline/system-props-module.ts
+function buildSystemPropsModule(opts) {
+	const dynamicPropConfig = buildDynamicPropConfig(opts.dynamicProps);
+	return `export const systemPropMap = ${opts.systemPropMapJson};\nexport const systemPropGroups = ${opts.groupRegistryJson};\nexport const dynamicPropConfig = ${JSON.stringify(dynamicPropConfig)};\nexport const transforms = ${opts.transformsSource ?? "{}"};\n`;
+}
+//#endregion
+//#region pipeline/timing-waterfall.ts
+const RUST_TIMING_PHASES = [
+	["parseAndWalk", "parse+walk"],
+	["importResolution", "imports"],
+	["extensionProvenance", "provenance"],
+	["topologicalSort", "topo-sort"],
+	["chainEvaluation", "chains"],
+	["jsxScanning", "jsx-scan"],
+	["systemPropAggregation", "sys-props"],
+	["usageLedger", "usage"],
+	["reconciliation", "reconcile"],
+	["cssGeneration", "css-gen"],
+	["manifestSerialization", "serialize"]
+];
+function formatRustTimingWaterfall(timing, opts) {
+	const lines = [];
+	for (const [key, label] of RUST_TIMING_PHASES) {
+		const ms = timing[key] ?? 0;
+		const pad = " ".repeat(Math.max(0, opts.labelWidth - label.length));
+		const extra = key === "parseAndWalk" ? `  (${timing.fileCount ?? 0} files, ${timing.cacheHits ?? 0} cached)` : "";
+		lines.push(`${opts.indent}${label}${pad}${String(ms).padStart(5)}ms${extra}`);
+	}
+	return lines;
+}
+//#endregion
+//#region pipeline/tsconfig-paths.ts
+/**
+* tsconfig `paths` → alias pairs, for drivers with no live bundler config.
+* The nearest config declaring `paths` wins wholesale — TS never merges.
+*/
+function stripJsonc(text) {
+	let out = "";
+	let inString = false;
+	let inLine = false;
+	let inBlock = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		const next = text[i + 1];
+		if (inLine) {
+			if (ch === "\n") {
+				inLine = false;
+				out += ch;
+			}
+			continue;
+		}
+		if (inBlock) {
+			if (ch === "*" && next === "/") {
+				inBlock = false;
+				i++;
+			}
+			continue;
+		}
+		if (inString) {
+			out += ch;
+			if (ch === "\\") {
+				out += next ?? "";
+				i++;
+			} else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			out += ch;
+			continue;
+		}
+		if (ch === "/" && next === "/") {
+			inLine = true;
+			i++;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			inBlock = true;
+			i++;
+			continue;
+		}
+		out += ch;
+	}
+	return out.replace(/,(\s*[}\]])/g, "$1");
+}
+/** `Object(value) === value` holds for exactly the blocks and lists
+*  `JSON.parse` produces; the `[object Object]` tag separates the two. */
+function isJsonBlock(value) {
+	return Object(value) === value && Object.prototype.toString.call(value) === "[object Object]";
+}
+/** A block or a list. A declared `paths` OWNS the setting and blocks its
+*  parents' even when it contributes nothing usable. */
+function isJsonKeyed(value) {
+	return Object(value) === value;
+}
+/** A JSON string, excluding the boxed `String` object, which no path join
+*  accepts. */
+function isJsonString(value) {
+	return Object(value) !== value && Object.prototype.toString.call(value) === "[object String]";
+}
+function decodePaths(value) {
+	if (!isJsonKeyed(value)) return null;
+	const decoded = /* @__PURE__ */ new Map();
+	for (const [pattern, targets] of Object.entries(value)) {
+		const [first] = Array.isArray(targets) ? targets : [];
+		if (isJsonString(first)) decoded.set(pattern, first);
+	}
+	return decoded;
+}
+/** TypeScript accepts one specifier or an array; a non-string member names
+*  no config and is dropped here. */
+function decodeExtends(value) {
+	return (Array.isArray(value) ? value : [value]).filter(isJsonString);
+}
+function readConfig(path) {
+	let raw;
+	try {
+		raw = readFileSync(path, "utf-8");
+	} catch {
+		return null;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(stripJsonc(raw));
+	} catch {
+		return null;
+	}
+	const root = isJsonBlock(parsed) ? parsed : {};
+	const compilerOptions = isJsonBlock(root.compilerOptions) ? root.compilerOptions : {};
+	return {
+		dir: dirname$1(path),
+		baseUrl: isJsonString(compilerOptions.baseUrl) ? compilerOptions.baseUrl : null,
+		paths: decodePaths(compilerOptions.paths),
+		extends: decodeExtends(root.extends)
+	};
+}
+function resolveExtendsTarget(specifier, fromDir) {
+	if (specifier.startsWith(".") || isAbsolute(specifier)) {
+		const base = resolve(fromDir, specifier);
+		for (const candidate of [
+			base,
+			`${base}.json`,
+			join$1(base, "tsconfig.json")
+		]) if (existsSync(candidate)) return candidate;
+		return null;
+	}
+	try {
+		return __require.resolve(specifier.endsWith(".json") ? specifier : `${specifier}/tsconfig.json`, { paths: [fromDir] });
+	} catch {
+		try {
+			return __require.resolve(specifier, { paths: [fromDir] });
+		} catch {
+			return null;
+		}
+	}
+}
+/** Child-first flattened extends chain starting at `entryPath`. */
+function loadChain(entryPath) {
+	const chain = [];
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [entryPath];
+	while (queue.length > 0) {
+		const path = queue.shift();
+		const key = resolve(path);
+		if (visited.has(key)) continue;
+		visited.add(key);
+		const node = readConfig(key);
+		if (!node) continue;
+		chain.push(node);
+		for (const parent of node.extends) {
+			const resolved = resolveExtendsTarget(parent, node.dir);
+			if (resolved) queue.push(resolved);
+		}
+	}
+	return chain;
+}
+/**
+* The project's tsconfig path aliases as `buildPathAliasesJson` pairs; empty
+* when no readable tsconfig, or no usable `paths`, exists.
+*/
+function readTsconfigAliasPairs(rootDir) {
+	const chain = loadChain(join$1(rootDir, "tsconfig.json"));
+	if (chain.length === 0) return [];
+	const pathsOwner = chain.find((node) => node.paths !== null);
+	const paths = pathsOwner?.paths ?? null;
+	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 pairs = [];
+	for (const [pattern, target] of paths) {
+		const patternStars = pattern.split("*").length - 1;
+		const targetStars = target.split("*").length - 1;
+		if (pattern === "*" || patternStars > 1 || targetStars > 1) continue;
+		if (pattern.endsWith("/*")) {
+			if (!target.endsWith("/*")) continue;
+			pairs.push({
+				pattern: pattern.slice(0, -2),
+				target: resolve(base, target.slice(0, -2)),
+				kind: "prefix"
+			});
+			continue;
+		}
+		if (patternStars > 0 || targetStars > 0) continue;
+		pairs.push({
+			pattern,
+			target: resolve(base, target),
+			kind: "exact"
+		});
+	}
+	return pairs;
+}
+//#endregion
+//#region pipeline/error-diagnostics.ts
+function assertNoErrorDiagnostics(diagnostics) {
+	const errors = (diagnostics ?? []).filter((diagnostic) => diagnostic.kind === "error");
+	if (errors.length === 0) return;
+	const lines = [...new Set(errors.map((diagnostic) => `[animus] ${diagnostic.component || "<unknown component>"} (${diagnostic.file || "<unknown file>"}): ${diagnostic.message || "<no message>"}`))];
+	throw new Error(lines.join("\n"));
+}
+//#endregion
+//#region pipeline/replacement-plans.ts
+const snapshotByManifest = /* @__PURE__ */ new WeakMap();
+/** `null` (a context before its first analysis) snapshots to the empty plan
+*  set — the same state as an empty universe. */
+function snapshotFilePlans(manifest) {
+	if (manifest === null) return /* @__PURE__ */ new Map();
+	const cached = snapshotByManifest.get(manifest);
+	if (cached) return cached;
+	const entriesByFile = /* @__PURE__ */ new Map();
+	for (const [id, desc] of Object.entries(manifest.components)) {
+		const list = entriesByFile.get(desc.file) ?? [];
+		list.push([id, desc.replacement]);
+		entriesByFile.set(desc.file, list);
+	}
+	const snapshot = /* @__PURE__ */ new Map();
+	for (const [file, entries] of entriesByFile) {
+		entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+		snapshot.set(file, JSON.stringify(entries));
+	}
+	snapshotByManifest.set(manifest, snapshot);
+	return snapshot;
+}
+/**
+* Paths whose plan changed: absent↔present, membership, or content.
+* `exclude` drops one path whose own modules are already being updated.
+*/
+function diffFilePlans(prev, next, opts) {
+	const changed = /* @__PURE__ */ new Set();
+	for (const [file, plan] of next) if (prev.get(file) !== plan) changed.add(file);
+	for (const file of prev.keys()) if (!next.has(file)) changed.add(file);
+	if (opts?.exclude) changed.delete(opts.exclude);
+	return [...changed].sort();
+}
+/** Domain prefix keeping this hash disjoint from every other `contentHash`
+*  use in the pipeline. */
+const REPLACEMENT_PLANS_DOMAIN = "animus-replacement-plans-v1\0";
+/** Leads with NUL: entries end with `\0` and contain none, so `\0\0` is
+*  unreachable from entries alone and the section cannot be forged. */
+const SERVED_DEPENDENCY_DOMAIN = "\0animus-served-dependency-v1\0";
+/**
+* THE replacement epoch: integrations consume this hash, never their own.
+* `servedDependencyWitness` folds in content the plans cannot see.
+*/
+function hashReplacementPlans(snapshot, servedDependencyWitness) {
+	const entries = [...snapshot.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	let serialized = REPLACEMENT_PLANS_DOMAIN;
+	for (const [file, plan] of entries) serialized += file + "\0" + plan + "\0";
+	if (servedDependencyWitness !== void 0) serialized += SERVED_DEPENDENCY_DOMAIN + servedDependencyWitness;
+	return contentHash(serialized);
+}
+//#endregion
+//#region pipeline/watch-keys.ts
+function toWatchKeys(input) {
+	const lexical = normalize(input);
+	const canonical = realpathThroughNearestExistingAncestor(lexical);
+	return canonical === lexical ? [lexical] : [lexical, canonical];
+}
+/** Canonicalizes a path that may not exist, through its nearest existing
+*  ancestor. A symlink retargeted after load fails open: no match. */
+function realpathThroughNearestExistingAncestor(path) {
+	try {
+		return realpathSync$1(path);
+	} catch {}
+	const suffix = [];
+	let current = path;
+	for (;;) {
+		const parent = dirname(current);
+		if (parent === current) return path;
+		suffix.unshift(basename(current));
+		current = parent;
+		try {
+			return join(realpathSync$1(current), ...suffix);
+		} catch {}
+	}
+}
+//#endregion
+export { DEFAULT_EXCLUDE as $, enforceExternalTokenContracts as A, firstOwners as B, surfaceManifestDiagnostics as C, validateLayerOrder as Ct, postProcessCss as D, vocabularyWitnessDiagnostics as E, createSourceCorpus as F, walkPackageSources as G, resolveAbsolutePathSpecifier as H, collectExternalPackageSources as I, sharesVolumeRoot as J, createSourceIdentity as K, excludeCollectedPackages as L, resolveThroughPathAliases as M, findAssetSpecifiers as N, resolveLightningTargets as O, substituteAssetPlaceholders as P, CORE_OPTION_KEYS as Q, extractSystemFilePackages as R, isUnresolvedParentDrop as S, stripLeadingLayerDeclaration as St, unresolvedParentName as T, staleDistIncludesMessage as U, isExcludedPackageRelativePath as V, unresolvableIncludesMessage as W, discoverFiles as X, compareDiscoveryOrder as Y, AnimusConfigError as Z, clearEngineCache as _, preprocessMdx as _t, assertNoErrorDiagnostics as a, resolveMode as at, VOCABULARY_COLLISION as b, ANIMUS_LAYERS as bt, buildSystemPropsModule as c, createV2EngineApi as ct, loadSystemConfig as d, parseFilesJson as dt, DRIVER_NAMESPACES as et, applyPrefix as f, projectExternalFileOwners as ft, buildAnalysisInputs as g, isEngineTransformExtension as gt, stableStringify as h, ENGINE_TRANSFORM_EXTENSIONS as ht, snapshotFilePlans as i, createExcludeMatcher as it, resolveAssetFile as j, buildPathAliasesJson as k, buildDynamicPropConfig as l, ingestSourceEntries as lt, camelToKebab as m, DEFAULT_EXTENSIONS as mt, diffFilePlans as n, STRUCTURAL_EXCLUDE as nt, readTsconfigAliasPairs as o, RETIRED_ENGINE_MESSAGE as ot, serializeStaticCss as p, adaptSvelteSource as pt, isPathWithinRoot as q, hashReplacementPlans as r, assertKnownOptionKeys as rt, formatRustTimingWaterfall as s, assertNoRetiredEngineSelection as st, toWatchKeys as t, REPLACEABLE_DEFAULT_EXCLUDE as tt, runStructuralSelfCheck as u, isAdvisorySourceDiagnostic as ut, runProjectAnalysis as v, contentHash as vt, unreadableSourceDiagnostic as w, __require as wt, VOCABULARY_LEGACY_VERB as x, assembleStylesheet as xt, applyUnitFallback as y, buildAnalyzeProjectArgs as yt, findPackageRoot as z };