@animus-ui/vite-plugin 0.1.0-next.9 → 0.1.0

package/dist/index.mjs

@@ -1,113 +1,14 @@
 import { createRequire } from "node:module";
-import { execSync } from "child_process";
+import { DEFAULT_EXTENSIONS, applyUnitFallback, assembleStylesheet, extractSystemFilePackages, preprocessMdx, stripLeadingLayerDeclaration, validateLayerOrder } from "@animus-ui/extract/pipeline";
+import browserslist from "browserslist";
 import { createHash } from "crypto";
-import { existsSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { browserslistToTargets, transform } from "lightningcss";
 import { dirname, extname, join, relative, resolve } from "path";
-import { fileURLToPath } from "url";
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
-//#region src/theme-evaluator.ts
-/**
-* Evaluate a theme object that has already been loaded/imported.
-*
-* This is the pure logic: takes a theme object, flattens scales, builds variable CSS.
-* Use this when you have already loaded the module yourself.
-*/
-function evaluateThemeObject(theme) {
-	const flat = {};
-	for (const [scaleName, scaleValue] of Object.entries(theme)) {
-		if (scaleName.startsWith("_")) continue;
-		if (scaleName === "breakpoints") {
-			flattenScale(flat, "breakpoints", scaleValue);
-			continue;
-		}
-		if (typeof scaleValue === "object" && scaleValue !== null && !Array.isArray(scaleValue)) flattenScale(flat, scaleName, scaleValue);
-	}
-	const variableMap = {};
-	for (const [tokenPath, value] of Object.entries(flat)) if (value.startsWith("var(") && value.endsWith(")")) variableMap[tokenPath] = value.slice(4, -1);
-	const variableCss = buildVariableCss(theme);
-	return {
-		scalesJson: JSON.stringify(flat),
-		variableMapJson: JSON.stringify(variableMap),
-		variableCss
-	};
-}
-/**
-* Evaluate a theme module and flatten all scales to a JSON map.
-* Format: { "scale_name.key": "css_value" }
-*
-* Uses Vite's ssrLoadModule to evaluate the theme at build start,
-* so all computed scales (shadows, gradients that depend on colors)
-* are resolved to their final values.
-*/
-async function evaluateTheme(ssrLoadModule, themePath) {
-	const mod = await ssrLoadModule(themePath);
-	const theme = mod.theme || mod.default;
-	if (!theme) throw new Error(`Theme module at ${themePath} must export 'theme' or a default export`);
-	return evaluateThemeObject(theme);
-}
-/**
-* Build the full CSS variable block from a theme's _variables and _tokens.
-*
-* Produces:
-*   :root { --color-navy-500: #282a36; ... }
-*   [data-color-mode="dark"] { --color-primary: #ff80bf; ... }
-*/
-function buildVariableCss(theme) {
-	const parts = [];
-	if (theme._variables != null && typeof theme._variables === "object") {
-		const rootLines = [];
-		for (const categoryValue of Object.values(theme._variables)) {
-			if (categoryValue == null || typeof categoryValue !== "object") continue;
-			for (const [cssVar, cssValue] of Object.entries(categoryValue)) if (typeof cssValue === "string") rootLines.push(`  ${cssVar}: ${cssValue};`);
-		}
-		if (rootLines.length > 0) parts.push(`:root {\n${rootLines.join("\n")}\n}`);
-	}
-	if (theme._tokens?.modes != null && typeof theme._tokens.modes === "object") for (const [modeName, modeTokens] of Object.entries(theme._tokens.modes)) {
-		if (modeTokens == null || typeof modeTokens !== "object") continue;
-		const modeLines = [];
-		flattenModeTokens(modeLines, modeTokens, "");
-		if (modeLines.length > 0) parts.push(`[data-color-mode="${modeName}"] {\n${modeLines.join("\n")}\n}`);
-	}
-	return parts.join("\n\n");
-}
-/**
-* Recursively flatten mode token objects into CSS variable declarations.
-*
-* Examples:
-*   { primary: '#ff80bf' }           → '  --color-primary: #ff80bf;'
-*   { background: { _: '#fff', muted: '#f5f5f5' } }
-*     → '  --color-background: #fff;'
-*        '  --color-background-muted: #f5f5f5;'
-*
-* The special key `_` maps to the base name (no suffix).
-*/
-function flattenModeTokens(lines, obj, prefix) {
-	for (const [key, value] of Object.entries(obj)) {
-		let namePart;
-		if (key === "_") namePart = prefix;
-		else namePart = prefix ? `${prefix}-${key}` : key;
-		if (typeof value === "string" || typeof value === "number") lines.push(`  --color-${namePart}: ${value};`);
-		else if (value != null && typeof value === "object" && !Array.isArray(value)) flattenModeTokens(lines, value, namePart);
-	}
-}
-function flattenScale(flat, prefix, obj, parentKey = "") {
-	if (typeof obj !== "object" || obj === null) {
-		const key = parentKey ? `${prefix}.${parentKey}` : prefix;
-		flat[key] = String(obj);
-		return;
-	}
-	for (const [key, value] of Object.entries(obj)) {
-		const fullKey = parentKey ? `${parentKey}-${key}` : key;
-		if (typeof value === "object" && value !== null && !Array.isArray(value)) flattenScale(flat, prefix, value, fullKey);
-		else flat[`${prefix}.${fullKey}`] = String(value);
-	}
-}
-//#endregion
 //#region src/index.ts
-const __pluginDir = dirname(fileURLToPath(import.meta.url));
 const VIRTUAL_CSS_ID = "virtual:animus/styles.css";
 const RESOLVED_CSS_ID = "\0virtual:animus/styles.css";
 const VIRTUAL_COMPONENTS_ID = "virtual:animus/components.js";
@@ -116,19 +17,13 @@ const VIRTUAL_BRIDGE_ID = "virtual:animus/hmr-bridge.js";
 const RESOLVED_BRIDGE_ID = "\0virtual:animus/hmr-bridge.js";
 const VIRTUAL_SYSTEM_PROPS_ID = "virtual:animus/system-props";
 const RESOLVED_SYSTEM_PROPS_ID = "\0virtual:animus/system-props";
-const DEFAULT_EXTENSIONS = new Set([
-	".ts",
-	".tsx",
-	".js",
-	".jsx"
-]);
 const DEFAULT_EXCLUDE = [
 	"node_modules",
 	"dist",
 	".test.",
 	".spec."
 ];
-function discoverFiles(dir, rootDir, excludePatterns) {
+function discoverFiles(dir, rootDir, excludePatterns, extensionsSet) {
 	const results = [];
 	let entries;
 	try {
@@ -146,115 +41,42 @@ function discoverFiles(dir, rootDir, excludePatterns) {
 		} catch {
 			continue;
 		}
-		if (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, excludePatterns));
-		else if (DEFAULT_EXTENSIONS.has(extname(entry))) results.push(fullPath);
+		if (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, excludePatterns, extensionsSet));
+		else if (extensionsSet.has(extname(entry))) results.push(fullPath);
 	}
 	return results;
 }
 /**
-* Apply transform placeholders emitted by the Rust pipeline.
-*
-* Rust emits `__TRANSFORM__name__rawValue__` for props with transforms.
-* This function resolves each placeholder using the actual JS transform
-* functions from the config.
+* Resolve browser targets for Lightning CSS.
+* Priority: explicit config → project browserslist → 'defaults' fallback.
 */
-function applyTransformPlaceholders(css, transformRegistry) {
-	return css.replace(/__TRANSFORM__(\w+)__(.+?)__/g, (_match, name, rawValue) => {
-		const fn = transformRegistry.get(name);
-		if (!fn) {
-			console.warn(`[animus-extract] Unknown transform: "${name}" — using raw value`);
-			return rawValue;
-		}
-		const result = fn(rawValue !== "" && !isNaN(Number(rawValue)) ? Number(rawValue) : rawValue);
-		return typeof result === "object" ? JSON.stringify(result) : String(result);
-	});
+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");
+	}
+	return browserslistToTargets(Array.isArray(queries) && typeof queries[0] === "string" && queries[0].includes(" ") ? browserslist(queries) : queries);
 }
 /**
-* CSS properties that accept unitless numeric values.
-* Matches @emotion/unitless and React DOM's style handling.
-* Bare numerics on properties NOT in this set receive `px`.
+* Post-process CSS with Lightning CSS: autoprefixing + optional minification.
+* On failure, returns the original CSS and logs a warning.
 */
-const UNITLESS_PROPERTIES = new Set([
-	"animation-iteration-count",
-	"border-image-outset",
-	"border-image-slice",
-	"border-image-width",
-	"box-flex",
-	"box-flex-group",
-	"box-ordinal-group",
-	"column-count",
-	"columns",
-	"flex",
-	"flex-grow",
-	"flex-positive",
-	"flex-shrink",
-	"flex-negative",
-	"flex-order",
-	"grid-area",
-	"grid-row",
-	"grid-row-end",
-	"grid-row-span",
-	"grid-row-start",
-	"grid-column",
-	"grid-column-end",
-	"grid-column-span",
-	"grid-column-start",
-	"font-weight",
-	"line-clamp",
-	"line-height",
-	"opacity",
-	"order",
-	"orphans",
-	"tab-size",
-	"widows",
-	"z-index",
-	"zoom",
-	"fill-opacity",
-	"flood-opacity",
-	"stop-opacity",
-	"stroke-dasharray",
-	"stroke-dashoffset",
-	"stroke-miterlimit",
-	"stroke-opacity",
-	"stroke-width"
-]);
-/**
-* Append `px` to bare numeric values in CSS declarations for properties
-* that expect length units. Unitless properties are preserved as-is.
-* Numbers inside CSS function calls (cubic-bezier, rgb, calc, etc.) are skipped.
-*/
-function applyUnitFallback(css) {
-	return css.replace(/([a-z-]+)\s*:\s*([^;{}]+);/g, (match, prop, value) => {
-		if (UNITLESS_PROPERTIES.has(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;
-	});
+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;
+	}
 }
 /** Compute MD5 content hash for a string. */
 function contentHash(source) {
@@ -275,44 +97,14 @@ function buildFileEntriesFromCache(cache, changedPath) {
 	});
 	return entries;
 }
-/**
-* Resolve transform placeholders in CSS via bun subprocess.
-* Falls back to in-process resolution if the subprocess fails.
-*/
-function resolveTransformPlaceholders(css, rootDir, configPath, transformRegistry) {
-	if (!css.includes("__TRANSFORM__")) return css;
-	try {
-		const ts = Date.now();
-		const tmpCss = join(tmpdir(), `animus-transforms-${ts}.css`);
-		const tmpOut = join(tmpdir(), `animus-transforms-${ts}.out.css`);
-		writeFileSync(tmpCss, css);
-		const candidates = [join(__pluginDir, "resolve-transforms.ts"), join(__pluginDir, "..", "src", "resolve-transforms.ts")];
-		try {
-			const pkgDir = dirname(__require.resolve("@animus-ui/vite-plugin/package.json", { paths: [rootDir] }));
-			candidates.push(join(pkgDir, "src", "resolve-transforms.ts"));
-		} catch {}
-		const scriptPath = candidates.find((p) => existsSync(p));
-		if (!scriptPath) throw new Error(`resolve-transforms.ts not found in: ${candidates.join(", ")}`);
-		execSync(`bun run "${scriptPath}" "${tmpCss}" "${tmpOut}" ${configPath ? `"${resolve(rootDir, configPath)}"` : ""}`, {
-			cwd: rootDir,
-			encoding: "utf-8"
-		});
-		const resolved = readFileSync(tmpOut, "utf-8");
-		try {
-			unlinkSync(tmpCss);
-			unlinkSync(tmpOut);
-		} catch {}
-		return resolved;
-	} catch (e) {
-		console.error("[animus-extract] Transform resolution failed:", e?.message || e);
-		return applyTransformPlaceholders(css, transformRegistry);
-	}
-}
-function animusExtract(options = {}) {
+function animusExtract(options) {
 	let themeJson = "{}";
 	let variableMapJson = "{}";
+	let contextualVarsJson = "{}";
 	let configJson = "{}";
 	let groupRegistryJson = "{}";
+	let selectorAliasesJson = null;
+	let selectorOrderJson = null;
 	let isProd = false;
 	let rootDir = "";
 	const verbose = options.verbose || process.env.ANIMUS_DEBUG === "1" || process.env.ANIMUS_DEBUG === "true";
@@ -323,176 +115,92 @@ function animusExtract(options = {}) {
 	function warn(msg) {
 		(logger ?? console).warn(`[animus] ${msg}`);
 	}
+	function logTimingWaterfall(timing) {
+		if (!verbose) return;
+		for (const [key, label] of [
+			["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"]
+		]) {
+			const ms = timing[key] ?? 0;
+			const pad = " ".repeat(Math.max(0, 15 - label.length));
+			const extra = key === "parseAndWalk" ? `  (${timing.fileCount ?? 0} files, ${timing.cacheHits ?? 0} cached)` : "";
+			log(`         ${label}${pad}${String(ms).padStart(5)}ms${extra}`);
+		}
+	}
+	let lcssTargets = {};
 	let variableCss = "";
 	let globalCss = "";
-	let transformRegistry = /* @__PURE__ */ new Map();
+	let globalStyleBlocksJson = null;
+	let keyframesBlocksJson = null;
+	let pathAliasesJson = null;
+	let extensionsSet = new Set(options.extensions ?? DEFAULT_EXTENSIONS);
 	let storedManifest = null;
 	let storedManifestJson = "";
 	let resolvedComponentCss = "";
 	let storedSheets = null;
+	let layerDeclaration = "";
+	let fragmentCache = /* @__PURE__ */ new Map();
+	let reverseProvenance = {};
 	let storedSystemPropMapJson = "{}";
 	let storedDynamicPropsJson = "{}";
-	let storedTransformsSource = "";
+	let storedTransformsSource = "{}";
 	const fileCache = /* @__PURE__ */ new Map();
 	let packageMap = {};
+	let externalPackageDirs = [];
+	const externalSourceEntries = /* @__PURE__ */ new Map();
+	let devServer;
 	let bridgeInjected = false;
-	let resolvedConfigPath = null;
-	let resolvedThemePath = null;
 	let resolvedSystemPath = null;
-	/** Resolve config via bun subprocess. Updates configJson + groupRegistryJson. */
-	function loadConfig() {
-		if (options.config) {
-			configJson = options.config;
-			groupRegistryJson = options.groupRegistry ?? groupRegistryJson;
-			return;
-		}
-		const configSource = options.configPath ? resolve(rootDir, options.configPath) : "@animus-ui/core";
-		const requireExpr = options.configPath ? `require('${configSource.replace(/\\/g, "/")}')` : `require('@animus-ui/core')`;
-		if (options.configPath) resolvedConfigPath = resolve(rootDir, options.configPath);
-		try {
-			const result = execSync(`bun -e "const m = ${requireExpr}; const r = m.getExtractConfig(); process.stdout.write(JSON.stringify(r))"`, {
-				cwd: rootDir,
-				encoding: "utf-8"
-			});
-			const { propConfig, groupRegistry } = JSON.parse(result);
-			configJson = propConfig;
-			groupRegistryJson = groupRegistry;
-		} catch (e) {
-			if (options.strict) throw new Error(`[animus-extract] Failed to auto-import config from ${configSource}: ${e}`);
-			console.warn(`[animus-extract] Failed to auto-import config from ${configSource}:`, e);
-		}
-	}
-	/** Resolve theme via bun subprocess. Updates themeJson + variableCss. */
-	function loadTheme() {
-		if (options.theme) {
-			if (typeof options.theme === "string") {
-				themeJson = options.theme;
-				variableCss = "";
-			} else {
-				themeJson = options.theme.scales;
-				variableCss = options.theme.variables;
-			}
-			return;
-		}
-		resolvedThemePath = null;
-		if (options.themePath) {
-			const p = resolve(rootDir, options.themePath);
-			if (existsSync(p)) resolvedThemePath = p;
-			else if (options.strict) throw new Error(`[animus-extract] Theme file not found: ${p}`);
-			else console.warn(`[animus-extract] Theme file not found: ${p}`);
-		} else {
-			const candidates = [
-				join(rootDir, "src", "theme.ts"),
-				join(rootDir, "src", "theme.js"),
-				join(rootDir, "theme.ts"),
-				join(rootDir, "theme.js")
-			];
-			for (const candidate of candidates) if (existsSync(candidate)) {
-				resolvedThemePath = candidate;
-				break;
-			}
-		}
-		if (resolvedThemePath) try {
-			const themeJson_ = execSync(`bun -e "${[
-				`const m = require(${JSON.stringify(resolvedThemePath)});`,
-				`const theme = m.theme || m.default;`,
-				`process.stdout.write(JSON.stringify(theme || {}));`
-			].join(" ").replace(/"/g, "\\\"")}"`, {
-				cwd: rootDir,
-				encoding: "utf-8"
-			});
-			const theme = JSON.parse(themeJson_);
-			if (theme && Object.keys(theme).length > 0) {
-				const result = evaluateThemeObject(theme);
-				themeJson = result.scalesJson;
-				variableMapJson = result.variableMapJson;
-				variableCss = result.variableCss;
-			}
-		} catch (e) {
-			if (options.strict) throw new Error(`[animus-extract] Failed to load theme from ${resolvedThemePath}: ${e}`);
-			console.warn(`[animus-extract] Failed to load theme from ${resolvedThemePath}:`, e);
-		}
-	}
 	/**
-	* Load a SystemInstance via single bun subprocess.
-	* Replaces loadConfig() + loadTheme() when `system` option is provided.
-	* The subprocess imports the module and calls .serialize().
+	* Load a SystemInstance via Rust NAPI (rquickjs bundled eval).
+	* The Rust crate reads the system file, strips TS types via OXC, resolves
+	* workspace package dependencies, bundles all modules, evaluates with
+	* rquickjs, and returns serialized config directly — no subprocess needed.
 	*/
 	function loadSystem() {
-		if (!options.system) return;
 		resolvedSystemPath = resolve(rootDir, options.system);
 		try {
-			const ts = Date.now();
-			const tmpScript = join(tmpdir(), `animus-system-${ts}.js`);
-			const tmpOut = join(tmpdir(), `animus-system-${ts}.json`);
-			writeFileSync(tmpScript, `const m = require(${JSON.stringify(resolvedSystemPath)});\nconst ds = m.ds || m.default || m.system;\nif (!ds || !ds.serialize) { throw new Error('Module does not export a SystemInstance with .serialize()'); }\nconst cfg = ds.serialize();\nconst tokens = m.tokens || m.theme || null;\nrequire('fs').writeFileSync(${JSON.stringify(tmpOut)}, JSON.stringify({\n  propConfig: cfg.propConfig,\n  groupRegistry: cfg.groupRegistry,\n  tokens: tokens,\n  transformNames: Object.keys(cfg.transforms || {}),\n  globalStyles: cfg.globalStyles || null\n}));\n`);
-			execSync(`bun run "${tmpScript}"`, {
-				cwd: rootDir,
-				encoding: "utf-8"
-			});
-			const result = readFileSync(tmpOut, "utf-8");
-			try {
-				unlinkSync(tmpScript);
-				unlinkSync(tmpOut);
-			} catch {}
-			const parsed = JSON.parse(result);
-			configJson = parsed.propConfig;
-			groupRegistryJson = parsed.groupRegistry;
-			if (parsed.tokens && Object.keys(parsed.tokens).length > 0) {
-				const result = evaluateThemeObject(parsed.tokens);
-				themeJson = result.scalesJson;
-				variableMapJson = result.variableMapJson;
-				variableCss = result.variableCss;
-			} else if (logger) logger.warn("[animus] No tokens export found in system module — CSS variables will not be generated. Export your theme as `tokens` or `theme`.");
-			if (parsed.globalStyles) {
-				const hasReset = parsed.globalStyles.reset && Object.keys(parsed.globalStyles.reset).length > 0;
-				const hasGlobal = parsed.globalStyles.global && Object.keys(parsed.globalStyles.global).length > 0;
-				if (hasReset || hasGlobal) try {
-					const gsTmp = Date.now();
-					const gsThemeFile = join(tmpdir(), `animus-gs-theme-${gsTmp}.json`);
-					const gsOut = join(tmpdir(), `animus-global-${gsTmp}.json`);
-					writeFileSync(gsThemeFile, themeJson);
-					const gsCandidates = [join(__pluginDir, "resolve-global-styles.ts"), join(__pluginDir, "..", "src", "resolve-global-styles.ts")];
-					try {
-						const pkgDir = dirname(__require.resolve("@animus-ui/vite-plugin/package.json", { paths: [rootDir] }));
-						gsCandidates.push(join(pkgDir, "src", "resolve-global-styles.ts"));
-					} catch {}
-					const gsScriptPath = gsCandidates.find((p) => existsSync(p));
-					if (!gsScriptPath) throw new Error(`resolve-global-styles.ts not found in: ${gsCandidates.join(", ")}`);
-					execSync(`bun run "${gsScriptPath}" "${resolvedSystemPath}" "${gsThemeFile}" "${gsOut}"`, {
-						cwd: rootDir,
-						encoding: "utf-8"
-					});
-					const gsResult = JSON.parse(readFileSync(gsOut, "utf-8"));
-					const parts = [gsResult.reset, gsResult.global].filter(Boolean);
-					if (parts.length > 0) globalCss = `@layer global {\n${parts.join("\n\n")}\n}`;
-					try {
-						unlinkSync(gsThemeFile);
-						unlinkSync(gsOut);
-					} catch {}
-				} catch (e) {
-					console.warn("[animus-extract] Global styles resolution failed:", e?.message || e);
-				}
-			}
-			if (parsed.transformNames && parsed.transformNames.length > 0) {
-				const tsTmp = Date.now();
-				const tmpResolve = join(tmpdir(), `animus-transforms-resolve-${tsTmp}.js`);
-				writeFileSync(tmpResolve, `const m = require(${JSON.stringify(resolvedSystemPath)});\nconst ds = m.ds || m.default || m.system;\nconst cfg = ds.serialize();\nconst css = require('fs').readFileSync(process.argv[2], 'utf-8');\nconst resolved = css.replace(/__TRANSFORM__(\\w+)__(.+?)__/g, (_, name, rawValue) => {\n  const fn = cfg.transforms[name];\n  if (!fn) return rawValue;\n  const value = rawValue !== '' && !isNaN(Number(rawValue)) ? Number(rawValue) : rawValue;\n  const result = fn(value);\n  return typeof result === 'object' ? JSON.stringify(result) : String(result);\n});\nrequire('fs').writeFileSync(process.argv[3], resolved);\n`);
-				globalThis.__animus_system_resolve_script = tmpResolve;
-			}
+			const { loadSystemModule } = __require("@animus-ui/extract");
+			const config = loadSystemModule(resolvedSystemPath, rootDir);
+			configJson = config.propConfig;
+			groupRegistryJson = config.groupRegistry;
+			selectorAliasesJson = config.selectorAliases || null;
+			selectorOrderJson = config.selectorOrder || null;
+			themeJson = config.scalesJson;
+			variableMapJson = config.variableMapJson;
+			variableCss = config.variableCss;
+			contextualVarsJson = config.contextualVarsJson;
+			globalStyleBlocksJson = config.globalStyleBlocks || null;
+			keyframesBlocksJson = config.keyframesBlocks || null;
 		} catch (e) {
-			if (options.strict) throw new Error(`[animus-extract] Failed to load system from ${resolvedSystemPath}: ${e}`);
+			if (options.strict) throw new Error(`[animus-extract] Failed to load system from ${resolvedSystemPath}: ${e}`, { cause: e });
 			console.warn(`[animus-extract] Failed to load system from ${resolvedSystemPath}:`, e);
 		}
 	}
 	/**
 	* Run project analysis and update the manifest.
-	* Uses fileCache if populated (dev mode), otherwise uses provided entries.
+	*
+	* Pipeline: NAPI analyzeProject → unit fallback.
+	* Transforms are resolved in-process via boa_engine during Rust extraction.
+	* No subprocess needed.
 	*/
 	function runAnalysis(fileEntries) {
 		try {
 			const { analyzeProject } = __require("@animus-ui/extract");
-			const manifestJson = analyzeProject(JSON.stringify(fileEntries), themeJson, variableMapJson, configJson, groupRegistryJson, JSON.stringify(packageMap), !isProd);
+			const emitterConfig = JSON.stringify({
+				runtime_import: "@animus-ui/system",
+				css_module_id: "virtual:animus/styles.css"
+			});
+			const manifestJson = analyzeProject(JSON.stringify(fileEntries), themeJson, variableMapJson, contextualVarsJson || null, configJson, groupRegistryJson, JSON.stringify(packageMap), !isProd, emitterConfig, selectorAliasesJson, selectorOrderJson, globalStyleBlocksJson, pathAliasesJson, keyframesBlocksJson);
 			storedManifest = JSON.parse(manifestJson);
 			storedManifestJson = manifestJson;
 			storedSystemPropMapJson = JSON.stringify(storedManifest?.system_prop_map ?? {});
@@ -508,62 +216,104 @@ function animusExtract(options = {}) {
 						for (const match of matches) usedTransformNames.add(match[1]);
 					}
 				}
-				if (usedTransformNames.size > 0 && transformRegistry.size > 0) {
-					const transformParts = [];
-					for (const name of usedTransformNames) {
-						const fn = transformRegistry.get(name);
-						if (fn) try {
-							transformParts.push(`${JSON.stringify(name)}: ${fn.toString()}`);
-						} catch {
-							console.warn(`[animus-extract] Could not serialize transform "${name}" — dynamic props using it will fall back to raw values`);
-						}
-					}
-					storedTransformsSource = transformParts.length > 0 ? `{ ${transformParts.join(", ")} }` : "{}";
-				} else storedTransformsSource = "{}";
+				storedTransformsSource = "{}";
 			}
 			bridgeInjected = false;
-			storedSheets = storedManifest?.sheets ?? null;
-			const rawCss = storedManifest?.css || "";
-			const systemResolveScript = globalThis.__animus_system_resolve_script;
-			if (systemResolveScript && rawCss.includes("__TRANSFORM__") && isProd) try {
-				const tsTmp = Date.now();
-				const tmpIn = join(tmpdir(), `animus-css-${tsTmp}.css`);
-				const tmpOut = join(tmpdir(), `animus-css-${tsTmp}.out.css`);
-				writeFileSync(tmpIn, rawCss);
-				execSync(`bun run "${systemResolveScript}" "${tmpIn}" "${tmpOut}"`, {
-					cwd: rootDir,
-					encoding: "utf-8"
-				});
-				resolvedComponentCss = readFileSync(tmpOut, "utf-8");
-				try {
-					unlinkSync(tmpIn);
-					unlinkSync(tmpOut);
-				} catch {}
-			} catch (e) {
-				console.warn("[animus-extract] System transform resolution failed:", e?.message);
-				resolvedComponentCss = resolveTransformPlaceholders(rawCss, rootDir, options.configPath, transformRegistry);
+			const newFragments = storedManifest?.component_fragments;
+			if (newFragments && typeof newFragments === "object") {
+				fragmentCache.clear();
+				for (const [id, sheets] of Object.entries(newFragments)) fragmentCache.set(id, sheets);
 			}
-			else resolvedComponentCss = resolveTransformPlaceholders(rawCss, rootDir, options.configPath, transformRegistry);
+			reverseProvenance = storedManifest?.reverse_provenance ?? {};
+			storedSheets = storedManifest?.sheets ?? null;
+			globalCss = storedManifest?.sheets?.global || "";
+			resolvedComponentCss = storedManifest?.css || "";
 			resolvedComponentCss = applyUnitFallback(resolvedComponentCss);
 		} catch (e) {
-			if (options.strict) throw new Error(`[animus-extract] analyzeProject failed: ${e}`);
+			if (options.strict) throw new Error(`[animus-extract] analyzeProject failed: ${e}`, { cause: e });
 			console.warn("[animus-extract] analyzeProject failed:", e);
 		}
 	}
+	function runSelfVerify() {
+		const failures = [];
+		if (resolvedComponentCss.trim().length === 0) failures.push("No component CSS produced — check system file and include patterns");
+		if (!variableCss.includes(":root")) failures.push("No :root variable block found in variable CSS");
+		if (`${variableCss}\n${globalCss}\n${resolvedComponentCss}`.includes("__TRANSFORM__")) failures.push("Unresolved __TRANSFORM__ placeholders found in CSS output");
+		if (storedManifest && resolvedComponentCss.length > 0) {
+			const assembled = assembleStylesheet({
+				layers: options.layers,
+				variableCss,
+				globalCss,
+				componentCss: resolvedComponentCss
+			});
+			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})`);
+		}
+		for (const message of failures) {
+			const line = `[animus:verify] ${message}`;
+			if (options.strict) throw new Error(line);
+			if (logger) logger.warn(line, { timestamp: true });
+			else console.warn(line);
+		}
+		if (failures.length === 0) log("[animus:verify] structural self-check passed");
+	}
 	return {
 		name: "animus-extract",
 		enforce: "pre",
+		configureServer(server) {
+			devServer = server;
+		},
 		configResolved(config) {
 			isProd = config.command === "build";
 			rootDir = config.root;
 			logger = config.logger;
+			lcssTargets = resolveLightningTargets(options.targets, rootDir);
+			log(`Lightning CSS targets resolved (${Object.keys(lcssTargets).length} browsers)`);
+			const rawAlias = config.resolve?.alias;
+			if (rawAlias) {
+				const entries = [];
+				if (Array.isArray(rawAlias)) {
+					for (const entry of rawAlias) if (typeof entry.find === "string" && typeof entry.replacement === "string") {
+						const replacement = entry.replacement.startsWith(rootDir) ? entry.replacement.slice(rootDir.length + 1) : entry.replacement;
+						entries.push({
+							pattern: entry.find.endsWith("/") ? entry.find : entry.find + "/",
+							replacement: replacement.endsWith("/") ? replacement : replacement + "/",
+							type: "prefix"
+						});
+					}
+				} else if (typeof rawAlias === "object" && rawAlias !== null) {
+					for (const [key, value] of Object.entries(rawAlias)) if (typeof value === "string") {
+						const replacement = value.startsWith(rootDir) ? value.slice(rootDir.length + 1) : value;
+						if (/\.\w+$/.test(replacement)) entries.push({
+							pattern: key,
+							replacement,
+							type: "exact"
+						});
+						else entries.push({
+							pattern: key.endsWith("/") ? key : key + "/",
+							replacement: replacement.endsWith("/") ? replacement : replacement + "/",
+							type: "prefix"
+						});
+					}
+				}
+				entries.sort((a, b) => b.pattern.length - a.pattern.length);
+				if (entries.length > 0) {
+					pathAliasesJson = JSON.stringify({ aliases: entries });
+					log(`Path aliases forwarded: ${entries.length} entries`);
+				}
+			}
 		},
 		async buildStart() {
+			try {
+				const { clearAnalysisCache } = __require("@animus-ui/extract");
+				clearAnalysisCache();
+			} catch {}
 			let t0 = performance.now();
-			if (options.system) loadSystem();
-			else {
-				loadConfig();
-				loadTheme();
+			loadSystem();
+			if (options.layers) {
+				validateLayerOrder(options.layers);
+				log(`Custom layers: [${options.layers.join(", ")}]`);
 			}
 			if (verbose) {
 				const propCount = Object.keys(JSON.parse(configJson)).length;
@@ -572,11 +322,30 @@ function animusExtract(options = {}) {
 			}
 			t0 = performance.now();
 			const excludePatterns = options.exclude ?? DEFAULT_EXCLUDE;
-			const filePaths = discoverFiles(rootDir, rootDir, excludePatterns);
+			extensionsSet = new Set(options.extensions ?? DEFAULT_EXTENSIONS);
+			const shouldHandleMdx = extensionsSet.has(".mdx");
+			let mdxMissingDepWarned = false;
+			const filePaths = discoverFiles(rootDir, rootDir, excludePatterns, extensionsSet);
 			const fileEntries = [];
 			for (const filePath of filePaths) try {
-				const source = readFileSync(filePath, "utf-8");
-				const relPath = relative(rootDir, filePath);
+				let source = readFileSync(filePath, "utf-8");
+				let relPath = relative(rootDir, filePath);
+				if (shouldHandleMdx && extname(filePath) === ".mdx") {
+					const result = await preprocessMdx(source, relPath);
+					if (result.kind === "missing-dep") {
+						if (!mdxMissingDepWarned) {
+							warn("⚠ .mdx in extensions but @mdx-js/mdx not installed; MDX files skipped");
+							mdxMissingDepWarned = true;
+						}
+						continue;
+					}
+					if (result.kind === "error") {
+						warn(`⚠ MDX preprocessing failed for ${relPath}: ${result.error}`);
+						continue;
+					}
+					source = result.source;
+					relPath = relPath + ".tsx";
+				}
 				const hash = !isProd ? contentHash(source) : void 0;
 				fileEntries.push({
 					path: relPath,
@@ -589,58 +358,78 @@ function animusExtract(options = {}) {
 				});
 			} catch {}
 			const localFileCount = fileEntries.length;
-			const patterns = options.packagePatterns ?? ["@animus-ui/*"];
-			const packageSpecifiers = /* @__PURE__ */ new Set();
-			for (const entry of fileEntries) {
-				const importRegex = /from\s+['"]([^'"]+)['"]/g;
-				let match;
-				while ((match = importRegex.exec(entry.source)) !== null) {
-					const source = match[1];
-					for (const pattern of patterns) {
-						const prefix = pattern.replace("*", "");
-						if (source.startsWith(prefix) || source === pattern.replace("/*", "")) packageSpecifiers.add(source);
-					}
-				}
-			}
+			const packageSpecifiers = extractSystemFilePackages(resolvedSystemPath);
 			packageMap = {};
+			externalSourceEntries.clear();
+			const collectedPkgDirs = [];
 			for (const specifier of packageSpecifiers) try {
 				const resolved = await this.resolve(specifier);
 				if (resolved && resolved.id) {
 					const absPath = resolved.id;
-					const relPath = relative(rootDir, absPath);
-					if (!fileEntries.some((e) => e.path === relPath)) {
-						const entrySource = readFileSync(absPath, "utf-8");
-						const entryHash = !isProd ? contentHash(entrySource) : void 0;
-						fileEntries.push({
-							path: relPath,
-							source: entrySource,
-							hash: entryHash
-						});
-						if (!isProd && entryHash) fileCache.set(relPath, {
-							hash: entryHash,
-							source: entrySource
-						});
-					}
-					const pkgFiles = discoverFiles(dirname(absPath), rootDir, excludePatterns);
-					for (const pkgFile of pkgFiles) {
-						const pkgRelPath = relative(rootDir, pkgFile);
-						if (!fileEntries.some((e) => e.path === pkgRelPath)) {
-							const pkgSource = readFileSync(pkgFile, "utf-8");
-							const pkgHash = !isProd ? contentHash(pkgSource) : void 0;
+					let pkgRoot = dirname(absPath);
+					while (pkgRoot !== dirname(pkgRoot) && !existsSync(join(pkgRoot, "package.json"))) pkgRoot = dirname(pkgRoot);
+					const srcDir = join(pkgRoot, "src");
+					if (existsSync(srcDir)) {
+						collectedPkgDirs.push(srcDir);
+						const pkgFiles = discoverFiles(srcDir, rootDir, excludePatterns, extensionsSet);
+						for (const pkgFile of pkgFiles) {
+							let pkgRelPath = relative(rootDir, pkgFile);
+							if (!fileEntries.some((e) => e.path === pkgRelPath)) {
+								let pkgSource = readFileSync(pkgFile, "utf-8");
+								if (shouldHandleMdx && extname(pkgFile) === ".mdx") {
+									const result = await preprocessMdx(pkgSource, pkgRelPath);
+									if (result.kind === "missing-dep") {
+										if (!mdxMissingDepWarned) {
+											warn("⚠ .mdx in extensions but @mdx-js/mdx not installed; MDX files skipped");
+											mdxMissingDepWarned = true;
+										}
+										continue;
+									}
+									if (result.kind === "error") {
+										warn(`⚠ MDX preprocessing failed for ${pkgRelPath}: ${result.error}`);
+										continue;
+									}
+									pkgSource = result.source;
+									pkgRelPath = pkgRelPath + ".tsx";
+								}
+								const pkgHash = !isProd ? contentHash(pkgSource) : void 0;
+								fileEntries.push({
+									path: pkgRelPath,
+									source: pkgSource,
+									hash: pkgHash
+								});
+								if (!isProd && pkgHash) fileCache.set(pkgRelPath, {
+									hash: pkgHash,
+									source: pkgSource
+								});
+							}
+						}
+						const srcEntry = join(srcDir, "index.ts");
+						if (existsSync(srcEntry)) {
+							packageMap[specifier] = relative(rootDir, srcEntry);
+							externalSourceEntries.set(specifier, srcEntry);
+						} else packageMap[specifier] = relative(rootDir, absPath);
+					} else {
+						const relPath = relative(rootDir, absPath);
+						if (!fileEntries.some((e) => e.path === relPath)) {
+							const entrySource = readFileSync(absPath, "utf-8");
+							const entryHash = !isProd ? contentHash(entrySource) : void 0;
 							fileEntries.push({
-								path: pkgRelPath,
-								source: pkgSource,
-								hash: pkgHash
+								path: relPath,
+								source: entrySource,
+								hash: entryHash
 							});
-							if (!isProd && pkgHash) fileCache.set(pkgRelPath, {
-								hash: pkgHash,
-								source: pkgSource
+							if (!isProd && entryHash) fileCache.set(relPath, {
+								hash: entryHash,
+								source: entrySource
 							});
 						}
+						collectedPkgDirs.push(dirname(absPath));
+						packageMap[specifier] = relPath;
 					}
-					packageMap[specifier] = relPath;
 				}
 			} catch {}
+			externalPackageDirs = collectedPkgDirs;
 			const packageFileCount = fileEntries.length - localFileCount;
 			log(`Discovered ${fileEntries.length} files (${packageFileCount} from packages) (${Math.round(performance.now() - t0)}ms)`);
 			t0 = performance.now();
@@ -649,9 +438,11 @@ function animusExtract(options = {}) {
 				const report = storedManifest.report;
 				if (report) {
 					log(`Extracted ${report.components_extracted}/${report.components_total} components (${Math.round(performance.now() - t0)}ms)`);
+					logTimingWaterfall(storedManifest.timing ?? {});
 					log(`Reconciliation: ${report.components_extracted} kept, ${report.variants_eliminated} variants pruned, ${report.states_eliminated} states pruned`);
 					const details = report.eliminated_details || [];
 					for (const d of details) if (d.kind === "component") warn(`⚠ ${d.component} eliminated: ${d.reason}`);
+					else if (d.kind === "prospective_component") warn(`⚠ ${d.component} would be eliminated in production: ${d.reason}`);
 					else if (d.kind === "variant") warn(`⚠ ${d.component} variant '${d.name}' pruned: ${d.reason}`);
 					else if (d.kind === "state") warn(`⚠ ${d.component} state '${d.name}' pruned: ${d.reason}`);
 				}
@@ -660,37 +451,69 @@ function animusExtract(options = {}) {
 				else if (d.kind === "skip") warn(`⚠ ${d.component}: skipped ${d.message}`);
 				log(`CSS: ${resolvedComponentCss.length} bytes (${Object.keys(storedManifest.components || {}).length} components)`);
 				if (!isProd && storedSheets) {
-					const staticSize = (storedSheets.declaration + variableCss + globalCss).length;
+					const staticSize = assembleStylesheet({
+						layers: options.layers,
+						variableCss,
+						globalCss
+					}).length;
 					const componentSize = resolvedComponentCss.length;
 					log(`Delivery: split mode — static ${staticSize} bytes, components ${componentSize} bytes (adopted stylesheet)`);
 				} else log("Delivery: single file mode (production)");
 			}
+			const { declaration } = assembleStylesheet({
+				layers: options.layers,
+				variableCss: "",
+				globalCss: "",
+				split: true
+			});
+			layerDeclaration = declaration;
+			if (options.verify) runSelfVerify();
 		},
 		resolveId(id) {
 			if (id === VIRTUAL_CSS_ID) return RESOLVED_CSS_ID;
 			if (id === VIRTUAL_COMPONENTS_ID) return RESOLVED_COMPONENTS_ID;
 			if (id === VIRTUAL_BRIDGE_ID) return RESOLVED_BRIDGE_ID;
 			if (id === VIRTUAL_SYSTEM_PROPS_ID) return RESOLVED_SYSTEM_PROPS_ID;
+			const srcEntry = externalSourceEntries.get(id);
+			if (srcEntry) return srcEntry;
 			return null;
 		},
 		load(id) {
+			const lcssOpts = {
+				minify: options.minify ?? isProd,
+				targets: lcssTargets,
+				warnFn: warn
+			};
 			if (id === RESOLVED_CSS_ID) {
-				if (!isProd && storedSheets) return [
-					storedSheets.declaration,
-					variableCss,
-					globalCss
-				].filter(Boolean).join("\n");
-				return [
+				if (!isProd && storedSheets) {
+					const { variables, body } = assembleStylesheet({
+						layers: options.layers,
+						variableCss,
+						globalCss,
+						split: true
+					});
+					return [variables, postProcessCss(body, {
+						...lcssOpts,
+						minify: false
+					})].filter(Boolean).join("\n");
+				}
+				const { variables, body } = assembleStylesheet({
+					layers: options.layers,
 					variableCss,
 					globalCss,
-					resolvedComponentCss
-				].filter(Boolean).join("\n");
+					componentCss: resolvedComponentCss,
+					split: true
+				});
+				return [variables, postProcessCss(body, lcssOpts)].filter(Boolean).join("\n");
 			}
-			if (id === RESOLVED_COMPONENTS_ID) return `export default \`${(resolvedComponentCss || "").replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;`;
+			if (id === RESOLVED_COMPONENTS_ID) return `export default \`${postProcessCss(stripLeadingLayerDeclaration(resolvedComponentCss || ""), {
+				...lcssOpts,
+				minify: false
+			}).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;`;
 			if (id === RESOLVED_BRIDGE_ID) return `
 import css from '${VIRTUAL_COMPONENTS_ID}';
 
-const GLOBAL_KEY = '__animus_component_sheet__';
+const GLOBAL_KEY = '__animus_sheet_${createHash("md5").update(options.system).digest("hex").slice(0, 8)}__';
 let sheet = globalThis[GLOBAL_KEY] || null;
 
 if (typeof CSSStyleSheet !== 'undefined' && 'adoptedStyleSheets' in document) {
@@ -734,18 +557,41 @@ if (import.meta.hot) {
 						...meta.scale_values && Object.keys(meta.scale_values).length > 0 ? { scaleValues: meta.scale_values } : {}
 					};
 					moduleSource += `\nexport const dynamicPropConfig = ${JSON.stringify(configEntries)};`;
-					moduleSource += `\nexport const transforms = ${storedTransformsSource};`;
-				}
+				} else moduleSource += `\nexport const dynamicPropConfig = {};`;
+				moduleSource += `\nexport const transforms = ${storedTransformsSource};`;
 				return moduleSource;
 			}
 			return null;
 		},
 		transform(code, id) {
 			if (!storedManifest) return null;
-			if (!/\.[jt]sx?$/.test(id)) return null;
-			if (id.includes("node_modules")) return null;
+			if (!externalPackageDirs.some((dir) => id.startsWith(dir))) {
+				if (!/\.[jt]sx?$/.test(id)) return null;
+				if (id.includes("node_modules")) return null;
+			}
 			const relativePath = relative(rootDir, id);
-			if (!storedManifest.files?.[relativePath]?.length) return null;
+			if (!storedManifest.files?.[relativePath]?.length) {
+				if (!isProd && !fileCache.has(relativePath)) {
+					const hash = contentHash(code);
+					fileCache.set(relativePath, {
+						hash,
+						source: code
+					});
+					runAnalysis(buildFileEntriesFromCache(fileCache, relativePath));
+					const compCount = storedManifest.files?.[relativePath]?.length ?? 0;
+					log(`New file detected: ${relativePath} — ${compCount ? `${compCount} components extracted` : "no components"}`);
+					if (compCount && devServer) {
+						const compModule = devServer.moduleGraph.getModuleById(RESOLVED_COMPONENTS_ID);
+						if (compModule) devServer.moduleGraph.invalidateModule(compModule);
+						const sysPropModule = devServer.moduleGraph.getModuleById(RESOLVED_SYSTEM_PROPS_ID);
+						if (sysPropModule) devServer.moduleGraph.invalidateModule(sysPropModule);
+						setTimeout(() => {
+							devServer.hot.send({ type: "full-reload" });
+						}, 100);
+					}
+				}
+				if (!storedManifest.files?.[relativePath]?.length) return null;
+			}
 			try {
 				const { transformFile } = __require("@animus-ui/extract");
 				const result = transformFile(code, relativePath, storedManifestJson);
@@ -762,29 +608,35 @@ if (import.meta.hot) {
 					map: null
 				};
 			} catch (e) {
-				if (options.strict) throw new Error(`[animus-extract] Failed to transform ${id}: ${e}`);
+				if (options.strict) throw new Error(`[animus-extract] Failed to transform ${id}: ${e}`, { cause: e });
 				console.warn(`[animus-extract] Failed to transform ${id}:`, e);
 				return null;
 			}
 		},
-		handleHotUpdate({ file, server: hmrServer, modules }) {
+		transformIndexHtml: {
+			order: "pre",
+			handler() {
+				if (!layerDeclaration) return [];
+				return [{
+					tag: "style",
+					attrs: { "data-animus-layers": "" },
+					children: layerDeclaration,
+					injectTo: "head-prepend"
+				}];
+			}
+		},
+		async handleHotUpdate({ file, server: hmrServer, modules }) {
 			if (isProd) return;
 			const ext = extname(file);
-			if (!DEFAULT_EXTENSIONS.has(ext)) return;
-			if ((options.exclude ?? DEFAULT_EXCLUDE).some((pattern) => file.includes(pattern) || relative(rootDir, file).includes(pattern))) return;
+			if (!extensionsSet.has(ext)) return;
+			const excludePatterns = options.exclude ?? DEFAULT_EXCLUDE;
+			if (!externalPackageDirs.some((dir) => file.startsWith(dir)) && excludePatterns.some((pattern) => file.includes(pattern) || relative(rootDir, file).includes(pattern))) return;
 			const absFile = resolve(file);
 			const relPath = relative(rootDir, absFile);
-			const isConfigChange = resolvedConfigPath && absFile === resolve(resolvedConfigPath);
-			const isThemeChange = resolvedThemePath && absFile === resolve(resolvedThemePath);
-			const isSystemChange = resolvedSystemPath && absFile === resolve(resolvedSystemPath);
-			if (isConfigChange || isThemeChange || isSystemChange) {
+			if (resolvedSystemPath && absFile === resolve(resolvedSystemPath)) {
 				const resetStart = performance.now();
 				log(`HMR geological reset: ${relPath}`);
-				if (isSystemChange) loadSystem();
-				else {
-					if (isConfigChange) loadConfig();
-					if (isThemeChange) loadTheme();
-				}
+				loadSystem();
 				try {
 					const { clearAnalysisCache } = __require("@animus-ui/extract");
 					clearAnalysisCache();
@@ -821,19 +673,47 @@ if (import.meta.hot) {
 			} catch {
 				return;
 			}
+			let scannerRelPath = relPath;
+			if (ext === ".mdx") {
+				const result = await preprocessMdx(source, relPath);
+				if (result.kind === "missing-dep") {
+					warn("⚠ .mdx HMR skipped: @mdx-js/mdx not installed; restart dev server after installing");
+					return;
+				}
+				if (result.kind === "error") {
+					warn(`⚠ MDX preprocessing failed for ${relPath}: ${result.error}`);
+					return;
+				}
+				source = result.source;
+				scannerRelPath = relPath + ".tsx";
+			}
 			const hash = contentHash(source);
-			const cached = fileCache.get(relPath);
+			const cached = fileCache.get(scannerRelPath);
 			if (cached && cached.hash === hash) {
-				log(`HMR skip: ${relPath} (unchanged)`);
+				log(`HMR skip: ${scannerRelPath} (unchanged)`);
 				return [];
 			}
-			fileCache.set(relPath, {
+			fileCache.set(scannerRelPath, {
 				hash,
 				source
 			});
 			const hmrStart = performance.now();
 			const prevReplacements = /* @__PURE__ */ new Map();
 			if (storedManifest?.components) for (const [id, desc] of Object.entries(storedManifest.components)) prevReplacements.set(id, desc.replacement ?? "");
+			const directComponentIds = storedManifest?.files?.[scannerRelPath] ?? [];
+			const invalidatedIds = new Set(directComponentIds);
+			const queue = [...directComponentIds];
+			while (queue.length > 0) {
+				const parentId = queue.shift();
+				const children = reverseProvenance[parentId];
+				if (children) {
+					for (const childId of children) if (!invalidatedIds.has(childId)) {
+						invalidatedIds.add(childId);
+						queue.push(childId);
+					}
+				}
+			}
+			if (verbose && invalidatedIds.size > directComponentIds.length) log(`HMR: ${directComponentIds.length} direct + ${invalidatedIds.size - directComponentIds.length} transitive components invalidated`);
 			const analysisStart = performance.now();
 			runAnalysis(buildFileEntriesFromCache(fileCache, relPath));
 			const analysisMs = Math.round(performance.now() - analysisStart);
@@ -864,9 +744,10 @@ if (import.meta.hot) {
 			}
 			const hmrMs = Math.round(performance.now() - hmrStart);
 			log(`HMR update: ${relPath} — analysis ${analysisMs}ms, ${modulesToUpdate.length - modules.length} modules invalidated, total ${hmrMs}ms`);
+			logTimingWaterfall(storedManifest?.timing ?? {});
 			if (modulesToUpdate.length > modules.length) return modulesToUpdate;
 		}
 	};
 }
 //#endregion
-export { animusExtract, animusExtract as default, evaluateTheme, evaluateThemeObject };
+export { animusExtract, animusExtract as default, discoverFiles };