@animus-ui/unplugin 0.1.11

package/dist/core-C3ZORO6V.mjs

@@ -0,0 +1,420 @@
+import { AnimusConfigError, ENGINE_TRANSFORM_EXTENSIONS, assertKnownOptionKeys, assertNoRetiredEngineSelection, buildPathAliasesJson, isPathWithinRoot, readTsconfigAliasPairs, resolveMode } from "@animus-ui/extract/pipeline";
+import { ANIMUS_CSS_MODULE_ID, ExtractionSession, SESSION_ASSETS_DIR, TURBOPACK_SYSTEM_PROPS_ID, claimExclusiveSessionOwner, collectSessionAssets, engineApi, getAnalyzedHashes, getManifestJson, getSessionArtifactDir, getSharedCss, getSharedSystemProps } from "@animus-ui/extract/session";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+//#region src/options.ts
+/**
+* Host option intake — the transform host is the fourth driver over the
+* shared option core (openspec: standalone-extraction-cli, D2/D9): one
+* schema, `assertKnownOptionKeys` at the boundary, and an explicit
+* emission `mode` that is plumbed — never environment-sniffed (D10).
+*
+* Unlike the Vite/Next plugin drivers, this host HONORS the core `root`
+* key: rollup and esbuild expose no root authority a plugin could derive,
+* so the host's root is the explicit option, defaulting to the process
+* working directory (the CLI's shape, not the plugin drivers').
+*/
+/**
+* Validate raw options and resolve the root authority. Throws
+* `AnimusConfigError` (the shared config-error class) on unknown keys,
+* invalid `mode` values, a retired engine selection, or a missing
+* `system`.
+*/
+function resolveHostOptions(raw, cwd = process.cwd()) {
+	const options = raw ?? {};
+	assertNoRetiredEngineSelection(options.engine);
+	assertKnownOptionKeys(options);
+	if (typeof options.system !== "string" || options.system.length === 0) throw new AnimusConfigError("Missing required option `system` — pass `system: \"./src/ds.ts\"` to the Animus plugin.");
+	return {
+		root: options.root ? resolve(cwd, options.root) : cwd,
+		options
+	};
+}
+/**
+* Resolve the effective emission mode: the explicit option wins over every
+* bundler signal; otherwise the adapter-supplied command oracle applies;
+* otherwise production (the documented host default — never NODE_ENV).
+*/
+function resolveHostMode(explicit, oracle) {
+	return resolveMode(explicit, () => oracle ?? "production").mode;
+}
+//#endregion
+//#region src/core.ts
+/**
+* The Animus transform host core (openspec: standalone-extraction-cli,
+* D4 under D10): an unplugin factory that drives the ONE
+* `ExtractionSession` at buildStart inside the consumer's bundler process
+* and serves per-file transforms from retained engine state. No artifacts,
+* no lock, no staleness protocol — analysis failure IS build failure,
+* never a passthrough (the session's strict/policy seams carry this).
+*
+* Ported from the winning DEF-1 prototype arm
+* (e2e/rollup-app/prototype/animus-t0-plugin.mjs), productized per the
+* inc 05 packet: the emitted CSS reaches the consumer as a real asset
+* (NS3 — the prototype's CSS-as-string module was measurement
+* scaffolding), `__ANIMUS_DEV__` goes through each adapter's define
+* mechanism, kit-specifier redirects come from the session's discovery
+* output (the Turbopack alias assembly generalized), and the session
+* directory is cleaned on success AND failure (inc 04 rider F6).
+*
+* ORDERING CONTRACT: the host transform must run before any TS/JSX
+* transpilation — the engine parses raw TSX. `enforce: 'pre'` covers
+* webpack/rspack; rollup consumers must list this plugin before their
+* transpiler (see the e2e/rollup-app lane config).
+*/
+/** Resolved virtual id of the stylesheet import. Deliberately
+*  extension-free: esbuild guesses loaders from extensions, and this
+*  module is a JS stub in every bundler — the CSS itself is delivered as
+*  an emitted asset, never as a module (NS3). No `\0` prefix: webpack's
+*  virtual-module bridge requires plain ids. */
+const STYLES_VIRTUAL_ID = "animus:styles";
+/** Resolved virtual id of the emitted system-props runtime module. */
+const PROPS_VIRTUAL_ID = "animus:system-props";
+/** File name of the emitted stylesheet asset. */
+const CSS_ASSET_NAME = "animus.css";
+/** Files the engine transform may rewrite — derived from the ONE shared
+*  extension set (also the Turbopack rule glob's source). */
+const ENGINE_TRANSFORM_RE = new RegExp(`\\.(?:${ENGINE_TRANSFORM_EXTENSIONS.join("|")})$`);
+/** Files the transform hook claims at all (define substitution included —
+*  `.cjs` carries no components but may read the dev-signal token). */
+const TRANSFORM_INCLUDE_RE = new RegExp(`\\.(?:${[...ENGINE_TRANSFORM_EXTENSIONS, "cjs"].join("|")})$`);
+/** Bare dev-signal token, assignment-guarded like @rollup/plugin-replace's
+*  `preventAssignment` — `__ANIMUS_DEV__ = x` is left alone. */
+const DEV_DEFINE_RE = /\b__ANIMUS_DEV__\b(?!\s*=[^=])/g;
+function createHostState() {
+	return {
+		pipeline: null,
+		mode: null,
+		cssText: "",
+		systemPropsJs: "",
+		kitRedirects: /* @__PURE__ */ new Map(),
+		redirectTargets: /* @__PURE__ */ new Set(),
+		externalPackageDirs: [],
+		watchPaths: [],
+		transformFile: null,
+		sessionDir: null
+	};
+}
+/**
+* The transform-claim predicate over module paths. The analysis universe
+* deliberately excludes node_modules (external kits ride their own
+* collection path), so the transform must too — the Next webpack rule's
+* exclude, ported: without it every dependency module in the graph is
+* routed through the engine, scaling build time with dependency-graph size
+* instead of source-file count. node_modules paths are claimed only when
+* they belong to an ADMITTED external package (or are a kit redirect
+* target) — those carry builder chains the engine must rewrite. Such files
+* only enter the module graph after discovery published (their specifiers
+* resolve through the pipeline-gated kitRedirects), so consulting captured
+* state here is race-free.
+*/
+function shouldClaimTransform(filePath, state) {
+	if (!filePath.includes("node_modules")) return true;
+	return state.redirectTargets.has(filePath) || state.externalPackageDirs.some((dir) => isPathWithinRoot(dir, filePath));
+}
+/** Remove the one-shot session tree; idempotent, runs on success AND
+*  failure paths (inc 04 rider F6). */
+function disposeSessionDir(state, removeDir = (dir) => rmSync(dir, {
+	recursive: true,
+	force: true
+})) {
+	if (state.sessionDir) {
+		removeDir(state.sessionDir);
+		state.sessionDir = null;
+	}
+}
+/**
+* Run one pipeline attempt through the shared drive loop, recording it as
+* `state.pipeline` for hook joiners. A failed attempt disposes the session
+* directory before rethrowing — the consumer's build fails; nothing leaks.
+*/
+async function drivePipeline(state, run, removeDir) {
+	const attempt = run();
+	state.pipeline = attempt;
+	try {
+		await attempt;
+	} catch (error) {
+		if (!state.sessionDir) state.sessionDir = getSessionArtifactDir();
+		disposeSessionDir(state, removeDir);
+		throw error;
+	}
+}
+/**
+* Map an import id onto the host's CONSTANT resolution family: the
+* stylesheet id and the system-props id — the mappings that answer without
+* the pipeline. Kit-specifier redirects are the caller's second step (they
+* exist only after discovery published, behind the pipeline join).
+*/
+function resolveAnimusId(id) {
+	if (id === ANIMUS_CSS_MODULE_ID || id.endsWith(`/${ANIMUS_CSS_MODULE_ID}`)) return STYLES_VIRTUAL_ID;
+	if (id === "animus:styles" || id === "animus:system-props") return id;
+	if (id === TURBOPACK_SYSTEM_PROPS_ID) return PROPS_VIRTUAL_ID;
+	return null;
+}
+/**
+* Substitute the bare `__ANIMUS_DEV__` token with its boolean literal —
+* the define mechanism for bundlers without a native one (rollup). The
+* token-as-initializer-conditional shape in the system runtime's is-dev
+* module folds under the bundler's own dead-branch elimination once the
+* literal lands. Returns null when the code carries no token.
+*/
+function substituteDevDefine(code, isDev) {
+	if (!code.includes("__ANIMUS_DEV__")) return null;
+	return code.replace(DEV_DEFINE_RE, isDev ? "true" : "false");
+}
+/**
+* Per-file engine transform from retained state. The path handed to the
+* engine is the rootDir-relative posix key the analysis used — external
+* kit sources ride the same derivation (`../…` keys). Files outside the
+* analysis universe come back unchanged (`hasComponents: false`); a
+* transform before analysis fails loud inside the engine adapter.
+*/
+function transformWithEngine(code, id, ctx) {
+	const filename = relative(ctx.rootDir, resolve(id)).split("\\").join("/");
+	const result = ctx.transformFile(code, filename, ctx.manifestJson);
+	return result.hasComponents ? result.code : null;
+}
+/** Strip a bundler query suffix (`?worker`, webpack resource queries). */
+function moduleFilePath(id) {
+	const query = id.indexOf("?");
+	return query === -1 ? id : id.slice(0, query);
+}
+const PLUGIN_NAME = "animus-host";
+/**
+* The one-live-host-per-process constraint, enforced where the invariant
+* lives: the SESSION singleton (its slots are what concurrent hosts would
+* clobber). Re-exported under the host's historical name; the key sits in
+* `SINGLETON_GLOBAL_KEYS`, so test harness resets clear a leaked claim.
+*/
+const claimProcessHost = claimExclusiveSessionOwner;
+/**
+* The unplugin factory. One factory invocation = one host = one session
+* per build; the singleton drive loop stays exactly-one (guardrail G1 —
+* the host defines no session class and no drive loop of its own).
+*/
+const unpluginFactory = (rawOptions, meta) => {
+	const { root, options } = resolveHostOptions(rawOptions);
+	const state = createHostState();
+	/** Release handle of this host's process claim, or null when not held. */
+	let releaseHostClaim = null;
+	/** Adapter-supplied command oracle (null = no bundler signal). */
+	let modeOracle = null;
+	let esbuildOptions = null;
+	/** Resolves once buildStart has begun — hooks that can fire before the
+	*  bundler-parallel buildStart (webpack's make taps run concurrently)
+	*  wait on this, then join the pipeline itself. */
+	let signalPipelineStarted;
+	const pipelineStarted = new Promise((res) => {
+		signalPipelineStarted = res;
+	});
+	const effectiveMode = () => resolveHostMode(options.mode, modeOracle);
+	/** The define is supplied natively where the bundler has a mechanism
+	*  (esbuild define, webpack/rspack DefinePlugin); everywhere else the
+	*  transform substitutes the token itself. */
+	const needsInlineDefine = meta.framework !== "esbuild" && meta.framework !== "webpack" && meta.framework !== "rspack";
+	async function startPipeline() {
+		signalPipelineStarted();
+		releaseHostClaim = claimProcessHost(`${PLUGIN_NAME}:${root}`);
+		try {
+			await runClaimedPipeline();
+		} catch (error) {
+			releaseClaim();
+			throw error;
+		}
+	}
+	function releaseClaim() {
+		releaseHostClaim?.();
+		releaseHostClaim = null;
+	}
+	async function runClaimedPipeline() {
+		await drivePipeline(state, async () => {
+			const mode = effectiveMode();
+			state.mode = mode;
+			const session = new ExtractionSession({
+				...options,
+				mode
+			});
+			session.driverLabel = "animus-unplugin";
+			session.rootDir = root;
+			session.systemPropsModuleId = TURBOPACK_SYSTEM_PROPS_ID;
+			const builtAliases = buildPathAliasesJson(readTsconfigAliasPairs(root), root);
+			if (builtAliases) session.pathAliasesJson = builtAliases.json;
+			await session.runFullPipeline();
+			state.sessionDir = getSessionArtifactDir();
+			const analyzed = getAnalyzedHashes();
+			if (!analyzed || analyzed.size === 0) throw new Error(`[animus] discovery found zero source files under ${root} — check the plugin's \`root\` and \`exclude\` options`);
+			state.cssText = getSharedCss();
+			state.systemPropsJs = getSharedSystemProps();
+			state.kitRedirects = new Map(session.externalSourceEntries);
+			state.redirectTargets = new Set(state.kitRedirects.values());
+			state.externalPackageDirs = [...session.externalPackageDirs];
+			const watchPaths = /* @__PURE__ */ new Set();
+			for (const key of getAnalyzedHashes()?.keys() ?? []) watchPaths.add(resolve(root, key));
+			for (const dep of session.systemDependencyPaths) watchPaths.add(dep);
+			for (const dep of session.assetDependencyPaths) watchPaths.add(dep);
+			watchPaths.add(join(root, "tsconfig.json"));
+			state.watchPaths = [...watchPaths];
+			state.transformFile = engineApi().transformFile;
+		});
+	}
+	/** Join the analysis: every serving hook waits for buildStart to have
+	*  begun, then for the pipeline to have published. A rejected pipeline
+	*  rejects every joiner — analysis failure is build failure, never a
+	*  passthrough. */
+	async function joinPipeline() {
+		await pipelineStarted;
+		await state.pipeline;
+	}
+	function emitCssAsset(context) {
+		if (!state.cssText) return;
+		const assets = collectSessionAssets(state.sessionDir);
+		if (meta.framework === "esbuild") {
+			const outDir = esbuildOptions?.outdir ?? (esbuildOptions?.outfile ? dirname(esbuildOptions.outfile) : null);
+			if (outDir === null) {
+				console.warn(`[animus] esbuild build has no outdir/outfile — the extracted stylesheet (${CSS_ASSET_NAME}) was not written`);
+				return;
+			}
+			if (esbuildOptions?.write === false) {
+				console.warn(`[animus] esbuild \`write: false\` build — the extracted stylesheet (${CSS_ASSET_NAME}) and its asset files were NOT produced (no in-memory output seam); use \`write: true\` or the standalone \`animus build\` CLI for in-memory pipelines`);
+				return;
+			}
+			const absOut = resolve(esbuildOptions?.absWorkingDir ?? process.cwd(), outDir);
+			mkdirSync(absOut, { recursive: true });
+			writeFileSync(join(absOut, CSS_ASSET_NAME), state.cssText);
+			if (assets.length > 0) {
+				mkdirSync(join(absOut, SESSION_ASSETS_DIR), { recursive: true });
+				for (const { name, bytes } of assets) writeFileSync(join(absOut, SESSION_ASSETS_DIR, name), bytes);
+			}
+			return;
+		}
+		context.emitFile({
+			type: "asset",
+			fileName: CSS_ASSET_NAME,
+			source: state.cssText
+		});
+		for (const { name, bytes } of assets) context.emitFile({
+			type: "asset",
+			fileName: `${SESSION_ASSETS_DIR}/${name}`,
+			source: bytes
+		});
+	}
+	/** Register the analysis universe with the bundler's watcher — the
+	*  session analyzes a filesystem WALK, so watch mode misses edits to
+	*  analyzed-but-unimported files (and tsconfig/system deps) without
+	*  this. esbuild has no per-plugin watch-file seam; its rebuilds rely on
+	*  the module graph alone. */
+	function registerWatchTargets(context) {
+		if (meta.framework === "esbuild") return;
+		for (const path of state.watchPaths) try {
+			context.addWatchFile(path);
+		} catch {}
+	}
+	return {
+		name: PLUGIN_NAME,
+		enforce: "pre",
+		async buildStart() {
+			await startPipeline();
+			registerWatchTargets(this);
+		},
+		async resolveId(id) {
+			const virtual = resolveAnimusId(id);
+			if (virtual !== null) return virtual;
+			if (id.startsWith(".") || id.startsWith("/") || id.startsWith("\0") || id.startsWith("animus:")) return null;
+			await joinPipeline();
+			return state.kitRedirects.get(id) ?? null;
+		},
+		loadInclude(id) {
+			return id === "animus:styles" || id === "animus:system-props" || state.redirectTargets.has(moduleFilePath(id));
+		},
+		async load(id) {
+			if (id === "animus:styles") {
+				await joinPipeline();
+				return {
+					code: "export {};\n",
+					map: null
+				};
+			}
+			if (id === "animus:system-props") {
+				await joinPipeline();
+				return {
+					code: state.systemPropsJs,
+					map: null
+				};
+			}
+			const filePath = moduleFilePath(id);
+			if (state.redirectTargets.has(filePath)) return {
+				code: readFileSync(filePath, "utf-8"),
+				map: null
+			};
+			return null;
+		},
+		transformInclude(id) {
+			const filePath = moduleFilePath(id);
+			return !id.startsWith("\0") && !id.startsWith("animus:") && TRANSFORM_INCLUDE_RE.test(filePath) && shouldClaimTransform(filePath, state);
+		},
+		async transform(code, id) {
+			await joinPipeline();
+			const filePath = moduleFilePath(id);
+			let output = code;
+			if (ENGINE_TRANSFORM_RE.test(filePath)) {
+				const transformFile = state.transformFile ?? engineApi().transformFile;
+				const transformed = transformWithEngine(output, filePath, {
+					rootDir: root,
+					manifestJson: getManifestJson() ?? "",
+					transformFile
+				});
+				if (transformed !== null) output = transformed;
+			}
+			if (needsInlineDefine) {
+				const substituted = substituteDevDefine(output, state.mode === "development");
+				if (substituted !== null) output = substituted;
+			}
+			return output === code ? null : {
+				code: output,
+				map: null
+			};
+		},
+		buildEnd() {
+			try {
+				emitCssAsset(this);
+			} finally {
+				disposeSessionDir(state);
+				releaseClaim();
+			}
+		},
+		rollup: { async buildStart() {
+			modeOracle = this.meta?.watchMode ? "development" : "production";
+			await startPipeline();
+			registerWatchTargets(this);
+		} },
+		webpack(compiler) {
+			wireWebpackLike(compiler);
+		},
+		rspack(compiler) {
+			wireWebpackLike(compiler);
+		},
+		esbuild: { config(buildOptions) {
+			esbuildOptions = buildOptions;
+			buildOptions.define = {
+				...buildOptions.define,
+				__ANIMUS_DEV__: JSON.stringify(effectiveMode() === "development")
+			};
+		} }
+	};
+	function wireWebpackLike(compiler) {
+		modeOracle = compiler.options.mode === "development" ? "development" : "production";
+		const DefinePlugin = compiler.webpack?.DefinePlugin ?? compiler.rspack?.DefinePlugin;
+		if (!DefinePlugin) throw new Error("[animus] compiler exposes no DefinePlugin — cannot supply the __ANIMUS_DEV__ dev-signal define");
+		new DefinePlugin({ __ANIMUS_DEV__: JSON.stringify(effectiveMode() === "development") }).apply(compiler);
+		compiler.hooks.done.tap(PLUGIN_NAME, () => {
+			disposeSessionDir(state);
+			releaseClaim();
+		});
+		compiler.hooks.failed?.tap(PLUGIN_NAME, () => {
+			disposeSessionDir(state);
+			releaseClaim();
+		});
+	}
+};
+//#endregion
+export { unpluginFactory as t };

package/dist/core.d.ts

@@ -0,0 +1,136 @@
+/**
+ * The Animus transform host core (openspec: standalone-extraction-cli,
+ * D4 under D10): an unplugin factory that drives the ONE
+ * `ExtractionSession` at buildStart inside the consumer's bundler process
+ * and serves per-file transforms from retained engine state. No artifacts,
+ * no lock, no staleness protocol — analysis failure IS build failure,
+ * never a passthrough (the session's strict/policy seams carry this).
+ *
+ * Ported from the winning DEF-1 prototype arm
+ * (e2e/rollup-app/prototype/animus-t0-plugin.mjs), productized per the
+ * inc 05 packet: the emitted CSS reaches the consumer as a real asset
+ * (NS3 — the prototype's CSS-as-string module was measurement
+ * scaffolding), `__ANIMUS_DEV__` goes through each adapter's define
+ * mechanism, kit-specifier redirects come from the session's discovery
+ * output (the Turbopack alias assembly generalized), and the session
+ * directory is cleaned on success AND failure (inc 04 rider F6).
+ *
+ * ORDERING CONTRACT: the host transform must run before any TS/JSX
+ * transpilation — the engine parses raw TSX. `enforce: 'pre'` covers
+ * webpack/rspack; rollup consumers must list this plugin before their
+ * transpiler (see the e2e/rollup-app lane config).
+ */
+import { claimExclusiveSessionOwner } from '@animus-ui/extract/session';
+import type { AnimusUnpluginOptions } from './options';
+import type { AnimusMode } from '@animus-ui/extract/pipeline';
+import type { UnpluginFactory } from 'unplugin';
+/** Resolved virtual id of the stylesheet import. Deliberately
+ *  extension-free: esbuild guesses loaders from extensions, and this
+ *  module is a JS stub in every bundler — the CSS itself is delivered as
+ *  an emitted asset, never as a module (NS3). No `\0` prefix: webpack's
+ *  virtual-module bridge requires plain ids. */
+export declare const STYLES_VIRTUAL_ID = "animus:styles";
+/** Resolved virtual id of the emitted system-props runtime module. */
+export declare const PROPS_VIRTUAL_ID = "animus:system-props";
+/** File name of the emitted stylesheet asset. */
+export declare const CSS_ASSET_NAME = "animus.css";
+/** Mutable per-build host state (one per factory invocation). */
+export interface HostState {
+    /** The in-flight (or settled) analysis; transforms and loads await it. */
+    pipeline: Promise<void> | null;
+    /** Resolved emission mode of the current build. */
+    mode: AnimusMode | null;
+    /** Assembled stylesheet of the published analysis ('' until published). */
+    cssText: string;
+    /** Emitted system-props runtime module source. */
+    systemPropsJs: string;
+    /** Kit specifier → absolute analyzed source entry (discovery output). */
+    kitRedirects: Map<string, string>;
+    /** Absolute analyzed entries (values of kitRedirects) — load allowlist. */
+    redirectTargets: Set<string>;
+    /** Admitted external package dirs (discovery output) — the ONLY
+     *  node_modules subtrees the transform claims. */
+    externalPackageDirs: string[];
+    /** Absolute paths of the ANALYSIS UNIVERSE — every analyzed source file
+     *  plus the system module's evaluated dependencies, asset() files, and
+     *  the tsconfig alias source. Registered with the bundler's watcher: the
+     *  session analyzes a filesystem walk, not the module graph, so an edit
+     *  to an analyzed-but-unimported file must still trigger a rebuild. */
+    watchPaths: string[];
+    /** The engine adapter's transformFile, resolved once per pipeline run —
+     *  never per module. */
+    transformFile: ((source: string, path: string, manifestJson: string) => {
+        code: string;
+        hasComponents: boolean;
+    }) | null;
+    /** Session artifact directory awaiting cleanup, or null. */
+    sessionDir: string | null;
+}
+export declare function createHostState(): HostState;
+/**
+ * The transform-claim predicate over module paths. The analysis universe
+ * deliberately excludes node_modules (external kits ride their own
+ * collection path), so the transform must too — the Next webpack rule's
+ * exclude, ported: without it every dependency module in the graph is
+ * routed through the engine, scaling build time with dependency-graph size
+ * instead of source-file count. node_modules paths are claimed only when
+ * they belong to an ADMITTED external package (or are a kit redirect
+ * target) — those carry builder chains the engine must rewrite. Such files
+ * only enter the module graph after discovery published (their specifiers
+ * resolve through the pipeline-gated kitRedirects), so consulting captured
+ * state here is race-free.
+ */
+export declare function shouldClaimTransform(filePath: string, state: Pick<HostState, 'externalPackageDirs' | 'redirectTargets'>): boolean;
+/** Remove the one-shot session tree; idempotent, runs on success AND
+ *  failure paths (inc 04 rider F6). */
+export declare function disposeSessionDir(state: HostState, removeDir?: (dir: string) => void): void;
+/**
+ * Run one pipeline attempt through the shared drive loop, recording it as
+ * `state.pipeline` for hook joiners. A failed attempt disposes the session
+ * directory before rethrowing — the consumer's build fails; nothing leaks.
+ */
+export declare function drivePipeline(state: HostState, run: () => Promise<void>, removeDir?: (dir: string) => void): Promise<void>;
+/**
+ * Map an import id onto the host's CONSTANT resolution family: the
+ * stylesheet id and the system-props id — the mappings that answer without
+ * the pipeline. Kit-specifier redirects are the caller's second step (they
+ * exist only after discovery published, behind the pipeline join).
+ */
+export declare function resolveAnimusId(id: string): string | null;
+/**
+ * Substitute the bare `__ANIMUS_DEV__` token with its boolean literal —
+ * the define mechanism for bundlers without a native one (rollup). The
+ * token-as-initializer-conditional shape in the system runtime's is-dev
+ * module folds under the bundler's own dead-branch elimination once the
+ * literal lands. Returns null when the code carries no token.
+ */
+export declare function substituteDevDefine(code: string, isDev: boolean): string | null;
+/**
+ * Per-file engine transform from retained state. The path handed to the
+ * engine is the rootDir-relative posix key the analysis used — external
+ * kit sources ride the same derivation (`../…` keys). Files outside the
+ * analysis universe come back unchanged (`hasComponents: false`); a
+ * transform before analysis fails loud inside the engine adapter.
+ */
+export declare function transformWithEngine(code: string, id: string, ctx: {
+    rootDir: string;
+    manifestJson: string;
+    transformFile: (source: string, path: string, manifestJson: string) => {
+        code: string;
+        hasComponents: boolean;
+    };
+}): string | null;
+/**
+ * The one-live-host-per-process constraint, enforced where the invariant
+ * lives: the SESSION singleton (its slots are what concurrent hosts would
+ * clobber). Re-exported under the host's historical name; the key sits in
+ * `SINGLETON_GLOBAL_KEYS`, so test harness resets clear a leaked claim.
+ */
+export declare const claimProcessHost: typeof claimExclusiveSessionOwner;
+/**
+ * The unplugin factory. One factory invocation = one host = one session
+ * per build; the singleton drive loop stays exactly-one (guardrail G1 —
+ * the host defines no session class and no drive loop of its own).
+ */
+export declare const unpluginFactory: UnpluginFactory<AnimusUnpluginOptions | undefined>;
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"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"}

package/dist/esbuild.cjs

@@ -0,0 +1,17 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_core = require("./core-B2NB6x1D.cjs");
+//#region src/esbuild.ts
+/**
+* esbuild entry: `import animus from '@animus-ui/unplugin/esbuild'`.
+* The dev-signal define rides `build.initialOptions.define`; the emitted
+* stylesheet is written into `outdir` (or beside `outfile`).
+*/
+/** Named beside default: keeps the CJS emission on the `exports.default`
+*  interop shape (attw node16). */
+const animusEsbuild = (0, require("unplugin").createEsbuildPlugin)(require_core.unpluginFactory);
+//#endregion
+exports.animusEsbuild = animusEsbuild;
+exports.default = animusEsbuild;

package/dist/esbuild.d.ts

@@ -0,0 +1,11 @@
+/**
+ * esbuild entry: `import animus from '@animus-ui/unplugin/esbuild'`.
+ * The dev-signal define rides `build.initialOptions.define`; the emitted
+ * stylesheet is written into `outdir` (or beside `outfile`).
+ */
+export type { AnimusUnpluginOptions } from './options';
+/** Named beside default: keeps the CJS emission on the `exports.default`
+ *  interop shape (attw node16). */
+export declare const animusEsbuild: (options?: import("@animus-ui/extract/pipeline").AnimusCoreOptions | undefined) => import("unplugin").EsbuildPlugin;
+export default animusEsbuild;
+//# sourceMappingURL=esbuild.d.ts.map

package/dist/esbuild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild.d.ts","sourceRoot":"","sources":["../src/esbuild.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,YAAY,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAEvD;mCACmC;AACnC,eAAO,MAAM,aAAa,qHAAuC,CAAC;eAEnD,aAAa"}

package/dist/esbuild.mjs

@@ -0,0 +1,13 @@
+import { t as unpluginFactory } from "./core-C3ZORO6V.mjs";
+import { createEsbuildPlugin } from "unplugin";
+//#region src/esbuild.ts
+/**
+* esbuild entry: `import animus from '@animus-ui/unplugin/esbuild'`.
+* The dev-signal define rides `build.initialOptions.define`; the emitted
+* stylesheet is written into `outdir` (or beside `outfile`).
+*/
+/** Named beside default: keeps the CJS emission on the `exports.default`
+*  interop shape (attw node16). */
+const animusEsbuild = createEsbuildPlugin(unpluginFactory);
+//#endregion
+export { animusEsbuild, animusEsbuild as default };

package/dist/index.cjs

@@ -0,0 +1,24 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_core = require("./core-B2NB6x1D.cjs");
+//#region src/index.ts
+/**
+* `@animus-ui/unplugin` — the Animus transform host for non-plugin
+* bundlers (openspec: standalone-extraction-cli, D4/D10). Per-bundler
+* entry points live on subpaths (`./rollup`, `./esbuild`, `./rspack`,
+* `./webpack`); this root exports the unplugin instance and the factory.
+*
+* UNSTABLE MODULE SURFACE: the supported consumer surface is the
+* per-bundler subpath entries. The factory and instance exports exist for
+* the repo's own lanes and tests and may change without semver ceremony
+* until the consumer contract ships (standalone-extraction-cli inc 07).
+*/
+/** The unplugin instance: `animusUnplugin.rollup(options)`, `.esbuild(…)`,
+*  `.webpack(…)`, `.rspack(…)`. */
+const animusUnplugin = (0, require("unplugin").createUnplugin)(require_core.unpluginFactory);
+//#endregion
+exports.animusUnplugin = animusUnplugin;
+exports.default = animusUnplugin;
+exports.unpluginFactory = require_core.unpluginFactory;

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@animus-ui/unplugin` — the Animus transform host for non-plugin
+ * bundlers (openspec: standalone-extraction-cli, D4/D10). Per-bundler
+ * entry points live on subpaths (`./rollup`, `./esbuild`, `./rspack`,
+ * `./webpack`); this root exports the unplugin instance and the factory.
+ *
+ * UNSTABLE MODULE SURFACE: the supported consumer surface is the
+ * per-bundler subpath entries. The factory and instance exports exist for
+ * the repo's own lanes and tests and may change without semver ceremony
+ * until the consumer contract ships (standalone-extraction-cli inc 07).
+ */
+import { unpluginFactory } from './core';
+export type { AnimusUnpluginOptions } from './options';
+export { unpluginFactory };
+/** The unplugin instance: `animusUnplugin.rollup(options)`, `.esbuild(…)`,
+ *  `.webpack(…)`, `.rspack(…)`. */
+export declare const animusUnplugin: import("unplugin").UnpluginInstance<import("@animus-ui/extract/pipeline").AnimusCoreOptions | undefined, boolean>;
+export default animusUnplugin;
+//# 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":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAEzC,YAAY,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B;mCACmC;AACnC,eAAO,MAAM,cAAc,mHAAkC,CAAC;eAE/C,cAAc"}