@animus-ui/next-plugin 0.1.0-next.39 → 0.1.0-next.44

package/dist/index.cjs

@@ -0,0 +1,465 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_singleton = require("./singleton-VPOM1BCR.cjs");
+let fs = require("fs");
+let path = require("path");
+let url = require("url");
+let crypto = require("crypto");
+let os = require("os");
+let _animus_ui_extract_pipeline = require("@animus-ui/extract/pipeline");
+//#region src/plugin.ts
+const PLUGIN_NAME = "AnimusWebpackPlugin";
+var AnimusWebpackPlugin = class {
+	options;
+	rootDir = null;
+	configJson = "";
+	groupRegistryJson = "";
+	themeJson = "";
+	variableMapJson = "";
+	variableCss = "";
+	contextualVarsJson = null;
+	globalCss = "";
+	systemResolveScript = null;
+	fileCache = /* @__PURE__ */ new Map();
+	lastCssHash = null;
+	externalPackageDirs = [];
+	externalSourceEntries = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	initialized = false;
+	apply(compiler) {
+		compiler.hooks.run.tapPromise(PLUGIN_NAME, async (_compiler) => {
+			this.rootDir = _compiler.context;
+			const existing = require_singleton.getAnalysisPromise();
+			if (existing) {
+				await existing;
+				return;
+			}
+			const promise = this.runFullPipeline();
+			require_singleton.setAnalysisPromise(promise);
+			await promise;
+		});
+		compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async (_compiler) => {
+			this.rootDir = _compiler.context;
+			if (!this.initialized) {
+				const existing = require_singleton.getAnalysisPromise();
+				if (existing) {
+					await existing;
+					this.initialized = true;
+					return;
+				}
+				const promise = this.runFullPipeline();
+				require_singleton.setAnalysisPromise(promise);
+				await promise;
+				this.initialized = true;
+				return;
+			}
+			await this.handleWatchUpdate();
+		});
+	}
+	async handleWatchUpdate() {
+		const rootDir = this.rootDir;
+		const resolvedSystemPath = (0, path.resolve)(rootDir, this.options.system);
+		try {
+			const systemSource = (0, fs.readFileSync)(resolvedSystemPath, "utf-8");
+			const systemRelPath = (0, path.relative)(rootDir, resolvedSystemPath);
+			const cached = this.fileCache.get(systemRelPath);
+			const currentHash = (0, crypto.createHash)("md5").update(systemSource).digest("hex");
+			if (cached && cached.hash !== currentHash) {
+				this.resetForHmr();
+				this.initialized = false;
+				const promise = this.runFullPipeline();
+				require_singleton.setAnalysisPromise(promise);
+				await promise;
+				this.initialized = true;
+				return;
+			}
+		} catch {}
+		const excludePatterns = this.options.exclude ?? [
+			"node_modules",
+			"dist",
+			".test.",
+			".spec.",
+			".next",
+			".animus"
+		];
+		const files = this.discoverFiles(rootDir, rootDir, excludePatterns);
+		let hasChanges = false;
+		for (const filePath of files) {
+			const relPath = (0, path.relative)(rootDir, filePath);
+			const cached = this.fileCache.get(relPath);
+			const source = (0, fs.readFileSync)(filePath, "utf-8");
+			const hash = (0, crypto.createHash)("md5").update(source).digest("hex");
+			if (!cached || cached.hash !== hash) {
+				hasChanges = true;
+				this.fileCache.set(relPath, {
+					hash,
+					source
+				});
+			}
+		}
+		if (hasChanges) {
+			require_singleton.resetAnalysisPromise();
+			const promise = this.runFullPipeline();
+			require_singleton.setAnalysisPromise(promise);
+			await promise;
+		}
+	}
+	async runFullPipeline() {
+		const rootDir = this.rootDir;
+		const resolvedSystemPath = (0, path.resolve)(rootDir, this.options.system);
+		this.loadSystem(rootDir, resolvedSystemPath);
+		const excludePatterns = this.options.exclude ?? [
+			"node_modules",
+			"dist",
+			".test.",
+			".spec.",
+			".next",
+			".animus"
+		];
+		const files = this.discoverFiles(rootDir, rootDir, excludePatterns);
+		const fileEntries = [];
+		for (const filePath of files) {
+			const source = (0, fs.readFileSync)(filePath, "utf-8");
+			const relPath = (0, path.relative)(rootDir, filePath);
+			const hash = (0, crypto.createHash)("md5").update(source).digest("hex");
+			this.fileCache.set(relPath, {
+				hash,
+				source
+			});
+			fileEntries.push({
+				path: relPath,
+				source,
+				hash
+			});
+		}
+		const packageNames = (0, _animus_ui_extract_pipeline.extractSystemFilePackages)(resolvedSystemPath);
+		const packageMap = this.resolvePackagesByName(rootDir, packageNames);
+		const excludePatternsForPkgs = [
+			"dist",
+			".test.",
+			".spec."
+		];
+		const collectedPkgDirs = [];
+		this.externalSourceEntries.clear();
+		for (const [specifier, entryRelPath] of Object.entries(packageMap)) {
+			const absEntry = (0, path.resolve)(rootDir, entryRelPath);
+			let pkgRoot = (0, path.dirname)(absEntry);
+			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 srcEntry = (0, path.join)(srcDir, "index.ts");
+				if ((0, fs.existsSync)(srcEntry)) {
+					packageMap[specifier] = (0, path.relative)(rootDir, srcEntry);
+					this.externalSourceEntries.set(specifier, srcEntry);
+				}
+				const pkgFiles = this.discoverFiles(srcDir, rootDir, excludePatternsForPkgs);
+				for (const pkgFile of pkgFiles) {
+					const pkgRelPath = (0, path.relative)(rootDir, pkgFile);
+					if (!fileEntries.some((e) => e.path === pkgRelPath)) try {
+						const pkgSource = (0, fs.readFileSync)(pkgFile, "utf-8");
+						const pkgHash = (0, crypto.createHash)("md5").update(pkgSource).digest("hex");
+						this.fileCache.set(pkgRelPath, {
+							hash: pkgHash,
+							source: pkgSource
+						});
+						fileEntries.push({
+							path: pkgRelPath,
+							source: pkgSource,
+							hash: pkgHash
+						});
+					} catch {}
+				}
+			} else collectedPkgDirs.push((0, path.dirname)(absEntry));
+		}
+		this.externalPackageDirs = collectedPkgDirs;
+		const { analyzeProject } = require("@animus-ui/extract");
+		const animusDirPath = (0, path.join)(rootDir, ".animus");
+		const emitterConfig = JSON.stringify({
+			runtime_import: "@animus-ui/system/runtime",
+			css_module_id: ".animus/styles.css",
+			system_props_module_id: (0, path.join)(animusDirPath, "system-props.js")
+		});
+		const manifestJson = analyzeProject(JSON.stringify(fileEntries), this.themeJson, this.variableMapJson, this.contextualVarsJson || null, this.configJson, this.groupRegistryJson, JSON.stringify(packageMap), false, this.options.prefix || null, emitterConfig);
+		const manifest = JSON.parse(manifestJson);
+		let componentCss = manifest?.css || "";
+		if (this.systemResolveScript && componentCss.includes("__TRANSFORM__")) componentCss = this.resolveTransforms(rootDir, componentCss);
+		componentCss = (0, _animus_ui_extract_pipeline.applyUnitFallback)(componentCss);
+		const fullCss = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
+			layers: this.options.layers,
+			variableCss: this.variableCss,
+			globalCss: this.globalCss,
+			componentCss
+		});
+		const cssHash = (0, crypto.createHash)("md5").update(fullCss).digest("hex");
+		if (cssHash !== this.lastCssHash) {
+			const animusDir = (0, path.join)(rootDir, ".animus");
+			if (!(0, fs.existsSync)(animusDir)) (0, fs.mkdirSync)(animusDir, { recursive: true });
+			(0, fs.writeFileSync)((0, path.join)(animusDir, "styles.css"), fullCss);
+			this.lastCssHash = cssHash;
+		}
+		const systemPropMap = JSON.stringify(manifest?.system_prop_map ?? {});
+		const dynamicProps = manifest?.dynamic_props ?? {};
+		const dynamicPropConfig = {};
+		for (const [propName, meta] of Object.entries(dynamicProps)) dynamicPropConfig[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 } : {}
+		};
+		let transformsSource = "{}";
+		if (this.systemResolveScript) try {
+			const resolvedSystemPath = (0, path.resolve)(rootDir, this.options.system);
+			const tmpOut = (0, path.join)((0, os.tmpdir)(), `animus-transforms-${Date.now()}.json`);
+			(0, _animus_ui_extract_pipeline.execSubprocess)(`const m = require(${JSON.stringify(resolvedSystemPath)});\nconst ds = m.ds || m.default || m.system;\nconst cfg = ds.toConfig();\nconst out = {};\nfor (const [name, fn] of Object.entries(cfg.transforms || {})) {\n  out[name] = fn.toString();\n}\nrequire('fs').writeFileSync(${JSON.stringify(tmpOut)}, JSON.stringify(out));\n`, rootDir);
+			const fnStrings = JSON.parse((0, fs.readFileSync)(tmpOut, "utf-8"));
+			try {
+				require("fs").unlinkSync(tmpOut);
+			} catch {}
+			transformsSource = `{\n${Object.entries(fnStrings).map(([name, src]) => `  ${JSON.stringify(name)}: ${src}`).join(",\n")}\n}`;
+		} catch {}
+		const animusDir = (0, path.join)(rootDir, ".animus");
+		if (!(0, fs.existsSync)(animusDir)) (0, fs.mkdirSync)(animusDir, { recursive: true });
+		(0, fs.writeFileSync)((0, path.join)(animusDir, "system-props.js"), `export const systemPropMap = ${systemPropMap};\nexport const systemPropGroups = ${this.groupRegistryJson};\nexport const dynamicPropConfig = ${JSON.stringify(dynamicPropConfig)};\nexport const transforms = ${transformsSource};\n`);
+		require_singleton.setManifestJson(manifestJson);
+	}
+	loadSystem(rootDir, systemPath) {
+		const tmpOut = (0, path.join)((0, os.tmpdir)(), `animus-system-${Date.now()}.json`);
+		(0, _animus_ui_extract_pipeline.execSubprocess)(`const m = require(${JSON.stringify(systemPath)});\nconst exportNames = Object.keys(m);\nconst candidates = exportNames.filter(k => m[k] && typeof m[k].toConfig === 'function');\nif (candidates.length === 0) {\n  throw new Error('[animus-extract] No SystemInstance found. Exports: [' + exportNames.join(', ') + ']. None have a .toConfig() method. A SystemInstance is created by: export const ds = createSystem().build()');\n}\nif (candidates.length > 1) {\n  throw new Error('[animus-extract] Multiple SystemInstance candidates found: [' + candidates.join(', ') + ']. Specify which one to use.');\n}\nconst ds = m[candidates[0]];\nconst cfg = ds.toConfig();\nconst tokens = m.tokens || m.theme || null;\nconst serialized = tokens && typeof tokens.serialize === 'function' ? tokens.serialize() : null;\nconst globalStyleBlocks = {};\nfor (const [key, val] of Object.entries(m)) {\n  if (val && typeof val === 'object' && val.__brand === 'GlobalStyleBlock') {\n    globalStyleBlocks[key] = val.styles;\n  }\n}\nconst transformSources = {};\nfor (const [name, fn] of Object.entries(cfg.transforms || {})) {\n  transformSources[name] = fn.toString();\n}\nrequire('fs').writeFileSync(${JSON.stringify(tmpOut)}, JSON.stringify({\n  propConfig: cfg.propConfig,\n  groupRegistry: cfg.groupRegistry,\n  serialized: serialized,\n  transformNames: Object.keys(cfg.transforms || {}),\n  transformSources: transformSources,\n  globalStyleBlocks: Object.keys(globalStyleBlocks).length > 0 ? globalStyleBlocks : null\n}));\n`, rootDir);
+		const result = (0, fs.readFileSync)(tmpOut, "utf-8");
+		try {
+			require("fs").unlinkSync(tmpOut);
+		} catch {}
+		const parsed = JSON.parse(result);
+		this.configJson = parsed.propConfig;
+		this.groupRegistryJson = parsed.groupRegistry;
+		if (parsed.serialized) {
+			this.themeJson = parsed.serialized.scalesJson;
+			this.variableMapJson = parsed.serialized.variableMapJson;
+			this.variableCss = parsed.serialized.variableCss;
+			this.contextualVarsJson = parsed.serialized.contextualVarsJson;
+			if (this.options.prefix) {
+				const prefixed = (0, _animus_ui_extract_pipeline.applyPrefix)(this.options.prefix, this.variableMapJson, this.variableCss, this.themeJson, this.contextualVarsJson || void 0);
+				this.variableMapJson = prefixed.variableMapJson;
+				this.variableCss = prefixed.variableCss;
+				if (prefixed.themeJson) this.themeJson = prefixed.themeJson;
+				if (prefixed.contextualVarsJson) this.contextualVarsJson = prefixed.contextualVarsJson;
+			}
+		} else throw new Error("[animus-extract] Theme must be built with createTheme().build(). No .serialize() method found on tokens export.");
+		if (parsed.globalStyleBlocks) {
+			if (Object.keys(parsed.globalStyleBlocks).length > 0) try {
+				const hasTransforms = parsed.transformNames && parsed.transformNames.length > 0;
+				const flat = JSON.parse(this.themeJson);
+				const propConfig = JSON.parse(this.configJson);
+				const variableMap = {};
+				for (const [tokenPath, value] of Object.entries(flat)) if (typeof value === "string" && value.startsWith("var(") && value.endsWith(")")) variableMap[tokenPath] = value.slice(4, -1);
+				const transforms = {};
+				if (hasTransforms && parsed.transformSources) for (const [name, src] of Object.entries(parsed.transformSources)) try {
+					transforms[name] = new Function(`return (${src})`)();
+				} catch {}
+				const gsResult = (0, _animus_ui_extract_pipeline.resolveGlobalStyles)(parsed.globalStyleBlocks, propConfig, flat, variableMap, transforms);
+				const parts = Object.values(gsResult).filter(Boolean);
+				if (parts.length > 0) this.globalCss = `@layer global {\n${parts.join("\n\n")}\n}`;
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				if (this.options.strict) throw new Error(`[animus-extract] Global styles resolution failed: ${msg}`);
+				console.warn("[animus-extract] Global styles resolution failed:", msg);
+			}
+		}
+		if (parsed.transformNames && parsed.transformNames.length > 0) {
+			const tmpResolve = (0, path.join)((0, os.tmpdir)(), `animus-transforms-resolve-${Date.now()}.js`);
+			(0, fs.writeFileSync)(tmpResolve, `const m = require(${JSON.stringify(systemPath)});\nconst ds = m.ds || m.default || m.system;\nconst cfg = ds.toConfig();\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`);
+			this.systemResolveScript = tmpResolve;
+		}
+	}
+	resolveTransforms(rootDir, css) {
+		const { execSync } = require("child_process");
+		const ts = Date.now();
+		const tmpIn = (0, path.join)((0, os.tmpdir)(), `animus-css-${ts}.css`);
+		const tmpOut = (0, path.join)((0, os.tmpdir)(), `animus-css-${ts}.out.css`);
+		(0, fs.writeFileSync)(tmpIn, css);
+		execSync(`${(0, _animus_ui_extract_pipeline.detectRuntime)()} run "${this.systemResolveScript}" "${tmpIn}" "${tmpOut}"`, {
+			cwd: rootDir,
+			encoding: "utf-8"
+		});
+		const resolved = (0, fs.readFileSync)(tmpOut, "utf-8");
+		try {
+			require("fs").unlinkSync(tmpIn);
+			require("fs").unlinkSync(tmpOut);
+		} catch {}
+		return resolved;
+	}
+	discoverFiles(dir, rootDir, excludePatterns) {
+		const results = [];
+		const extensions = new Set([
+			".ts",
+			".tsx",
+			".js",
+			".jsx"
+		]);
+		const walk = (currentDir) => {
+			let entries;
+			try {
+				entries = (0, fs.readdirSync)(currentDir);
+			} catch {
+				return;
+			}
+			for (const entry of entries) {
+				const fullPath = (0, path.join)(currentDir, entry);
+				const relPath = (0, path.relative)(rootDir, fullPath);
+				if (excludePatterns.some((p) => relPath.includes(p))) continue;
+				let stat;
+				try {
+					stat = (0, fs.statSync)(fullPath);
+				} catch {
+					continue;
+				}
+				if (stat.isDirectory()) walk(fullPath);
+				else if (extensions.has((0, path.extname)(entry))) results.push(fullPath);
+			}
+		};
+		walk(dir);
+		return results;
+	}
+	resolvePackagesByName(rootDir, names) {
+		if (names.length === 0) return {};
+		const nameSet = new Set(names);
+		const resolved = /* @__PURE__ */ new Set();
+		const packageMap = {};
+		try {
+			const workspaces = JSON.parse((0, fs.readFileSync)((0, path.join)(rootDir, "package.json"), "utf-8")).workspaces || [];
+			for (const ws of workspaces) {
+				const wsDir = (0, path.resolve)(rootDir, ws);
+				if (!(0, fs.existsSync)(wsDir)) continue;
+				try {
+					const pkg = JSON.parse((0, fs.readFileSync)((0, path.join)(wsDir, "package.json"), "utf-8"));
+					const name = pkg.name || "";
+					if (nameSet.has(name)) {
+						const entryPath = (0, path.resolve)(wsDir, pkg.main || pkg.module || "index.ts");
+						if ((0, fs.existsSync)(entryPath)) {
+							packageMap[name] = (0, path.relative)(rootDir, entryPath);
+							resolved.add(name);
+						}
+					}
+				} catch {}
+			}
+		} catch {}
+		for (const name of nameSet) {
+			if (resolved.has(name)) continue;
+			try {
+				packageMap[name] = (0, path.relative)(rootDir, require.resolve(name, { paths: [rootDir] }));
+			} catch {}
+		}
+		return packageMap;
+	}
+	/**
+	* Reset analysis state for HMR geological reset.
+	*/
+	resetForHmr() {
+		require_singleton.resetAnalysisPromise();
+		this.lastCssHash = null;
+		try {
+			const { clearAnalysisCache } = require("@animus-ui/extract");
+			clearAnalysisCache();
+		} catch {}
+	}
+	/** Expose file cache for HMR change detection */
+	getFileCache() {
+		return this.fileCache;
+	}
+	/** Expose options for the loader */
+	getOptions() {
+		return this.options;
+	}
+	/** Expose external package directories for webpack loader allowlisting */
+	getExternalPackageDirs() {
+		return this.externalPackageDirs;
+	}
+	/** Expose external package source entries for webpack resolve alias */
+	getExternalSourceEntries() {
+		return this.externalSourceEntries;
+	}
+};
+//#endregion
+//#region src/with-animus.ts
+const __dirname$1 = (0, path.dirname)((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+let warnedGitignore = false;
+/**
+* Wrap a Next.js config to enable Animus static CSS extraction.
+*
+* ```ts
+* // next.config.ts
+* import { withAnimus } from '@animus-ui/next-plugin';
+* export default withAnimus({ system: './src/ds.ts' })({});
+* ```
+*/
+function withAnimus(options) {
+	if (!options.system) throw new Error("[animus-extract] Missing required option `system`. Provide the path to your SystemInstance module: withAnimus({ system: \"./src/ds.ts\" })");
+	return (nextConfig) => {
+		const existingWebpack = nextConfig.webpack;
+		return {
+			...nextConfig,
+			webpack(config, context) {
+				const rootDir = process.cwd();
+				const animusDir = (0, path.join)(rootDir, ".animus");
+				if (!(0, fs.existsSync)(animusDir)) (0, fs.mkdirSync)(animusDir, { recursive: true });
+				if (!warnedGitignore) {
+					warnedGitignore = true;
+					try {
+						const gitignorePath = (0, path.join)(rootDir, ".gitignore");
+						if ((0, fs.existsSync)(gitignorePath)) {
+							if (!(0, fs.readFileSync)(gitignorePath, "utf-8").includes(".animus")) console.warn("[animus-extract] Add `.animus/` to your .gitignore — it contains generated build artifacts.");
+						}
+					} catch {}
+				}
+				const plugin = new AnimusWebpackPlugin({
+					system: options.system,
+					exclude: options.exclude,
+					strict: options.strict,
+					verbose: options.verbose,
+					prefix: options.prefix
+				});
+				config.plugins = config.plugins || [];
+				config.plugins.push(plugin);
+				config.resolve = config.resolve || {};
+				config.resolve.alias = config.resolve.alias || {};
+				config.resolve.alias[".animus/styles.css"] = (0, path.join)(rootDir, ".animus", "styles.css");
+				const systemPropsPath = (0, path.join)(rootDir, ".animus", "system-props.js");
+				config.plugins.push({ apply(compiler) {
+					compiler.hooks.normalModuleFactory.tap("AnimusVirtualResolve", (nmf) => {
+						nmf.hooks.beforeResolve.tap("AnimusVirtualResolve", (resolveData) => {
+							if (resolveData.request === "virtual:animus/system-props") resolveData.request = systemPropsPath;
+							const srcEntry = plugin.getExternalSourceEntries().get(resolveData.request);
+							if (srcEntry) resolveData.request = srcEntry;
+						});
+					});
+				} });
+				const loaderPath = (0, path.resolve)(__dirname$1, "loader.mjs");
+				const actualLoaderPath = (0, fs.existsSync)(loaderPath) ? loaderPath : (0, path.resolve)(__dirname$1, "loader.ts");
+				config.module = config.module || {};
+				config.module.rules = config.module.rules || [];
+				config.module.rules.push({
+					test: (filePath) => {
+						if (/\.[jt]sx?$/.test(filePath)) return true;
+						if (/\.mjs$/.test(filePath)) return plugin.getExternalPackageDirs().some((dir) => filePath.startsWith(dir + path.sep) || filePath === dir);
+						return false;
+					},
+					exclude: (filePath) => {
+						if (!filePath.includes("node_modules")) return false;
+						return !plugin.getExternalPackageDirs().some((dir) => filePath.startsWith(dir + path.sep) || filePath === dir);
+					},
+					enforce: "pre",
+					use: [{
+						loader: actualLoaderPath,
+						options: { strict: options.strict }
+					}]
+				});
+				if (typeof existingWebpack === "function") return existingWebpack(config, context);
+				return config;
+			}
+		};
+	};
+}
+//#endregion
+exports.withAnimus = withAnimus;

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { a as setManifestJson, i as setAnalysisPromise, o as __require, r as resetAnalysisPromise, t as getAnalysisPromise } from "./singleton-BZ7W87Ir.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
 import { dirname, extname, join, relative, resolve, sep } from "path";
+import { fileURLToPath } from "url";
 import { createHash } from "crypto";
 import { tmpdir } from "os";
 import { applyPrefix, applyUnitFallback, assembleStylesheet, detectRuntime, execSubprocess, extractSystemFilePackages, resolveGlobalStyles } from "@animus-ui/extract/pipeline";
@@ -381,6 +382,7 @@ var AnimusWebpackPlugin = class {
 };
 //#endregion
 //#region src/with-animus.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
 let warnedGitignore = false;
 /**
 * Wrap a Next.js config to enable Animus static CSS extraction.

package/dist/loader.cjs

@@ -0,0 +1,53 @@
+const require_singleton = require("./singleton-VPOM1BCR.cjs");
+let path = require("path");
+//#region src/loader.ts
+/**
+* Regex matching CSS import lines injected by the Rust emitter.
+* Catches both the alias form (`import '.animus/styles.css'`) and
+* relative forms (`import '../.animus/styles.css'`).
+*/
+const CSS_IMPORT_RE = /import\s+['"][^'"]*\.animus\/styles\.css['"];\n?/g;
+/**
+* Root entry file patterns. CSS is imported ONLY here to prevent
+* per-chunk duplication in Next.js builds.
+*
+* - App Router: `app/layout.tsx` (root layout wraps all routes)
+* - Pages Router: `pages/_app.tsx` (custom App wraps all pages)
+*
+* The `(src\/)?` prefix handles projects that use a `src/` directory.
+*/
+const ROOT_ENTRY_RE = /^(src\/)?(?:app\/layout|pages\/_app)\.[tj]sx?$/;
+/**
+* Webpack loader for Animus source transformation.
+* Runs with enforce: 'pre' to see original source before Babel/SWC.
+* Replaces builder chains with createComponent() calls using the pre-built manifest.
+*
+* CSS handling: the Rust emitter injects `import '.animus/styles.css'` into every
+* file with extracted components. Without intervention, webpack duplicates the full
+* stylesheet into every route chunk. This loader strips those imports and re-injects
+* a single CSS import in the root layout/app file, ensuring one copy for the whole app.
+*/
+function animusLoader(source) {
+	const manifestJson = require_singleton.getManifestJson();
+	if (!manifestJson) return source;
+	const filename = (0, path.relative)(this.rootContext, this.resourcePath);
+	const isRootEntry = ROOT_ENTRY_RE.test(filename);
+	try {
+		const { transformFile } = require("@animus-ui/extract");
+		const result = transformFile(source, filename, manifestJson);
+		let code = result.hasComponents ? result.code : source;
+		code = code.replace(CSS_IMPORT_RE, "");
+		if (isRootEntry && !code.includes(".animus/styles.css")) if (code.startsWith("'use client'") || code.startsWith("\"use client\"")) {
+			const nl = code.indexOf("\n");
+			code = `${code.slice(0, nl + 1)}import '.animus/styles.css';\n${code.slice(nl + 1)}`;
+		} else code = `import '.animus/styles.css';\n${code}`;
+		return code;
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		if ((this.getOptions?.() ?? {}).strict) throw new Error(`[animus-extract] Transform failed for ${filename}: ${msg}`);
+		console.warn(`[animus-extract] Transform failed for ${filename}:`, msg);
+		return source;
+	}
+}
+//#endregion
+module.exports = animusLoader;

package/dist/singleton-VPOM1BCR.cjs

@@ -0,0 +1,56 @@
+//#region src/singleton.ts
+/**
+* Module-scope singleton for sharing analysis state between the webpack plugin and loader.
+*
+* Uses globalThis to survive the ESM/CJS module boundary: the plugin is loaded via ESM
+* (next.config.ts import) while the loader is loaded by webpack via require(). Without
+* globalThis, each module system gets its own singleton instance.
+*/
+const MANIFEST_KEY = "__animus_manifest_json__";
+const PROMISE_KEY = "__animus_analysis_promise__";
+function getManifestJson() {
+	return globalThis[MANIFEST_KEY];
+}
+function setManifestJson(json) {
+	globalThis[MANIFEST_KEY] = json;
+}
+function getAnalysisPromise() {
+	return globalThis[PROMISE_KEY];
+}
+function setAnalysisPromise(promise) {
+	globalThis[PROMISE_KEY] = promise;
+}
+function resetAnalysisPromise() {
+	globalThis[PROMISE_KEY] = null;
+}
+//#endregion
+Object.defineProperty(exports, "getAnalysisPromise", {
+	enumerable: true,
+	get: function() {
+		return getAnalysisPromise;
+	}
+});
+Object.defineProperty(exports, "getManifestJson", {
+	enumerable: true,
+	get: function() {
+		return getManifestJson;
+	}
+});
+Object.defineProperty(exports, "resetAnalysisPromise", {
+	enumerable: true,
+	get: function() {
+		return resetAnalysisPromise;
+	}
+});
+Object.defineProperty(exports, "setAnalysisPromise", {
+	enumerable: true,
+	get: function() {
+		return setAnalysisPromise;
+	}
+});
+Object.defineProperty(exports, "setManifestJson", {
+	enumerable: true,
+	get: function() {
+		return setManifestJson;
+	}
+});

package/dist/with-animus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"with-animus.d.ts","sourceRoot":"","sources":["../src/with-animus.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,KAAK,aAAa,GAAG;IACnB,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAChC,CAAC;IACF,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,KAAK,CAAC;YACZ,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;YAC5C,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;YAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;YACjB,GAAG,CAAC,EAAE,KAAK,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAC;gBAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;aAAE,CAAC,CAAC;SACpE,CAAC,CAAC;KACJ,CAAC;CACH,CAAC;AAEF,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC1C,OAAO,CAAC,EAAE,CACR,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,aAAa,CAAC;CACpB,CAAC;AAIF;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,iBAAiB,GACzB,CAAC,UAAU,EAAE,UAAU,KAAK,UAAU,CA4JxC"}
+{"version":3,"file":"with-animus.d.ts","sourceRoot":"","sources":["../src/with-animus.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAKjD,KAAK,aAAa,GAAG;IACnB,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAChC,CAAC;IACF,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,KAAK,CAAC;YACZ,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;YAC5C,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;YAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;YACjB,GAAG,CAAC,EAAE,KAAK,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAC;gBAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;aAAE,CAAC,CAAC;SACpE,CAAC,CAAC;KACJ,CAAC;CACH,CAAC;AAEF,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC1C,OAAO,CAAC,EAAE,CACR,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,aAAa,CAAC;CACpB,CAAC;AAIF;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,iBAAiB,GACzB,CAAC,UAAU,EAAE,UAAU,KAAK,UAAU,CA4JxC"}

package/package.json

@@ -1,22 +1,24 @@
 {
   "name": "@animus-ui/next-plugin",
-  "version": "0.1.0-next.39",
+  "version": "0.1.0-next.44",
   "description": "Animus static CSS extraction for Next.js (webpack)",
   "author": "codecaaron <airrobb@gmail.com>",
   "license": "MIT",
-  "main": "./dist/index.mjs",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "default": "./dist/index.mjs"
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
     },
     "./loader": {
       "types": "./dist/loader.d.ts",
       "import": "./dist/loader.mjs",
-      "default": "./dist/loader.mjs"
+      "require": "./dist/loader.cjs",
+      "default": "./dist/loader.cjs"
     }
   },
   "files": [
@@ -51,6 +53,6 @@
     "webpack": ">=5.0.0"
   },
   "dependencies": {
-    "@animus-ui/extract": "0.1.0-next.39"
+    "@animus-ui/extract": "0.1.0-next.44"
   }
 }