@animus-ui/next-plugin 0.1.11 → 0.1.12

package/dist/index.mjs

@@ -1,17 +1,11 @@
-import { ENGINE_TRANSFORM_EXTENSIONS, assembleStylesheet, assertKnownOptionKeys, assertNoRetiredEngineSelection, buildPathAliasesJson, isPathWithinRoot, readTsconfigAliasPairs, resolveMode } from "@animus-ui/extract/pipeline";
-import { ANIMUS_CSS_MODULE_ID, ANIMUS_CSS_MODULE_ID as ANIMUS_CSS_MODULE_ID$1, ExtractionSession, STYLES_ARTIFACT, SYSTEM_PROPS_ARTIFACT, TURBOPACK_SYSTEM_PROPS_ID, getAnalysisPromise, getReplacementEpoch, getSharedCss, getSharedExternalDirs, getSharedExternalEntries, replacementEpochPath, runSessionPipeline, sessionArtifactDir, setAnalysisPromise, setSharedEngine, startTurbopackWatcher, stylesPath, systemPropsPath } from "@animus-ui/extract/session";
+import { ENGINE_TRANSFORM_EXTENSIONS, assembleStylesheet, assertKnownOptionKeys, assertNoRetiredEngineSelection, buildPathAliasesJson, isEngineTransformExtension, isPathWithinRoot, readTsconfigAliasPairs, resolveMode } from "@animus-ui/extract/pipeline";
+import { ANIMUS_CSS_MODULE_ID, ANIMUS_CSS_MODULE_ID as ANIMUS_CSS_MODULE_ID$1, ExtractionSession, STYLES_ARTIFACT, SYSTEM_PROPS_ARTIFACT, TURBOPACK_SYSTEM_PROPS_ID, getAnalysisStartedPromise, getReplacementEpoch, getSharedCss, getSharedExternalDirs, getSharedExternalEntries, replacementEpochPath, runSessionPipeline, sessionArtifactDir, setAnalysisStartedPromise, setSharedEngine, startTurbopackWatcher, stylesPath, systemPropsPath } from "@animus-ui/extract/session";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join, relative, resolve } from "path";
 import { fileURLToPath } from "url";
 //#region src/loader-path.ts
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-/**
-* The one loader-path derivation: first existing dist candidate under the
-* plugin dir, else the in-repo source fallback. Both loader resolvers below
-* are thin wrappers, so rule registration and any loader-chain predicate
-* can never drift (openspec: next-webpack-served-transform-coherence,
-* design D1).
-*/
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
 function resolveLoaderPath(pluginDir, distCandidates, sourceFallback) {
 	for (const candidate of distCandidates) {
 		const distPath = resolve(pluginDir, candidate);
@@ -19,69 +13,38 @@ function resolveLoaderPath(pluginDir, distCandidates, sourceFallback) {
 	}
 	return resolve(pluginDir, sourceFallback);
 }
-/**
-* This package's webpack loader path, shared by the rule registration
-* (with-animus) and the needBuild loader-chain predicate (plugin). Compiled
-* dist ships `loader.mjs` next to this module; running from source falls
-* back to the TypeScript loader.
-*/
 function resolveAnimusLoaderPath() {
 	return resolveLoaderPath(__dirname$1, ["loader.mjs"], "loader.ts");
 }
 //#endregion
 //#region src/plugin.ts
-/** Loud unsupported-version failure (design D7): the coherence mechanism
-*  cannot exist without the per-compilation needBuild hook, so a webpack
-*  that lacks it fails immediately instead of serving stale transforms. */
-const UNSUPPORTED_WEBPACK_MESSAGE = "[animus-extract] Unsupported webpack: NormalModule.getCompilationHooks(compilation).needBuild is required for dev transform coherence and this webpack does not expose it. Use a Next.js version covered by the animus webpack gauntlet.";
+/** The value arrives from a consumer's `next.config`, so the union above is a
+*  model of what webpack accepts, not a proof about the value in hand. */
+const isWatchIgnoreString = (ignored) => Object.prototype.toString.call(ignored) === "[object String]";
+const isWatchIgnoreMatcher = (ignored) => Object.prototype.toString.call(ignored) === "[object Function]";
+const UNSUPPORTED_WEBPACK_MESSAGE = "[animus-extract] Unsupported webpack: NormalModule.getCompilationHooks(compilation).needBuild is required for dev transform coherence and this webpack does not expose it. Use a Next.js version whose webpack exposes this hook.";
 const PLUGIN_NAME = "AnimusWebpackPlugin";
-/**
-* Webpack adapter for the extraction pipeline. All pipeline logic lives in
-* the bundler-agnostic ExtractionSession — this class owns only the webpack
-* wiring: hook registration, cross-compiler analysis dedup, alias
-* harvesting from the compiler config, watch-event translation, and
-* in-memory CSS asset replacement.
-*/
 var AnimusWebpackPlugin = class {
 	options;
 	session;
 	initialized = false;
 	aliasesExtracted = false;
-	/** Loader paths counting as "the animus loader" in a module's chain —
-	*  this package's own loader plus an optional harness override. */
 	animusLoaderPaths;
-	/** Epoch THIS compiler last proceeded with (set after every awaited
-	*  watchRun transaction — including joined ones). Null until the
-	*  initialization pipeline publishes. */
 	lastBuiltEpoch = null;
-	/** Armed by watchRun when the transaction moved the epoch; captured and
-	*  disarmed by the next compilation's needBuild wiring (design D1). */
 	epochMovedForNextCompilation = false;
 	constructor(options) {
 		this.options = options;
 		assertNoRetiredEngineSelection(options.engine);
 		setSharedEngine(options.engine ?? "v2");
 		this.session = new ExtractionSession(options);
-		this.animusLoaderPaths = new Set([resolveAnimusLoaderPath()]);
+		this.animusLoaderPaths = /* @__PURE__ */ new Set([resolveAnimusLoaderPath()]);
 		if (options.loaderPath) this.animusLoaderPaths.add(options.loaderPath);
 	}
-	/** True when the module's loader chain contains the animus loader — the
-	*  needBuild fan-out predicate (design D1: no historical records; covers
-	*  restored persistent-cache modules and raw passthroughs alike). */
 	moduleUsesAnimusLoader(module) {
 		const loaders = module?.loaders;
 		if (!Array.isArray(loaders)) return false;
-		return loaders.some((entry) => typeof entry?.loader === "string" && this.animusLoaderPaths.has(entry.loader));
+		return loaders.some((entry) => entry?.loader !== void 0 && this.animusLoaderPaths.has(entry.loader));
 	}
-	/** Append the exact epoch artifact path to `watchOptions.ignored`,
-	*  preserving the user's shape (design D2: the artifact participates in
-	*  module snapshots via addDependency but never triggers live watch
-	*  turns — no echo compilations). Session identity is process-claimed,
-	*  so every compiler's plugin instance derives the SAME session-scoped
-	*  path here regardless of which instance ends up owning the pipeline.
-	*  Derived from the ONE root (session.rootDir, set at config time by
-	*  with-animus); compiler.context is the fallback for bare-apply
-	*  harnesses — identical when compiler.context === cwd. */
 	appendEpochWatchIgnore(compiler) {
 		const options = compiler.options;
 		if (!options) return;
@@ -92,25 +55,22 @@ var AnimusWebpackPlugin = class {
 		if (ignored === void 0 || ignored === null) watchOptions.ignored = [epochPath];
 		else if (Array.isArray(ignored)) {
 			if (!ignored.includes(epochPath)) ignored.push(epochPath);
-		} else if (typeof ignored === "string") watchOptions.ignored = [ignored, epochPath];
+		} else if (isWatchIgnoreString(ignored)) watchOptions.ignored = [ignored, epochPath];
 		else if (ignored instanceof RegExp) watchOptions.ignored = (path) => path === epochPath || ignored.test(path);
-		else if (typeof ignored === "function") {
-			const original = ignored;
-			watchOptions.ignored = (path) => path === epochPath || Boolean(original(path));
-		}
+		else if (isWatchIgnoreMatcher(ignored)) watchOptions.ignored = (path) => path === epochPath || Boolean(ignored(path));
 	}
-	/** Extract path aliases from webpack's resolve.alias config. Runs once per
-	*  plugin instance — the resolve config is immutable after apply. */
 	extractAliases(compiler) {
 		if (this.aliasesExtracted) return;
 		this.aliasesExtracted = true;
 		const rootDir = compiler.context;
 		const rawAlias = compiler.options?.resolve?.alias;
-		if (!rawAlias || typeof rawAlias !== "object") return;
+		if (rawAlias === void 0) return;
+		if (Object.prototype.toString.call(rawAlias) !== "[object Object]") return;
 		const pairs = [];
 		for (const [key, value] of Object.entries(rawAlias)) {
-			const target = Array.isArray(value) ? value[0] : value;
-			if (typeof target !== "string") continue;
+			if (value === false) continue;
+			const target = Array.isArray(value) ? value.at(0) : value;
+			if (target === void 0) continue;
 			if (key === ANIMUS_CSS_MODULE_ID) continue;
 			pairs.push({
 				pattern: key,
@@ -123,13 +83,13 @@ var AnimusWebpackPlugin = class {
 	apply(compiler) {
 		if (compiler.options?.name === "edge-server") return;
 		const NormalModule = compiler.webpack?.NormalModule;
-		if (typeof NormalModule?.getCompilationHooks !== "function") throw new Error(UNSUPPORTED_WEBPACK_MESSAGE);
+		if (NormalModule?.getCompilationHooks === void 0) throw new Error(UNSUPPORTED_WEBPACK_MESSAGE);
 		this.appendEpochWatchIgnore(compiler);
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const epochMoved = this.epochMovedForNextCompilation;
 			this.epochMovedForNextCompilation = false;
 			const needBuild = NormalModule.getCompilationHooks(compilation).needBuild;
-			if (typeof needBuild?.tapAsync !== "function") throw new Error(UNSUPPORTED_WEBPACK_MESSAGE);
+			if (needBuild === void 0) throw new Error(UNSUPPORTED_WEBPACK_MESSAGE);
 			needBuild.tapAsync(PLUGIN_NAME, (module, _context, callback) => {
 				if (epochMoved && this.moduleUsesAnimusLoader(module)) {
 					callback(null, true);
@@ -156,7 +116,8 @@ var AnimusWebpackPlugin = class {
 				registerSystemDependencies();
 				const css = getSharedCss();
 				if (!css || !RawSource) return;
-				const cssPath = stylesPath(sessionArtifactDir(this.session.rootDir || compiler.context, this.session.sessionId));
+				const rootDir = this.session.rootDir || compiler.context;
+				const cssPath = stylesPath(sessionArtifactDir(rootDir, this.session.sessionId));
 				if (compilation.getAsset(cssPath)) {
 					compilation.updateAsset(cssPath, new RawSource(css));
 					return;
@@ -167,24 +128,24 @@ var AnimusWebpackPlugin = class {
 		compiler.hooks.run.tapPromise(PLUGIN_NAME, async (_compiler) => {
 			this.adoptCompilerContext(_compiler);
 			this.extractAliases(_compiler);
-			const existing = getAnalysisPromise();
+			const existing = getAnalysisStartedPromise();
 			if (existing) {
 				await existing;
 				return;
 			}
 			const promise = this.session.runFullPipeline();
-			setAnalysisPromise(promise);
+			setAnalysisStartedPromise(promise);
 			await promise;
 		});
 		compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async (_compiler) => {
 			this.adoptCompilerContext(_compiler);
 			this.extractAliases(_compiler);
 			if (!this.initialized) {
-				const existing = getAnalysisPromise();
+				const existing = getAnalysisStartedPromise();
 				if (existing) await existing;
 				else {
 					const promise = this.session.runFullPipeline();
-					setAnalysisPromise(promise);
+					setAnalysisStartedPromise(promise);
 					await promise;
 				}
 				this.initialized = true;
@@ -200,35 +161,20 @@ var AnimusWebpackPlugin = class {
 			if (epoch !== null) this.lastBuiltEpoch = epoch;
 		});
 	}
-	/**
-	* Reset analysis state for HMR geological reset.
-	*/
 	resetForHmr() {
 		this.session.resetForHmr();
 	}
-	/** Session identity (process-claimed) — with-animus derives the
-	*  session-scoped alias/stub paths from it (design D2). */
 	get sessionId() {
 		return this.session.sessionId;
 	}
-	/** Set the project root at CONFIG time (with-animus) — the ONE root all
-	*  session-path derivations use. The compiler hooks ADOPT
-	*  compiler.context only when no root was published (bare-apply
-	*  harnesses); they never overwrite this. */
 	setRootDir(rootDir) {
 		this.session.rootDir = rootDir;
 	}
-	/** One warning per plugin instance for a context/root mismatch. */
 	warnedRootDivergence = false;
-	/** The run/watchRun taps' root handling: adopt compiler.context when no
-	*  config-time root exists; otherwise KEEP the configured root — every
-	*  frozen config-time derivation (stub path, css alias target,
-	*  virtual:animus/system-props target, watch-ignore) came from it, and a
-	*  silent overwrite re-keys sessionDir so the pipeline publishes
-	*  artifacts where none of those consumers look. A disagreement is
-	*  surfaced loudly instead (with-animus derives the root from Next's own
-	*  `dir`, which equals compiler.context in real Next runs — a mismatch
-	*  means a custom-webpack setup wired the plugin differently). */
+	/** Adopts `compiler.context` only when no config-time root exists: every
+	*  frozen derivation came from that root, so an overwrite re-keys it.
+	*  Stub path, css alias, virtual system-props target and watch-ignore are
+	*  all frozen from it, so a disagreement is warned, never reconciled. */
 	adoptCompilerContext(compiler) {
 		const context = compiler.context;
 		if (!this.session.rootDir) {
@@ -240,73 +186,47 @@ var AnimusWebpackPlugin = class {
 			console.warn(`[animus-extract] compiler.context (${context}) differs from the configured project root (${this.session.rootDir}); keeping the configured root — run next against the app directory (or align your custom webpack context) so both agree`);
 		}
 	}
-	/** This session's artifact directory, derived from the one root. */
 	get sessionDir() {
 		return this.session.sessionDir;
 	}
-	/** Expose options for the loader */
 	getOptions() {
 		return this.options;
 	}
-	/** Expose external package directories for webpack loader allowlisting.
-	*  Falls back to shared globalThis state for non-owning compiler instances. */
 	getExternalPackageDirs() {
 		return this.session.externalPackageDirs.length > 0 ? this.session.externalPackageDirs : getSharedExternalDirs();
 	}
-	/** Expose external package source entries for webpack resolve alias.
-	*  Falls back to shared globalThis state for non-owning compiler instances. */
 	getExternalSourceEntries() {
 		return this.session.externalSourceEntries.size > 0 ? this.session.externalSourceEntries : getSharedExternalEntries();
 	}
 };
 //#endregion
 //#region src/turbopack-config.ts
-/** The single glob the Animus loader registers under — derived from the
-*  ONE shared engine extension set (also the unplugin transform gate's
-*  source), so the two bundler families cannot drift. `.mjs` is in that
-*  set for webpack parity: an external package without `src/` is ingested
-*  via its resolved dist entry (often `dist/index.mjs`) and must still
-*  reach the loader — manifest lookup remains the file-level gate. */
+/** The one glob the loader registers under, derived from the shared engine
+*  extension set so the bundler families cannot drift. `.mjs` belongs in that
+*  set: an external package with no src/ is ingested through its dist entry
+*  and must still reach the loader, so do not trim it. */
 const ANIMUS_TURBOPACK_RULE_GLOB = `*.{${ENGINE_TRANSFORM_EXTENSIONS.join(",")}}`;
-/**
-* Resolve whether Turbopack wiring is active for this process. Default is
-* `'auto'`: active exactly when the TURBOPACK environment variable is set
-* (Next sets it for every Turbopack dev/build). The stable `turbopack`
-* option wins over the deprecated `unstable_turbopack` alias.
-*/
 function resolveTurbopackMode(options, env = process.env) {
 	const mode = options.turbopack?.mode ?? options.unstable_turbopack?.mode ?? "auto";
 	if (mode === "on") return true;
 	if (mode === "auto") return env.TURBOPACK !== void 0;
 	return false;
 }
-/** rootDir-relative module request for an absolute path — always forward
-*  slashes, even when path.relative produced Windows separators. */
 function rootRelativeRequest(rootDir, absPath) {
 	return `./${relative(rootDir, absPath).replace(/\\/g, "/")}`;
 }
-/**
-* Build the `turbopack` config fragment: one glob-keyed loader rule
-* (file-level allowlisting lives in the loader via manifest lookup — Next 15
-* rules have no condition algebra) plus resolve aliases for the virtual
-* system-props id, the emitter's stylesheet id, and each collected external
-* package specifier redirected to its source entry. Loader options carry
-* the session identity (design D2: an options-borne, JSON-serializable
-* Turbopack task input — restart-cold by construction), and the artifact
-* aliases point into the session-scoped tree.
-*/
 function buildTurbopackConfig(args) {
 	const { rootDir, loaderPath, options, externalSourceEntries, sessionId, sessionDir } = args;
 	const loaderOptions = {
 		rootDir,
 		sessionId,
-		sessionDir,
-		...options.strict !== void 0 ? { strict: options.strict } : {},
-		...options.cssImportTarget !== void 0 ? { cssImportTarget: options.cssImportTarget } : {}
+		sessionDir
 	};
+	if (options.strict !== void 0) loaderOptions.strict = options.strict;
+	if (options.cssImportTarget !== void 0) loaderOptions.cssImportTarget = options.cssImportTarget;
 	const resolveAlias = {
 		[TURBOPACK_SYSTEM_PROPS_ID]: rootRelativeRequest(rootDir, join(sessionDir, SYSTEM_PROPS_ARTIFACT)),
-		".animus/styles.css": rootRelativeRequest(rootDir, join(sessionDir, STYLES_ARTIFACT))
+		[ANIMUS_CSS_MODULE_ID]: rootRelativeRequest(rootDir, join(sessionDir, STYLES_ARTIFACT))
 	};
 	for (const [specifier, srcEntry] of externalSourceEntries) resolveAlias[specifier] = rootRelativeRequest(rootDir, srcEntry);
 	return {
@@ -317,40 +237,25 @@ function buildTurbopackConfig(args) {
 		resolveAlias
 	};
 }
-/**
-* Locate the Turbopack loader module: built dist first, source fallback for
-* in-repo development. CJS preferred — Turbopack's loader-runner follows
-* the webpack loader contract (`module.exports = fn`), and the .cjs build
-* is loadable by every runner version; ESM default-export acceptance is
-* not guaranteed.
-*/
 function resolveTurbopackLoaderPath(pluginDir) {
 	return resolveLoaderPath(pluginDir, ["turbopack-loader.cjs", "turbopack-loader.mjs"], "turbopack-loader.ts");
 }
 //#endregion
 //#region src/with-animus.ts
-const __dirname = dirname(fileURLToPath(import.meta.url));
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 let warnedGitignore = false;
 let warnedUnstableTurbopack = 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\" })");
-	assertKnownOptionKeys(options, [
+	assertKnownOptionKeys({ ...options }, [
 		"cssImportTarget",
 		"turbopack",
 		"unstable_turbopack",
 		"loaderPath"
 	], [{
 		key: "root",
-		reason: "the Next driver's root is Next's `dir` at config time"
+		reason: "this driver derives its own root — Next's `dir` under webpack, `process.cwd()` under Turbopack (Next passes no dir to a config module)"
 	}], {
 		onUnknownKey: "warn",
 		warn: (message) => console.warn(`[animus-extract] ${message}`)
@@ -365,8 +270,8 @@ function withAnimus(options) {
 		return {
 			...nextConfig,
 			webpack(config, context) {
-				if (typeof existingWebpack === "function") config = existingWebpack(config, context);
-				const rootDir = typeof context.dir === "string" && context.dir.length > 0 ? context.dir : process.cwd();
+				if (existingWebpack) config = existingWebpack(config, context);
+				const rootDir = context.dir?.length ? context.dir : process.cwd();
 				const plugin = new AnimusWebpackPlugin(options);
 				plugin.setRootDir(rootDir);
 				const sessionDir = plugin.sessionDir;
@@ -393,8 +298,8 @@ function withAnimus(options) {
 				const isExternalPackageFile = (filePath) => plugin.getExternalPackageDirs().some((dir) => isPathWithinRoot(dir, filePath));
 				config.plugins = config.plugins || [];
 				config.plugins.push(plugin);
-				const { DefinePlugin } = context.webpack ?? {};
-				if (typeof DefinePlugin === "function") config.plugins.push(new DefinePlugin({ __ANIMUS_DEV__: JSON.stringify(resolveMode(options.mode, () => context.dev === true ? "development" : "production").mode === "development") }));
+				const DefinePlugin = context.webpack?.DefinePlugin;
+				if (DefinePlugin) config.plugins.push(new DefinePlugin({ __ANIMUS_DEV__: JSON.stringify(resolveMode(options.mode, () => context.dev === true ? "development" : "production").mode === "development") }));
 				config.resolve = config.resolve || {};
 				config.resolve.alias = config.resolve.alias || {};
 				config.resolve.alias[ANIMUS_CSS_MODULE_ID$1] = stylesPath(sessionDir);
@@ -413,10 +318,7 @@ function withAnimus(options) {
 				config.module = config.module || {};
 				config.module.rules = config.module.rules || [];
 				config.module.rules.push({
-					test: (filePath) => {
-						if (/\.[jt]sx?$/.test(filePath)) return true;
-						return /\.mjs$/.test(filePath) && isExternalPackageFile(filePath);
-					},
+					test: (filePath) => isEngineTransformExtension(filePath),
 					exclude: (filePath) => {
 						if (!filePath.includes("node_modules")) return false;
 						return !isExternalPackageFile(filePath);
@@ -435,20 +337,25 @@ function withAnimus(options) {
 		};
 	};
 }
-/**
-* Turbopack wiring: run the full extraction now (artifacts on disk before
-* bundling), start the dev watcher, and merge the generated rules/aliases
-* into `nextConfig.turbopack`. Consumer-managed rules for the same glob are
-* a hard error — silently stacking loaders would be undebuggable.
-*/
+function bindTurbopackWatchDeathReport(outcome, rootDir) {
+	if (outcome.kind !== "started") return;
+	const handle = outcome.handle;
+	handle.onDied = () => {
+		console.error(`[animus-extract] dev watcher for ${rootDir} died — source edits are no longer extracted; restart the dev server`);
+	};
+}
+let liveTurbopackSession = null;
 async function wireTurbopack(nextConfig, options) {
 	const rootDir = process.cwd();
 	const session = new ExtractionSession(options);
+	liveTurbopackSession?.close();
+	liveTurbopackSession = session;
 	session.rootDir = rootDir;
-	const builtAliases = buildPathAliasesJson(readTsconfigAliasPairs(rootDir), rootDir);
+	const aliasPairs = readTsconfigAliasPairs(rootDir);
+	const builtAliases = buildPathAliasesJson(aliasPairs, rootDir);
 	if (builtAliases) session.pathAliasesJson = builtAliases.json;
 	await runSessionPipeline(session);
-	if (process.env.NODE_ENV === "development") startTurbopackWatcher(session, rootDir);
+	if (process.env.NODE_ENV === "development") bindTurbopackWatchDeathReport(startTurbopackWatcher(session, rootDir), rootDir);
 	const fragment = buildTurbopackConfig({
 		rootDir,
 		loaderPath: resolveTurbopackLoaderPath(__dirname),

package/dist/loader-core-BthLSJQF.cjs

@@ -0,0 +1,47 @@
+let _animus_ui_extract_session = require("@animus-ui/extract/session");
+//#region src/loader-core.ts
+/** Matches every already-emitted stylesheet import — arbitrary relative
+*  prefixes and the Vite emitter's virtual id — not this bundler's id.
+*  Never derive it from the shared module-id constant: this reads foreign
+*  output, and deriving it silently stops matching the other forms. */
+const CSS_IMPORT_RE = /import\s+['"](?:[^'"]*\.animus\/styles\.css|virtual:animus\/styles\.css)['"];\n?/g;
+const CSS_IMPORT_STATEMENT = `import '${_animus_ui_extract_session.ANIMUS_CSS_MODULE_ID}';\n`;
+const ROOT_ENTRY_RE = /^(src\/)?(?:app\/layout|pages\/_app)\.[tj]sx?$/;
+function normalizePath(p) {
+	return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isCssImportTarget(filename, cssImportTarget) {
+	const normalized = normalizePath(filename);
+	if (cssImportTarget) return normalized === normalizePath(cssImportTarget);
+	return ROOT_ENTRY_RE.test(normalized);
+}
+function transformWithManifest(args) {
+	const { source, filename, manifestJson, engineApi, opts } = args;
+	const isRootEntry = isCssImportTarget(filename, opts.cssImportTarget);
+	try {
+		const { transformFile } = engineApi();
+		const result = transformFile(source, filename, manifestJson);
+		let code = result.hasComponents ? result.code : source;
+		code = code.replace(CSS_IMPORT_RE, "");
+		if (isRootEntry && !code.includes(_animus_ui_extract_session.ANIMUS_CSS_MODULE_ID)) {
+			if (code.startsWith("'use client'") || code.startsWith("\"use client\"")) {
+				const nl = code.indexOf("\n");
+				if (nl === -1) code = `${code}\n${CSS_IMPORT_STATEMENT}`;
+				else code = `${code.slice(0, nl + 1)}${CSS_IMPORT_STATEMENT}${code.slice(nl + 1)}`;
+			} else code = `${CSS_IMPORT_STATEMENT}${code}`;
+		}
+		return code;
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		if (opts.strict) throw new Error(`[animus-extract] Transform failed for ${filename}: ${msg}`, { cause: e });
+		console.warn(`[animus-extract] Transform failed for ${filename}:`, msg);
+		return source;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "transformWithManifest", {
+	enumerable: true,
+	get: function() {
+		return transformWithManifest;
+	}
+});

package/dist/loader-core-x6cOzF9v.mjs

@@ -0,0 +1,42 @@
+import { ANIMUS_CSS_MODULE_ID } from "@animus-ui/extract/session";
+//#region src/loader-core.ts
+/** Matches every already-emitted stylesheet import — arbitrary relative
+*  prefixes and the Vite emitter's virtual id — not this bundler's id.
+*  Never derive it from the shared module-id constant: this reads foreign
+*  output, and deriving it silently stops matching the other forms. */
+const CSS_IMPORT_RE = /import\s+['"](?:[^'"]*\.animus\/styles\.css|virtual:animus\/styles\.css)['"];\n?/g;
+const CSS_IMPORT_STATEMENT = `import '${ANIMUS_CSS_MODULE_ID}';\n`;
+const ROOT_ENTRY_RE = /^(src\/)?(?:app\/layout|pages\/_app)\.[tj]sx?$/;
+function normalizePath(p) {
+	return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isCssImportTarget(filename, cssImportTarget) {
+	const normalized = normalizePath(filename);
+	if (cssImportTarget) return normalized === normalizePath(cssImportTarget);
+	return ROOT_ENTRY_RE.test(normalized);
+}
+function transformWithManifest(args) {
+	const { source, filename, manifestJson, engineApi, opts } = args;
+	const isRootEntry = isCssImportTarget(filename, opts.cssImportTarget);
+	try {
+		const { transformFile } = engineApi();
+		const result = transformFile(source, filename, manifestJson);
+		let code = result.hasComponents ? result.code : source;
+		code = code.replace(CSS_IMPORT_RE, "");
+		if (isRootEntry && !code.includes(ANIMUS_CSS_MODULE_ID)) {
+			if (code.startsWith("'use client'") || code.startsWith("\"use client\"")) {
+				const nl = code.indexOf("\n");
+				if (nl === -1) code = `${code}\n${CSS_IMPORT_STATEMENT}`;
+				else code = `${code.slice(0, nl + 1)}${CSS_IMPORT_STATEMENT}${code.slice(nl + 1)}`;
+			} else code = `${CSS_IMPORT_STATEMENT}${code}`;
+		}
+		return code;
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		if (opts.strict) throw new Error(`[animus-extract] Transform failed for ${filename}: ${msg}`, { cause: e });
+		console.warn(`[animus-extract] Transform failed for ${filename}:`, msg);
+		return source;
+	}
+}
+//#endregion
+export { transformWithManifest as t };

package/dist/loader-core.d.ts

@@ -1,20 +1,13 @@
-/**
- * Bundler-neutral loader policy shared by the webpack loader (manifest from
- * the process singleton) and the Turbopack loader (manifest hydrated from
- * disk artifacts). Owns the transform invocation, strict-mode error
- * handling, and the single-stylesheet-import policy.
- */
 export interface LoaderPolicyOptions {
     strict?: boolean;
     cssImportTarget?: string;
 }
-/**
- * Transform one source file against a manifest: replace builder chains via
- * the engine, strip emitter-injected stylesheet imports everywhere, and
- * re-inject a single import at the root entry (after any leading
- * `'use client'` directive). On failure: throw in strict mode, otherwise
- * warn and return the source unchanged.
- */
+export interface LoaderContextBase<O extends LoaderPolicyOptions = LoaderPolicyOptions> {
+    resourcePath: string;
+    rootContext: string;
+    getOptions: () => O;
+    addDependency?: (file: string) => void;
+}
 export declare function transformWithManifest(args: {
     source: string;
     /** Project-root-relative path of the file being transformed. */

package/dist/loader-core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader-core.d.ts","sourceRoot":"","sources":["../src/loader-core.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AA+CD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IAErB,SAAS,EAAE,MAAM,GAAG,CAAC;IACrB,IAAI,EAAE,mBAAmB,CAAC;CAC3B,GAAG,MAAM,CA4CT"}
+{"version":3,"file":"loader-core.d.ts","sourceRoot":"","sources":["../src/loader-core.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB,CAChC,CAAC,SAAS,mBAAmB,GAAG,mBAAmB;IAEnD,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC,CAAC;IACpB,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AA4BD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IAErB,SAAS,EAAE,MAAM,GAAG,CAAC;IACrB,IAAI,EAAE,mBAAmB,CAAC;CAC3B,GAAG,MAAM,CAwCT"}

package/dist/loader-path.d.ts

@@ -1,16 +1,3 @@
-/**
- * The one loader-path derivation: first existing dist candidate under the
- * plugin dir, else the in-repo source fallback. Both loader resolvers below
- * are thin wrappers, so rule registration and any loader-chain predicate
- * can never drift (openspec: next-webpack-served-transform-coherence,
- * design D1).
- */
 export declare function resolveLoaderPath(pluginDir: string, distCandidates: string[], sourceFallback: string): string;
-/**
- * This package's webpack loader path, shared by the rule registration
- * (with-animus) and the needBuild loader-chain predicate (plugin). Compiled
- * dist ships `loader.mjs` next to this module; running from source falls
- * back to the TypeScript loader.
- */
 export declare function resolveAnimusLoaderPath(): string;
 //# sourceMappingURL=loader-path.d.ts.map

package/dist/loader-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader-path.d.ts","sourceRoot":"","sources":["../src/loader-path.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EAAE,EACxB,cAAc,EAAE,MAAM,GACrB,MAAM,CAMR;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}
+{"version":3,"file":"loader-path.d.ts","sourceRoot":"","sources":["../src/loader-path.ts"],"names":[],"mappings":"AAOA,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EAAE,EACxB,cAAc,EAAE,MAAM,GACrB,MAAM,CAMR;AAED,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/loader.cjs

@@ -1,35 +1,12 @@
-const require_loader_core = require("./loader-core-D2rh--tX.cjs");
-require("./turbopack-loader.cjs");
+const require_loader_core = require("./loader-core-BthLSJQF.cjs");
 let _animus_ui_extract_pipeline = require("@animus-ui/extract/pipeline");
 let _animus_ui_extract_session = require("@animus-ui/extract/session");
 let fs = require("fs");
 let path = require("path");
 //#region src/loader.ts
-/** Session dirs whose epoch artifact has been SEEN on disk. A sibling
-*  session's reconciliation may delete the artifact, but the owning
-*  session self-heals it on its next publish, so a positive existsSync
-*  stays a sound basis for registering the dependency: a module built
-*  during the missing window records a missing-file witness that the
-*  recreation then invalidates (over-invalidation, never under).
-*  Negatives always re-probe. */
 const epochSeenForSessionDir = /* @__PURE__ */ new Set();
-/**
-* Webpack loader for Animus source transformation.
-* Runs with enforce: 'pre' to see original source before Babel/SWC.
-* The manifest arrives via the process singleton (the webpack pipeline and
-* this loader share one process); the transform + CSS-import policy lives
-* in the shared loader-core.
-*
-* Coherence duties (openspec: next-webpack-served-transform-coherence):
-* every dev invocation registers the replacement-epoch artifact as a file
-* dependency (design D2 — restored persistent-cache modules snapshot it, so
-* offline epoch moves invalidate them), and an analyzed file whose current
-* source hash mismatches its analyzed hash fails with the stable diagnostic
-* `ANIMUS_ANALYSIS_CATCHING_UP` after one refreshed re-check (design D4 —
-* unconditional: a zero-entry stale manifest must never publish raw bytes).
-*/
 function animusLoader(source) {
-	if (this.mode !== "production" && typeof this.addDependency === "function") {
+	if (this.mode !== "production" && this.addDependency !== void 0) {
 		const sessionDir = (0, _animus_ui_extract_session.getSessionArtifactDir)();
 		if (sessionDir) {
 			const epochPath = (0, _animus_ui_extract_session.replacementEpochPath)(sessionDir);

package/dist/loader.d.ts

@@ -1,29 +1,7 @@
-import type { LoaderPolicyOptions } from './loader-core';
-type LoaderContext = {
-    resourcePath: string;
-    rootContext: string;
-    getOptions: () => LoaderPolicyOptions;
-    /** webpack file-dependency registration — optional so bare policy tests
-     *  can drive the loader without a full context. */
-    addDependency?: (file: string) => void;
-    /** webpack build mode; production invocations stay engine-verbatim. */
+import type { LoaderContextBase } from './loader-core';
+type LoaderContext = LoaderContextBase & {
     mode?: 'development' | 'production' | 'none';
 };
-/**
- * Webpack loader for Animus source transformation.
- * Runs with enforce: 'pre' to see original source before Babel/SWC.
- * The manifest arrives via the process singleton (the webpack pipeline and
- * this loader share one process); the transform + CSS-import policy lives
- * in the shared loader-core.
- *
- * Coherence duties (openspec: next-webpack-served-transform-coherence):
- * every dev invocation registers the replacement-epoch artifact as a file
- * dependency (design D2 — restored persistent-cache modules snapshot it, so
- * offline epoch moves invalidate them), and an analyzed file whose current
- * source hash mismatches its analyzed hash fails with the stable diagnostic
- * `ANIMUS_ANALYSIS_CATCHING_UP` after one refreshed re-check (design D4 —
- * unconditional: a zero-entry stale manifest must never publish raw bytes).
- */
 export default function animusLoader(this: LoaderContext, source: string): string;
 export {};
 //# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAWzD,KAAK,aAAa,GAAG;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,mBAAmB,CAAC;IACtC;uDACmD;IACnD,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,uEAAuE;IACvE,IAAI,CAAC,EAAE,aAAa,GAAG,YAAY,GAAG,MAAM,CAAC;CAC9C,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,MAAM,GACb,MAAM,CAmDR"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIvD,KAAK,aAAa,GAAG,iBAAiB,GAAG;IACvC,IAAI,CAAC,EAAE,aAAa,GAAG,YAAY,GAAG,MAAM,CAAC;CAC9C,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,MAAM,GACb,MAAM,CAsCR"}