@animus-ui/next-plugin 0.1.8 → 0.1.11

package/dist/index.mjs

@@ -1,1328 +1,8 @@
-import { S as __require, _ as replacementEpochPath, a as REPLACEMENT_EPOCH_ARTIFACT, b as stylesPath, c as SYSTEM_PROPS_ARTIFACT, f as envelopeCssArtifact, g as readJsonEnvelope, h as readCssEnvelope, i as MANIFEST_ARTIFACT, l as analysisCommitPath, n as ANALYSIS_INPUTS_ARTIFACT, o as SESSION_ASSETS_DIR, p as envelopeJsonArtifact, r as ANALYSIS_STATUS_ARTIFACT, s as STYLES_ARTIFACT, t as ANALYSIS_COMMIT_ARTIFACT, v as sessionArtifactDir, x as systemPropsPath, y as sessionsRootDir } from "./session-paths-DfYIPDcM.mjs";
-import { C as setWatchTransaction, S as setSharedSystemProps, _ as setSessionArtifactDir, b as setSharedExternalDirs, c as getSharedCss, d as getWatchTransaction, f as resetAnalysisPromise, g as setReplacementEpoch, h as setManifestJson, l as getSharedExternalDirs, m as setAnalyzedHashes, n as engineApi, o as getReplacementEpoch, p as setAnalysisPromise, r as getAnalysisPromise, t as claimProcessSessionId, u as getSharedExternalEntries, v as setSharedCss, x as setSharedExternalEntries, y as setSharedEngine } from "./singleton-372wiSRr.mjs";
-import { DEFAULT_EXTENSIONS, assembleStylesheet, assertNoRetiredEngineSelection, buildPathAliasesJson, buildSystemPropsModule, clearEngineCache, collectExternalPackageSources, contentHash, createSourceIdentity, discoverFiles, enforceExternalTokenContracts, excludeCollectedPackages, extractSystemFilePackages, findAssetSpecifiers, findPackageRoot, firstOwners, formatRustTimingWaterfall, hashReplacementPlans, isExcludedPackageRelativePath, isPathWithinRoot, loadSystemConfig, mergeExternalKeyframes, postProcessCss, preprocessMdx, readTsconfigAliasPairs, resolveAssetFile, resolveLightningTargets, runProjectAnalysis, serializeStaticCss, sharesVolumeRoot, snapshotFilePlans, staleDistIncludesMessage, substituteAssetPlaceholders, toWatchKeys, unresolvableIncludesMessage, walkPackageSources } from "@animus-ui/extract/pipeline";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync } from "fs";
-import { basename, dirname, extname, join, relative, resolve } from "path";
+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 { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, relative, resolve } from "path";
 import { fileURLToPath } from "url";
-//#region src/resolve-packages.ts
-/**
-* Resolve external DS package specifiers to rootDir-relative entry paths.
-* Node-generic (no webpack APIs): Pass 1 walks the consumer's workspaces for
-* matching package names; Pass 2 falls back to `require.resolve`. Specifiers
-* that resolve nowhere are simply omitted (spec: silent skip).
-*/
-function resolvePackagesByName(rootDir, names) {
-	if (names.length === 0) return {};
-	const nameSet = new Set(names);
-	const resolved = /* @__PURE__ */ new Set();
-	const packageMap = {};
-	try {
-		const rootPkg = JSON.parse(readFileSync(join(rootDir, "package.json"), "utf-8"));
-		const workspaces = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces?.packages ?? [];
-		for (const ws of workspaces) {
-			const wsDir = resolve(rootDir, ws);
-			if (!existsSync(wsDir)) continue;
-			try {
-				const pkg = JSON.parse(readFileSync(join(wsDir, "package.json"), "utf-8"));
-				const name = pkg.name || "";
-				if (nameSet.has(name)) {
-					const entryPath = resolve(wsDir, pkg.main || pkg.module || "index.ts");
-					if (existsSync(entryPath)) {
-						packageMap[name] = relative(rootDir, entryPath);
-						resolved.add(name);
-					}
-				}
-			} catch {}
-		}
-	} catch {}
-	for (const name of nameSet) {
-		if (resolved.has(name)) continue;
-		try {
-			packageMap[name] = relative(rootDir, __require.resolve(name, { paths: [rootDir] }));
-		} catch {}
-	}
-	return packageMap;
-}
-//#endregion
-//#region src/timing.ts
-/**
-* Verbose build-timing waterfall: JS phases, analysis sub-phases, and the
-* shared Rust phase table. `ANIMUS_TIMING_JSON=1` additionally dumps a
-* machine-readable merged record.
-*/
-function logBuildTimings(bt, rustTiming, log, verbose) {
-	if (!verbose) return;
-	const pad = (label, width) => label + " ".repeat(Math.max(0, width - label.length));
-	for (const [key, label] of [
-		["systemLoad", "system-load"],
-		["fileDiscovery", "file-discovery"],
-		["fileRead", "file-read+hash"],
-		["packageResolve", "pkg-resolve"],
-		["analysis", "analysis"]
-	]) {
-		const ms = bt[key] ?? 0;
-		if (ms === 0 && !Object.hasOwn(bt, key)) continue;
-		log(`  ${pad(label, 17)}${String(ms).padStart(5)}ms`);
-		if (key === "analysis") for (const [sk, sl] of [
-			["jsonSerialize", "json-serialize"],
-			["rustExtract", "rust-extract"],
-			["jsonParse", "json-parse"]
-		]) {
-			const sms = bt[sk] ?? 0;
-			log(`    ${pad(sl, 15)}${String(sms).padStart(5)}ms`);
-			if (sk === "rustExtract" && rustTiming) for (const line of formatRustTimingWaterfall(rustTiming, {
-				indent: "      ",
-				labelWidth: 13
-			})) log(line);
-		}
-	}
-	log(`  total             ${String(bt.total).padStart(5)}ms`);
-	if (process.env.ANIMUS_TIMING_JSON === "1") {
-		const merged = {};
-		for (const [k, v] of Object.entries(bt)) merged[`buildStart.${k}`] = v;
-		if (rustTiming) {
-			for (const [k, v] of Object.entries(rustTiming)) if (typeof v === "number") merged[`rust.${k}`] = v;
-		}
-		console.info(`[animus:timing] ${JSON.stringify(merged)}`);
-	}
-}
-//#endregion
-//#region src/extraction-session.ts
-/**
-* Module id the Rust emitter injects for the extracted stylesheet — also the
-* exact resolve.alias key with-animus registers for it, which the adapter's
-* alias harvesting must skip.
-*/
-const ANIMUS_CSS_MODULE_ID = ".animus/styles.css";
-/** Retention window for sibling session directories (design D2). */
-const SESSION_DIR_MAX_AGE_MS = 1440 * 60 * 1e3;
-/** Watchdog added to the debounce ceiling for status deadlines (D3). */
-const STATUS_WATCHDOG_MS = 2e3;
-/** Flat legacy `.animus/` artifacts removed at session start — unreachable
-*  by session-scoped loaders and no longer written by anyone. */
-const LEGACY_FLAT_ARTIFACTS = [
-	MANIFEST_ARTIFACT,
-	ANALYSIS_INPUTS_ARTIFACT,
-	STYLES_ARTIFACT,
-	SYSTEM_PROPS_ARTIFACT,
-	REPLACEMENT_EPOCH_ARTIFACT,
-	ANALYSIS_COMMIT_ARTIFACT,
-	ANALYSIS_STATUS_ARTIFACT
-];
-/** Default path fragments excluded from source discovery (full + watch). */
-const DEFAULT_EXCLUDE = [
-	"node_modules",
-	"dist",
-	".test.",
-	".spec.",
-	".next",
-	".animus"
-];
-/**
-* Bundler-agnostic extraction pipeline: system loading, source discovery
-* and ingestion, external-package collection, analysis, stylesheet and
-* system-props emission, and watch-cycle diffing.
-*
-* The webpack adapter (plugin.ts) owns only bundler wiring: hook
-* registration, alias harvesting from the compiler config, in-memory asset
-* replacement, and translating watch events into `handleWatchUpdate`
-* change sets. Keeping this class free of webpack types is deliberate — a
-* future Turbopack integration must drive the same session from outside
-* the bundler (Turbopack has no compiler-hook surface), reusing everything
-* here unchanged.
-*
-* Outputs are published through the package singleton (shared CSS,
-* manifest, system props) and written to `.animus/` on disk.
-*/
-var ExtractionSession = class {
-	/** Set by the adapter before any pipeline run. */
-	rootDir = null;
-	/** Serialized path aliases, harvested by the adapter from bundler config. */
-	pathAliasesJson = null;
-	assetCopyCache = /* @__PURE__ */ new Map();
-	/** Physical asset files registered with the host watcher. */
-	assetDependencyPaths = /* @__PURE__ */ new Set();
-	assetDependencyKeys = /* @__PURE__ */ new Set();
-	/** Emitter identity override for the system-props module id. Webpack mode
-	*  (null) injects the absolute `.animus/system-props.js` path, resolved by
-	*  NormalModuleReplacement; Turbopack rejects absolute-path imports, so
-	*  its driver sets the virtual id that `resolveAlias` maps to disk. */
-	systemPropsModuleId = null;
-	/** Whether the analysis-inputs hydration corpus is serialized + written.
-	*  False (webpack mode): the loader shares the pipeline process and reads
-	*  the manifest from memory — the corpus is never persisted. True is set
-	*  by the Turbopack orchestration driver, whose isolated loader workers
-	*  replay it (spec: next-turbopack-integration, "Manifest disk artifact" /
-	*  "Webpack mode skips the hydration corpus"). */
-	persistAnalysisInputs = false;
-	/** Absolute directory prefixes for external DS packages (loader allowlisting). */
-	externalPackageDirs = [];
-	/** Absolute package dir → owning specifier (cross-source correlation). */
-	externalDirOwners = {};
-	/** rootDir-relative external file → owning specifier (correlation join). */
-	externalFileOwners = {};
-	/** External package specifier → absolute source entry path. */
-	externalSourceEntries = /* @__PURE__ */ new Map();
-	/** SourceId derivation authority for the current generation (openspec:
-	*  external-source-watch-ingestion, design D2) — canonical roots
-	*  realpath'd once per full pipeline; alias→SourceId associations
-	*  recorded while files exist so deletion resolves through the cache. */
-	sourceIdentity = null;
-	/** Canonical admitted external root → declared specifiers (set-valued
-	*  ownership, design D2; duplicate specifiers resolving to one canonical
-	*  root share it). Engine watch wiring and tests read this. */
-	externalRootOwners = /* @__PURE__ */ new Map();
-	/** Canonical admitted external watch roots — the engine-side watch
-	*  surface (webpack contextDependencies / Turbopack watchers). */
-	externalWatchRoots = [];
-	/** Canonical external root → (raw sourceKey → {raw content hash, recorded
-	*  abs spelling}): the previous-generation inventory a dirty-root rewalk
-	*  diffs against (design D3). Raw hashes — MDX preprocessing never skews
-	*  the diff; the recorded abs path is a registered deletion alias, so a
-	*  reconstructed deletion always resolves through cached identity. */
-	externalInventory = /* @__PURE__ */ new Map();
-	/** Sticky diagnostics (design D5/D7): stable key → message, re-surfaced
-	*  on every full pipeline until the underlying condition clears. */
-	stickyDiagnostics = /* @__PURE__ */ new Map();
-	/** Volume-membership predicate for the cross-volume gate (design D5).
-	*  Injected seam: the shared predicate only discriminates on Windows
-	*  (win32 semantics are unit-tested via path.win32), so runtime tests
-	*  drive the gate through this. */
-	sharesProjectVolume = sharesVolumeRoot;
-	/** Orchestrator seams (openspec: external-source-watch-ingestion, design
-	*  D4). `onExternalRootResolved` fires per volume-admitted external root
-	*  DURING collection — after resolution, BEFORE that root's sources are
-	*  walked — so a watching host can open its handle with no blind gap
-	*  between scan and watch. `onExternalRootsCommitted` fires once after a
-	*  successful full-pipeline publication with the complete admitted
-	*  canonical root set (the host's promote/replay/close-old phase; a
-	*  failed pipeline never fires it, so the host rolls back). */
-	onExternalRootResolved = null;
-	onExternalRootsCommitted = null;
-	options;
-	staticCssJson;
-	system = null;
-	/** Discovery-time keyframes diagnostics awaiting the shared surfacing pass. */
-	externalKeyframesDiagnostics = [];
-	/** Full package-resolution map from the last full pipeline — replayed by
-	*  incremental passes (sourceEntries alone omits dist-resolved packages). */
-	lastPackageMap = {};
-	fileCache = /* @__PURE__ */ new Map();
-	systemDependencyKeys = /* @__PURE__ */ new Set();
-	/** Loader-reported dependency paths for bundler watch registration. */
-	systemDependencyPaths = [];
-	systemDependencyHashes = /* @__PURE__ */ new Map();
-	lastSystemPropsHash = null;
-	/** Per-payload write guards: payloadHash gates rewrites (byte-identical
-	*  payloads leave disk untouched); diskHash is the hash of the CURRENT
-	*  disk bytes (envelope included) recorded in the analysis-commit. null =
-	*  not yet seeded (first publication reads the artifact's envelope so a
-	*  same-session restart never rewrites byte-identical artifacts). */
-	artifactRecords = {
-		manifest: null,
-		inputs: null,
-		styles: null
-	};
-	/** Last written analysis-commit; null = seeded from disk on first use. */
-	lastCommit = null;
-	/** Session identity — claimed once per PROCESS (one Next invocation),
-	*  adopted by every subsequent session instance so all compilers share
-	*  one artifact tree (design D2: `next dev`/`next build` co-writing are
-	*  separate processes and therefore separate sessions). */
-	sessionId = claimProcessSessionId();
-	/** Epoch value of the last published analysis; null = not yet known
-	*  (seeded from the session dir's artifact on first publication so a
-	*  same-session restart with unchanged plans never rewrites bytes). */
-	lastEpochValue = null;
-	/** Watcher debounce ceiling feeding status deadlines (design D3). */
-	debounceCeilingMs = 75;
-	/** Test seam: observes every session-artifact write (name, content)
-	*  post-rename — write ORDER is part of the transaction contract. */
-	onArtifactWrite = null;
-	/** Status attempt bookkeeping (design D3). */
-	statusAttemptId = 0;
-	statusAttemptOpen = false;
-	/** Debounce-window observations pending analysis (sourceKey → hash). */
-	debouncePending = /* @__PURE__ */ new Map();
-	/** Session-start hygiene (pruning + legacy cleanup) runs once. */
-	sessionStartHygieneDone = false;
-	lcssTargets = null;
-	constructor(options) {
-		this.options = options;
-		this.staticCssJson = serializeStaticCss(options.staticCss);
-	}
-	/** This session's artifact directory. Requires `rootDir` to be set. */
-	get sessionDir() {
-		return sessionArtifactDir(this.rootDir, this.sessionId);
-	}
-	get verbose() {
-		return this.options.verbose === true || process.env.ANIMUS_DEBUG === "1" || process.env.ANIMUS_DEBUG === "true";
-	}
-	log(msg) {
-		if (this.verbose) console.info(`[animus] ${msg}`);
-	}
-	warn(msg) {
-		console.warn(`[animus] ${msg}`);
-	}
-	now() {
-		return this.verbose ? performance.now() : 0;
-	}
-	elapsed(t) {
-		return this.verbose ? Math.round(performance.now() - t) : 0;
-	}
-	/** Lazily-computed scan config (options are constructor-fixed, so the
-	*  derivation is stable for the session's lifetime). */
-	scanConfigMemo = null;
-	/** Resolve the scan configuration from options — the single source of the
-	*  exclude/extension policy shared by the full and incremental pipelines. */
-	resolveScanConfig() {
-		if (this.scanConfigMemo === null) {
-			const extensionsSet = new Set(this.options.extensions ?? DEFAULT_EXTENSIONS);
-			this.scanConfigMemo = {
-				excludePatterns: this.options.exclude ?? DEFAULT_EXCLUDE,
-				extensionsSet,
-				shouldHandleMdx: extensionsSet.has(".mdx")
-			};
-		}
-		return this.scanConfigMemo;
-	}
-	/**
-	* Watch entry point: one single-flight analysis transaction per event
-	* batch (openspec: next-webpack-served-transform-coherence, design D3).
-	* The first entering session runs the transaction; every concurrent
-	* entry — same session re-entered, or another compiler's session
-	* (client/server/RSC each hold their own instance) — joins the in-flight
-	* promise, so no compiler proceeds against a generation older than the
-	* one the transaction publishes. A rejected transaction rejects every
-	* joiner; the gate always clears.
-	*/
-	async handleWatchUpdate(changes) {
-		const inflight = getWatchTransaction();
-		if (inflight) {
-			await inflight;
-			return;
-		}
-		if (!this.system) return;
-		const transaction = this.processWatchUpdate(changes);
-		setWatchTransaction(transaction);
-		try {
-			await transaction;
-		} finally {
-			setWatchTransaction(null);
-		}
-	}
-	/**
-	* Incremental watch pass: geological reset when the system file changed,
-	* otherwise content-hash diffing restricted to the watcher's change sets
-	* (falling back to a full discovery walk when no sets are provided).
-	*/
-	async processWatchUpdate(changes) {
-		const rootDir = this.rootDir;
-		try {
-			changes = this.reconcileExternalRoots(changes);
-		} catch (err) {
-			this.warn(`external root reconciliation failed: ${String(err)}`);
-		}
-		const changed = [...changes.modifiedFiles ?? [], ...changes.removedFiles ?? []];
-		let assetChanged = false;
-		try {
-			let systemHit;
-			if (!changes.modifiedFiles && !changes.removedFiles) for (const [dep, hash] of this.systemDependencyHashes) {
-				let current = "";
-				try {
-					current = contentHash(readFileSync(dep, "utf-8"));
-				} catch {}
-				if (current !== hash) {
-					systemHit = dep;
-					break;
-				}
-			}
-			else systemHit = changed.find((path) => toWatchKeys(path).some((key) => this.systemDependencyKeys.has(key)));
-			if (systemHit) {
-				this.log(`geological reset: system dependency changed (${relative(rootDir, systemHit)})`);
-				this.resetForHmr();
-				const promise = this.runFullPipeline(this.pendingFromBatch(changes));
-				setAnalysisPromise(promise);
-				await promise;
-				return;
-			}
-			if (changed.some((path) => toWatchKeys(path).some((key) => this.assetDependencyKeys.has(key)))) {
-				this.assetCopyCache.clear();
-				assetChanged = true;
-			}
-		} catch (err) {
-			this.warn(`HMR geological-reset check failed: ${String(err)}`);
-		}
-		const { excludePatterns, extensionsSet, shouldHandleMdx } = this.resolveScanConfig();
-		const priorCacheEntries = /* @__PURE__ */ new Map();
-		const recordPrior = (key) => {
-			if (!priorCacheEntries.has(key)) priorCacheEntries.set(key, this.fileCache.get(key) ?? null);
-		};
-		const inventoryUpdates = [];
-		let removedAny = false;
-		if (changes.removedFiles) for (const removedPath of changes.removedFiles) {
-			let key;
-			let owningRoot = null;
-			if (isPathWithinRoot(rootDir, removedPath)) key = relative(rootDir, removedPath);
-			else {
-				const resolved = this.sourceIdentity?.resolveDeletedSourceId(removedPath);
-				if (!resolved) continue;
-				key = resolved.sourceKey;
-				owningRoot = resolved.owningRoot;
-			}
-			recordPrior(key);
-			recordPrior(key + ".tsx");
-			if (this.fileCache.delete(key) || this.fileCache.delete(key + ".tsx")) {
-				removedAny = true;
-				if (owningRoot) {
-					inventoryUpdates.push({
-						root: owningRoot,
-						key,
-						hash: null,
-						abs: removedPath
-					});
-					delete this.externalFileOwners[key];
-					delete this.externalFileOwners[key + ".tsx"];
-				}
-			}
-		}
-		let targets;
-		if (changes.modifiedFiles) {
-			targets = [];
-			for (const modifiedPath of changes.modifiedFiles) {
-				const classified = this.classifyWatchPath(modifiedPath, {
-					excludePatterns,
-					extensionsSet
-				});
-				if (classified) targets.push({
-					abs: modifiedPath,
-					...classified
-				});
-			}
-		} else targets = discoverFiles(rootDir, rootDir, excludePatterns, extensionsSet).map((abs) => ({
-			abs,
-			key: relative(rootDir, abs),
-			owningRoot: null
-		}));
-		const changedPaths = [];
-		for (const target of targets) {
-			let relPath = target.key;
-			let source;
-			try {
-				source = readFileSync(target.abs, "utf-8");
-			} catch {
-				continue;
-			}
-			const rawHash = contentHash(source);
-			if (shouldHandleMdx && extname(target.abs) === ".mdx") {
-				const processed = await this.preprocessMdxEntry(source, relPath, { warn: false });
-				if (!processed) continue;
-				source = processed.source;
-				relPath = processed.relPath;
-			}
-			const cached = this.fileCache.get(relPath);
-			const hash = relPath === target.key ? rawHash : contentHash(source);
-			if (!cached || cached.hash !== hash) {
-				changedPaths.push(relPath);
-				recordPrior(relPath);
-				this.fileCache.set(relPath, {
-					hash,
-					source
-				});
-				if (target.owningRoot) {
-					const owner = this.externalRootOwners.get(target.owningRoot)?.values().next().value;
-					if (owner !== void 0) this.externalFileOwners[relPath] ??= owner;
-					inventoryUpdates.push({
-						root: target.owningRoot,
-						key: target.key,
-						hash: rawHash,
-						abs: target.abs
-					});
-				}
-			}
-		}
-		if (changedPaths.length > 0 || removedAny || assetChanged) {
-			const fileEntries = this.buildFileEntriesFromCache();
-			const pending = changedPaths.map((rel) => [rel, this.fileCache.get(rel).hash]);
-			resetAnalysisPromise();
-			const promise = this.runIncrementalPipeline(fileEntries, pending);
-			setAnalysisPromise(promise);
-			try {
-				await promise;
-			} catch (err) {
-				for (const [key, prior] of priorCacheEntries) if (prior === null) this.fileCache.delete(key);
-				else this.fileCache.set(key, prior);
-				throw err;
-			}
-			for (const update of inventoryUpdates) {
-				let inventory = this.externalInventory.get(update.root);
-				if (!inventory) {
-					inventory = /* @__PURE__ */ new Map();
-					this.externalInventory.set(update.root, inventory);
-				}
-				if (update.hash === null) inventory.delete(update.key);
-				else inventory.set(update.key, {
-					hash: update.hash,
-					abs: update.abs
-				});
-			}
-		} else if (this.statusAttemptOpen) {
-			this.debouncePending.clear();
-			this.writeAnalysisStatus("idle", []);
-		}
-	}
-	/**
-	* Preprocess one `.mdx` entry into scanner-consumable tsx. Returns the
-	* rewritten source plus the `relPath + '.tsx'` path on success, or null
-	* when the file must be skipped.
-	*
-	* `warn: false` (incremental watch pass) skips silently — the full
-	* pipeline already surfaced the warning. `warn: true` (full pipeline)
-	* warns ONCE for a missing @mdx-js/mdx dependency via the shared
-	* `missingDepFlag` holder, and every time for a preprocessing error.
-	*/
-	async preprocessMdxEntry(source, relPath, opts) {
-		const result = await preprocessMdx(source, relPath);
-		if (result.kind === "missing-dep") {
-			if (opts.warn && opts.missingDepFlag && !opts.missingDepFlag.warned) {
-				console.warn("[animus] ⚠ .mdx in extensions but @mdx-js/mdx not installed; MDX files skipped");
-				opts.missingDepFlag.warned = true;
-			}
-			return null;
-		}
-		if (result.kind === "error") {
-			if (opts.warn) console.warn(`[animus] ⚠ MDX preprocessing failed for ${relPath}: ${result.error}`);
-			return null;
-		}
-		return {
-			source: result.source,
-			relPath: relPath + ".tsx"
-		};
-	}
-	async runFullPipeline(pending = []) {
-		const pipelineStart = this.now();
-		const bt = {};
-		this.runSessionStartHygiene();
-		setSessionArtifactDir(this.sessionDir);
-		clearEngineCache(engineApi);
-		const rootDir = this.rootDir;
-		const resolvedSystemPath = resolve(rootDir, this.options.system);
-		let t = this.now();
-		this.system = loadSystemConfig(engineApi, {
-			systemPath: resolvedSystemPath,
-			rootDir,
-			prefix: this.options.prefix
-		});
-		this.assetCopyCache.clear();
-		this.assetDependencyPaths.clear();
-		this.assetDependencyKeys.clear();
-		{
-			const deps = this.system.dependencies ?? [];
-			const keys = /* @__PURE__ */ new Set();
-			for (const key of toWatchKeys(resolvedSystemPath)) keys.add(key);
-			for (const dep of deps) for (const key of toWatchKeys(dep)) keys.add(key);
-			this.systemDependencyKeys = keys;
-			this.systemDependencyPaths = deps;
-			const hashes = /* @__PURE__ */ new Map();
-			for (const dep of deps.length > 0 ? deps : [resolvedSystemPath]) try {
-				hashes.set(dep, contentHash(readFileSync(dep, "utf-8")));
-			} catch {
-				hashes.set(dep, "");
-			}
-			this.systemDependencyHashes = hashes;
-		}
-		bt.systemLoad = this.elapsed(t);
-		t = this.now();
-		const { excludePatterns, extensionsSet, shouldHandleMdx } = this.resolveScanConfig();
-		const missingDepFlag = { warned: false };
-		const files = discoverFiles(rootDir, rootDir, excludePatterns, extensionsSet);
-		bt.fileDiscovery = this.elapsed(t);
-		t = this.now();
-		const fileEntries = [];
-		for (const filePath of files) {
-			let source = readFileSync(filePath, "utf-8");
-			let relPath = relative(rootDir, filePath);
-			if (shouldHandleMdx && extname(filePath) === ".mdx") {
-				const processed = await this.preprocessMdxEntry(source, relPath, {
-					warn: true,
-					missingDepFlag
-				});
-				if (!processed) continue;
-				source = processed.source;
-				relPath = processed.relPath;
-			}
-			const hash = contentHash(source);
-			this.fileCache.set(relPath, {
-				hash,
-				source
-			});
-			fileEntries.push({
-				path: relPath,
-				source,
-				hash
-			});
-		}
-		bt.fileRead = this.elapsed(t);
-		bt.fileCount = fileEntries.length;
-		t = this.now();
-		const packageNames = extractSystemFilePackages(resolvedSystemPath);
-		const preResolved = resolvePackagesByName(rootDir, packageNames);
-		const rawExternalFiles = /* @__PURE__ */ new Map();
-		const collected = await collectExternalPackageSources({
-			specifiers: packageNames,
-			resolveSpecifier: (name) => preResolved[name] ? resolve(rootDir, preResolved[name]) : null,
-			rootDir,
-			extensionsSet,
-			hasEntry: (relPath) => fileEntries.some((e) => e.path === relPath),
-			preprocessFile: async (source, relPath, absPath) => {
-				rawExternalFiles.set(absPath, contentHash(source));
-				if (shouldHandleMdx && extname(absPath) === ".mdx") return this.preprocessMdxEntry(source, relPath, {
-					warn: true,
-					missingDepFlag
-				});
-				return {
-					source,
-					relPath
-				};
-			},
-			onUnreadable: (relPath, err) => this.warn(`skipped unreadable package file ${relPath}: ${String(err)}`),
-			onPackageResolved: (_specifier, packageDir) => {
-				if (!this.onExternalRootResolved) return;
-				if (!this.sharesProjectVolume(rootDir, packageDir)) return;
-				let canonical = packageDir;
-				try {
-					canonical = realpathSync(packageDir);
-				} catch {}
-				this.onExternalRootResolved(canonical);
-			}
-		});
-		for (const record of collected.outcomes) if (record.outcome === "empty") this.warn(`include '${record.specifier}' resolved but discovered no component sources`);
-		const unresolvableMessage = unresolvableIncludesMessage(collected.outcomes);
-		if (unresolvableMessage !== null) {
-			if (this.options.strict) throw new Error(unresolvableMessage);
-			this.warn(unresolvableMessage);
-		}
-		const staleDistMessage = staleDistIncludesMessage(collected.outcomes);
-		if (staleDistMessage !== null) {
-			if (this.options.strict) throw new Error(staleDistMessage);
-			this.warn(staleDistMessage);
-		}
-		const rejectedSpecifiers = /* @__PURE__ */ new Set();
-		const crossVolumeDetails = [];
-		for (const [dir, specifiers] of Object.entries(collected.dirOwnerSets)) {
-			if (this.sharesProjectVolume(rootDir, dir)) continue;
-			for (const specifier of specifiers) rejectedSpecifiers.add(specifier);
-			crossVolumeDetails.push(`${specifiers.join(", ")} → ${dir}`);
-		}
-		this.stickyDiagnostics.delete("cross-volume");
-		if (rejectedSpecifiers.size > 0) {
-			const message = `ANIMUS_EXTERNAL_CROSS_VOLUME_UNSUPPORTED: external package source root(s) on a different volume than the project root (${rootDir}): ${crossVolumeDetails.join("; ")} — cross-volume workspace sources are unsupported; the package(s) are excluded from extraction and watching`;
-			if (this.options.strict) throw new Error(`[animus-next] ${message}`);
-			this.stickyDiagnostics.set("cross-volume", message);
-		}
-		for (const message of this.stickyDiagnostics.values()) this.warn(message);
-		const admitted = excludeCollectedPackages(collected, rejectedSpecifiers, rootDir);
-		const identity = createSourceIdentity(rootDir);
-		this.externalRootOwners = /* @__PURE__ */ new Map();
-		for (const [dir, specifiers] of Object.entries(admitted.dirOwnerSets)) {
-			const canonical = identity.registerExternalRoot(dir);
-			const owners = this.externalRootOwners.get(canonical) ?? /* @__PURE__ */ new Set();
-			for (const specifier of specifiers) owners.add(specifier);
-			this.externalRootOwners.set(canonical, owners);
-		}
-		this.sourceIdentity = identity;
-		this.externalWatchRoots = identity.externalRoots();
-		this.externalInventory = /* @__PURE__ */ new Map();
-		for (const [absPath, rawHash] of rawExternalFiles) {
-			const resolved = identity.resolveSourceId(absPath);
-			if (!resolved?.owningRoot) continue;
-			let inventory = this.externalInventory.get(resolved.owningRoot);
-			if (!inventory) {
-				inventory = /* @__PURE__ */ new Map();
-				this.externalInventory.set(resolved.owningRoot, inventory);
-			}
-			inventory.set(resolved.sourceKey, {
-				hash: rawHash,
-				abs: absPath
-			});
-		}
-		const packageMap = admitted.packageMap;
-		this.lastPackageMap = packageMap;
-		this.externalDirOwners = firstOwners(admitted.dirOwnerSets);
-		this.externalFileOwners = admitted.fileOwners;
-		this.externalSourceEntries = admitted.sourceEntries;
-		for (const entry of admitted.entries) {
-			const hash = contentHash(entry.source);
-			this.fileCache.set(entry.path, {
-				hash,
-				source: entry.source
-			});
-			fileEntries.push({
-				path: entry.path,
-				source: entry.source,
-				hash
-			});
-		}
-		this.externalPackageDirs = admitted.packageDirs;
-		setSharedExternalDirs(admitted.packageDirs);
-		setSharedExternalEntries(admitted.sourceEntries);
-		if (this.system && admitted.keyframesScanEntries.size > 0) {
-			const api = engineApi();
-			const merge = mergeExternalKeyframes((entry, root) => api.scanKeyframesExports(entry, root), this.system.keyframesJson, admitted.keyframesScanEntries.values(), this.rootDir);
-			this.system.keyframesJson = merge.keyframesJson;
-			this.externalKeyframesDiagnostics = merge.diagnostics;
-		}
-		bt.packageResolve = this.elapsed(t);
-		const universe = new Set(fileEntries.map((entry) => entry.path));
-		for (const key of [...this.fileCache.keys()]) if (!universe.has(key)) this.fileCache.delete(key);
-		await this.analyzeAndEmit(fileEntries, packageMap, false, bt, pipelineStart, pending);
-		this.onExternalRootsCommitted?.(this.externalWatchRoots);
-	}
-	/**
-	* Reset analysis state for HMR geological reset. Payload write guards go
-	* back to null so the next publication reseeds them from the disk
-	* envelopes — a byte-identical post-reset artifact is still not
-	* rewritten.
-	*/
-	resetForHmr() {
-		resetAnalysisPromise();
-		this.artifactRecords = {
-			manifest: null,
-			inputs: null,
-			styles: null
-		};
-		this.lastSystemPropsHash = null;
-		clearEngineCache(engineApi);
-	}
-	/**
-	* The (sourceKey, observedSourceHash) pairs of a watch batch — cheap
-	* evidence for the status file's pending set on the geological-reset
-	* path, where the batch's component edits ride along with the system
-	* edit (design D3: loaders wait only on observed inputs).
-	*/
-	pendingFromBatch(changes) {
-		const { excludePatterns, extensionsSet } = this.resolveScanConfig();
-		const pending = [];
-		for (const path of changes.modifiedFiles ?? []) {
-			const classified = this.classifyWatchPath(path, {
-				excludePatterns,
-				extensionsSet
-			});
-			if (!classified) continue;
-			try {
-				pending.push([classified.key, contentHash(readFileSync(path, "utf-8"))]);
-			} catch {}
-		}
-		return pending;
-	}
-	/**
-	* Root-dirty inventory reconciliation (design D3): partition the
-	* watcher's change sets into explicit FILE events and external ROOT hits
-	* (a reported path that IS an admitted root, or a directory inside one),
-	* rewalk each dirty root through the shared discovery policy, diff the
-	* SourceId+raw-hash inventory against the previous generation, and merge
-	* the reconstructed created/edited/deleted deltas with the explicit
-	* events (identity-level dedup happens downstream at the cache gate).
-	* Deletion falls out of the inventory diff — webpack may report only the
-	* directory (probe-proven).
-	*/
-	reconcileExternalRoots(changes) {
-		const identity = this.sourceIdentity;
-		if (!identity) return changes;
-		if (!changes.modifiedFiles && !changes.removedFiles) return changes;
-		if (this.externalWatchRoots.length === 0) return changes;
-		const { extensionsSet } = this.resolveScanConfig();
-		const dirtyRoots = /* @__PURE__ */ new Set();
-		const modified = /* @__PURE__ */ new Set();
-		const removed = /* @__PURE__ */ new Set();
-		const rootHitFor = (path) => {
-			const containing = identity.containingExternalRoot(path);
-			if (!containing) return null;
-			try {
-				return statSync(path).isDirectory() ? containing : null;
-			} catch {
-				return identity.resolveDeletedSourceId(path) ? null : containing;
-			}
-		};
-		for (const path of changes.modifiedFiles ?? []) {
-			const root = rootHitFor(path);
-			if (root) dirtyRoots.add(root);
-			else modified.add(path);
-		}
-		for (const path of changes.removedFiles ?? []) {
-			const root = rootHitFor(path);
-			if (root) dirtyRoots.add(root);
-			else removed.add(path);
-		}
-		for (const root of dirtyRoots) {
-			const previous = this.externalInventory.get(root) ?? /* @__PURE__ */ new Map();
-			const seen = /* @__PURE__ */ new Set();
-			const walked = walkPackageSources(root, extensionsSet);
-			for (const abs of walked) {
-				const resolved = identity.resolveSourceId(abs);
-				if (!resolved || resolved.owningRoot !== root) continue;
-				seen.add(resolved.sourceKey);
-				let rawHash;
-				try {
-					rawHash = contentHash(readFileSync(abs, "utf-8"));
-				} catch {
-					continue;
-				}
-				if (previous.get(resolved.sourceKey)?.hash !== rawHash) modified.add(abs);
-			}
-			for (const [key, entry] of previous) if (!seen.has(key)) removed.add(entry.abs);
-		}
-		return {
-			modifiedFiles: modified,
-			removedFiles: removed
-		};
-	}
-	/**
-	* Route one watcher-reported path (design D1/D2): a project-root member
-	* (lexical containment — existing local semantics preserved; consumer
-	* exclude patterns apply) or an admitted external member (identity
-	* resolution with symlink-escape rejection; package-relative excludes
-	* mirror the collection walk's filters — guardrail G1, one policy).
-	* Returns null for dropped paths.
-	*/
-	classifyWatchPath(absPath, scan) {
-		if (!scan.extensionsSet.has(extname(absPath))) return null;
-		const rootDir = this.rootDir;
-		if (isPathWithinRoot(rootDir, absPath)) {
-			const rel = relative(rootDir, absPath);
-			if (scan.excludePatterns.some((pattern) => absPath.includes(pattern) || rel.includes(pattern))) return null;
-			return {
-				key: rel,
-				owningRoot: null
-			};
-		}
-		const resolved = this.sourceIdentity?.resolveSourceId(absPath);
-		if (!resolved) return null;
-		if (resolved.owningRoot === null) {
-			if (scan.excludePatterns.some((pattern) => resolved.sourceKey.includes(pattern))) return null;
-			return {
-				key: resolved.sourceKey,
-				owningRoot: null
-			};
-		}
-		if (isExcludedPackageRelativePath(resolved.pathInRoot)) return null;
-		return {
-			key: resolved.sourceKey,
-			owningRoot: resolved.owningRoot
-		};
-	}
-	/**
-	* Build file entries from cache: every cached file rides with full source.
-	* The v2 engine has NO Rust-side cache (arch-extract-v2-spine: uncached
-	* re-analysis beats a cache-hit path), so it must always receive full sources
-	* (openspec: retire-extract-v1 removed the v1 empty-source cache contract).
-	*/
-	buildFileEntriesFromCache() {
-		const entries = [];
-		for (const [path, { hash, source }] of this.fileCache) entries.push({
-			path,
-			source,
-			hash
-		});
-		return entries;
-	}
-	/**
-	* Run incremental pipeline with cache-aware file entries.
-	* Reuses system config from the last full pipeline run.
-	*/
-	async runIncrementalPipeline(fileEntries, pending = []) {
-		const bt = {};
-		const pipelineStart = this.now();
-		await this.analyzeAndEmit(fileEntries, this.lastPackageMap, true, bt, pipelineStart, pending);
-	}
-	/**
-	* Shared analysis + emit core for both pipelines — the single call site
-	* that routes every manifest through the shared `runProjectAnalysis`,
-	* reachable from both runFullPipeline (production) and
-	* runIncrementalPipeline (HMR).
-	*
-	* Owns diagnostic surfacing, CSS assembly + styles.css write guard,
-	* system-props module emit, and the timing log. The `devMode` flag is the
-	* ONLY behavioral fork:
-	*
-	* - `false` (production): computes bt.analysis + logs the extraction
-	*   report, and writes system-props.js UNCONDITIONALLY (no
-	*   lastSystemPropsHash guard).
-	* - `true` (HMR): skips the report log, and guards the system-props.js
-	*   write by lastSystemPropsHash.
-	*
-	* The disk artifacts land under the session directory in transaction
-	* order (design D1): manifest → analysis-inputs (Turbopack orchestration
-	* only) → styles.css → system-props → analysis-commit →
-	* replacements-epoch (last, only when moved). The analysis-status file walks starting → analyzing →
-	* committing → idle around the attempt, landing in `failed` (with the
-	* diagnostic) on any throw (design D3).
-	*/
-	async analyzeAndEmit(fileEntries, packageMap, devMode, bt, pipelineStart, pending = []) {
-		this.beginStatusAttempt();
-		this.debouncePending.clear();
-		this.writeAnalysisStatus("starting", pending);
-		try {
-			await this.analyzeAndEmitAttempt(fileEntries, packageMap, devMode, bt, pipelineStart, pending);
-			this.writeAnalysisStatus("idle", []);
-		} catch (err) {
-			this.writeAnalysisStatus("failed", pending, String(err));
-			throw err;
-		}
-	}
-	async analyzeAndEmitAttempt(fileEntries, packageMap, devMode, bt, pipelineStart, pending) {
-		const system = this.system;
-		const analysisOptions = {
-			fileEntries,
-			packageMap,
-			system,
-			emitter: {
-				runtimeImport: "@animus-ui/system/runtime",
-				cssModuleId: ANIMUS_CSS_MODULE_ID,
-				systemPropsModuleId: this.systemPropsModuleId ?? systemPropsPath(this.sessionDir)
-			},
-			pathAliasesJson: this.pathAliasesJson,
-			staticCssJson: this.staticCssJson,
-			externalDirs: this.externalPackageDirs.map((dir) => relative(this.rootDir, dir)),
-			devMode
-		};
-		this.writeAnalysisStatus("analyzing", pending);
-		const result = runProjectAnalysis(engineApi, {
-			...analysisOptions,
-			warn: (message) => this.warn(message),
-			strict: this.options.strict,
-			extraDiagnostics: this.externalKeyframesDiagnostics
-		});
-		enforceExternalTokenContracts({
-			diagnostics: result.manifest?.diagnostics,
-			fileOwners: this.externalFileOwners,
-			dirOwners: this.externalDirOwners,
-			sourceThemeManifestsJson: system.sourceThemeManifestsJson,
-			strict: this.options.strict,
-			prefix: "[animus-next]",
-			warn: (message) => this.warn(message)
-		});
-		bt.jsonSerialize = result.timings.serializeMs;
-		bt.rustExtract = result.timings.extractMs;
-		bt.jsonParse = result.timings.parseMs;
-		const manifest = result.manifest;
-		if (!devMode) {
-			bt.analysis = (bt.jsonSerialize ?? 0) + (bt.rustExtract ?? 0) + (bt.jsonParse ?? 0);
-			if (manifest?.report) this.log(`Extracted ${manifest.report.components_extracted ?? "?"}/${manifest.report.components_total ?? "?"} components (${bt.analysis}ms)`);
-		}
-		const globalCss = this.substituteAssetReferences(result.globalCss, devMode);
-		const { declaration, variables, body } = assembleStylesheet({
-			layers: this.options.layers,
-			variableCss: system.variableCss,
-			globalCss,
-			componentCss: result.componentCss,
-			split: true
-		});
-		if (this.lcssTargets === null) this.lcssTargets = resolveLightningTargets(this.options.targets, this.rootDir);
-		const fullCss = [
-			declaration,
-			variables,
-			postProcessCss(body, {
-				minify: this.options.minify ?? process.env.NODE_ENV === "production",
-				targets: this.lcssTargets,
-				warnFn: (msg) => this.warn(msg)
-			})
-		].filter(Boolean).join("\n");
-		setSharedCss(fullCss);
-		const systemPropsContent = buildSystemPropsModule({
-			systemPropMapJson: JSON.stringify(manifest?.system_prop_map ?? {}),
-			groupRegistryJson: system.groupRegistryJson,
-			dynamicProps: manifest?.dynamic_props ?? {}
-		});
-		setSharedSystemProps(systemPropsContent);
-		setManifestJson(result.manifestJson);
-		setAnalyzedHashes(new Map(fileEntries.map((entry) => [entry.path, entry.hash])));
-		this.writeAnalysisStatus("committing", pending);
-		const epoch = hashReplacementPlans(snapshotFilePlans(manifest), systemPropsContent);
-		if (this.lastCommit === null) this.lastCommit = this.seedCommitFromDisk();
-		const generation = (this.lastCommit?.generation ?? 0) + 1;
-		this.publishPayloadArtifact("manifest", MANIFEST_ARTIFACT, result.manifestJson, epoch, generation, envelopeJsonArtifact);
-		if (this.persistAnalysisInputs) this.publishPayloadArtifact("inputs", ANALYSIS_INPUTS_ARTIFACT, JSON.stringify({
-			analyzedHashes: Object.fromEntries(fileEntries.map((entry) => [entry.path, entry.hash])),
-			...result.inputs
-		}), epoch, generation, envelopeJsonArtifact);
-		this.publishPayloadArtifact("styles", STYLES_ARTIFACT, fullCss, epoch, generation, envelopeCssArtifact);
-		if (devMode) {
-			const systemPropsHash = contentHash(systemPropsContent);
-			if (systemPropsHash !== this.lastSystemPropsHash) {
-				this.writeSessionArtifact(SYSTEM_PROPS_ARTIFACT, systemPropsContent);
-				this.lastSystemPropsHash = systemPropsHash;
-			}
-		} else this.writeSessionArtifact(SYSTEM_PROPS_ARTIFACT, systemPropsContent);
-		this.publishAnalysisCommit(epoch, generation);
-		this.publishReplacementEpoch(epoch);
-		bt.total = this.elapsed(pipelineStart);
-		logBuildTimings(bt, manifest?.timing, (msg) => this.log(msg), this.verbose);
-	}
-	/** Open a status attempt (attemptId increments once per burst — a
-	*  debouncing pre-write and the analysis that follows share one id). */
-	beginStatusAttempt() {
-		if (!this.statusAttemptOpen) {
-			this.statusAttemptId += 1;
-			this.statusAttemptOpen = true;
-		}
-	}
-	/** Write the session's analysis-status artifact (design D3). Terminal
-	*  states (idle/failed) close the attempt. */
-	writeAnalysisStatus(state, pending, diagnostic) {
-		const status = {
-			schema: 1,
-			sessionId: this.sessionId,
-			attemptId: this.statusAttemptId,
-			state,
-			pending,
-			deadlineAt: Date.now() + this.debounceCeilingMs + STATUS_WATCHDOG_MS,
-			...diagnostic !== void 0 ? { diagnostic } : {}
-		};
-		this.writeSessionArtifact(ANALYSIS_STATUS_ARTIFACT, JSON.stringify(status));
-		if (state === "idle" || state === "failed") this.statusAttemptOpen = false;
-	}
-	/**
-	* Orchestrator seam (Turbopack watcher): record watch events observed
-	* during the debounce window so a loader running ahead of the analysis
-	* has positive evidence to wait on (design D3 'debouncing'). Paths are
-	* filtered by the scan config and hashed at observation time.
-	*/
-	noteDebouncedWatchEvents(absPaths) {
-		if (!this.rootDir) return;
-		const additions = this.pendingFromBatch({ modifiedFiles: new Set(absPaths) });
-		if (additions.length === 0) return;
-		this.beginStatusAttempt();
-		for (const [key, hash] of additions) this.debouncePending.set(key, hash);
-		if (this.debounceStatusWriteScheduled) return;
-		this.debounceStatusWriteScheduled = true;
-		queueMicrotask(() => {
-			this.debounceStatusWriteScheduled = false;
-			if (this.debouncePending.size === 0) return;
-			this.writeAnalysisStatus("debouncing", [...this.debouncePending.entries()]);
-		});
-	}
-	/** One pending microtask flushes a burst of debounce observations. */
-	debounceStatusWriteScheduled = false;
-	/**
-	* Write one payload artifact into the session directory, enveloped with
-	* `{sessionId, generation, replacementEpoch, payloadHash}` and rewritten
-	* only when the PAYLOAD bytes changed (byte-identical re-analyses leave
-	* disk untouched — spec: "Unchanged manifest is not rewritten"). The
-	* recorded diskHash (hash of the enveloped bytes) feeds the
-	* analysis-commit.
-	*/
-	publishPayloadArtifact(key, name, payload, epoch, generation, wrap) {
-		const payloadHash = contentHash(payload);
-		if (this.artifactRecords[key] === null) this.artifactRecords[key] = this.seedPayloadRecord(key, name);
-		const record = this.artifactRecords[key];
-		if (record !== null && record.payloadHash === payloadHash) return;
-		const envelope = {
-			sessionId: this.sessionId,
-			generation,
-			replacementEpoch: epoch,
-			payloadHash
-		};
-		const bytes = wrap(payload, JSON.stringify(envelope));
-		this.writeSessionArtifact(name, bytes);
-		this.artifactRecords[key] = {
-			payloadHash,
-			diskHash: contentHash(bytes)
-		};
-	}
-	/** Reconstruct a payload write guard from the on-disk artifact's envelope
-	*  (same-session restart: a byte-identical payload must not rewrite). */
-	seedPayloadRecord(key, name) {
-		let bytes;
-		try {
-			bytes = readFileSync(join(this.sessionDir, name), "utf-8");
-		} catch {
-			return null;
-		}
-		let envelope;
-		try {
-			envelope = key === "styles" ? readCssEnvelope(bytes) : readJsonEnvelope(bytes);
-		} catch {
-			return null;
-		}
-		if (!envelope || typeof envelope.payloadHash !== "string") return null;
-		return {
-			payloadHash: envelope.payloadHash,
-			diskHash: contentHash(bytes)
-		};
-	}
-	/** Last analysis-commit persisted in this session's directory, or null. */
-	seedCommitFromDisk() {
-		try {
-			const parsed = JSON.parse(readFileSync(analysisCommitPath(this.sessionDir), "utf-8"));
-			return parsed.schema === 1 && parsed.sessionId === this.sessionId && typeof parsed.generation === "number" ? parsed : null;
-		} catch {
-			return null;
-		}
-	}
-	/**
-	* Publish the analysis-commit — the transaction identity (design D1).
-	* Written AFTER every payload and BEFORE the epoch; skipped entirely when
-	* the payload set (disk hashes) and epoch are unchanged, so a no-op
-	* re-analysis neither re-keys loader-worker hydration nor burns a
-	* generation.
-	*/
-	publishAnalysisCommit(epoch, generation) {
-		const manifestHash = this.artifactRecords.manifest?.diskHash ?? "";
-		const inputsHash = this.persistAnalysisInputs ? this.artifactRecords.inputs?.diskHash ?? "" : void 0;
-		const stylesHash = this.artifactRecords.styles?.diskHash ?? "";
-		const prev = this.lastCommit;
-		if (prev !== null && prev.manifestHash === manifestHash && prev.inputsHash === inputsHash && prev.stylesHash === stylesHash && prev.replacementEpoch === epoch) return;
-		const commit = {
-			schema: 1,
-			sessionId: this.sessionId,
-			generation,
-			replacementEpoch: epoch,
-			manifestHash,
-			...inputsHash !== void 0 ? { inputsHash } : {},
-			stylesHash
-		};
-		this.writeSessionArtifact(ANALYSIS_COMMIT_ARTIFACT, JSON.stringify(commit));
-		this.lastCommit = commit;
-	}
-	/**
-	* Publish the canonical replacement epoch: maintain the session-scoped
-	* disk witness `{schema, sessionId, epoch}`, rewritten ONLY when the
-	* epoch VALUE changes so style-only analyses and same-session restarts
-	* leave bytes and mtime untouched, then expose the value through the
-	* singleton for the plugin's needBuild fan-out and the loader's catch-up
-	* re-check. Every VALUE move also reconciles sibling sessions' epoch
-	* artifacts (below) — the webpack cold-cache validity witness.
-	*/
-	publishReplacementEpoch(epoch) {
-		if (this.lastEpochValue === null) this.lastEpochValue = this.diskEpochValue();
-		if (epoch !== this.lastEpochValue) {
-			this.writeSessionArtifact(REPLACEMENT_EPOCH_ARTIFACT, JSON.stringify({
-				schema: 1,
-				sessionId: this.sessionId,
-				epoch
-			}));
-			this.lastEpochValue = epoch;
-			this.reconcileSiblingEpochs(epoch);
-		}
-		setReplacementEpoch(epoch);
-	}
-	/**
-	* Sibling epoch reconciliation — the cross-session half of the webpack
-	* persistent-cache witness (spec: dev-served-transform-coherence,
-	* "Offline change invalidates restored modules"). Restored-module
-	* snapshots reference the epoch artifact of the session that BUILT them;
-	* with session-scoped trees that file would otherwise sit untouched
-	* forever, keeping stale snapshots valid. Whenever this session's epoch
-	* value moves, delete every sibling epoch artifact that disagrees (their
-	* snapshots must invalidate — restore-on-demand then rebuilds from the
-	* current generation) and leave agreeing siblings byte-untouched (warm
-	* restores stay valid). Deleting a stale artifact is pruning, not a
-	* foreign-session write; races with concurrent sessions are tolerated
-	* (S14).
-	*/
-	/** Sibling ids already reconciled away (artifact deleted or absent) —
-	*  nothing left to invalidate for them on later moves. */
-	reconciledSiblingIds = /* @__PURE__ */ new Set();
-	/** sessions-root listing memo, keyed by the root dir's mtime — a new or
-	*  pruned sibling DIRECTORY moves it; agreeing siblings stay listed. */
-	siblingListing = null;
-	reconcileSiblingEpochs(epoch) {
-		const rootPath = sessionsRootDir(this.rootDir);
-		let entries;
-		try {
-			const mtimeMs = statSync(rootPath).mtimeMs;
-			if (this.siblingListing?.mtimeMs === mtimeMs) entries = this.siblingListing.entries;
-			else {
-				entries = readdirSync(rootPath);
-				this.siblingListing = {
-					mtimeMs,
-					entries
-				};
-			}
-		} catch {
-			return;
-		}
-		for (const entry of entries) {
-			if (entry === this.sessionId) continue;
-			if (this.reconciledSiblingIds.has(entry)) continue;
-			const siblingEpochPath = join(rootPath, entry, REPLACEMENT_EPOCH_ARTIFACT);
-			try {
-				if (JSON.parse(readFileSync(siblingEpochPath, "utf-8")).epoch === epoch) continue;
-			} catch (err) {
-				if (err?.code === "ENOENT") {
-					this.reconciledSiblingIds.add(entry);
-					continue;
-				}
-			}
-			try {
-				unlinkSync(siblingEpochPath);
-			} catch {}
-			this.reconciledSiblingIds.add(entry);
-		}
-	}
-	/** Epoch value held by this session's on-disk artifact, or null when
-	*  absent, unreadable, or not the expected schema. */
-	diskEpochValue() {
-		try {
-			const parsed = JSON.parse(readFileSync(replacementEpochPath(this.sessionDir), "utf-8"));
-			return parsed.schema === 1 && typeof parsed.epoch === "string" ? parsed.epoch : null;
-		} catch {
-			return null;
-		}
-	}
-	/** Session-start hygiene (design D2): delete legacy flat artifacts
-	*  (unreachable by session-scoped loaders) and prune sibling session
-	*  directories older than the retention window — never the own dir,
-	*  tolerating races with concurrently-pruning sessions (S14). */
-	runSessionStartHygiene() {
-		if (this.sessionStartHygieneDone) return;
-		this.sessionStartHygieneDone = true;
-		const animusDir = join(this.rootDir, ".animus");
-		for (const name of LEGACY_FLAT_ARTIFACTS) try {
-			unlinkSync(join(animusDir, name));
-		} catch {}
-		let entries;
-		try {
-			entries = readdirSync(sessionsRootDir(this.rootDir));
-		} catch {
-			return;
-		}
-		const cutoff = Date.now() - SESSION_DIR_MAX_AGE_MS;
-		for (const entry of entries) {
-			if (entry === this.sessionId) continue;
-			const dir = join(sessionsRootDir(this.rootDir), entry);
-			try {
-				if (statSync(dir).mtimeMs < cutoff) rmSync(dir, {
-					recursive: true,
-					force: true
-				});
-			} catch {}
-		}
-	}
-	/** Ensure the session directory exists and write one artifact into it.
-	*  Write-then-rename so cross-process readers (Turbopack loader workers)
-	*  can never observe a torn half-written file. The tmp name carries the
-	*  pid — Next dev evaluates the config in more than one process, and two
-	*  sessions writing the same artifact must not race on one tmp path. */
-	writeSessionArtifact(name, content) {
-		const dir = this.sessionDir;
-		mkdirSync(dir, { recursive: true });
-		const tmpPath = join(dir, `.${name}.${process.pid}.tmp`);
-		writeFileSync(tmpPath, content);
-		renameSync(tmpPath, join(dir, name));
-		this.onArtifactWrite?.(name, content);
-	}
-	/**
-	* asset() placeholder substitution (global-styles-system): resolve each
-	* referenced specifier through Node resolution, copy the bytes into the
-	* session directory's `assets/` under a content-hashed name, and
-	* substitute a RELATIVE url — relative to the session-scoped styles.css,
-	* which sits beside `assets/`, so the emitted `./assets/<file>` form is
-	* unchanged. The stylesheet is processed by Next's own CSS pipeline
-	* (webpack and Turbopack alike), which applies its native asset handling
-	* — publicPath and output hashing — to relative url() references.
-	* Unsubstitutable specifiers warn and emit literally in non-strict mode,
-	* fail the build under `strict: true`.
-	*/
-	substituteAssetReferences(globalCss, devMode) {
-		const specifiers = findAssetSpecifiers(globalCss);
-		const assetsDir = join(this.sessionDir, SESSION_ASSETS_DIR);
-		const expected = /* @__PURE__ */ new Set();
-		this.assetDependencyPaths.clear();
-		this.assetDependencyKeys.clear();
-		const urlBySpecifier = /* @__PURE__ */ new Map();
-		for (const specifier of specifiers) {
-			const cached = this.assetCopyCache.get(specifier);
-			if (cached && existsSync(join(assetsDir, cached.fileName))) try {
-				const current = statSync(cached.sourcePath);
-				if (current.mtimeMs === cached.mtimeMs && current.size === cached.size) {
-					this.trackAssetDependency(cached.sourcePath);
-					expected.add(cached.fileName);
-					urlBySpecifier.set(specifier, cached.url);
-					continue;
-				}
-			} catch {}
-			const resolvedPath = this.resolveAssetSpecifier(specifier);
-			if (!resolvedPath) {
-				const message = `unresolvable asset() specifier: ${specifier}`;
-				if (this.options.strict) throw new Error(`[animus-next] ${message}`);
-				this.warn(message);
-				urlBySpecifier.set(specifier, specifier);
-				continue;
-			}
-			const bytes = readFileSync(resolvedPath);
-			const sourceStat = statSync(resolvedPath);
-			this.trackAssetDependency(resolvedPath);
-			const ext = extname(resolvedPath);
-			const fileName = `${basename(resolvedPath, ext)}.${contentHash(bytes).slice(0, 8)}${ext}`;
-			expected.add(fileName);
-			if (!existsSync(assetsDir)) mkdirSync(assetsDir, { recursive: true });
-			const assetPath = join(assetsDir, fileName);
-			if (!existsSync(assetPath)) writeFileSync(assetPath, bytes);
-			const url = `./assets/${fileName}`;
-			urlBySpecifier.set(specifier, url);
-			this.assetCopyCache.set(specifier, {
-				sourcePath: resolvedPath,
-				mtimeMs: sourceStat.mtimeMs,
-				size: sourceStat.size,
-				fileName,
-				url
-			});
-		}
-		if (!devMode) pruneStaleAssets(assetsDir, expected);
-		return substituteAssetPlaceholders(globalCss, urlBySpecifier);
-	}
-	trackAssetDependency(path) {
-		this.assetDependencyPaths.add(path);
-		for (const key of toWatchKeys(path)) this.assetDependencyKeys.add(key);
-	}
-	/**
-	* Resolve an asset specifier to an absolute file via the shared pipeline
-	* resolver (host aliases → Node resolution → package root), with one
-	* session-local last resort: an already-discovered source entry's package
-	* root (dist-less workspace kits the shared resolver cannot see).
-	*/
-	resolveAssetSpecifier(specifier) {
-		const resolved = resolveAssetFile(specifier, this.rootDir, this.pathAliasesJson);
-		if (resolved) return resolved;
-		const segments = specifier.split("/");
-		const packageName = specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
-		const subpath = specifier.slice(packageName.length + 1);
-		if (!subpath) return null;
-		const sourceEntry = this.externalSourceEntries.get(packageName) ?? [...this.externalSourceEntries].find(([declared]) => declared === packageName || declared.startsWith(`${packageName}/`))?.[1];
-		if (sourceEntry) {
-			const candidate = join(findPackageRoot(sourceEntry), subpath);
-			if (existsSync(candidate)) return candidate;
-		}
-		return null;
-	}
-};
-/**
-* Sync `.animus/assets/` to the current build's content-hashed file set:
-* anything else in the directory is a superseded revision (the copies are
-* content-addressed and never overwritten) or the leftover of an asset()
-* reference that no longer exists. Failures are tolerated per entry — Next
-* dev evaluates the config in more than one process, and a concurrent
-* session may have removed (or be about to rewrite) the same file; every
-* pass rewrites whatever of its own set is missing, so races self-heal.
-*/
-function pruneStaleAssets(assetsDir, expected) {
-	if (!existsSync(assetsDir)) return;
-	let entries;
-	try {
-		entries = readdirSync(assetsDir);
-	} catch {
-		return;
-	}
-	for (const entry of entries) {
-		if (expected.has(entry)) continue;
-		try {
-			unlinkSync(join(assetsDir, entry));
-		} catch {}
-	}
-}
-//#endregion
 //#region src/loader-path.ts
 const __dirname$1 = dirname(fileURLToPath(import.meta.url));
 /**
@@ -1431,7 +111,7 @@ var AnimusWebpackPlugin = class {
 		for (const [key, value] of Object.entries(rawAlias)) {
 			const target = Array.isArray(value) ? value[0] : value;
 			if (typeof target !== "string") continue;
-			if (key === ".animus/styles.css") continue;
+			if (key === ANIMUS_CSS_MODULE_ID) continue;
 			pairs.push({
 				pattern: key,
 				target
@@ -1481,11 +161,11 @@ var AnimusWebpackPlugin = class {
 					compilation.updateAsset(cssPath, new RawSource(css));
 					return;
 				}
-				if (compilation.getAsset(".animus/styles.css")) compilation.updateAsset(ANIMUS_CSS_MODULE_ID, new RawSource(css));
+				if (compilation.getAsset(ANIMUS_CSS_MODULE_ID)) compilation.updateAsset(ANIMUS_CSS_MODULE_ID, new RawSource(css));
 			});
 		});
 		compiler.hooks.run.tapPromise(PLUGIN_NAME, async (_compiler) => {
-			this.session.rootDir = _compiler.context;
+			this.adoptCompilerContext(_compiler);
 			this.extractAliases(_compiler);
 			const existing = getAnalysisPromise();
 			if (existing) {
@@ -1497,7 +177,7 @@ var AnimusWebpackPlugin = class {
 			await promise;
 		});
 		compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async (_compiler) => {
-			this.session.rootDir = _compiler.context;
+			this.adoptCompilerContext(_compiler);
 			this.extractAliases(_compiler);
 			if (!this.initialized) {
 				const existing = getAnalysisPromise();
@@ -1532,11 +212,34 @@ var AnimusWebpackPlugin = class {
 		return this.session.sessionId;
 	}
 	/** Set the project root at CONFIG time (with-animus) — the ONE root all
-	*  session-path derivations use. The compiler hooks re-assert it from
-	*  compiler.context (identical when compiler.context === cwd). */
+	*  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). */
+	adoptCompilerContext(compiler) {
+		const context = compiler.context;
+		if (!this.session.rootDir) {
+			this.session.rootDir = context;
+			return;
+		}
+		if (context && this.session.rootDir !== context && !this.warnedRootDivergence) {
+			this.warnedRootDivergence = true;
+			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;
@@ -1558,15 +261,13 @@ var AnimusWebpackPlugin = class {
 };
 //#endregion
 //#region src/turbopack-config.ts
-/** The single glob the Animus loader registers under. `.mjs` is included
-*  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. */
-const ANIMUS_TURBOPACK_RULE_GLOB = "*.{ts,tsx,js,jsx,mjs}";
-/** Virtual system-props id emitted into transformed sources under Turbopack
-*  (absolute-path imports are rejected there); resolveAlias maps it to the
-*  on-disk artifact. */
-const TURBOPACK_SYSTEM_PROPS_ID = "virtual:animus/system-props";
+/** 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. */
+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
@@ -1627,211 +328,6 @@ function resolveTurbopackLoaderPath(pluginDir) {
 	return resolveLoaderPath(pluginDir, ["turbopack-loader.cjs", "turbopack-loader.mjs"], "turbopack-loader.ts");
 }
 //#endregion
-//#region src/turbopack-orchestrator.ts
-/**
-* Out-of-band pipeline orchestration for Turbopack (spec:
-* next-turbopack-integration). Turbopack exposes no compiler hooks, so the
-* pipeline runs during next.config resolution and, in dev, from a
-* filesystem watcher — the bundler only ever sees the `.animus/` disk
-* artifacts.
-*/
-/** Run the full pipeline with the Turbopack emitter identity: the virtual
-*  system-props id (Turbopack rejects the webpack path's absolute-path
-*  imports). Turbopack orchestration persists the analysis-inputs
-*  hydration corpus — its isolated loader workers replay it (spec:
-*  next-turbopack-integration, "Manifest disk artifact"; webpack mode
-*  skips the corpus). */
-async function runTurbopackPipeline(session) {
-	session.systemPropsModuleId = TURBOPACK_SYSTEM_PROPS_ID;
-	session.persistAnalysisInputs = true;
-	await session.runFullPipeline();
-}
-const activeWatcherRoots = /* @__PURE__ */ new Set();
-const IGNORED_SEGMENTS = new Set([
-	".animus",
-	".next",
-	"node_modules"
-]);
-/**
-* Start the dev watcher: fs.watch per eligible top-level directory (plus a
-* non-recursive watch on the root itself), debounced into
-* existence-partitioned modified/removed sets feeding
-* `session.handleWatchUpdate` (serialized — updates never overlap).
-* Generated and vendored trees (`.animus`, `.next`, node_modules) are never
-* registered with the OS — recursive registration of those trees exhausts
-* inotify/kqueue descriptors (EMFILE/ENOSPC) on large projects.
-* Idempotent per project root; unref'd so it never holds the process open.
-* Asynchronous FSWatcher errors degrade to no-watch with a warning instead
-* of crashing the dev server. Returns a close handle, or null when this
-* root is already watched or the platform lacks recursive fs.watch (Linux
-* before Node 20 — degrades to no-watch with a warning).
-*/
-function startTurbopackWatcher(session, rootDir, debounceMs = 75, watchFn = watch) {
-	if (activeWatcherRoots.has(rootDir)) return null;
-	activeWatcherRoots.add(rootDir);
-	if (typeof session.noteDebouncedWatchEvents === "function") session.debounceCeilingMs = debounceMs;
-	const pendingPaths = /* @__PURE__ */ new Set();
-	const watchers = /* @__PURE__ */ new Map();
-	let timer = null;
-	let updateChain = Promise.resolve();
-	let closed = false;
-	const externalWatchers = /* @__PURE__ */ new Map();
-	let pendingOpened = /* @__PURE__ */ new Map();
-	let capturedDuringSnapshot = [];
-	const externalDiagnosticKey = (root) => `external-watch:${root}`;
-	const failureReason = (err) => {
-		const code = err?.code;
-		if (code === "EMFILE" || code === "ENFILE" || code === "ENOSPC" || code === "EPERM") return `capacity(${code})`;
-		if (/inotify|too many/i.test(String(err))) return "capacity";
-		return code ?? "error";
-	};
-	const degradeExternalRoot = (root, err) => {
-		externalWatchers.get(root)?.close();
-		externalWatchers.delete(root);
-		pendingOpened.get(root)?.close();
-		pendingOpened.delete(root);
-		const message = `ANIMUS_EXTERNAL_WATCH_UNAVAILABLE root=${relative(rootDir, root)} reason=${failureReason(err)} effect=changes in this workspace source may require restart`;
-		session.stickyDiagnostics?.set(externalDiagnosticKey(root), message);
-		console.warn(`[animus-extract] ${message}`);
-	};
-	const flush = () => {
-		timer = null;
-		const modifiedFiles = /* @__PURE__ */ new Set();
-		const removedFiles = /* @__PURE__ */ new Set();
-		for (const path of pendingPaths) (existsSync(path) ? modifiedFiles : removedFiles).add(path);
-		pendingPaths.clear();
-		updateChain = updateChain.then(() => session.handleWatchUpdate({
-			modifiedFiles,
-			removedFiles
-		}).catch((err) => {
-			console.warn(`[animus-extract] Turbopack watch update failed: ${String(err)}`);
-		}).then(() => {
-			if (pendingOpened.size > 0 || capturedDuringSnapshot.length > 0) rollbackPendingExternal();
-		}));
-	};
-	const rollbackPendingExternal = () => {
-		for (const watcher of pendingOpened.values()) watcher.close();
-		pendingOpened = /* @__PURE__ */ new Map();
-		capturedDuringSnapshot = [];
-	};
-	const closeAll = () => {
-		if (closed) return;
-		closed = true;
-		if (timer) clearTimeout(timer);
-		timer = null;
-		for (const watcher of watchers.values()) watcher.close();
-		watchers.clear();
-		for (const watcher of externalWatchers.values()) watcher.close();
-		externalWatchers.clear();
-		rollbackPendingExternal();
-		session.onExternalRootResolved = null;
-		session.onExternalRootsCommitted = null;
-		activeWatcherRoots.delete(rootDir);
-	};
-	const onWatcherError = (err) => {
-		closeAll();
-		console.warn(`[animus-extract] Turbopack dev watcher failed (${String(err)}); source edits require a dev-server restart`);
-	};
-	const enqueuePath = (abs) => {
-		pendingPaths.add(abs);
-		try {
-			session.noteDebouncedWatchEvents?.([abs]);
-		} catch (err) {
-			console.warn(`[animus-extract] Turbopack debounce status update failed: ${String(err)}`);
-		}
-		if (!timer) {
-			timer = setTimeout(flush, debounceMs);
-			timer.unref?.();
-		}
-	};
-	const onEvent = (baseDir, filename) => {
-		if (closed || !filename) return;
-		const rel = filename.toString();
-		if (rel.split(/[\\/]/).some((segment) => IGNORED_SEGMENTS.has(segment))) return;
-		const abs = join(baseDir, rel);
-		if (baseDir === rootDir && !watchers.has(abs)) try {
-			if (statSync(abs).isDirectory()) addWatcher(abs, true);
-		} catch {}
-		enqueuePath(abs);
-	};
-	/** External-root event path: fenced by watcher identity ({watcherRootId,
-	*  generation} — a handle that is neither current nor pending belongs to
-	*  a retired generation and its events are rejected), `filename == null`
-	*  marks the ROOT dirty for rediscovery, and events observed while the
-	*  root's generation is still snapshotting are buffered for replay. */
-	const onExternalEvent = (root, self, filename) => {
-		if (closed) return;
-		const watcher = self();
-		const active = watcher !== void 0 && externalWatchers.get(root) === watcher;
-		const isPending = watcher !== void 0 && pendingOpened.get(root) === watcher;
-		if (!active && !isPending) return;
-		let abs;
-		if (filename == null) abs = root;
-		else {
-			const rel = filename.toString();
-			if (rel.split(/[\\/]/).some((segment) => IGNORED_SEGMENTS.has(segment))) return;
-			abs = rel === "" ? root : join(root, rel);
-		}
-		if (isPending && !active) {
-			capturedDuringSnapshot.push(abs);
-			return;
-		}
-		enqueuePath(abs);
-	};
-	/** Open one external-root watcher into `into` (the committed set at
-	*  startup, the pending set during reset reconciliation). Failures
-	*  degrade ONLY this root (design D7); node_modules-resident roots are
-	*  documented unwatchable and never registered (guardrail G2). */
-	const openExternalWatcher = (root, into) => {
-		if (root.split(/[\\/]/).includes("node_modules")) return;
-		try {
-			let watcher;
-			watcher = watchFn(root, { recursive: true }, (_event, filename) => onExternalEvent(root, () => watcher, filename));
-			watcher.on("error", (err) => degradeExternalRoot(root, err));
-			watcher.unref?.();
-			into.set(root, watcher);
-			session.stickyDiagnostics?.delete(externalDiagnosticKey(root));
-		} catch (err) {
-			degradeExternalRoot(root, err);
-		}
-	};
-	const addWatcher = (dir, recursive) => {
-		const watcher = watchFn(dir, { recursive }, (_event, filename) => onEvent(dir, filename));
-		watcher.on("error", onWatcherError);
-		watcher.unref?.();
-		watchers.set(dir, watcher);
-	};
-	try {
-		addWatcher(rootDir, false);
-		for (const entry of readdirSync(rootDir, { withFileTypes: true })) {
-			if (!entry.isDirectory() || IGNORED_SEGMENTS.has(entry.name)) continue;
-			addWatcher(join(rootDir, entry.name), true);
-		}
-	} catch (err) {
-		closeAll();
-		console.warn(`[animus-extract] Turbopack dev watcher unavailable (${String(err)}); source edits require a dev-server restart`);
-		return null;
-	}
-	for (const root of session.externalWatchRoots ?? []) openExternalWatcher(root, externalWatchers);
-	session.onExternalRootResolved = (root) => {
-		if (closed) return;
-		if (externalWatchers.has(root) || pendingOpened.has(root)) return;
-		openExternalWatcher(root, pendingOpened);
-	};
-	session.onExternalRootsCommitted = (roots) => {
-		if (closed) return;
-		const admitted = new Set(roots);
-		for (const [root, watcher] of pendingOpened) externalWatchers.set(root, watcher);
-		pendingOpened = /* @__PURE__ */ new Map();
-		for (const [root, watcher] of [...externalWatchers]) if (!admitted.has(root)) {
-			watcher.close();
-			externalWatchers.delete(root);
-		}
-		for (const abs of capturedDuringSnapshot.splice(0)) enqueuePath(abs);
-	};
-	return { close: closeAll };
-}
-//#endregion
 //#region src/with-animus.ts
 const __dirname = dirname(fileURLToPath(import.meta.url));
 let warnedGitignore = false;
@@ -1847,6 +343,18 @@ let warnedUnstableTurbopack = false;
 */
 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, [
+		"cssImportTarget",
+		"turbopack",
+		"unstable_turbopack",
+		"loaderPath"
+	], [{
+		key: "root",
+		reason: "the Next driver's root is Next's `dir` at config time"
+	}], {
+		onUnknownKey: "warn",
+		warn: (message) => console.warn(`[animus-extract] ${message}`)
+	});
 	if (options.unstable_turbopack && !options.turbopack && !warnedUnstableTurbopack) {
 		warnedUnstableTurbopack = true;
 		console.warn("[animus-extract] `unstable_turbopack` is deprecated — rename it to `turbopack` (same shape)");
@@ -1858,7 +366,7 @@ function withAnimus(options) {
 			...nextConfig,
 			webpack(config, context) {
 				if (typeof existingWebpack === "function") config = existingWebpack(config, context);
-				const rootDir = process.cwd();
+				const rootDir = typeof context.dir === "string" && context.dir.length > 0 ? context.dir : process.cwd();
 				const plugin = new AnimusWebpackPlugin(options);
 				plugin.setRootDir(rootDir);
 				const sessionDir = plugin.sessionDir;
@@ -1886,10 +394,10 @@ function withAnimus(options) {
 				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(context.dev === true) }));
+				if (typeof DefinePlugin === "function") 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] = stylesPath(sessionDir);
+				config.resolve.alias[ANIMUS_CSS_MODULE_ID$1] = stylesPath(sessionDir);
 				const sessionSystemPropsPath = systemPropsPath(sessionDir);
 				config.plugins.push({ apply(compiler) {
 					compiler.hooks.normalModuleFactory.tap("AnimusVirtualResolve", (nmf) => {
@@ -1939,7 +447,7 @@ async function wireTurbopack(nextConfig, options) {
 	session.rootDir = rootDir;
 	const builtAliases = buildPathAliasesJson(readTsconfigAliasPairs(rootDir), rootDir);
 	if (builtAliases) session.pathAliasesJson = builtAliases.json;
-	await runTurbopackPipeline(session);
+	await runSessionPipeline(session);
 	if (process.env.NODE_ENV === "development") startTurbopackWatcher(session, rootDir);
 	const fragment = buildTurbopackConfig({
 		rootDir,
@@ -1950,7 +458,7 @@ async function wireTurbopack(nextConfig, options) {
 		sessionDir: session.sessionDir
 	});
 	const existing = nextConfig.turbopack ?? {};
-	if (existing.rules && "*.{ts,tsx,js,jsx,mjs}" in existing.rules) throw new Error(`[animus-extract] turbopack.rules['${ANIMUS_TURBOPACK_RULE_GLOB}'] is already configured — remove the consumer rule or disable unstable_turbopack`);
+	if (existing.rules && ANIMUS_TURBOPACK_RULE_GLOB in existing.rules) throw new Error(`[animus-extract] turbopack.rules['${ANIMUS_TURBOPACK_RULE_GLOB}'] is already configured — remove the consumer rule or disable unstable_turbopack`);
 	return {
 		...nextConfig,
 		turbopack: {