@animus-ui/vite-plugin 0.1.0-next.1

package/dist/config-serializer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Serialize the prop config from @animus-ui/core for the Rust extraction pipeline.
+ *
+ * Maps JS transform functions to string identifiers that the Rust crate
+ * can dispatch to its native implementations.
+ */
+interface PropConfig {
+    property: string;
+    properties?: string[];
+    scale?: string | Record<string, any> | any[];
+    transform?: Function;
+}
+/**
+ * Serialize all prop groups from the animus config into a JSON map.
+ * Prop config entries with inline scales (object/array) are skipped
+ * since the Rust crate only handles named theme scales.
+ */
+export declare function serializeConfig(propRegistry: Record<string, PropConfig>): string;
+/**
+ * Serialize the group registry from the Animus config.
+ * Maps each group name to its array of constituent prop names.
+ */
+export declare function serializeGroupRegistry(groupRegistry: Record<string, string[]>): string;
+export {};
+//# sourceMappingURL=config-serializer.d.ts.map

package/dist/config-serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-serializer.d.ts","sourceRoot":"","sources":["../src/config-serializer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,UAAU,UAAU;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC;IAC7C,SAAS,CAAC,EAAE,QAAQ,CAAC;CACtB;AASD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GACvC,MAAM,CA8BR;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACtC,MAAM,CAER"}

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import type { Plugin } from 'vite';
+export interface AnimusExtractOptions {
+    /**
+     * Theme data for the extraction pipeline.
+     *
+     * Two forms are accepted:
+     *   - `string` — pre-serialized flat JSON (legacy; no CSS variable emission)
+     *   - `{ scales: string; variables: string }` — pre-evaluated scales JSON
+     *     plus fully-formed CSS variable declarations to prepend to the virtual
+     *     stylesheet.  The caller is responsible for evaluating the theme module
+     *     (e.g. via `evaluateTheme` or a Bun subprocess) before passing it here.
+     *
+     * When omitted, the plugin auto-detects `src/theme.ts`, `src/theme.js`,
+     * `theme.ts`, or `theme.js` relative to the project root.
+     */
+    theme?: string | {
+        scales: string;
+        variables: string;
+    };
+    /**
+     * Explicit path to the theme module (relative to project root or absolute).
+     * Takes precedence over auto-detection, but lower priority than `theme`.
+     */
+    themePath?: string;
+    /**
+     * Path to a module exporting a SystemInstance from `@animus-ui/system`.
+     * The module is loaded via a single bun subprocess at build start.
+     * Replaces configPath + themePath when using the system package.
+     */
+    system?: string;
+    /**
+     * Path to a module exporting `getExtractConfig()`. The module is loaded via
+     * bun subprocess at build start. Use this for custom Animus instances created
+     * with `createAnimus().addGroup(...).build()`.
+     *
+     * When omitted, automatically imported from `@animus-ui/core`.
+     */
+    configPath?: string;
+    /**
+     * Pre-serialized prop config JSON. When omitted, automatically imported from
+     * `@animus-ui/core` via `getExtractConfig()`.
+     */
+    config?: string;
+    /** Pre-serialized group registry JSON. Maps group names to prop name arrays. */
+    groupRegistry?: string;
+    /** Glob patterns to include. Defaults to .ts/.tsx/.js/.jsx files. */
+    include?: string[];
+    /** Glob patterns to exclude. */
+    exclude?: string[];
+    /** Package name patterns to resolve and include in analysis. Defaults to ['@animus-ui/*']. */
+    packagePatterns?: string[];
+    /** When true, extraction failures throw instead of warning. Use in CI to enforce full extraction. */
+    strict?: boolean;
+    /** Enable verbose logging. Also activatable via ANIMUS_DEBUG=1 env var. */
+    verbose?: boolean;
+}
+export declare function animusExtract(options?: AnimusExtractOptions): Plugin;
+export { evaluateTheme, evaluateThemeObject } from './theme-evaluator';
+export default animusExtract;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;AAM3C,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACvD;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gCAAgC;IAChC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,8FAA8F;IAC9F,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,qGAAqG;IACrG,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AA0RD,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,MAAM,CAq5BxE;AAED,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACvE,eAAe,aAAa,CAAC"}

package/dist/index.mjs

@@ -0,0 +1,818 @@
+import { createRequire } from "node:module";
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import { existsSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, extname, join, relative, resolve } from "path";
+import { fileURLToPath } from "url";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/theme-evaluator.ts
+/**
+* Evaluate a theme object that has already been loaded/imported.
+*
+* This is the pure logic: takes a theme object, flattens scales, builds variable CSS.
+* Use this when you have already loaded the module yourself.
+*/
+function evaluateThemeObject(theme) {
+	const flat = {};
+	for (const [scaleName, scaleValue] of Object.entries(theme)) {
+		if (scaleName.startsWith("_")) continue;
+		if (scaleName === "breakpoints") {
+			flattenScale(flat, "breakpoints", scaleValue);
+			continue;
+		}
+		if (typeof scaleValue === "object" && scaleValue !== null && !Array.isArray(scaleValue)) flattenScale(flat, scaleName, scaleValue);
+	}
+	const variableMap = {};
+	for (const [tokenPath, value] of Object.entries(flat)) if (value.startsWith("var(") && value.endsWith(")")) variableMap[tokenPath] = value.slice(4, -1);
+	const variableCss = buildVariableCss(theme);
+	return {
+		scalesJson: JSON.stringify(flat),
+		variableMapJson: JSON.stringify(variableMap),
+		variableCss
+	};
+}
+/**
+* Evaluate a theme module and flatten all scales to a JSON map.
+* Format: { "scale_name.key": "css_value" }
+*
+* Uses Vite's ssrLoadModule to evaluate the theme at build start,
+* so all computed scales (shadows, gradients that depend on colors)
+* are resolved to their final values.
+*/
+async function evaluateTheme(ssrLoadModule, themePath) {
+	const mod = await ssrLoadModule(themePath);
+	const theme = mod.theme || mod.default;
+	if (!theme) throw new Error(`Theme module at ${themePath} must export 'theme' or a default export`);
+	return evaluateThemeObject(theme);
+}
+/**
+* Build the full CSS variable block from a theme's _variables and _tokens.
+*
+* Produces:
+*   :root { --color-navy-500: #282a36; ... }
+*   [data-color-mode="dark"] { --color-primary: #ff80bf; ... }
+*/
+function buildVariableCss(theme) {
+	const parts = [];
+	if (theme._variables != null && typeof theme._variables === "object") {
+		const rootLines = [];
+		for (const categoryValue of Object.values(theme._variables)) {
+			if (categoryValue == null || typeof categoryValue !== "object") continue;
+			for (const [cssVar, cssValue] of Object.entries(categoryValue)) if (typeof cssValue === "string") rootLines.push(`  ${cssVar}: ${cssValue};`);
+		}
+		if (rootLines.length > 0) parts.push(`:root {\n${rootLines.join("\n")}\n}`);
+	}
+	if (theme._tokens?.modes != null && typeof theme._tokens.modes === "object") {
+		const defaultMode = typeof theme.mode === "string" ? theme.mode : Object.keys(theme._tokens.modes)[0];
+		for (const [modeName, modeTokens] of Object.entries(theme._tokens.modes)) {
+			if (modeName === defaultMode) continue;
+			if (modeTokens == null || typeof modeTokens !== "object") continue;
+			const modeLines = [];
+			flattenModeTokens(modeLines, modeTokens, "");
+			if (modeLines.length > 0) parts.push(`[data-color-mode="${modeName}"] {\n${modeLines.join("\n")}\n}`);
+		}
+	}
+	return parts.join("\n\n");
+}
+/**
+* Recursively flatten mode token objects into CSS variable declarations.
+*
+* Examples:
+*   { primary: '#ff80bf' }           → '  --color-primary: #ff80bf;'
+*   { background: { _: '#fff', muted: '#f5f5f5' } }
+*     → '  --color-background: #fff;'
+*        '  --color-background-muted: #f5f5f5;'
+*
+* The special key `_` maps to the base name (no suffix).
+*/
+function flattenModeTokens(lines, obj, prefix) {
+	for (const [key, value] of Object.entries(obj)) {
+		let namePart;
+		if (key === "_") namePart = prefix;
+		else namePart = prefix ? `${prefix}-${key}` : key;
+		if (typeof value === "string" || typeof value === "number") lines.push(`  --color-${namePart}: ${value};`);
+		else if (value != null && typeof value === "object" && !Array.isArray(value)) flattenModeTokens(lines, value, namePart);
+	}
+}
+function flattenScale(flat, prefix, obj, parentKey = "") {
+	if (typeof obj !== "object" || obj === null) {
+		const key = parentKey ? `${prefix}.${parentKey}` : prefix;
+		flat[key] = String(obj);
+		return;
+	}
+	for (const [key, value] of Object.entries(obj)) {
+		const fullKey = parentKey ? `${parentKey}-${key}` : key;
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) flattenScale(flat, prefix, value, fullKey);
+		else flat[`${prefix}.${fullKey}`] = String(value);
+	}
+}
+//#endregion
+//#region src/index.ts
+const __pluginDir = dirname(fileURLToPath(import.meta.url));
+const VIRTUAL_CSS_ID = "virtual:animus/styles.css";
+const RESOLVED_CSS_ID = "\0virtual:animus/styles.css";
+const VIRTUAL_COMPONENTS_ID = "virtual:animus/components.js";
+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 DEFAULT_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+]);
+const DEFAULT_EXCLUDE = [
+	"node_modules",
+	"dist",
+	".test.",
+	".spec."
+];
+function discoverFiles(dir, rootDir, excludePatterns) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir, { encoding: "utf8" });
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		const relativePath = relative(rootDir, fullPath);
+		if (excludePatterns.some((pattern) => fullPath.includes(pattern) || relativePath.includes(pattern))) continue;
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, excludePatterns));
+		else if (DEFAULT_EXTENSIONS.has(extname(entry))) results.push(fullPath);
+	}
+	return results;
+}
+/**
+* Apply transform placeholders emitted by the Rust pipeline.
+*
+* Rust emits `__TRANSFORM__name__rawValue__` for props with transforms.
+* This function resolves each placeholder using the actual JS transform
+* functions from the config.
+*/
+function applyTransformPlaceholders(css, transformRegistry) {
+	return css.replace(/__TRANSFORM__(\w+)__(.+?)__/g, (_match, name, rawValue) => {
+		const fn = transformRegistry.get(name);
+		if (!fn) {
+			console.warn(`[animus-extract] Unknown transform: "${name}" — using raw value`);
+			return rawValue;
+		}
+		const result = fn(rawValue !== "" && !isNaN(Number(rawValue)) ? Number(rawValue) : rawValue);
+		return typeof result === "object" ? JSON.stringify(result) : String(result);
+	});
+}
+/**
+* CSS properties that accept unitless numeric values.
+* Matches @emotion/unitless and React DOM's style handling.
+* Bare numerics on properties NOT in this set receive `px`.
+*/
+const UNITLESS_PROPERTIES = new Set([
+	"animation-iteration-count",
+	"border-image-outset",
+	"border-image-slice",
+	"border-image-width",
+	"box-flex",
+	"box-flex-group",
+	"box-ordinal-group",
+	"column-count",
+	"columns",
+	"flex",
+	"flex-grow",
+	"flex-positive",
+	"flex-shrink",
+	"flex-negative",
+	"flex-order",
+	"grid-area",
+	"grid-row",
+	"grid-row-end",
+	"grid-row-span",
+	"grid-row-start",
+	"grid-column",
+	"grid-column-end",
+	"grid-column-span",
+	"grid-column-start",
+	"font-weight",
+	"line-clamp",
+	"line-height",
+	"opacity",
+	"order",
+	"orphans",
+	"tab-size",
+	"widows",
+	"z-index",
+	"zoom",
+	"fill-opacity",
+	"flood-opacity",
+	"stop-opacity",
+	"stroke-dasharray",
+	"stroke-dashoffset",
+	"stroke-miterlimit",
+	"stroke-opacity",
+	"stroke-width"
+]);
+/**
+* Append `px` to bare numeric values in CSS declarations for properties
+* that expect length units. Unitless properties are preserved as-is.
+* Numbers inside CSS function calls (cubic-bezier, rgb, calc, etc.) are skipped.
+*/
+function applyUnitFallback(css) {
+	return css.replace(/([a-z-]+)\s*:\s*([^;]+);/g, (match, prop, value) => {
+		if (UNITLESS_PROPERTIES.has(prop)) return match;
+		let depth = 0;
+		let fixed = "";
+		let i = 0;
+		while (i < value.length) if (value[i] === "(") {
+			depth++;
+			fixed += value[i];
+			i++;
+		} else if (value[i] === ")") {
+			depth--;
+			fixed += value[i];
+			i++;
+		} else if (depth > 0) {
+			fixed += value[i];
+			i++;
+		} else {
+			const numMatch = value.slice(i).match(/^(-?\d+\.?\d*)/);
+			if (numMatch) {
+				const num = numMatch[1];
+				const after = value[i + num.length];
+				if (after && /[a-z%]/i.test(after)) fixed += num;
+				else fixed += num + "px";
+				i += num.length;
+			} else {
+				fixed += value[i];
+				i++;
+			}
+		}
+		return fixed !== value ? `${prop}:${fixed};` : match;
+	});
+}
+/** Compute MD5 content hash for a string. */
+function contentHash(source) {
+	return 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, { hash, source }] of cache) entries.push({
+		path,
+		source: path === changedPath ? source : "",
+		hash
+	});
+	return entries;
+}
+/**
+* Resolve transform placeholders in CSS via bun subprocess.
+* Falls back to in-process resolution if the subprocess fails.
+*/
+function resolveTransformPlaceholders(css, rootDir, configPath, transformRegistry) {
+	if (!css.includes("__TRANSFORM__")) return css;
+	try {
+		const ts = Date.now();
+		const tmpCss = join(tmpdir(), `animus-transforms-${ts}.css`);
+		const tmpOut = join(tmpdir(), `animus-transforms-${ts}.out.css`);
+		writeFileSync(tmpCss, css);
+		const candidates = [join(__pluginDir, "resolve-transforms.ts"), join(__pluginDir, "..", "src", "resolve-transforms.ts")];
+		try {
+			const pkgDir = dirname(__require.resolve("@animus-ui/vite-plugin/package.json", { paths: [rootDir] }));
+			candidates.push(join(pkgDir, "src", "resolve-transforms.ts"));
+		} catch {}
+		const scriptPath = candidates.find((p) => existsSync(p));
+		if (!scriptPath) throw new Error(`resolve-transforms.ts not found in: ${candidates.join(", ")}`);
+		execSync(`bun run "${scriptPath}" "${tmpCss}" "${tmpOut}" ${configPath ? `"${resolve(rootDir, configPath)}"` : ""}`, {
+			cwd: rootDir,
+			encoding: "utf-8"
+		});
+		const resolved = readFileSync(tmpOut, "utf-8");
+		try {
+			unlinkSync(tmpCss);
+			unlinkSync(tmpOut);
+		} catch {}
+		return resolved;
+	} catch (e) {
+		console.error("[animus-extract] Transform resolution failed:", e?.message || e);
+		return applyTransformPlaceholders(css, transformRegistry);
+	}
+}
+function animusExtract(options = {}) {
+	let themeJson = "{}";
+	let variableMapJson = "{}";
+	let configJson = "{}";
+	let groupRegistryJson = "{}";
+	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}`);
+	}
+	let variableCss = "";
+	let globalCss = "";
+	let transformRegistry = /* @__PURE__ */ new Map();
+	let storedManifest = null;
+	let storedManifestJson = "";
+	let resolvedComponentCss = "";
+	let storedSheets = null;
+	const fileCache = /* @__PURE__ */ new Map();
+	let packageMap = {};
+	let bridgeInjected = false;
+	let resolvedConfigPath = null;
+	let resolvedThemePath = null;
+	let resolvedSystemPath = null;
+	/** Resolve config via bun subprocess. Updates configJson + groupRegistryJson. */
+	function loadConfig() {
+		if (options.config) {
+			configJson = options.config;
+			groupRegistryJson = options.groupRegistry ?? groupRegistryJson;
+			return;
+		}
+		const configSource = options.configPath ? resolve(rootDir, options.configPath) : "@animus-ui/core";
+		const requireExpr = options.configPath ? `require('${configSource.replace(/\\/g, "/")}')` : `require('@animus-ui/core')`;
+		if (options.configPath) resolvedConfigPath = resolve(rootDir, options.configPath);
+		try {
+			const result = execSync(`bun -e "const m = ${requireExpr}; const r = m.getExtractConfig(); process.stdout.write(JSON.stringify(r))"`, {
+				cwd: rootDir,
+				encoding: "utf-8"
+			});
+			const { propConfig, groupRegistry } = JSON.parse(result);
+			configJson = propConfig;
+			groupRegistryJson = groupRegistry;
+		} catch (e) {
+			if (options.strict) throw new Error(`[animus-extract] Failed to auto-import config from ${configSource}: ${e}`);
+			console.warn(`[animus-extract] Failed to auto-import config from ${configSource}:`, e);
+		}
+	}
+	/** Resolve theme via bun subprocess. Updates themeJson + variableCss. */
+	function loadTheme() {
+		if (options.theme) {
+			if (typeof options.theme === "string") {
+				themeJson = options.theme;
+				variableCss = "";
+			} else {
+				themeJson = options.theme.scales;
+				variableCss = options.theme.variables;
+			}
+			return;
+		}
+		resolvedThemePath = null;
+		if (options.themePath) {
+			const p = resolve(rootDir, options.themePath);
+			if (existsSync(p)) resolvedThemePath = p;
+			else if (options.strict) throw new Error(`[animus-extract] Theme file not found: ${p}`);
+			else console.warn(`[animus-extract] Theme file not found: ${p}`);
+		} else {
+			const candidates = [
+				join(rootDir, "src", "theme.ts"),
+				join(rootDir, "src", "theme.js"),
+				join(rootDir, "theme.ts"),
+				join(rootDir, "theme.js")
+			];
+			for (const candidate of candidates) if (existsSync(candidate)) {
+				resolvedThemePath = candidate;
+				break;
+			}
+		}
+		if (resolvedThemePath) try {
+			const themeJson_ = execSync(`bun -e "${[
+				`const m = require(${JSON.stringify(resolvedThemePath)});`,
+				`const theme = m.theme || m.default;`,
+				`process.stdout.write(JSON.stringify(theme || {}));`
+			].join(" ").replace(/"/g, "\\\"")}"`, {
+				cwd: rootDir,
+				encoding: "utf-8"
+			});
+			const theme = JSON.parse(themeJson_);
+			if (theme && Object.keys(theme).length > 0) {
+				const result = evaluateThemeObject(theme);
+				themeJson = result.scalesJson;
+				variableMapJson = result.variableMapJson;
+				variableCss = result.variableCss;
+			}
+		} catch (e) {
+			if (options.strict) throw new Error(`[animus-extract] Failed to load theme from ${resolvedThemePath}: ${e}`);
+			console.warn(`[animus-extract] Failed to load theme from ${resolvedThemePath}:`, e);
+		}
+	}
+	/**
+	* Load a SystemInstance via single bun subprocess.
+	* Replaces loadConfig() + loadTheme() when `system` option is provided.
+	* The subprocess imports the module and calls .serialize().
+	*/
+	function loadSystem() {
+		if (!options.system) return;
+		resolvedSystemPath = resolve(rootDir, options.system);
+		try {
+			const ts = Date.now();
+			const tmpScript = join(tmpdir(), `animus-system-${ts}.js`);
+			const tmpOut = join(tmpdir(), `animus-system-${ts}.json`);
+			writeFileSync(tmpScript, `const m = require(${JSON.stringify(resolvedSystemPath)});\nconst ds = m.ds || m.default || m.system;\nif (!ds || !ds.serialize) { throw new Error('Module does not export a SystemInstance with .serialize()'); }\nconst cfg = ds.serialize();\nrequire('fs').writeFileSync(${JSON.stringify(tmpOut)}, JSON.stringify({\n  propConfig: cfg.propConfig,\n  groupRegistry: cfg.groupRegistry,\n  tokens: cfg.tokens,\n  transformNames: Object.keys(cfg.transforms || {}),\n  globalStyles: cfg.globalStyles || null\n}));\n`);
+			execSync(`bun run "${tmpScript}"`, {
+				cwd: rootDir,
+				encoding: "utf-8"
+			});
+			const result = readFileSync(tmpOut, "utf-8");
+			try {
+				unlinkSync(tmpScript);
+				unlinkSync(tmpOut);
+			} catch {}
+			const parsed = JSON.parse(result);
+			configJson = parsed.propConfig;
+			groupRegistryJson = parsed.groupRegistry;
+			if (parsed.tokens && Object.keys(parsed.tokens).length > 0) {
+				const result = evaluateThemeObject(parsed.tokens);
+				themeJson = result.scalesJson;
+				variableMapJson = result.variableMapJson;
+				variableCss = result.variableCss;
+			}
+			if (parsed.globalStyles) {
+				const hasReset = parsed.globalStyles.reset && Object.keys(parsed.globalStyles.reset).length > 0;
+				const hasGlobal = parsed.globalStyles.global && Object.keys(parsed.globalStyles.global).length > 0;
+				if (hasReset || hasGlobal) try {
+					const gsTmp = Date.now();
+					const gsThemeFile = join(tmpdir(), `animus-gs-theme-${gsTmp}.json`);
+					const gsOut = join(tmpdir(), `animus-global-${gsTmp}.json`);
+					writeFileSync(gsThemeFile, themeJson);
+					const gsCandidates = [join(__pluginDir, "resolve-global-styles.ts"), join(__pluginDir, "..", "src", "resolve-global-styles.ts")];
+					try {
+						const pkgDir = dirname(__require.resolve("@animus-ui/vite-plugin/package.json", { paths: [rootDir] }));
+						gsCandidates.push(join(pkgDir, "src", "resolve-global-styles.ts"));
+					} catch {}
+					const gsScriptPath = gsCandidates.find((p) => existsSync(p));
+					if (!gsScriptPath) throw new Error(`resolve-global-styles.ts not found in: ${gsCandidates.join(", ")}`);
+					execSync(`bun run "${gsScriptPath}" "${resolvedSystemPath}" "${gsThemeFile}" "${gsOut}"`, {
+						cwd: rootDir,
+						encoding: "utf-8"
+					});
+					const gsResult = JSON.parse(readFileSync(gsOut, "utf-8"));
+					const parts = [gsResult.reset, gsResult.global].filter(Boolean);
+					if (parts.length > 0) globalCss = `@layer global {\n${parts.join("\n\n")}\n}`;
+					try {
+						unlinkSync(gsThemeFile);
+						unlinkSync(gsOut);
+					} catch {}
+				} catch (e) {
+					console.warn("[animus-extract] Global styles resolution failed:", e?.message || e);
+				}
+			}
+			if (parsed.transformNames && parsed.transformNames.length > 0) {
+				const tsTmp = Date.now();
+				const tmpResolve = join(tmpdir(), `animus-transforms-resolve-${tsTmp}.js`);
+				writeFileSync(tmpResolve, `const m = require(${JSON.stringify(resolvedSystemPath)});\nconst ds = m.ds || m.default || m.system;\nconst cfg = ds.serialize();\nconst css = require('fs').readFileSync(process.argv[2], 'utf-8');\nconst resolved = css.replace(/__TRANSFORM__(\\w+)__(.+?)__/g, (_, name, rawValue) => {\n  const fn = cfg.transforms[name];\n  if (!fn) return rawValue;\n  const value = rawValue !== '' && !isNaN(Number(rawValue)) ? Number(rawValue) : rawValue;\n  const result = fn(value);\n  return typeof result === 'object' ? JSON.stringify(result) : String(result);\n});\nrequire('fs').writeFileSync(process.argv[3], resolved);\n`);
+				globalThis.__animus_system_resolve_script = tmpResolve;
+			}
+		} catch (e) {
+			if (options.strict) throw new Error(`[animus-extract] Failed to load system from ${resolvedSystemPath}: ${e}`);
+			console.warn(`[animus-extract] Failed to load system from ${resolvedSystemPath}:`, e);
+		}
+	}
+	/**
+	* Run project analysis and update the manifest.
+	* Uses fileCache if populated (dev mode), otherwise uses provided entries.
+	*/
+	function runAnalysis(fileEntries) {
+		try {
+			const { analyzeProject } = __require("@animus-ui/extract");
+			const manifestJson = analyzeProject(JSON.stringify(fileEntries), themeJson, variableMapJson, configJson, groupRegistryJson, JSON.stringify(packageMap), !isProd);
+			storedManifest = JSON.parse(manifestJson);
+			storedManifestJson = manifestJson;
+			bridgeInjected = false;
+			storedSheets = storedManifest?.sheets ?? null;
+			const rawCss = storedManifest?.css || "";
+			const systemResolveScript = globalThis.__animus_system_resolve_script;
+			if (systemResolveScript && rawCss.includes("__TRANSFORM__") && isProd) try {
+				const tsTmp = Date.now();
+				const tmpIn = join(tmpdir(), `animus-css-${tsTmp}.css`);
+				const tmpOut = join(tmpdir(), `animus-css-${tsTmp}.out.css`);
+				writeFileSync(tmpIn, rawCss);
+				execSync(`bun run "${systemResolveScript}" "${tmpIn}" "${tmpOut}"`, {
+					cwd: rootDir,
+					encoding: "utf-8"
+				});
+				resolvedComponentCss = readFileSync(tmpOut, "utf-8");
+				try {
+					unlinkSync(tmpIn);
+					unlinkSync(tmpOut);
+				} catch {}
+			} catch (e) {
+				console.warn("[animus-extract] System transform resolution failed:", e?.message);
+				resolvedComponentCss = resolveTransformPlaceholders(rawCss, rootDir, options.configPath, transformRegistry);
+			}
+			else resolvedComponentCss = resolveTransformPlaceholders(rawCss, rootDir, options.configPath, transformRegistry);
+			resolvedComponentCss = applyUnitFallback(resolvedComponentCss);
+		} catch (e) {
+			if (options.strict) throw new Error(`[animus-extract] analyzeProject failed: ${e}`);
+			console.warn("[animus-extract] analyzeProject failed:", e);
+		}
+	}
+	return {
+		name: "animus-extract",
+		enforce: "pre",
+		configResolved(config) {
+			isProd = config.command === "build";
+			rootDir = config.root;
+			logger = config.logger;
+		},
+		async buildStart() {
+			let t0 = performance.now();
+			if (options.system) loadSystem();
+			else {
+				loadConfig();
+				loadTheme();
+			}
+			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;
+			const filePaths = discoverFiles(rootDir, rootDir, excludePatterns);
+			const fileEntries = [];
+			for (const filePath of filePaths) try {
+				const source = readFileSync(filePath, "utf-8");
+				const relPath = relative(rootDir, filePath);
+				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 patterns = options.packagePatterns ?? ["@animus-ui/*"];
+			const packageSpecifiers = /* @__PURE__ */ new Set();
+			for (const entry of fileEntries) {
+				const importRegex = /from\s+['"]([^'"]+)['"]/g;
+				let match;
+				while ((match = importRegex.exec(entry.source)) !== null) {
+					const source = match[1];
+					for (const pattern of patterns) {
+						const prefix = pattern.replace("*", "");
+						if (source.startsWith(prefix) || source === pattern.replace("/*", "")) packageSpecifiers.add(source);
+					}
+				}
+			}
+			packageMap = {};
+			for (const specifier of packageSpecifiers) try {
+				const resolved = await this.resolve(specifier);
+				if (resolved && resolved.id) {
+					const absPath = resolved.id;
+					const relPath = relative(rootDir, absPath);
+					if (!fileEntries.some((e) => e.path === relPath)) {
+						const entrySource = readFileSync(absPath, "utf-8");
+						const entryHash = !isProd ? contentHash(entrySource) : void 0;
+						fileEntries.push({
+							path: relPath,
+							source: entrySource,
+							hash: entryHash
+						});
+						if (!isProd && entryHash) fileCache.set(relPath, {
+							hash: entryHash,
+							source: entrySource
+						});
+					}
+					const pkgFiles = discoverFiles(dirname(absPath), rootDir, excludePatterns);
+					for (const pkgFile of pkgFiles) {
+						const pkgRelPath = relative(rootDir, pkgFile);
+						if (!fileEntries.some((e) => e.path === pkgRelPath)) {
+							const pkgSource = readFileSync(pkgFile, "utf-8");
+							const pkgHash = !isProd ? contentHash(pkgSource) : void 0;
+							fileEntries.push({
+								path: pkgRelPath,
+								source: pkgSource,
+								hash: pkgHash
+							});
+							if (!isProd && pkgHash) fileCache.set(pkgRelPath, {
+								hash: pkgHash,
+								source: pkgSource
+							});
+						}
+					}
+					packageMap[specifier] = relPath;
+				}
+			} catch {}
+			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)`);
+					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 === "variant") warn(`⚠ ${d.component} variant '${d.name}' pruned: ${d.reason}`);
+					else if (d.kind === "state") warn(`⚠ ${d.component} state '${d.name}' pruned: ${d.reason}`);
+				}
+				const diagnostics = storedManifest.diagnostics || [];
+				for (const d of diagnostics) if (d.kind === "bail") warn(`⚠ ${d.component} not extracted: ${d.message}`);
+				else if (d.kind === "skip") warn(`⚠ ${d.component}: skipped ${d.message}`);
+				log(`CSS: ${resolvedComponentCss.length} bytes (${Object.keys(storedManifest.components || {}).length} components)`);
+				if (!isProd && storedSheets) {
+					const staticSize = (storedSheets.declaration + variableCss + globalCss).length;
+					const componentSize = resolvedComponentCss.length;
+					log(`Delivery: split mode — static ${staticSize} bytes, components ${componentSize} bytes (adopted stylesheet)`);
+				} else log("Delivery: single file mode (production)");
+			}
+		},
+		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;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_CSS_ID) {
+				if (!isProd && storedSheets) return [
+					storedSheets.declaration,
+					variableCss,
+					globalCss
+				].filter(Boolean).join("\n");
+				return [
+					variableCss,
+					globalCss,
+					resolvedComponentCss
+				].filter(Boolean).join("\n");
+			}
+			if (id === RESOLVED_COMPONENTS_ID) return `export default \`${(resolvedComponentCss || "").replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;`;
+			if (id === RESOLVED_BRIDGE_ID) return `
+import css from '${VIRTUAL_COMPONENTS_ID}';
+
+const GLOBAL_KEY = '__animus_component_sheet__';
+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;
+    }
+  });
+}
+`;
+			return null;
+		},
+		transform(code, id) {
+			if (!storedManifest) return null;
+			if (!/\.[jt]sx?$/.test(id)) return null;
+			if (id.includes("node_modules")) return null;
+			const relativePath = relative(rootDir, id);
+			if (!storedManifest.files?.[relativePath]?.length) return null;
+			try {
+				const { transformFile } = __require("@animus-ui/extract");
+				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}`);
+				console.warn(`[animus-extract] Failed to transform ${id}:`, e);
+				return null;
+			}
+		},
+		handleHotUpdate({ file, server: hmrServer, modules }) {
+			if (isProd) return;
+			const ext = extname(file);
+			if (!DEFAULT_EXTENSIONS.has(ext)) return;
+			if ((options.exclude ?? DEFAULT_EXCLUDE).some((pattern) => file.includes(pattern) || relative(rootDir, file).includes(pattern))) return;
+			const absFile = resolve(file);
+			const relPath = relative(rootDir, absFile);
+			const isConfigChange = resolvedConfigPath && absFile === resolve(resolvedConfigPath);
+			const isThemeChange = resolvedThemePath && absFile === resolve(resolvedThemePath);
+			const isSystemChange = resolvedSystemPath && absFile === resolve(resolvedSystemPath);
+			if (isConfigChange || isThemeChange || isSystemChange) {
+				const resetStart = performance.now();
+				log(`HMR geological reset: ${relPath}`);
+				if (isSystemChange) loadSystem();
+				else {
+					if (isConfigChange) loadConfig();
+					if (isThemeChange) loadTheme();
+				}
+				try {
+					const { clearAnalysisCache } = __require("@animus-ui/extract");
+					clearAnalysisCache();
+				} catch {}
+				const fileEntries = [];
+				for (const [path, { hash, source }] of fileCache) fileEntries.push({
+					path,
+					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);
+				}
+				return geologicalModules;
+			}
+			let source;
+			try {
+				source = readFileSync(absFile, "utf-8");
+			} catch {
+				return;
+			}
+			const hash = contentHash(source);
+			const cached = fileCache.get(relPath);
+			if (cached && cached.hash === hash) {
+				log(`HMR skip: ${relPath} (unchanged)`);
+				return [];
+			}
+			fileCache.set(relPath, {
+				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 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);
+			}
+			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 = 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`);
+			if (modulesToUpdate.length > modules.length) return modulesToUpdate;
+		}
+	};
+}
+//#endregion
+export { animusExtract, animusExtract as default, evaluateTheme, evaluateThemeObject };

package/dist/resolve-global-styles.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Standalone script executed via `bun run` to resolve global styles.
+ *
+ * Usage: bun run resolve-global-styles.ts <system-path> <theme-json> <output-file>
+ *
+ * Imports the system module, extracts globalStyles from .serialize(),
+ * resolves prop shorthand (bg → background-color, etc.) using the full
+ * prop config + theme + transforms, and writes the resolved CSS to output.
+ *
+ * @keyframes blocks are serialized as raw CSS (no prop resolution needed).
+ */
+export {};
+//# sourceMappingURL=resolve-global-styles.d.ts.map

package/dist/resolve-global-styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-global-styles.d.ts","sourceRoot":"","sources":["../src/resolve-global-styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/resolve-transforms.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Standalone script executed via `bun run` to apply transform placeholders.
+ *
+ * Usage: bun run resolve-transforms.ts <input-file> <output-file> [config-path]
+ *
+ * Reads CSS from input file containing __TRANSFORM__name__rawValue__ placeholders,
+ * loads transform functions from @animus-ui/core (and optionally a custom config),
+ * applies them, and writes the resolved CSS to the output file.
+ *
+ * When config-path is provided, transforms from that module are loaded IN ADDITION
+ * to core transforms. Custom transforms take precedence on name collisions.
+ */
+export {};
+//# sourceMappingURL=resolve-transforms.d.ts.map

package/dist/resolve-transforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-transforms.d.ts","sourceRoot":"","sources":["../src/resolve-transforms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/theme-evaluator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Evaluate a theme object that has already been loaded/imported.
+ *
+ * This is the pure logic: takes a theme object, flattens scales, builds variable CSS.
+ * Use this when you have already loaded the module yourself.
+ */
+export declare function evaluateThemeObject(theme: Record<string, any>): {
+    scalesJson: string;
+    variableMapJson: string;
+    variableCss: string;
+};
+/**
+ * Evaluate a theme module and flatten all scales to a JSON map.
+ * Format: { "scale_name.key": "css_value" }
+ *
+ * Uses Vite's ssrLoadModule to evaluate the theme at build start,
+ * so all computed scales (shadows, gradients that depend on colors)
+ * are resolved to their final values.
+ */
+export declare function evaluateTheme(ssrLoadModule: (url: string) => Promise<Record<string, any>>, themePath: string): Promise<{
+    scalesJson: string;
+    variableMapJson: string;
+    variableCss: string;
+}>;
+/**
+ * Resolve global style objects to a CSS string.
+ *
+ * Each key in `globalStyles` is a CSS selector, each value is a style object
+ * using the same prop shorthand as component `.styles()` blocks.
+ */
+export declare function resolveGlobalStyles(globalStyles: Record<string, Record<string, any>>, propConfigJson: string, flat: Record<string, string>, transforms: Record<string, (v: any) => any>): string;
+//# sourceMappingURL=theme-evaluator.d.ts.map

package/dist/theme-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-evaluator.d.ts","sourceRoot":"","sources":["../src/theme-evaluator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACrB,CAuCA;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAC5D,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IACT,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC,CAWD;AA6KD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EACjD,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC,GAC1C,MAAM,CAiCR"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@animus-ui/vite-plugin",
+  "version": "0.1.0-next.1",
+  "description": "Animus static CSS extraction Vite plugin",
+  "author": "codecaaron <airrobb@gmail.com>",
+  "license": "MIT",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codecaaron/animus"
+  },
+  "scripts": {
+    "build": "tsdown && tsc -p tsconfig.build.json",
+    "compile": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "vite": ">=5.0.0"
+  },
+  "dependencies": {
+    "@animus-ui/core": "0.1.0-next.1",
+    "@animus-ui/extract": "0.1.0-next.1"
+  }
+}