@animus-ui/vite-plugin 0.1.0-next.v7 → 0.1.1-beta.2

package/dist/index.cjs

@@ -0,0 +1,872 @@
+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
+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",
+	"dist",
+	".test.",
+	".spec."
+];
+function discoverFiles(dir, rootDir, excludePatterns, extensionsSet) {
+	const results = [];
+	let entries;
+	try {
+		entries = (0, fs.readdirSync)(dir, { encoding: "utf8" });
+	} catch {
+		return results;
+	}
+	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 (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, excludePatterns, extensionsSet));
+		else if (extensionsSet.has((0, path.extname)(entry))) results.push(fullPath);
+	}
+	return results;
+}
+/**
+* Resolve browser targets for Lightning CSS.
+* Priority: explicit config → project browserslist → 'defaults' fallback.
+*/
+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);
+}
+/**
+* Post-process CSS with Lightning CSS: autoprefixing + optional minification.
+* On failure, returns the original CSS and logs a warning.
+*/
+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;
+	}
+}
+/** Compute MD5 content hash for a string. */
+function contentHash(source) {
+	return (0, crypto.createHash)("md5").update(source).digest("hex");
+}
+/**
+* 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.
+*/
+function buildFileEntriesFromCache(cache, changedPath) {
+	const entries = [];
+	for (const [path$1, { hash, source }] of cache) entries.push({
+		path: path$1,
+		source: path$1 === changedPath ? source : "",
+		hash
+	});
+	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);
+			},
+			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)`);
+				}
+				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}`);
+		}
+	}
+	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.
+	*/
+	function loadSystem() {
+		resolvedSystemPath = (0, path.resolve)(rootDir, options.system);
+		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;
+		} 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);
+		}
+	}
+	/**
+	* 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.
+	*/
+	function runAnalysis(fileEntries) {
+		try {
+			const { analyzeProject } = engineApi();
+			const emitterConfig = JSON.stringify({
+				runtime_import: "@animus-ui/system",
+				css_module_id: "virtual:animus/styles.css"
+			});
+			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;
+			if (newFragments && typeof newFragments === "object") {
+				fragmentCache.clear();
+				for (const [id, sheets] of Object.entries(newFragments)) 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);
+		} catch (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 = (0, _animus_ui_extract_pipeline.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 } = 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)");
+			}
+			const { declaration } = (0, _animus_ui_extract_pipeline.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) {
+					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 || ""), {
+				...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_sheet_${(0, crypto.createHash)("md5").update(options.system).digest("hex").slice(0, 8)}__';
+let sheet = globalThis[GLOBAL_KEY] || null;
+
+if (typeof CSSStyleSheet !== 'undefined' && 'adoptedStyleSheets' in document) {
+  if (!sheet) {
+    sheet = new CSSStyleSheet();
+    globalThis[GLOBAL_KEY] = sheet;
+    document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
+  }
+  sheet.replaceSync(css);
+} else {
+  // Fallback: inject or update <style> tag
+  let el = document.querySelector('style[data-animus-components]');
+  if (!el) {
+    el = document.createElement('style');
+    el.setAttribute('data-animus-components', '');
+    document.head.appendChild(el);
+  }
+  el.textContent = css;
+}
+
+if (import.meta.hot) {
+  import.meta.hot.accept('${VIRTUAL_COMPONENTS_ID}', (newModule) => {
+    if (sheet) {
+      sheet.replaceSync(newModule.default);
+    } else {
+      const el = document.querySelector('style[data-animus-components]');
+      if (el) el.textContent = newModule.default;
+    }
+  });
+}
+`;
+			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;
+		},
+		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;
+			}
+		},
+		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 = (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;
+		}
+	};
+}
+//#endregion
+exports.animusExtract = animusExtract;
+exports.default = animusExtract;
+exports.discoverFiles = discoverFiles;