@animus-ui/vite-plugin 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -2,71 +2,17 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
 let _animus_ui_extract_pipeline = require("@animus-ui/extract/pipeline");
-let browserslist = require("browserslist");
-browserslist = __toESM(browserslist);
-let crypto = require("crypto");
 let fs = require("fs");
-let lightningcss = require("lightningcss");
 let path = require("path");
-//#region src/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
-	];
-}
-//#endregion
-//#region src/manifest-diagnostics.ts
-function surfaceManifestDiagnostics(manifest, warn) {
-	for (const diagnostic of manifest.diagnostics ?? []) if (diagnostic.kind === "bail") warn(`⚠ ${diagnostic.component} not extracted: ${diagnostic.message}`);
-	else if (diagnostic.kind === "skip") warn(`⚠ ${diagnostic.component}: skipped ${diagnostic.message}`);
-	else if (diagnostic.kind === "warn") warn(`⚠ ${diagnostic.file}: ${diagnostic.component}: ${diagnostic.message}`);
-}
-//#endregion
-//#region src/index.ts
+let crypto = require("crypto");
+//#region src/constants.ts
 const VIRTUAL_CSS_ID = "virtual:animus/styles.css";
 const RESOLVED_CSS_ID = "\0virtual:animus/styles.css";
 const VIRTUAL_COMPONENTS_ID = "virtual:animus/components.js";
 const RESOLVED_COMPONENTS_ID = "\0virtual:animus/components.js";
 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_EXCLUDE = [
 	"node_modules",
@@ -74,70 +20,297 @@ const DEFAULT_EXCLUDE = [
 	".test.",
 	".spec."
 ];
-function discoverFiles(dir, rootDir, excludePatterns, extensionsSet) {
-	const results = [];
-	let entries;
-	try {
-		entries = (0, fs.readdirSync)(dir, { encoding: "utf8" });
-	} catch {
-		return results;
+//#endregion
+//#region src/build-start.ts
+/**
+* buildStart: load the system, discover and ingest sources (local +
+* external packages), run whole-project analysis, and log the report.
+* `resolveSpecifier` is the bundler seam — Vite's `this.resolve` mapped to
+* an absolute id.
+*/
+async function runBuildStart(ctx, resolveSpecifier) {
+	(0, _animus_ui_extract_pipeline.clearEngineCache)(ctx.engineApi);
+	let t0 = performance.now();
+	ctx.loadSystem();
+	if (ctx.options.layers) {
+		(0, _animus_ui_extract_pipeline.validateLayerOrder)(ctx.options.layers);
+		ctx.log(`Custom layers: [${ctx.options.layers.join(", ")}]`);
 	}
-	for (const entry of entries) {
-		const fullPath = (0, path.join)(dir, entry);
-		const relativePath = (0, path.relative)(rootDir, fullPath);
-		if (excludePatterns.some((pattern) => fullPath.includes(pattern) || relativePath.includes(pattern))) continue;
-		let stat;
-		try {
-			stat = (0, fs.statSync)(fullPath);
-		} catch {
-			continue;
+	if (ctx.verbose) {
+		const propCount = Object.keys(JSON.parse(ctx.system.propConfigJson)).length;
+		const groupCount = Object.keys(JSON.parse(ctx.system.groupRegistryJson)).length;
+		ctx.log(`System loaded: ${propCount} props, ${groupCount} groups (${Math.round(performance.now() - t0)}ms)`);
+	}
+	t0 = performance.now();
+	const excludePatterns = ctx.options.exclude ?? DEFAULT_EXCLUDE;
+	ctx.extensionsSet = new Set(ctx.options.extensions ?? _animus_ui_extract_pipeline.DEFAULT_EXTENSIONS);
+	const shouldHandleMdx = ctx.extensionsSet.has(".mdx");
+	let mdxMissingDepWarned = false;
+	const preprocessMdxEntry = async (source, relPath) => {
+		const result = await (0, _animus_ui_extract_pipeline.preprocessMdx)(source, relPath);
+		if (result.kind === "missing-dep") {
+			if (!mdxMissingDepWarned) {
+				ctx.warn("⚠ .mdx in extensions but @mdx-js/mdx not installed; MDX files skipped");
+				mdxMissingDepWarned = true;
+			}
+			return null;
 		}
-		if (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, excludePatterns, extensionsSet));
-		else if (extensionsSet.has((0, path.extname)(entry))) results.push(fullPath);
+		if (result.kind === "error") {
+			ctx.warn(`⚠ MDX preprocessing failed for ${relPath}: ${result.error}`);
+			return null;
+		}
+		return {
+			source: result.source,
+			relPath: relPath + ".tsx"
+		};
+	};
+	const filePaths = (0, _animus_ui_extract_pipeline.discoverFiles)(ctx.rootDir, ctx.rootDir, excludePatterns, ctx.extensionsSet);
+	const fileEntries = [];
+	for (const filePath of filePaths) try {
+		let source = (0, fs.readFileSync)(filePath, "utf-8");
+		let relPath = (0, path.relative)(ctx.rootDir, filePath);
+		if (shouldHandleMdx && (0, path.extname)(filePath) === ".mdx") {
+			const processed = await preprocessMdxEntry(source, relPath);
+			if (!processed) continue;
+			source = processed.source;
+			relPath = processed.relPath;
+		}
+		const hash = !ctx.isProd ? (0, _animus_ui_extract_pipeline.contentHash)(source) : void 0;
+		fileEntries.push({
+			path: relPath,
+			source,
+			hash
+		});
+		if (!ctx.isProd && hash) ctx.fileCache.set(relPath, {
+			hash,
+			source
+		});
+	} catch {}
+	const localFileCount = fileEntries.length;
+	const packageSpecifiers = (0, _animus_ui_extract_pipeline.extractSystemFilePackages)(ctx.resolvedSystemPath);
+	ctx.externalSourceEntries.clear();
+	const collected = await (0, _animus_ui_extract_pipeline.collectExternalPackageSources)({
+		specifiers: packageSpecifiers,
+		resolveSpecifier,
+		rootDir: ctx.rootDir,
+		extensionsSet: ctx.extensionsSet,
+		hasEntry: (relPath) => fileEntries.some((e) => e.path === relPath),
+		preprocessFile: async (source, relPath, absPath) => {
+			if (shouldHandleMdx && (0, path.extname)(absPath) === ".mdx") return preprocessMdxEntry(source, relPath);
+			return {
+				source,
+				relPath
+			};
+		},
+		onUnreadable: (relPath, err) => ctx.warn(`skipped unreadable package file ${relPath}: ${String(err)}`)
+	});
+	ctx.packageMap = collected.packageMap;
+	ctx.externalPackageOutcomes = collected.outcomes;
+	ctx.enforceIncludeResolution();
+	for (const [specifier, srcEntry] of collected.sourceEntries) ctx.externalSourceEntries.set(specifier, srcEntry);
+	for (const entry of collected.entries) {
+		const hash = !ctx.isProd ? (0, _animus_ui_extract_pipeline.contentHash)(entry.source) : void 0;
+		fileEntries.push({
+			path: entry.path,
+			source: entry.source,
+			hash
+		});
+		if (!ctx.isProd && hash) ctx.fileCache.set(entry.path, {
+			hash,
+			source: entry.source
+		});
+	}
+	ctx.externalPackageDirs = collected.packageDirs;
+	ctx.registerSystemWatchPaths();
+	const packageFileCount = fileEntries.length - localFileCount;
+	ctx.log(`Discovered ${fileEntries.length} files (${packageFileCount} from packages) (${Math.round(performance.now() - t0)}ms)`);
+	t0 = performance.now();
+	ctx.runAnalysis(fileEntries);
+	if (ctx.storedManifest) {
+		const report = ctx.storedManifest.report;
+		if (report) {
+			ctx.log(`Extracted ${report.components_extracted}/${report.components_total} components (${Math.round(performance.now() - t0)}ms)`);
+			ctx.logTimingWaterfall(ctx.storedManifest.timing ?? {});
+			ctx.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") ctx.warn(`⚠ ${d.component} eliminated: ${d.reason}`);
+			else if (d.kind === "prospective_component") ctx.warn(`⚠ ${d.component} would be eliminated in production: ${d.reason}`);
+			else if (d.kind === "variant") ctx.warn(`⚠ ${d.component} variant '${d.name}' pruned: ${d.reason}`);
+			else if (d.kind === "state") ctx.warn(`⚠ ${d.component} state '${d.name}' pruned: ${d.reason}`);
+		}
+		ctx.log(`CSS: ${ctx.resolvedComponentCss.length} bytes (${Object.keys(ctx.storedManifest.components || {}).length} components)`);
+		if (!ctx.isProd && ctx.storedSheets) {
+			const staticSize = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
+				layers: ctx.options.layers,
+				variableCss: ctx.system.variableCss,
+				globalCss: ctx.globalCss
+			}).length;
+			const componentSize = ctx.resolvedComponentCss.length;
+			ctx.log(`Delivery: split mode — static ${staticSize} bytes, components ${componentSize} bytes (adopted stylesheet)`);
+		} else ctx.log("Delivery: single file mode (production)");
 	}
-	return results;
+	const { declaration } = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
+		layers: ctx.options.layers,
+		variableCss: "",
+		globalCss: "",
+		split: true
+	});
+	ctx.layerDeclaration = declaration;
+	if (ctx.options.verify) ctx.runSelfVerify();
 }
+//#endregion
+//#region src/config.ts
 /**
-* Resolve browser targets for Lightning CSS.
-* Priority: explicit config → project browserslist → 'defaults' fallback.
+* configResolved: capture build mode, root, and logger; resolve Lightning
+* CSS targets; harvest resolve.alias into the Rust `pathAliasesJson`
+* contract via the shared encoder.
 */
-function resolveLightningTargets(explicitTargets, rootDir) {
-	let queries;
-	if (explicitTargets) queries = Array.isArray(explicitTargets) ? explicitTargets : [explicitTargets];
-	else {
-		const detected = (0, browserslist.default)(void 0, { path: rootDir });
-		queries = detected.length > 0 ? detected : (0, browserslist.default)("defaults");
-	}
-	return (0, lightningcss.browserslistToTargets)(Array.isArray(queries) && typeof queries[0] === "string" && queries[0].includes(" ") ? (0, browserslist.default)(queries) : queries);
+function applyResolvedConfig(ctx, config) {
+	ctx.isProd = config.command === "build";
+	ctx.rootDir = config.root;
+	ctx.logger = config.logger;
+	ctx.lcssTargets = (0, _animus_ui_extract_pipeline.resolveLightningTargets)(ctx.options.targets, ctx.rootDir);
+	ctx.log(`Lightning CSS targets resolved (${Object.keys(ctx.lcssTargets).length} browsers)`);
+	const rawAlias = config.resolve?.alias;
+	if (rawAlias) {
+		const pairs = [];
+		if (Array.isArray(rawAlias)) {
+			for (const entry of rawAlias) if (typeof entry.find === "string" && typeof entry.replacement === "string") pairs.push({
+				pattern: entry.find,
+				target: entry.replacement,
+				kind: "prefix"
+			});
+		} else if (typeof rawAlias === "object" && rawAlias !== null) {
+			for (const [key, value] of Object.entries(rawAlias)) if (typeof value === "string") pairs.push({
+				pattern: key,
+				target: value
+			});
+		}
+		const built = (0, _animus_ui_extract_pipeline.buildPathAliasesJson)(pairs, ctx.rootDir);
+		if (built) {
+			ctx.pathAliasesJson = built.json;
+			ctx.log(`Path aliases forwarded: ${built.count} entries`);
+		}
+	}
 }
+//#endregion
+//#region src/hot-update-events.ts
 /**
-* Post-process CSS with Lightning CSS: autoprefixing + optional minification.
-* On failure, returns the original CSS and logs a warning.
+* Once-per-file-event coordination across the `hotUpdate` dispatches.
+*
+* Vite 8 calls `hotUpdate` once per environment for a single file event — the
+* client environment first, then every non-client environment (see
+* `handleHMRUpdate` in vite/dist/node/chunks/node.js). Analysis work (cache
+* mutation, engine re-analysis, geological reset scheduling) must happen
+* exactly once per event; module invalidation must happen per environment
+* against that environment's own graph.
+*
+* The client dispatch always claims — it is dispatched first, so nothing can
+* have claimed the event before it, and claiming unconditionally keeps a
+* same-millisecond `(file, timestamp)` collision from ever costing a client
+* analysis. A non-client dispatch claims only when the event carries no
+* recorded claim at all, which happens when the plugin is filtered out of the
+* client environment.
+*
+* Keys are retained for a bounded number of recent events so that interleaved
+* file events (Vite does not serialize watcher handlers) still find their own
+* result.
 */
-function postProcessCss(css, opts) {
-	if (!css) return css;
-	try {
-		return (0, lightningcss.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;
+var HotUpdateEvents = class {
+	results = /* @__PURE__ */ new Map();
+	constructor(historyLimit = 16) {
+		this.historyLimit = historyLimit;
+	}
+	/** True when this environment dispatch owns the event's analysis work. */
+	claim(environmentName, file, timestamp) {
+		const key = eventKey(file, timestamp);
+		if (environmentName !== "client" && this.results.has(key)) return false;
+		this.results.set(key, { kind: "ignored" });
+		while (this.results.size > this.historyLimit) {
+			const oldest = this.results.keys().next().value;
+			if (oldest === void 0) break;
+			this.results.delete(oldest);
+		}
+		return true;
+	}
+	/** Publish the owning dispatch's decision to the other environments. */
+	record(file, timestamp, result) {
+		this.results.set(eventKey(file, timestamp), result);
 	}
+	/** The decision for this event — `ignored` when the event was evicted. */
+	resultOf(file, timestamp) {
+		return this.results.get(eventKey(file, timestamp)) ?? { kind: "ignored" };
+	}
+};
+/** A path can hold any character but NUL, so NUL is the safe separator. */
+function eventKey(file, timestamp) {
+	return `${file}\u0000${timestamp}`;
 }
-/** Compute MD5 content hash for a string. */
-function contentHash(source) {
-	return (0, crypto.createHash)("md5").update(source).digest("hex");
+//#endregion
+//#region src/reset-coalescer.ts
+/**
+* Coalesces bursts of system-dependency events into single geological
+* resets: a quiescence window before starting, at most one reset in
+* flight, and exactly one follow-up when requests arrive mid-reset. A
+* package build regenerating its dist fires one reset, not one per file.
+*
+* Timer functions are injected seams — `vi.mock` on node builtins silently
+* no-ops under vite-plus-test, so tests drive a manual scheduler instead.
+*/
+var ResetCoalescer = class {
+	timer = null;
+	running = false;
+	dirty = false;
+	constructor(run, quietMs = 60, schedule = (fn, ms) => setTimeout(fn, ms), cancel = (timer) => clearTimeout(timer)) {
+		this.run = run;
+		this.quietMs = quietMs;
+		this.schedule = schedule;
+		this.cancel = cancel;
+	}
+	/** Ask for a reset; bursts within the quiescence window collapse. */
+	request() {
+		if (this.running) {
+			this.dirty = true;
+			return;
+		}
+		if (this.timer !== null) this.cancel(this.timer);
+		this.timer = this.schedule(() => {
+			this.timer = null;
+			this.running = true;
+			try {
+				this.run();
+			} finally {
+				this.running = false;
+				if (this.dirty) {
+					this.dirty = false;
+					this.request();
+				}
+			}
+		}, this.quietMs);
+	}
+};
+//#endregion
+//#region src/context.ts
+/** Pre-load / failed-load defaults — the plugin's historical initial state. */
+function emptySystemConfig() {
+	return {
+		propConfigJson: "{}",
+		groupRegistryJson: "{}",
+		scalesJson: "{}",
+		variableMapJson: "{}",
+		variableCss: "",
+		contextualVarsJson: "{}",
+		selectorAliasesJson: null,
+		globalStyleBlocksJson: null,
+		keyframesJson: null
+	};
 }
 /**
 * Reconstruct file entries from cache, including content hashes.
 * For unchanged files (hash matches changedPath), sends empty source
 * to avoid serializing full source text across the NAPI boundary.
-* Rust cache-hit path never reads file.source, so empty string is safe.
+* The engine adapter's `rehydrateFilesJson` refills empty sources from
+* this same cache before analyze.
 */
 function buildFileEntriesFromCache(cache, changedPath) {
 	const entries = [];
@@ -148,223 +321,291 @@ function buildFileEntriesFromCache(cache, changedPath) {
 	});
 	return entries;
 }
-function animusExtract(options) {
-	const resolvedEngine = options.engine ?? "v2";
-	const engineModuleId = resolvedEngine === "v2" ? "@animus-ui/extract/engine-v2" : "@animus-ui/extract";
-	const requireEngine = () => require(engineModuleId);
-	let v2Engine = null;
-	const v2SentSources = /* @__PURE__ */ new Map();
-	let v2DriftWarned = false;
-	const engineApi = () => {
-		if (resolvedEngine !== "v2") return requireEngine();
-		const native = requireEngine();
-		return {
-			loadSystemModule: (...args) => native.loadSystemModule(...args),
-			analyzeProject: (filesJsonRaw, themeJson_, variableMapJson_, contextualVarsJson_, configJson_, groupRegistryJson_, packageResolutionJson_, devMode, emitterConfigJson, selectorAliasesJson_, _selectorOrderJson, globalStyleBlocksJson_, pathAliasesJson_, keyframesJson_) => {
-				let filesJson = filesJsonRaw;
-				if (filesJsonRaw.includes("\"source\":\"\"")) {
-					const entries = JSON.parse(filesJsonRaw);
-					for (const entry of entries) if (entry.source === "") entry.source = fileCache.get(entry.path)?.source ?? "";
-					filesJson = JSON.stringify(entries);
-				}
-				v2SentSources.clear();
-				for (const entry of JSON.parse(filesJson)) v2SentSources.set(entry.path, entry.source);
-				const emitterConfig = emitterConfigJson ? JSON.parse(emitterConfigJson) : {};
-				v2Engine = null;
-				const engine = new native.ExtractEngine({
-					runtimeImport: emitterConfig.runtime_import ?? void 0,
-					cssModuleId: emitterConfig.css_module_id ?? void 0,
-					systemPropsModuleId: emitterConfig.system_props_module_id ?? void 0,
-					themeJson: themeJson_,
-					variableMapJson: variableMapJson_,
-					contextualVarsJson: contextualVarsJson_ ?? void 0,
-					configJson: configJson_,
-					groupRegistryJson: groupRegistryJson_,
-					selectorAliasesJson: selectorAliasesJson_ ?? void 0,
-					globalStyleBlocksJson: globalStyleBlocksJson_ ?? void 0,
-					keyframesJson: keyframesJson_ ?? void 0,
-					packageResolutionJson: packageResolutionJson_ ?? void 0,
-					pathAliasesJson: pathAliasesJson_ ?? void 0,
-					devMode
-				});
-				v2Engine = engine;
-				return engine.analyze(filesJson);
+/**
+* Drop a deleted (or renamed-away) file from the dev file cache so its
+* last-known source stops riding along as a ghost entry on every later
+* re-analysis. Both key forms are tried: the plain rootDir-relative path, and
+* the `.tsx` suffix MDX sources carry after preprocessing. External package
+* entries are rootDir-relative too (with leading `..` segments) and prune the
+* same way. Returns whether an entry was actually removed.
+*/
+function pruneFileCache(cache, rootDir, absPath) {
+	const rel = (0, path.relative)(rootDir, (0, path.resolve)(absPath));
+	return cache.delete(rel) || cache.delete(rel + ".tsx");
+}
+/**
+* Per-plugin-instance state and the pipeline operations over it. Hook
+* bodies live in their own modules (build-start, virtual-modules,
+* transform, hmr) and receive this context — the plugin factory in
+* index.ts only wires Vite hooks to those functions.
+*
+* A class rather than closure variables so each hook module names exactly
+* the state it touches, and the engine store (DEF-1: per-instance, never
+* module-level) is explicit.
+*/
+var PluginContext = class {
+	options;
+	verbose;
+	/** Serialized staticCss forced-emission declarations (stable key order). */
+	staticCssJson;
+	isProd = false;
+	rootDir = "";
+	logger = null;
+	/** System-derived config (shared SystemConfig shape). */
+	system = emptySystemConfig();
+	lcssTargets = {};
+	pathAliasesJson = null;
+	extensionsSet;
+	storedManifest = null;
+	storedManifestJson = "";
+	globalCss = "";
+	resolvedComponentCss = "";
+	storedSheets = null;
+	layerDeclaration = "";
+	fragmentCache = /* @__PURE__ */ new Map();
+	reverseProvenance = {};
+	storedSystemPropMapJson = "{}";
+	storedDynamicPropsJson = "{}";
+	storedTransformsSource = "{}";
+	fileCache = /* @__PURE__ */ new Map();
+	hotUpdateEvents = new HotUpdateEvents();
+	packageMap = {};
+	externalPackageDirs = [];
+	externalSourceEntries = /* @__PURE__ */ new Map();
+	externalPackageOutcomes = [];
+	devServer;
+	bridgeInjected = false;
+	resolvedSystemPath = null;
+	systemDependencyKeys = /* @__PURE__ */ new Set();
+	systemDependencyPaths = [];
+	v2Engine = null;
+	v2SentSources = null;
+	v2DriftWarned = false;
+	/** Single engine choke-point for every native extraction call. */
+	engineApi;
+	constructor(options) {
+		this.options = options;
+		this.staticCssJson = (0, _animus_ui_extract_pipeline.serializeStaticCss)(options.staticCss);
+		this.verbose = options.verbose || process.env.ANIMUS_DEBUG === "1" || process.env.ANIMUS_DEBUG === "true";
+		this.extensionsSet = new Set(options.extensions ?? _animus_ui_extract_pipeline.DEFAULT_EXTENSIONS);
+		const engineModuleId = "@animus-ui/extract";
+		this.engineApi = (0, _animus_ui_extract_pipeline.createV2EngineApi)({
+			label: "animus-extract",
+			isV2: () => true,
+			loadNativeEngine: () => require(engineModuleId),
+			rehydrateFilesJson: (filesJsonRaw) => {
+				if (!filesJsonRaw.includes("\"source\":\"\"")) return filesJsonRaw;
+				const entries = JSON.parse(filesJsonRaw);
+				for (const entry of entries) if (entry.source === "") entry.source = this.fileCache.get(entry.path)?.source ?? "";
+				return JSON.stringify(entries);
 			},
-			transformFile: (source, path$2, _manifest) => {
-				if (!v2Engine) throw new Error("[animus-extract] v2 transform before analyze — engine state is per-instance");
-				const sent = v2SentSources.get(path$2);
-				if (sent !== void 0 && sent !== source && !v2DriftWarned) {
-					v2DriftWarned = true;
-					console.warn(`[animus-extract] v2: transform-time source for ${path$2} differs from analyze-time source — an upstream plugin transform may be reverted (engine v2 emits from analyzed sources)`);
+			store: {
+				getEngine: () => this.v2Engine,
+				setEngine: (engine) => {
+					this.v2Engine = engine;
+				},
+				getSentSources: () => this.v2SentSources,
+				setSentSources: (sources) => {
+					this.v2SentSources = sources;
+				},
+				getDriftWarned: () => this.v2DriftWarned,
+				setDriftWarned: (value) => {
+					this.v2DriftWarned = value;
 				}
-				return JSON.parse(v2Engine.transformFile(path$2));
-			},
-			clearAnalysisCache: () => {
-				if (v2Engine) v2Engine.clearCache();
-				v2Engine = null;
 			}
-		};
-	};
-	let themeJson = "{}";
-	let variableMapJson = "{}";
-	let contextualVarsJson = "{}";
-	let configJson = "{}";
-	let groupRegistryJson = "{}";
-	let selectorAliasesJson = null;
-	let isProd = false;
-	let rootDir = "";
-	const verbose = options.verbose || process.env.ANIMUS_DEBUG === "1" || process.env.ANIMUS_DEBUG === "true";
-	let logger = null;
-	function log(msg) {
-		if (verbose) (logger ?? console).info(`[animus] ${msg}`);
-	}
-	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}`);
-		}
+		});
+	}
+	log(msg) {
+		if (this.verbose) (this.logger ?? console).info(`[animus] ${msg}`);
+	}
+	warn(msg) {
+		(this.logger ?? console).warn(`[animus] ${msg}`);
+	}
+	logTimingWaterfall(timing) {
+		if (!this.verbose) return;
+		for (const line of (0, _animus_ui_extract_pipeline.formatRustTimingWaterfall)(timing, {
+			indent: "         ",
+			labelWidth: 15
+		})) this.log(line);
 	}
-	let lcssTargets = {};
-	let variableCss = "";
-	let globalCss = "";
-	let globalStyleBlocksJson = null;
-	let keyframesBlocksJson = null;
-	let pathAliasesJson = null;
-	let extensionsSet = new Set(options.extensions ?? _animus_ui_extract_pipeline.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 = "{}";
-	const fileCache = /* @__PURE__ */ new Map();
-	let packageMap = {};
-	let externalPackageDirs = [];
-	const externalSourceEntries = /* @__PURE__ */ new Map();
-	let devServer;
-	let bridgeInjected = false;
-	let resolvedSystemPath = null;
 	/**
-	* 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.
+	* Load a SystemInstance via Rust NAPI (rquickjs bundled eval) into
+	* `this.system`. On failure the previous config is kept (strict mode
+	* throws instead).
 	*/
-	function loadSystem() {
-		resolvedSystemPath = (0, path.resolve)(rootDir, options.system);
+	loadSystem() {
+		this.resolvedSystemPath = (0, path.resolve)(this.rootDir, this.options.system);
+		for (const key of (0, _animus_ui_extract_pipeline.toWatchKeys)(this.resolvedSystemPath)) this.systemDependencyKeys.add(key);
 		try {
-			const { loadSystemModule } = engineApi();
-			const config = loadSystemModule(resolvedSystemPath, rootDir);
-			configJson = config.propConfig;
-			groupRegistryJson = config.groupRegistry;
-			selectorAliasesJson = config.selectorAliases || null;
-			themeJson = config.scalesJson;
-			variableMapJson = config.variableMapJson;
-			variableCss = config.variableCss;
-			contextualVarsJson = config.contextualVarsJson;
-			globalStyleBlocksJson = config.globalStyleBlocks || null;
-			keyframesBlocksJson = config.keyframesBlocks || null;
+			this.system = (0, _animus_ui_extract_pipeline.loadSystemConfig)(this.engineApi, {
+				systemPath: this.resolvedSystemPath,
+				rootDir: this.rootDir,
+				prefix: this.options.prefix
+			});
+			const deps = this.system.dependencies ?? [];
+			const keys = /* @__PURE__ */ new Set();
+			for (const key of (0, _animus_ui_extract_pipeline.toWatchKeys)(this.resolvedSystemPath)) keys.add(key);
+			for (const dep of deps) for (const key of (0, _animus_ui_extract_pipeline.toWatchKeys)(dep)) keys.add(key);
+			this.systemDependencyKeys = keys;
+			this.systemDependencyPaths = deps;
+			this.registerSystemWatchPaths();
 		} catch (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);
+			if (this.options.strict) throw new Error(`[animus-extract] Failed to load system from ${this.resolvedSystemPath}: ${e}`, { cause: e });
+			console.warn(`[animus-extract] Failed to load system from ${this.resolvedSystemPath}:`, e);
 		}
 	}
 	/**
-	* Run project analysis and update the manifest.
-	*
-	* Pipeline: NAPI analyzeProject → unit fallback.
-	* Transforms are resolved in-process via boa_engine during Rust extraction.
-	* No subprocess needed.
+	* Run project analysis via the shared `runProjectAnalysis` and update
+	* all manifest-derived state.
 	*/
-	function runAnalysis(fileEntries) {
+	runAnalysis(fileEntries) {
 		try {
-			const { analyzeProject } = engineApi();
-			const emitterConfig = JSON.stringify({
-				runtime_import: "@animus-ui/system",
-				css_module_id: "virtual:animus/styles.css"
+			const result = (0, _animus_ui_extract_pipeline.runProjectAnalysis)(this.engineApi, {
+				fileEntries,
+				packageMap: this.packageMap,
+				system: this.system,
+				emitter: {
+					runtimeImport: "@animus-ui/system",
+					cssModuleId: VIRTUAL_CSS_ID
+				},
+				pathAliasesJson: this.pathAliasesJson,
+				staticCssJson: this.staticCssJson,
+				devMode: !this.isProd,
+				warn: (m) => this.warn(m)
 			});
-			const manifestJson = analyzeProject(...buildAnalyzeProjectArgs({
-				filesJson: JSON.stringify(fileEntries),
-				scalesJson: themeJson,
-				variableMapJson,
-				contextualVarsJson: contextualVarsJson || null,
-				propConfigJson: configJson,
-				groupRegistryJson,
-				packageResolutionJson: JSON.stringify(packageMap),
-				devMode: !isProd,
-				emitterConfigJson: emitterConfig,
-				selectorAliasesJson,
-				globalStyleBlocksJson,
-				pathAliasesJson,
-				keyframesJson: keyframesBlocksJson
-			}));
-			storedManifest = JSON.parse(manifestJson);
-			storedManifestJson = manifestJson;
-			surfaceManifestDiagnostics(storedManifest, warn);
-			storedSystemPropMapJson = JSON.stringify(storedManifest?.system_prop_map ?? {});
-			const dynamicProps = storedManifest?.dynamic_props ?? {};
-			const newDynamicPropsJson = JSON.stringify(dynamicProps);
-			if (newDynamicPropsJson !== storedDynamicPropsJson) {
-				storedDynamicPropsJson = newDynamicPropsJson;
-				const usedTransformNames = /* @__PURE__ */ new Set();
-				for (const meta of Object.values(dynamicProps)) if (meta.transform_name) usedTransformNames.add(meta.transform_name);
-				if (storedManifest?.components) {
-					for (const comp of Object.values(storedManifest.components)) if (comp.replacement) {
-						const matches = comp.replacement.matchAll(/transforms\.(\w+)/g);
-						for (const match of matches) usedTransformNames.add(match[1]);
-					}
-				}
-				storedTransformsSource = "{}";
-			}
-			bridgeInjected = false;
-			const newFragments = storedManifest?.component_fragments;
+			this.storedManifest = result.manifest;
+			this.storedManifestJson = result.manifestJson;
+			this.storedSystemPropMapJson = JSON.stringify(result.manifest?.system_prop_map ?? {});
+			this.storedDynamicPropsJson = JSON.stringify(result.manifest?.dynamic_props ?? {});
+			this.bridgeInjected = false;
+			const newFragments = result.manifest?.component_fragments;
 			if (newFragments && typeof newFragments === "object") {
-				fragmentCache.clear();
-				for (const [id, sheets] of Object.entries(newFragments)) fragmentCache.set(id, sheets);
+				this.fragmentCache.clear();
+				for (const [id, sheets] of Object.entries(newFragments)) this.fragmentCache.set(id, sheets);
 			}
-			reverseProvenance = storedManifest?.reverse_provenance ?? {};
-			storedSheets = storedManifest?.sheets ?? null;
-			globalCss = storedManifest?.sheets?.global || "";
-			resolvedComponentCss = storedManifest?.css || "";
-			resolvedComponentCss = (0, _animus_ui_extract_pipeline.applyUnitFallback)(resolvedComponentCss);
+			this.reverseProvenance = result.manifest?.reverse_provenance ?? {};
+			this.storedSheets = result.manifest?.sheets ?? null;
+			this.globalCss = result.globalCss;
+			this.resolvedComponentCss = result.componentCss;
 		} catch (e) {
-			if (options.strict) throw new Error(`[animus-extract] analyzeProject failed: ${e}`, { cause: e });
+			if (this.options.strict) throw new Error(`[animus-extract] analyzeProject failed: ${e}`, { cause: e });
 			console.warn("[animus-extract] analyzeProject failed:", e);
 		}
 	}
-	function runSelfVerify() {
+	resetCoalescer = null;
+	/**
+	* Schedule a geological reset through the burst coalescer. N dependency
+	* events within the quiescence window produce one reset; events during a
+	* running reset produce exactly one follow-up.
+	*/
+	requestGeologicalReset(trigger) {
+		this.log(`HMR geological reset scheduled: ${trigger}`);
+		this.resetCoalescer ??= new ResetCoalescer(() => this.performGeologicalReset());
+		this.resetCoalescer.request();
+	}
+	/**
+	* The geological reset: reload the system (refreshing the dependency
+	* set), clear the Rust per-file cache, re-analyze everything with full
+	* sources, then invalidate the static/component/system-prop virtual
+	* modules and reload the client.
+	*/
+	performGeologicalReset() {
+		const resetStart = performance.now();
+		this.loadSystem();
+		(0, _animus_ui_extract_pipeline.clearEngineCache)(this.engineApi);
+		const fileEntries = [];
+		for (const [path$2, { hash, source }] of this.fileCache) fileEntries.push({
+			path: path$2,
+			source,
+			hash
+		});
+		this.runAnalysis(fileEntries);
+		this.log(`HMR geological reset complete: ${Math.round(performance.now() - resetStart)}ms`);
+		const server = this.devServer;
+		if (!server) return;
+		for (const moduleId of [
+			RESOLVED_CSS_ID,
+			RESOLVED_COMPONENTS_ID,
+			RESOLVED_SYSTEM_PROPS_ID
+		]) {
+			const mod = server.moduleGraph.getModuleById(moduleId);
+			if (mod) server.moduleGraph.invalidateModule(mod);
+		}
+		server.hot?.send({ type: "full-reload" });
+	}
+	/**
+	* True when the file is a member of the system's evaluated module-file
+	* set. Tested BEFORE component-scan exclude filters: a system dependency
+	* edit invalidates the compiler registry regardless of what the user
+	* excluded from component scanning.
+	*/
+	isSystemDependency(absFile) {
+		return (0, _animus_ui_extract_pipeline.toWatchKeys)(absFile).some((key) => this.systemDependencyKeys.has(key));
+	}
+	/**
+	* Ask the dev watcher to watch every loader-reported dependency path.
+	* Covers system modules unreachable from app imports (workspace package
+	* config files). Vite's watcher hard-ignores `node_modules`, so
+	* node_modules-installed system dependencies produce no events — a
+	* documented limitation; workspace deps resolve to real paths outside
+	* node_modules and are watchable. No-ops without a dev server.
+	*/
+	registerSystemWatchPaths() {
+		const watcher = this.devServer?.watcher;
+		if (!watcher) return;
+		if (this.systemDependencyPaths.length > 0) watcher.add(this.systemDependencyPaths);
+		if (this.externalPackageDirs.length > 0) watcher.add(this.externalPackageDirs);
+	}
+	/**
+	* Invalidate the component CSS and system-props virtual modules, then
+	* reload the client. Shared by the two out-of-band re-analysis paths — a
+	* file created after buildStart (transform) and a file deleted during dev
+	* (the `hotUpdate` delete event) — which both mutate the cache, re-run
+	* analysis, and then need the client to pick up the regenerated CSS.
+	* No-ops outside dev.
+	*
+	* `devServer.moduleGraph` is Vite's back-compat mixed graph: its
+	* `getModuleById` searches the client AND ssr environment graphs and its
+	* `invalidateModule` invalidates both instances behind the returned node,
+	* which is exactly the reach this path wants. It stays the seam here.
+	*/
+	invalidateExtractedModules() {
+		const server = this.devServer;
+		if (!server) return;
+		for (const moduleId of [RESOLVED_COMPONENTS_ID, RESOLVED_SYSTEM_PROPS_ID]) {
+			const mod = server.moduleGraph.getModuleById(moduleId);
+			if (mod) server.moduleGraph.invalidateModule(mod);
+		}
+		setTimeout(() => {
+			this.devServer?.hot?.send({ type: "full-reload" });
+		}, 100);
+	}
+	/**
+	* The buildStart gate over include resolution
+	* (external-package-file-discovery: silence is never an outcome). An
+	* unresolvable `.includes()` specifier warns in non-strict mode and FAILS
+	* the build under `strict: true`, naming every offending specifier —
+	* a typo'd include must not ship a build missing its component CSS.
+	*/
+	enforceIncludeResolution() {
+		const message = (0, _animus_ui_extract_pipeline.unresolvableIncludesMessage)(this.externalPackageOutcomes);
+		if (message === null) return;
+		if (this.options.strict) throw new Error(message);
+		this.warn(message);
+	}
+	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) {
+		if (Object.keys(this.storedManifest?.components ?? {}).length === 0) failures.push("No component CSS produced — check the system file and its includes list");
+		for (const { specifier, outcome } of this.externalPackageOutcomes) 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 (!this.system.variableCss.includes(":root")) failures.push("No :root variable block found in variable CSS");
+		if (`${this.system.variableCss}\n${this.globalCss}\n${this.resolvedComponentCss}`.includes("__TRANSFORM__")) failures.push("Unresolved __TRANSFORM__ placeholders found in CSS output");
+		if (this.storedManifest && this.resolvedComponentCss.length > 0) {
 			const assembled = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
-				layers: options.layers,
-				variableCss,
-				globalCss,
-				componentCss: resolvedComponentCss
+				layers: this.options.layers,
+				variableCss: this.system.variableCss,
+				globalCss: this.globalCss,
+				componentCss: this.resolvedComponentCss
 			});
 			const baseIdx = assembled.search(/@layer\s+anm-base\s*\{/);
 			const variantsIdx = assembled.search(/@layer\s+anm-variants\s*\{/);
@@ -372,265 +613,323 @@ function animusExtract(options) {
 		}
 		for (const message of failures) {
 			const line = `[animus:verify] ${message}`;
-			if (options.strict) throw new Error(line);
-			if (logger) logger.warn(line, { timestamp: true });
+			if (this.options.strict) throw new Error(line);
+			if (this.logger) this.logger.warn(line, { timestamp: true });
 			else console.warn(line);
 		}
-		if (failures.length === 0) log("[animus:verify] structural self-check passed");
+		if (failures.length === 0) this.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 } = engineApi();
-				clearAnalysisCache();
-			} catch {}
-			let t0 = performance.now();
-			loadSystem();
-			if (options.layers) {
-				(0, _animus_ui_extract_pipeline.validateLayerOrder)(options.layers);
-				log(`Custom layers: [${options.layers.join(", ")}]`);
-			}
-			if (verbose) {
-				const propCount = Object.keys(JSON.parse(configJson)).length;
-				const groupCount = Object.keys(JSON.parse(groupRegistryJson)).length;
-				log(`System loaded: ${propCount} props, ${groupCount} groups (${Math.round(performance.now() - t0)}ms)`);
-			}
-			t0 = performance.now();
-			const excludePatterns = options.exclude ?? DEFAULT_EXCLUDE;
-			extensionsSet = new Set(options.extensions ?? _animus_ui_extract_pipeline.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 {
-				let source = (0, fs.readFileSync)(filePath, "utf-8");
-				let relPath = (0, path.relative)(rootDir, filePath);
-				if (shouldHandleMdx && (0, path.extname)(filePath) === ".mdx") {
-					const result = await (0, _animus_ui_extract_pipeline.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,
-					source,
-					hash
-				});
-				if (!isProd && hash) fileCache.set(relPath, {
-					hash,
-					source
-				});
-			} catch {}
-			const localFileCount = fileEntries.length;
-			const packageSpecifiers = (0, _animus_ui_extract_pipeline.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;
-					let pkgRoot = (0, path.dirname)(absPath);
-					while (pkgRoot !== (0, path.dirname)(pkgRoot) && !(0, fs.existsSync)((0, path.join)(pkgRoot, "package.json"))) pkgRoot = (0, path.dirname)(pkgRoot);
-					const srcDir = (0, path.join)(pkgRoot, "src");
-					if ((0, fs.existsSync)(srcDir)) {
-						collectedPkgDirs.push(srcDir);
-						const pkgFiles = discoverFiles(srcDir, rootDir, excludePatterns, extensionsSet);
-						for (const pkgFile of pkgFiles) {
-							let pkgRelPath = (0, path.relative)(rootDir, pkgFile);
-							if (!fileEntries.some((e) => e.path === pkgRelPath)) {
-								let pkgSource = (0, fs.readFileSync)(pkgFile, "utf-8");
-								if (shouldHandleMdx && (0, path.extname)(pkgFile) === ".mdx") {
-									const result = await (0, _animus_ui_extract_pipeline.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 = (0, path.join)(srcDir, "index.ts");
-						if ((0, fs.existsSync)(srcEntry)) {
-							packageMap[specifier] = (0, path.relative)(rootDir, srcEntry);
-							externalSourceEntries.set(specifier, srcEntry);
-						} else packageMap[specifier] = (0, path.relative)(rootDir, absPath);
-					} else {
-						const relPath = (0, path.relative)(rootDir, absPath);
-						if (!fileEntries.some((e) => e.path === relPath)) {
-							const entrySource = (0, fs.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
-							});
-						}
-						collectedPkgDirs.push((0, path.dirname)(absPath));
-						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();
-			runAnalysis(fileEntries);
-			if (storedManifest) {
-				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}`);
-				}
-				log(`CSS: ${resolvedComponentCss.length} bytes (${Object.keys(storedManifest.components || {}).length} components)`);
-				if (!isProd && storedSheets) {
-					const staticSize = (0, _animus_ui_extract_pipeline.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)");
+};
+//#endregion
+//#region src/hmr.ts
+/**
+* hotUpdate: the single dev file-event hook. Handles system-dependency
+* membership (geological reset), content-hash diffing with incremental
+* re-analysis, deleted-file cache pruning, and targeted module invalidation
+* (component CSS, system props, and definition files whose replacement
+* changed).
+*
+* Vite 8 dispatches this hook once per environment for ONE file event — the
+* client environment first, then every non-client environment (see
+* `handleHMRUpdate` in vite/dist/node/chunks/node.js). The analysis half is
+* therefore claimed by exactly one dispatch (`ctx.hotUpdateEvents`), while the
+* invalidation half runs in every environment against its own module graph —
+* what the mixed-graph `handleHotUpdate` used to achieve implicitly by
+* invalidating the client and SSR instance behind one module node.
+*
+* The hook fires for every watched file whether or not it has modules in any
+* graph, so system dependencies registered through `watcher.add` outside the
+* root still reach the reset branch, with an empty `modules` list.
+*/
+async function handleHotUpdate(ctx, environment, { type, file, timestamp, modules }) {
+	if (ctx.isProd) return;
+	const ownsEvent = ctx.hotUpdateEvents.claim(environment.name, file, timestamp);
+	const absFile = (0, path.resolve)(file);
+	ctx.log(`hotUpdate ${type} ${(0, path.relative)(ctx.rootDir, absFile)} env=${environment.name} owns=${ownsEvent}`);
+	if (ctx.isSystemDependency(absFile)) {
+		if (ownsEvent) ctx.requestGeologicalReset((0, path.relative)(ctx.rootDir, absFile));
+		return [];
+	}
+	if (type === "create") return;
+	if (type === "delete") {
+		if (ownsEvent) pruneDeletedFile(ctx, absFile);
+		return;
+	}
+	if (ownsEvent) ctx.hotUpdateEvents.record(file, timestamp, await analyzeChangedFile(ctx, file, absFile));
+	const result = ctx.hotUpdateEvents.resultOf(file, timestamp);
+	if (result.kind === "ignored") return;
+	if (result.kind === "unchanged") return [];
+	return invalidateStaleModules(ctx, environment, modules, result.staleDefinitionFiles);
+}
+/**
+* The once-per-event analysis half: gate the file, diff its content hash,
+* refresh the cache, and re-run project analysis. The returned result is what
+* the remaining environments act on.
+*/
+async function analyzeChangedFile(ctx, file, absFile) {
+	const ext = (0, path.extname)(file);
+	if (!ctx.extensionsSet.has(ext)) return { kind: "ignored" };
+	const excludePatterns = ctx.options.exclude ?? DEFAULT_EXCLUDE;
+	if (!ctx.externalPackageDirs.some((dir) => file.startsWith(dir + path.sep) || file === dir) && excludePatterns.some((pattern) => file.includes(pattern) || (0, path.relative)(ctx.rootDir, file).includes(pattern))) return { kind: "ignored" };
+	const relPath = (0, path.relative)(ctx.rootDir, absFile);
+	let source;
+	try {
+		source = (0, fs.readFileSync)(absFile, "utf-8");
+	} catch {
+		return { kind: "ignored" };
+	}
+	let scannerRelPath = relPath;
+	if (ext === ".mdx") {
+		const result = await (0, _animus_ui_extract_pipeline.preprocessMdx)(source, relPath);
+		if (result.kind === "missing-dep") {
+			ctx.warn("⚠ .mdx HMR skipped: @mdx-js/mdx not installed; restart dev server after installing");
+			return { kind: "ignored" };
+		}
+		if (result.kind === "error") {
+			ctx.warn(`⚠ MDX preprocessing failed for ${relPath}: ${result.error}`);
+			return { kind: "ignored" };
+		}
+		source = result.source;
+		scannerRelPath = relPath + ".tsx";
+	}
+	const hash = (0, _animus_ui_extract_pipeline.contentHash)(source);
+	const cached = ctx.fileCache.get(scannerRelPath);
+	if (cached && cached.hash === hash) {
+		ctx.log(`HMR skip: ${scannerRelPath} (unchanged)`);
+		return { kind: "unchanged" };
+	}
+	ctx.fileCache.set(scannerRelPath, {
+		hash,
+		source
+	});
+	const hmrStart = performance.now();
+	const prevReplacements = /* @__PURE__ */ new Map();
+	if (ctx.storedManifest?.components) for (const [id, desc] of Object.entries(ctx.storedManifest.components)) prevReplacements.set(id, desc.replacement ?? "");
+	const directComponentIds = ctx.storedManifest?.files?.[scannerRelPath] ?? [];
+	const invalidatedIds = new Set(directComponentIds);
+	const queue = [...directComponentIds];
+	while (queue.length > 0) {
+		const parentId = queue.shift();
+		const children = ctx.reverseProvenance[parentId];
+		if (children) {
+			for (const childId of children) if (!invalidatedIds.has(childId)) {
+				invalidatedIds.add(childId);
+				queue.push(childId);
 			}
-			const { declaration } = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
-				layers: options.layers,
-				variableCss: "",
-				globalCss: "",
+		}
+	}
+	if (ctx.verbose && invalidatedIds.size > directComponentIds.length) ctx.log(`HMR: ${directComponentIds.length} direct + ${invalidatedIds.size - directComponentIds.length} transitive components invalidated`);
+	const analysisStart = performance.now();
+	const fileEntries = buildFileEntriesFromCache(ctx.fileCache, relPath);
+	ctx.runAnalysis(fileEntries);
+	const analysisMs = Math.round(performance.now() - analysisStart);
+	const staleDefinitionFiles = [];
+	if (ctx.storedManifest?.components) {
+		const staleFiles = /* @__PURE__ */ new Set();
+		for (const [id, desc] of Object.entries(ctx.storedManifest.components)) if ((desc.replacement ?? "") !== (prevReplacements.get(id) ?? "")) staleFiles.add(desc.file);
+		for (const defFile of staleFiles) {
+			if ((0, path.resolve)(ctx.rootDir, defFile) === absFile) continue;
+			staleDefinitionFiles.push(defFile);
+		}
+	}
+	const hmrMs = Math.round(performance.now() - hmrStart);
+	ctx.log(`HMR update: ${relPath} — analysis ${analysisMs}ms, total ${hmrMs}ms`);
+	ctx.logTimingWaterfall(ctx.storedManifest?.timing ?? {});
+	return {
+		kind: "analyzed",
+		staleDefinitionFiles
+	};
+}
+/**
+* Reconcile a deleted file in dev.
+*
+* Without this the removed file's last-known source stays in `ctx.fileCache`,
+* and `buildFileEntriesFromCache` re-feeds that ghost entry to the engine on
+* every later re-analysis — the deleted component's CSS survives for the life
+* of the process.
+*/
+function pruneDeletedFile(ctx, absFile) {
+	if (!pruneFileCache(ctx.fileCache, ctx.rootDir, absFile)) return;
+	ctx.runAnalysis(buildFileEntriesFromCache(ctx.fileCache));
+	ctx.log(`Deleted file pruned: ${(0, path.relative)(ctx.rootDir, absFile)}`);
+	ctx.invalidateExtractedModules();
+}
+/**
+* The per-environment invalidation half: invalidate the modules this
+* environment serves and widen its update set with them. Static CSS
+* (virtual:animus/styles.css) is NOT invalidated here — it only changes on a
+* geological reset (vars/globals are stable during dev).
+*/
+function invalidateStaleModules(ctx, environment, modules, staleDefinitionFiles) {
+	const graph = environment.moduleGraph;
+	const modulesToUpdate = [...modules];
+	for (const moduleId of [RESOLVED_COMPONENTS_ID, RESOLVED_SYSTEM_PROPS_ID]) {
+		const mod = graph.getModuleById(moduleId);
+		if (mod) {
+			graph.invalidateModule(mod);
+			modulesToUpdate.push(mod);
+		}
+	}
+	for (const defFile of staleDefinitionFiles) {
+		const absDefPath = (0, path.resolve)(ctx.rootDir, defFile);
+		const defModule = graph.getModuleById(absDefPath) ?? graph.getModulesByFile(absDefPath)?.values().next().value;
+		if (defModule) {
+			ctx.log(`HMR invalidate: ${defFile} (replacement changed)`);
+			graph.invalidateModule(defModule);
+			modulesToUpdate.push(defModule);
+		}
+	}
+	const invalidated = modulesToUpdate.length - modules.length;
+	if (invalidated > 0) {
+		ctx.log(`HMR (${environment.name}): ${invalidated} modules invalidated`);
+		return modulesToUpdate;
+	}
+}
+//#endregion
+//#region src/index-html.ts
+/**
+* transformIndexHtml: build the head-prepend tag set.
+*
+* Two independent tags, both delivery-only:
+* - the appearance bootstrap script, when the host build passed a
+*   pre-generated artifact via `appearanceBootstrap` (absent otherwise);
+* - the `@layer` declaration style, when `buildStart` computed one.
+*
+* Both branches are guarded on non-empty CONTENT, not on mere presence: an
+* artifact whose `code` is empty is a caller defect, and emitting
+* `<script data-animus-bootstrap><\/script>` for it would break the
+* unconfigured-parity contract in spirit (a tag that does nothing) while
+* hiding the defect. Symmetric with `layerDeclaration`.
+*
+* Ordering: every descriptor rides the same `head-prepend` bucket, which Vite
+* serializes in array order (`serializeTags`) and splices in immediately after
+* `<head>`. The bootstrap script is therefore FIRST in the array so it runs
+* before the layer declaration and — since built stylesheet links are appended
+* at `</head>` — before any stylesheet reference.
+*
+* When neither input is set the array is empty, so an unconfigured build emits
+* no tag, attribute, or whitespace of its own.
+*/
+function buildIndexHtmlTags(ctx) {
+	const tags = [];
+	const bootstrap = ctx.options.appearanceBootstrap;
+	if (bootstrap?.code) tags.push({
+		tag: "script",
+		attrs: { "data-animus-bootstrap": "" },
+		children: bootstrap.code,
+		injectTo: "head-prepend"
+	});
+	if (ctx.layerDeclaration) tags.push({
+		tag: "style",
+		attrs: { "data-animus-layers": "" },
+		children: ctx.layerDeclaration,
+		injectTo: "head-prepend"
+	});
+	return tags;
+}
+//#endregion
+//#region src/transform.ts
+/**
+* transform: replace builder chains with `createComponent()` calls using
+* the pre-built manifest; inject the HMR bridge import once in dev; detect
+* files created after buildStart and fold them into the analysis.
+*/
+function transformSource(ctx, code, id) {
+	if (!ctx.storedManifest) return null;
+	if (!ctx.externalPackageDirs.some((dir) => id.startsWith(dir + path.sep) || id === dir)) {
+		if (!/\.[jt]sx?$/.test(id)) return null;
+		if (id.includes("node_modules")) return null;
+	}
+	const relativePath = (0, path.relative)(ctx.rootDir, id);
+	if (!ctx.storedManifest.files?.[relativePath]?.length) {
+		if (!ctx.isProd && !ctx.fileCache.has(relativePath)) {
+			const hash = (0, _animus_ui_extract_pipeline.contentHash)(code);
+			ctx.fileCache.set(relativePath, {
+				hash,
+				source: code
+			});
+			const fileEntries = buildFileEntriesFromCache(ctx.fileCache, relativePath);
+			ctx.runAnalysis(fileEntries);
+			const compCount = ctx.storedManifest.files?.[relativePath]?.length ?? 0;
+			ctx.log(`New file detected: ${relativePath} — ${compCount ? `${compCount} components extracted` : "no components"}`);
+			if (compCount) ctx.invalidateExtractedModules();
+		}
+		if (!ctx.storedManifest.files?.[relativePath]?.length) return null;
+	}
+	try {
+		const { transformFile } = ctx.engineApi();
+		const result = transformFile(code, relativePath, ctx.storedManifestJson);
+		if (!result.hasComponents) return null;
+		let transformedCode = result.code;
+		if (!ctx.isProd && !ctx.bridgeInjected && ctx.storedSheets) {
+			transformedCode = `import '${VIRTUAL_BRIDGE_ID}';\n${transformedCode}`;
+			ctx.bridgeInjected = true;
+			ctx.log("HMR bridge injected via transform");
+		}
+		if (ctx.verbose) {
+			const compCount = ctx.storedManifest.files?.[relativePath]?.length ?? 0;
+			ctx.log(`transform ${relativePath}: ${compCount} components`);
+		}
+		return {
+			code: transformedCode,
+			map: null
+		};
+	} catch (e) {
+		if (ctx.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;
+	}
+}
+//#endregion
+//#region src/virtual-modules.ts
+/** resolveId: map virtual ids and redirect external DS package imports. */
+function resolveVirtualId(ctx, id) {
+	if (id === "virtual:animus/styles.css") return RESOLVED_CSS_ID;
+	if (id === "virtual:animus/components.js") return RESOLVED_COMPONENTS_ID;
+	if (id === "virtual:animus/hmr-bridge.js") return RESOLVED_BRIDGE_ID;
+	if (id === "virtual:animus/system-props") return RESOLVED_SYSTEM_PROPS_ID;
+	const srcEntry = ctx.externalSourceEntries.get(id);
+	if (srcEntry) return srcEntry;
+	return null;
+}
+/** load: serve the virtual stylesheet, components CSS, HMR bridge, and
+*  system-props modules from manifest-derived state. */
+function loadVirtualModule(ctx, id) {
+	const lcssOpts = {
+		minify: ctx.options.minify ?? ctx.isProd,
+		targets: ctx.lcssTargets,
+		warnFn: (msg) => ctx.warn(msg)
+	};
+	if (id === "\0virtual:animus/styles.css") {
+		if (!ctx.isProd && ctx.storedSheets) {
+			const { variables, body } = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
+				layers: ctx.options.layers,
+				variableCss: ctx.system.variableCss,
+				globalCss: ctx.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) {
-					const { variables, body } = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
-						layers: options.layers,
-						variableCss,
-						globalCss,
-						split: true
-					});
-					return [variables, postProcessCss(body, {
-						...lcssOpts,
-						minify: false
-					})].filter(Boolean).join("\n");
-				}
-				const { variables, body } = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
-					layers: options.layers,
-					variableCss,
-					globalCss,
-					componentCss: resolvedComponentCss,
-					split: true
-				});
-				return [variables, postProcessCss(body, lcssOpts)].filter(Boolean).join("\n");
-			}
-			if (id === RESOLVED_COMPONENTS_ID) return `export default \`${postProcessCss((0, _animus_ui_extract_pipeline.stripLeadingLayerDeclaration)(resolvedComponentCss || ""), {
+			return [variables, (0, _animus_ui_extract_pipeline.postProcessCss)(body, {
 				...lcssOpts,
 				minify: false
-			}).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;`;
-			if (id === RESOLVED_BRIDGE_ID) return `
+			})].filter(Boolean).join("\n");
+		}
+		const { variables, body } = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
+			layers: ctx.options.layers,
+			variableCss: ctx.system.variableCss,
+			globalCss: ctx.globalCss,
+			componentCss: ctx.resolvedComponentCss,
+			split: true
+		});
+		return [variables, (0, _animus_ui_extract_pipeline.postProcessCss)(body, lcssOpts)].filter(Boolean).join("\n");
+	}
+	if (id === "\0virtual:animus/components.js") return `export default \`${(0, _animus_ui_extract_pipeline.postProcessCss)((0, _animus_ui_extract_pipeline.stripLeadingLayerDeclaration)(ctx.resolvedComponentCss || ""), {
+		...lcssOpts,
+		minify: false
+	}).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;`;
+	if (id === "\0virtual:animus/hmr-bridge.js") return `
 import css from '${VIRTUAL_COMPONENTS_ID}';
 
-const GLOBAL_KEY = '__animus_sheet_${(0, crypto.createHash)("md5").update(options.system).digest("hex").slice(0, 8)}__';
+const GLOBAL_KEY = '__animus_sheet_${(0, crypto.createHash)("md5").update(ctx.options.system).digest("hex").slice(0, 8)}__';
 let sheet = globalThis[GLOBAL_KEY] || null;
 
 if (typeof CSSStyleSheet !== 'undefined' && 'adoptedStyleSheets' in document) {
@@ -662,211 +961,65 @@ if (import.meta.hot) {
   });
 }
 `;
-			if (id === RESOLVED_SYSTEM_PROPS_ID) {
-				let moduleSource = `export const systemPropMap = ${storedSystemPropMapJson};\nexport const systemPropGroups = ${groupRegistryJson};`;
-				if (storedDynamicPropsJson !== "{}") {
-					const dynamicProps = JSON.parse(storedDynamicPropsJson);
-					const configEntries = {};
-					for (const [propName, meta] of Object.entries(dynamicProps)) configEntries[propName] = {
-						varName: meta.var_name,
-						slotClass: meta.slot_class,
-						...meta.transform_name ? { transformName: meta.transform_name } : {},
-						...meta.scale_values && Object.keys(meta.scale_values).length > 0 ? { scaleValues: meta.scale_values } : {}
-					};
-					moduleSource += `\nexport const dynamicPropConfig = ${JSON.stringify(configEntries)};`;
-				} else moduleSource += `\nexport const dynamicPropConfig = {};`;
-				moduleSource += `\nexport const transforms = ${storedTransformsSource};`;
-				return moduleSource;
-			}
-			return null;
+	if (id === "\0virtual:animus/system-props") return (0, _animus_ui_extract_pipeline.buildSystemPropsModule)({
+		systemPropMapJson: ctx.storedSystemPropMapJson,
+		groupRegistryJson: ctx.system.groupRegistryJson,
+		dynamicProps: JSON.parse(ctx.storedDynamicPropsJson),
+		transformsSource: ctx.storedTransformsSource
+	});
+	return null;
+}
+//#endregion
+//#region src/index.ts
+/**
+* Vite adapter for the extraction pipeline. State and pipeline operations
+* live in PluginContext; hook bodies live in their own modules — this
+* factory only validates options and wires Vite hooks to those functions.
+*/
+function animusExtract(options) {
+	(0, _animus_ui_extract_pipeline.assertNoRetiredEngineSelection)(options.engine);
+	const ctx = new PluginContext(options);
+	return {
+		name: "animus-extract",
+		enforce: "pre",
+		configureServer(server) {
+			ctx.devServer = server;
+			ctx.registerSystemWatchPaths();
+		},
+		configResolved(config) {
+			applyResolvedConfig(ctx, config);
+		},
+		async buildStart() {
+			await runBuildStart(ctx, async (specifier) => {
+				return (await this.resolve(specifier))?.id ?? null;
+			});
+		},
+		resolveId(id) {
+			return resolveVirtualId(ctx, id);
+		},
+		load(id) {
+			return loadVirtualModule(ctx, id);
 		},
 		transform(code, id) {
-			if (!storedManifest) 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 = (0, path.relative)(rootDir, id);
-			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 } = engineApi();
-				const result = transformFile(code, relativePath, storedManifestJson);
-				if (!result.hasComponents) return null;
-				let transformedCode = result.code;
-				if (!isProd && !bridgeInjected && storedSheets) {
-					transformedCode = `import '${VIRTUAL_BRIDGE_ID}';\n${transformedCode}`;
-					bridgeInjected = true;
-					log("HMR bridge injected via transform");
-				}
-				if (verbose) log(`transform ${relativePath}: ${storedManifest.files?.[relativePath]?.length ?? 0} components`);
-				return {
-					code: transformedCode,
-					map: null
-				};
-			} catch (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;
-			}
+			return transformSource(ctx, code, id);
 		},
 		transformIndexHtml: {
 			order: "pre",
 			handler() {
-				if (!layerDeclaration) return [];
-				return [{
-					tag: "style",
-					attrs: { "data-animus-layers": "" },
-					children: layerDeclaration,
-					injectTo: "head-prepend"
-				}];
+				return buildIndexHtmlTags(ctx);
 			}
 		},
-		async handleHotUpdate({ file, server: hmrServer, modules }) {
-			if (isProd) return;
-			const ext = (0, path.extname)(file);
-			if (!extensionsSet.has(ext)) return;
-			const excludePatterns = options.exclude ?? DEFAULT_EXCLUDE;
-			if (!externalPackageDirs.some((dir) => file.startsWith(dir)) && excludePatterns.some((pattern) => file.includes(pattern) || (0, path.relative)(rootDir, file).includes(pattern))) return;
-			const absFile = (0, path.resolve)(file);
-			const relPath = (0, path.relative)(rootDir, absFile);
-			if (resolvedSystemPath && absFile === (0, path.resolve)(resolvedSystemPath)) {
-				const resetStart = performance.now();
-				log(`HMR geological reset: ${relPath}`);
-				loadSystem();
-				try {
-					const { clearAnalysisCache } = engineApi();
-					clearAnalysisCache();
-				} catch {}
-				const fileEntries = [];
-				for (const [path$3, { hash, source }] of fileCache) fileEntries.push({
-					path: path$3,
-					source,
-					hash
-				});
-				runAnalysis(fileEntries);
-				log(`HMR geological reset complete: ${Math.round(performance.now() - resetStart)}ms`);
-				const geologicalModules = [...modules];
-				const cssModule = hmrServer.moduleGraph.getModuleById(RESOLVED_CSS_ID);
-				if (cssModule) {
-					hmrServer.moduleGraph.invalidateModule(cssModule);
-					geologicalModules.push(cssModule);
-				}
-				const compModule = hmrServer.moduleGraph.getModuleById(RESOLVED_COMPONENTS_ID);
-				if (compModule) {
-					hmrServer.moduleGraph.invalidateModule(compModule);
-					geologicalModules.push(compModule);
-				}
-				const sysPropModule = hmrServer.moduleGraph.getModuleById(RESOLVED_SYSTEM_PROPS_ID);
-				if (sysPropModule) {
-					hmrServer.moduleGraph.invalidateModule(sysPropModule);
-					geologicalModules.push(sysPropModule);
-				}
-				return geologicalModules;
-			}
-			let source;
-			try {
-				source = (0, fs.readFileSync)(absFile, "utf-8");
-			} catch {
-				return;
-			}
-			let scannerRelPath = relPath;
-			if (ext === ".mdx") {
-				const result = await (0, _animus_ui_extract_pipeline.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(scannerRelPath);
-			if (cached && cached.hash === hash) {
-				log(`HMR skip: ${scannerRelPath} (unchanged)`);
-				return [];
-			}
-			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);
-			const modulesToUpdate = [...modules];
-			const compModule = hmrServer.moduleGraph.getModuleById(RESOLVED_COMPONENTS_ID);
-			if (compModule) {
-				hmrServer.moduleGraph.invalidateModule(compModule);
-				modulesToUpdate.push(compModule);
-			}
-			const sysPropModule = hmrServer.moduleGraph.getModuleById(RESOLVED_SYSTEM_PROPS_ID);
-			if (sysPropModule) {
-				hmrServer.moduleGraph.invalidateModule(sysPropModule);
-				modulesToUpdate.push(sysPropModule);
-			}
-			if (storedManifest?.components) {
-				const staleFiles = /* @__PURE__ */ new Set();
-				for (const [id, desc] of Object.entries(storedManifest.components)) if ((desc.replacement ?? "") !== (prevReplacements.get(id) ?? "")) staleFiles.add(desc.file);
-				for (const defFile of staleFiles) {
-					const absDefPath = (0, path.resolve)(rootDir, defFile);
-					if (absDefPath === absFile) continue;
-					const defModule = hmrServer.moduleGraph.getModuleById(absDefPath) ?? hmrServer.moduleGraph.getModulesByFile(absDefPath)?.values().next().value;
-					if (defModule) {
-						log(`HMR invalidate: ${defFile} (replacement changed)`);
-						hmrServer.moduleGraph.invalidateModule(defModule);
-						modulesToUpdate.push(defModule);
-					}
-				}
-			}
-			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;
+		async hotUpdate(hmr) {
+			return handleHotUpdate(ctx, this.environment, hmr);
 		}
 	};
 }
 //#endregion
 exports.animusExtract = animusExtract;
 exports.default = animusExtract;
-exports.discoverFiles = discoverFiles;
+Object.defineProperty(exports, "discoverFiles", {
+	enumerable: true,
+	get: function() {
+		return _animus_ui_extract_pipeline.discoverFiles;
+	}
+});