@animus-ui/extract 0.1.9 → 0.1.12

package/dist/session.cjs

@@ -0,0 +1,1999 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_pipeline = require("./pipeline-x1yBZ2UP.cjs");
+let crypto = require("crypto");
+let fs = require("fs");
+let path = require("path");
+//#region session/session-paths.ts
+/**
+* Session artifact names, path derivations, and artifact shapes. Imports no
+* session or singleton module: the Turbopack loader graph stays worker-local.
+*/
+/** Session-dir-relative name of the replacement-epoch disk witness. */
+const REPLACEMENT_EPOCH_ARTIFACT = "replacements-epoch";
+/** Virtual module id of the emitted system-props module. */
+const TURBOPACK_SYSTEM_PROPS_ID = "virtual:animus/system-props";
+/** Session-dir-relative name of the analysis-commit transaction artifact. */
+const ANALYSIS_COMMIT_ARTIFACT = "analysis-commit";
+/** Session-dir-relative name of the analysis-status artifact. */
+const ANALYSIS_STATUS_ARTIFACT = "analysis-status.json";
+/** Session-dir-relative name of the manifest payload artifact. */
+const MANIFEST_ARTIFACT = "manifest.json";
+/** Session-dir-relative name of the analysis-inputs payload artifact — the
+*  Turbopack loader-worker hydration corpus. */
+const ANALYSIS_INPUTS_ARTIFACT = "analysis-inputs.json";
+/** Session-dir-relative name of the emitted stylesheet artifact. */
+const STYLES_ARTIFACT = "styles.css";
+/** Session-dir-relative name of the emitted system-props module. */
+const SYSTEM_PROPS_ARTIFACT = "system-props.js";
+/** Session-dir-relative directory holding copied asset() files. */
+const SESSION_ASSETS_DIR = "assets";
+/** The standalone CLI's published-set commit record in the flat `.animus/`
+*  tree; the session's start hygiene keys on this name before deleting. */
+const CLI_COMMIT_ARTIFACT = "commit.json";
+/** Advisory claim record (pid plus heartbeat) of whichever directory holds
+*  it; sessions write it into their own tree too, despite the `CLI_` name. */
+const CLI_LOCK_ARTIFACT = "lock.json";
+/** Project-relative artifact directory: the CLI's default output tree and
+*  the parent of every session tree. One spelling, or the tree splits. */
+const ANIMUS_ARTIFACT_DIR = ".animus";
+/** Module id the Rust emitter injects, and the alias key both bundlers
+*  register. A literal on purpose: a rename breaks built consumer packages.
+*  The Next plugin's webpack alias harvest skips this exact key, so a change
+*  here is a change in the emitter, both bundler arms and that harvest. */
+const ANIMUS_CSS_MODULE_ID = ".animus/styles.css";
+function sessionsRootDir(rootDir) {
+	return (0, path.join)(rootDir, ANIMUS_ARTIFACT_DIR, "sessions");
+}
+function sessionArtifactDir(rootDir, sessionId) {
+	return (0, path.join)(sessionsRootDir(rootDir), sessionId);
+}
+function replacementEpochPath(sessionDir) {
+	return (0, path.join)(sessionDir, REPLACEMENT_EPOCH_ARTIFACT);
+}
+function analysisCommitPath(sessionDir) {
+	return (0, path.join)(sessionDir, ANALYSIS_COMMIT_ARTIFACT);
+}
+function analysisStatusPath(sessionDir) {
+	return (0, path.join)(sessionDir, ANALYSIS_STATUS_ARTIFACT);
+}
+function manifestPath(sessionDir) {
+	return (0, path.join)(sessionDir, MANIFEST_ARTIFACT);
+}
+function analysisInputsPath(sessionDir) {
+	return (0, path.join)(sessionDir, ANALYSIS_INPUTS_ARTIFACT);
+}
+function stylesPath(sessionDir) {
+	return (0, path.join)(sessionDir, STYLES_ARTIFACT);
+}
+function systemPropsPath(sessionDir) {
+	return (0, path.join)(sessionDir, SYSTEM_PROPS_ARTIFACT);
+}
+/** Splices the envelope in as a leading `__animusSession` field without
+*  re-serializing: parse/re-stringify would reformat engine-emitted JSON. */
+function envelopeJsonArtifact(payload, envelopeJson) {
+	const trimmed = payload.trimStart();
+	if (!trimmed.startsWith("{")) return payload;
+	if (trimmed.slice(1).trimStart().startsWith("}")) return `{"__animusSession":${envelopeJson}}`;
+	return `{"__animusSession":${envelopeJson},${trimmed.slice(1)}`;
+}
+/** Trailing-comment side-band: a leading comment would displace the `@layer`
+*  declaration consumers pin at offset 0. */
+function envelopeCssArtifact(payload, envelopeJson) {
+	return `${payload}\n/* __animusSession ${envelopeJson} */\n`;
+}
+const ENVELOPE_CSS_COMMENT_RE = /\/\* __animusSession (\{.*\}) \*\//;
+/** Envelope of a JSON artifact's bytes, or undefined when it carries none.
+*  Throws on unparseable bytes; callers decide torn-artifact policy. */
+function readJsonEnvelope(bytes) {
+	return JSON.parse(bytes).__animusSession;
+}
+/** Envelope of the CSS side-band comment, or undefined when it is absent.
+*  Throws on an unparseable envelope body. */
+function readCssEnvelope(bytes) {
+	const match = bytes.match(ENVELOPE_CSS_COMMENT_RE);
+	return match ? JSON.parse(match[1]) : void 0;
+}
+//#endregion
+//#region session/published-set.ts
+function isPublishedSetRecord(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isPublishedSetString(value) {
+	return Object.prototype.toString.call(value) === "[object String]";
+}
+function isPublishedSetNumber(value) {
+	return Object.prototype.toString.call(value) === "[object Number]";
+}
+function decodeCommitRecord(bytes) {
+	let candidate;
+	try {
+		candidate = JSON.parse(bytes);
+	} catch {
+		return null;
+	}
+	if (!isPublishedSetRecord(candidate) || candidate.schema !== 1) return null;
+	const declared = candidate.payloads;
+	if (!isPublishedSetRecord(declared)) return null;
+	const payloads = {};
+	for (const [name, entry] of Object.entries(declared)) {
+		if (!isPublishedSetRecord(entry) || !isPublishedSetString(entry.hash)) return null;
+		payloads[name] = { hash: entry.hash };
+	}
+	return {
+		schema: 1,
+		payloads
+	};
+}
+/** Recompute every recorded payload hash over raw bytes — the writer's own
+*  hashing domain — and return the mismatches; empty means the set verifies. */
+function verifyCommitRecord(dir) {
+	let bytes;
+	try {
+		bytes = (0, fs.readFileSync)((0, path.join)(dir, CLI_COMMIT_ARTIFACT), "utf-8");
+	} catch (error) {
+		return [`commit record unreadable: ${String(error)}`];
+	}
+	const record = decodeCommitRecord(bytes);
+	if (record === null) return ["commit record is not a schema-1 payload record"];
+	const failures = [];
+	for (const [name, entry] of Object.entries(record.payloads)) try {
+		if (require_pipeline.contentHash((0, fs.readFileSync)((0, path.join)(dir, name))) !== entry.hash) failures.push(`${name}: bytes do not match the commit record`);
+	} catch (error) {
+		failures.push(`${name}: unreadable (${String(error)})`);
+	}
+	return failures;
+}
+const CLI_LOCK_HEARTBEAT_INTERVAL_MS = 6e4;
+/** A claim whose heartbeat is older than this has no live holder. Five missed
+*  refreshes: synchronous extraction can block the holder's refresh timer. */
+const CLI_LOCK_STALE_AFTER_MS = 5 * CLI_LOCK_HEARTBEAT_INTERVAL_MS;
+/** Absence of the file — the only read failure that means "no holder".
+*  ENOTDIR joins ENOENT: the path cannot exist under a non-directory. */
+function isMissingFile(error) {
+	return error instanceof Object && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+function readCliLockRecord(dir) {
+	let bytes;
+	try {
+		bytes = (0, fs.readFileSync)((0, path.join)(dir, CLI_LOCK_ARTIFACT), "utf-8");
+	} catch (error) {
+		if (isMissingFile(error)) return { kind: "none" };
+		throw error;
+	}
+	let candidate;
+	try {
+		candidate = JSON.parse(bytes);
+	} catch {
+		return { kind: "indeterminate" };
+	}
+	if (!isPublishedSetRecord(candidate) || !isPublishedSetNumber(candidate.pid)) return { kind: "indeterminate" };
+	const startedAt = candidate.startedAt;
+	const heartbeatAt = candidate.heartbeatAt;
+	const record = { pid: candidate.pid };
+	if (isPublishedSetString(startedAt)) record.startedAt = startedAt;
+	if (isPublishedSetString(heartbeatAt)) record.heartbeatAt = heartbeatAt;
+	return {
+		kind: "held",
+		record
+	};
+}
+function isPermissionDenied(error) {
+	return error instanceof Object && "code" in error && error.code === "EPERM";
+}
+function isLockHolderAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return isPermissionDenied(error);
+	}
+}
+function checkLockLiveness(record) {
+	if (!isLockHolderAlive(record.pid)) return {
+		live: false,
+		reason: `holder pid ${record.pid} is not running`
+	};
+	const beatAt = record.heartbeatAt === void 0 ? NaN : Date.parse(record.heartbeatAt);
+	if (Number.isNaN(beatAt)) return { live: true };
+	const ageMs = Date.now() - beatAt;
+	if (ageMs <= 3e5) return { live: true };
+	return {
+		live: false,
+		reason: `holder pid ${record.pid} is running but its lock heartbeat (${record.heartbeatAt}) is ${Math.round(ageMs / 1e3)}s old, past the ${CLI_LOCK_STALE_AFTER_MS / 1e3}s staleness window — the pid names a different process now`
+	};
+}
+function lockRecordBytes(startedAt) {
+	return JSON.stringify({
+		pid: process.pid,
+		startedAt,
+		heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+const HEARTBEAT_TEMP_PREFIX = ".lock-heartbeat-";
+function holdDirectoryClaim(dir, options = {}) {
+	const startedAt = options.startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const path$9 = (0, path.join)(dir, CLI_LOCK_ARTIFACT);
+	const tempPath = (0, path.join)(dir, `${HEARTBEAT_TEMP_PREFIX}${process.pid}`);
+	const rename = options.write === "rename";
+	let refresh = null;
+	let stopped = false;
+	const stop = () => {
+		stopped = true;
+		if (refresh !== null) clearInterval(refresh);
+		refresh = null;
+	};
+	const stamp = () => {
+		try {
+			if (rename) {
+				(0, fs.writeFileSync)(tempPath, lockRecordBytes(startedAt));
+				(0, fs.renameSync)(tempPath, path$9);
+			} else (0, fs.writeFileSync)(path$9, lockRecordBytes(startedAt));
+		} catch (error) {
+			stop();
+			if (isMissingFile(error)) return;
+			console.error(`[animus] Could not write the directory claim ${path$9}: ${String(error)}`);
+		}
+	};
+	stamp();
+	if (!stopped) {
+		refresh = setInterval(stamp, CLI_LOCK_HEARTBEAT_INTERVAL_MS);
+		refresh.unref?.();
+	}
+	return () => {
+		stop();
+		if (rename) (0, fs.rmSync)(tempPath, { force: true });
+		(0, fs.rmSync)(path$9, { force: true });
+	};
+}
+/** Snapshot the session's copied asset() files, sorted, BEFORE the session
+*  tree is disposed. Drivers publish them beside the emitted stylesheet. */
+function collectSessionAssets(sessionDir) {
+	if (!sessionDir) return [];
+	const dir = (0, path.join)(sessionDir, SESSION_ASSETS_DIR);
+	if (!(0, fs.existsSync)(dir)) return [];
+	return (0, fs.readdirSync)(dir).sort().map((name) => ({
+		name,
+		bytes: (0, fs.readFileSync)((0, path.join)(dir, name))
+	}));
+}
+//#endregion
+//#region session/resolve-packages.ts
+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((0, fs.readFileSync)((0, path.join)(rootDir, "package.json"), "utf-8"));
+		const workspaces = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces?.packages ?? [];
+		for (const ws of workspaces) {
+			const wsDir = (0, path.resolve)(rootDir, ws);
+			if (!(0, fs.existsSync)(wsDir)) continue;
+			try {
+				const pkg = JSON.parse((0, fs.readFileSync)((0, path.join)(wsDir, "package.json"), "utf-8"));
+				const name = pkg.name || "";
+				if (nameSet.has(name)) {
+					const main = pkg.main || pkg.module || "index.ts";
+					const entryPath = (0, path.resolve)(wsDir, main);
+					if ((0, fs.existsSync)(entryPath)) {
+						packageMap[name] = (0, path.relative)(rootDir, entryPath);
+						resolved.add(name);
+					}
+				}
+			} catch {}
+		}
+	} catch {}
+	for (const name of nameSet) {
+		if (resolved.has(name)) continue;
+		try {
+			const entryPath = require.resolve(name, { paths: [rootDir] });
+			packageMap[name] = (0, path.relative)(rootDir, entryPath);
+		} catch {}
+	}
+	return packageMap;
+}
+//#endregion
+//#region session/singleton.ts
+/**
+* globalThis-backed so the ESM plugin copy and the CJS webpack-loader copy
+* share one store; module scope alone gives each copy its own instance.
+*/
+const MANIFEST_KEY = "__animus_manifest_json__";
+const ANALYSIS_STARTED_KEY = "__animus_analysis_started__";
+const SHARED_CSS_KEY = "__animus_shared_css__";
+const SHARED_SYSTEM_PROPS_KEY = "__animus_shared_system_props__";
+const SHARED_EXTERNAL_DIRS_KEY = "__animus_external_pkg_dirs__";
+const SHARED_EXTERNAL_ENTRIES_KEY = "__animus_external_source_entries__";
+const ANALYZED_HASHES_KEY = "__animus_analyzed_hashes__";
+const REPLACEMENT_EPOCH_KEY = "__animus_replacement_epoch__";
+const WATCH_TRANSACTION_KEY = "__animus_watch_transaction__";
+const PROCESS_SESSION_ID_KEY = "__animus_process_session_id__";
+const SESSION_ARTIFACT_DIR_KEY = "__animus_session_artifact_dir__";
+const OWNING_WATCH_SESSION_KEY = "__animus_owning_watch_session__";
+const EXCLUSIVE_SESSION_OWNER_KEY = "__animus_exclusive_session_owner__";
+const ENGINE_KEY = "__animus_engine__";
+const V2_ENGINE_KEY = "__animus_v2_engine__";
+const V2_SENT_SOURCES_KEY = "__animus_v2_sent_sources__";
+const V2_DRIFT_WARNED_KEY = "__animus_v2_drift_warned__";
+const ENGINE_API_OVERRIDE_KEY = "__animus_engine_api_override__";
+const singletonStore = globalThis;
+const isSingletonString = (value) => {
+	if (Object(value) === value) return false;
+	try {
+		String.prototype.valueOf.call(value);
+		return true;
+	} catch {
+		return false;
+	}
+};
+function getManifestJson() {
+	return singletonStore[MANIFEST_KEY];
+}
+function setManifestJson(json) {
+	singletonStore[MANIFEST_KEY] = json;
+}
+/**
+* A latch over the most recently STARTED analysis, never cleared on settle:
+* non-null means one was scheduled. In-flight lives in getWatchTransaction.
+*/
+function getAnalysisStartedPromise() {
+	return singletonStore[ANALYSIS_STARTED_KEY];
+}
+function setAnalysisStartedPromise(promise) {
+	singletonStore[ANALYSIS_STARTED_KEY] = promise;
+}
+function resetAnalysisStartedPromise() {
+	singletonStore[ANALYSIS_STARTED_KEY] = null;
+}
+function getSharedCss() {
+	return singletonStore[SHARED_CSS_KEY] || "";
+}
+function setSharedCss(css) {
+	singletonStore[SHARED_CSS_KEY] = css;
+}
+function getSharedSystemProps() {
+	return singletonStore[SHARED_SYSTEM_PROPS_KEY] || "";
+}
+function setSharedSystemProps(content) {
+	singletonStore[SHARED_SYSTEM_PROPS_KEY] = content;
+}
+function getSharedExternalDirs() {
+	return singletonStore[SHARED_EXTERNAL_DIRS_KEY] || [];
+}
+function setSharedExternalDirs(dirs) {
+	singletonStore[SHARED_EXTERNAL_DIRS_KEY] = dirs;
+}
+function getSharedExternalEntries() {
+	return singletonStore[SHARED_EXTERNAL_ENTRIES_KEY] || /* @__PURE__ */ new Map();
+}
+function setSharedExternalEntries(entries) {
+	singletonStore[SHARED_EXTERNAL_ENTRIES_KEY] = entries;
+}
+function globalSlot(key) {
+	return {
+		get: () => singletonStore[key] ?? null,
+		set: (value) => {
+			singletonStore[key] = value;
+		}
+	};
+}
+const analyzedHashesSlot = globalSlot(ANALYZED_HASHES_KEY);
+const replacementEpochSlot = globalSlot(REPLACEMENT_EPOCH_KEY);
+const watchTransactionSlot = globalSlot(WATCH_TRANSACTION_KEY);
+const sessionArtifactDirSlot = globalSlot(SESSION_ARTIFACT_DIR_KEY);
+const owningWatchSessionSlot = globalSlot(OWNING_WATCH_SESSION_KEY);
+/**
+* The only session that can run watch analysis. A non-owning session forwards
+* its batch here; dropping it loses files only that watcher sees.
+*/
+function getOwningWatchSession() {
+	return owningWatchSessionSlot.get();
+}
+function setOwningWatchSession(session) {
+	owningWatchSessionSlot.set(session);
+}
+/**
+* Per-file content hashes of the last published analysis (relPath → hash of
+* the exact bytes analyzed), including files that produced zero entries.
+*/
+function getAnalyzedHashes() {
+	return analyzedHashesSlot.get();
+}
+function setAnalyzedHashes(hashes) {
+	analyzedHashesSlot.set(hashes);
+}
+/**
+* Session identity is per process: the first caller claims a fresh id and
+* every later one adopts it, so all compilers share one artifact tree.
+*/
+function claimProcessSessionId() {
+	const existing = singletonStore[PROCESS_SESSION_ID_KEY];
+	if (isSingletonString(existing) && existing.length > 0) return existing;
+	const fresh = (0, crypto.randomUUID)();
+	singletonStore[PROCESS_SESSION_ID_KEY] = fresh;
+	return fresh;
+}
+/**
+* Two CONCURRENT drive loops in one process would share one session tree and
+* clobber each other; sequential claim/release cycles are legal.
+*/
+function claimExclusiveSessionOwner(label) {
+	const active = singletonStore[EXCLUSIVE_SESSION_OWNER_KEY];
+	if (isSingletonString(active)) throw new Error(`[animus] a second Animus host ("${label}") started while "${active}" is still active in this process. The extraction session is process-global (one session tree, one manifest), so concurrent hosts would clobber each other's analysis. Run one Animus-enabled config per process, or make the builds sequential.`);
+	singletonStore[EXCLUSIVE_SESSION_OWNER_KEY] = label;
+	return () => {
+		if (singletonStore[EXCLUSIVE_SESSION_OWNER_KEY] === label) delete singletonStore[EXCLUSIVE_SESSION_OWNER_KEY];
+	};
+}
+/**
+* Absolute artifact directory of the OWNING session's last publication. The
+* Turbopack loader runs out of process and receives it via options instead.
+*/
+function getSessionArtifactDir() {
+	return sessionArtifactDirSlot.get();
+}
+function setSessionArtifactDir(dir) {
+	sessionArtifactDirSlot.set(dir);
+}
+/**
+* Replacement epoch of the last published analysis, written AFTER the
+* manifest so an epoch reader always sees at least that generation's manifest.
+*/
+function getReplacementEpoch() {
+	return replacementEpochSlot.get();
+}
+function setReplacementEpoch(epoch) {
+	replacementEpochSlot.set(epoch);
+}
+/**
+* The one in-flight watch-analysis transaction: a compiler that did not start
+* it joins this promise rather than read a pre-transaction generation.
+*/
+function getWatchTransaction() {
+	return watchTransactionSlot.get();
+}
+function setWatchTransaction(transaction) {
+	watchTransactionSlot.set(transaction);
+}
+/** Engine selection travels through the singleton so non-owning compilers
+*  and the webpack loader honor the owner's choice. */
+function setSharedEngine(engine) {
+	singletonStore[ENGINE_KEY] = engine;
+}
+function getSharedEngine() {
+	return singletonStore[ENGINE_KEY] || "v2";
+}
+/** Single choke-point for every native extraction call; the NAPI module's
+*  own `.d.ts` is the authoritative surface for what it returns. */
+function requireEngine() {
+	return require("@animus-ui/extract");
+}
+/**
+* The one engine API for this process: the instance, its analyze-time
+* sources, and the drift flag live on globalThis so both copies share them.
+*/
+const v2EngineApi = require_pipeline.createV2EngineApi({
+	label: "animus",
+	isV2: () => getSharedEngine() === "v2",
+	loadNativeEngine: requireEngine,
+	passThroughUnknownPaths: true,
+	store: {
+		getEngine: () => singletonStore[V2_ENGINE_KEY],
+		setEngine: (engine) => {
+			singletonStore[V2_ENGINE_KEY] = engine;
+		},
+		getSentSources: () => singletonStore[V2_SENT_SOURCES_KEY] ?? null,
+		setSentSources: (sources) => {
+			singletonStore[V2_SENT_SOURCES_KEY] = sources;
+		},
+		getDriftWarned: () => Boolean(singletonStore[V2_DRIFT_WARNED_KEY]),
+		setDriftWarned: (value) => {
+			singletonStore[V2_DRIFT_WARNED_KEY] = value;
+		}
+	}
+});
+function engineApi() {
+	const override = singletonStore[ENGINE_API_OVERRIDE_KEY];
+	return override ? override() : v2EngineApi();
+}
+//#endregion
+//#region session/timing.ts
+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 require_pipeline.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)) merged[`rust.${k}`] = v;
+		console.error(`[animus:timing] ${JSON.stringify(merged)}`);
+	}
+}
+//#endregion
+//#region session/extraction-session.ts
+const SESSION_DIR_MAX_AGE_MS = 864e5;
+const STATUS_WATCHDOG_MS = 2e3;
+const LEGACY_FLAT_ARTIFACTS = [
+	MANIFEST_ARTIFACT,
+	ANALYSIS_INPUTS_ARTIFACT,
+	STYLES_ARTIFACT,
+	SYSTEM_PROPS_ARTIFACT,
+	REPLACEMENT_EPOCH_ARTIFACT,
+	ANALYSIS_COMMIT_ARTIFACT,
+	ANALYSIS_STATUS_ARTIFACT
+];
+/** Brands values read back off DISK. `Object(value) !== value` rejects
+*  boxed primitives; the tag is unspoofable by `Symbol.toStringTag`. */
+function isDiskString(value) {
+	return Object(value) !== value && Object.prototype.toString.call(value) === "[object String]";
+}
+function isDiskNumber(value) {
+	return Object(value) !== value && Object.prototype.toString.call(value) === "[object Number]";
+}
+/** Bundler-agnostic extraction pipeline: system load, source ingestion,
+*  analysis, emission, and watch-cycle diffing. Carries no bundler types. */
+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();
+	/** System-props module id override. Turbopack rejects absolute-path
+	*  imports, so its driver sets a virtual id; null injects the abs path. */
+	systemPropsModuleId = null;
+	/** Whether the analysis-inputs hydration corpus is written to disk. Only
+	*  isolated loader workers replay it; an in-process loader reads memory. */
+	persistAnalysisInputs = false;
+	/** Absolute directory prefixes for external packages (loader allowlist). */
+	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 authority for this generation — roots realpath'd once per
+	*  pipeline; aliases recorded while files exist so deletions resolve. */
+	sourceIdentity = null;
+	/** Canonical admitted external root → declared specifiers; duplicate
+	*  specifiers resolving to one canonical root share an entry. */
+	externalRootOwners = /* @__PURE__ */ new Map();
+	/** Canonical external root → the extension set its collection walk used
+	*  (widened for dist-only roots); rewalks and classification share it. */
+	externalRootExtensions = /* @__PURE__ */ new Map();
+	/** Canonical admitted external watch roots — the engine-side watch
+	*  surface (webpack contextDependencies / Turbopack watchers). */
+	externalWatchRoots = [];
+	/** Canonical external root → sourceKey → {raw content hash, recorded abs}:
+	*  the inventory a dirty-root rewalk diffs against, hashed before MDX. */
+	externalInventory = /* @__PURE__ */ new Map();
+	/** 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. Injected seam:
+	*  the real predicate only discriminates on Windows, so tests replace it. */
+	sharesProjectVolume = require_pipeline.sharesVolumeRoot;
+	/** `onExternalRootResolved` fires per admitted root DURING collection,
+	*  before its walk; `onExternalRootsCommitted` only after publication. */
+	onExternalRootResolved = null;
+	onExternalRootsCommitted = null;
+	/** Fires exactly once per settled `handleWatchUpdate` — the failure cause,
+	*  or null when clean. Observation never alters delivery. */
+	onCycleSettled = null;
+	options;
+	staticCssJson;
+	system = null;
+	/** Vocabulary witness diagnostics from the sealed system's registration
+	*  record, awaiting the shared surfacing pass. */
+	systemVocabularyDiagnostics = [];
+	/** Configured external files that could not be read. Incremental passes
+	*  re-collect nothing, so they replay these instead of passing strict. */
+	ingestionFailureDiagnostics = [];
+	/** Full package-resolution map from the last full pipeline — replayed by
+	*  incremental passes (sourceEntries alone omits dist-resolved packages). */
+	lastPackageMap = {};
+	fileCache = /* @__PURE__ */ new Map();
+	corpus = require_pipeline.createSourceCorpus({
+		engineApi: () => engineApi(),
+		prefix: "[animus-next]",
+		strict: () => !!this.options.strict,
+		warn: (message) => this.warn(message)
+	});
+	systemDependencyKeys = /* @__PURE__ */ new Set();
+	/** Loader-reported dependency paths for bundler watch registration. */
+	systemDependencyPaths = [];
+	systemDependencyHashes = /* @__PURE__ */ new Map();
+	lastSystemPropsHash = null;
+	artifactRecords = {
+		manifest: null,
+		inputs: null,
+		styles: null
+	};
+	/** Last written analysis-commit; null seeds from disk on first use. Its
+	*  generation counter is correct only because one session owns the dir. */
+	lastCommit = null;
+	/** Release handle for the in-process owner slot AND the directory's
+	*  on-disk owner record, taken and released as one; null when unheld. */
+	releasePublicationClaim = null;
+	/** Session identity, claimed once per PROCESS and adopted by every later
+	*  session instance so all compilers share one artifact tree. */
+	sessionId = claimProcessSessionId();
+	/** Epoch of the last published analysis; null seeds from disk so a
+	*  same-session restart with unchanged plans rewrites no bytes. */
+	lastEpochValue = null;
+	/** Watcher debounce ceiling feeding status deadlines. */
+	debounceCeilingMs = 75;
+	/** Test seam: observes every session-artifact write (name, content)
+	*  post-rename — write ORDER is part of the transaction contract. */
+	onArtifactWrite = null;
+	statusAttemptId = 0;
+	statusAttemptOpen = false;
+	/** Monotonic readiness witness: flips true on the first complete
+	*  publication and never regresses; every later status write carries it. */
+	firstEmissionComplete = false;
+	/** Debounce-window observations pending analysis (sourceKey → hash). */
+	debouncePending = /* @__PURE__ */ new Map();
+	sessionStartHygieneDone = false;
+	lcssTargets = null;
+	constructor(options) {
+		this.options = options;
+		this.staticCssJson = require_pipeline.serializeStaticCss(options.staticCss);
+	}
+	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.error(`[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;
+	}
+	/** Diagnostic prefix label — drivers set their own so one host's errors
+	*  never masquerade as another driver's. */
+	driverLabel = "animus-next";
+	/** Per-specifier discovery outcomes from the last full collection —
+	*  driver-consumed reporting surface (the CLI's summary). */
+	lastExternalOutcomes = [];
+	/** Component count of the last published analysis, null before the first —
+	*  read by drivers instead of re-parsing the manifest JSON every cycle. */
+	lastComponentCount = null;
+	/** When superseded asset copies leave `assets/`: `'full-pipeline'` suits a
+	*  driver serving the dir in place, `'every-cycle'` one republishing it. */
+	staleAssetPruning = "full-pipeline";
+	/** Driver-owned STRUCTURAL exclusions, joined to the never-replaceable set
+	*  — never the user list, whose presence flips the replace semantics. */
+	structuralExclude = [];
+	scanConfigMemo = null;
+	/** Per-pattern exclusion hit counts from this session's matcher —
+	*  driver-consumed reporting surface (dead-pattern visibility). */
+	getExcludeStats() {
+		return this.resolveScanConfig().excludeMatcher.stats();
+	}
+	/** 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 ?? require_pipeline.DEFAULT_EXTENSIONS);
+			this.scanConfigMemo = {
+				excludeMatcher: require_pipeline.createExcludeMatcher(this.options.exclude, this.structuralExclude),
+				extensionsSet
+			};
+		}
+		return this.scanConfigMemo;
+	}
+	/** One single-flight analysis transaction per event batch: concurrent
+	*  entries join the in-flight promise; each settled entry reports outcome. */
+	async handleWatchUpdate(changes) {
+		try {
+			await this.routeWatchUpdate(changes);
+		} catch (error) {
+			this.onCycleSettled?.(error);
+			throw error;
+		}
+		this.onCycleSettled?.(null);
+	}
+	async routeWatchUpdate(changes) {
+		const inflight = getWatchTransaction();
+		if (inflight) {
+			await inflight;
+			return;
+		}
+		if (!this.system) {
+			const owner = getOwningWatchSession();
+			const hasBatch = (changes.modifiedFiles?.size ?? 0) > 0 || (changes.removedFiles?.size ?? 0) > 0;
+			if (owner && owner !== this && hasBatch) await owner.ingestForwardedBatch(changes);
+			return;
+		}
+		const transaction = this.processWatchUpdate(changes);
+		setWatchTransaction(transaction);
+		try {
+			await transaction;
+		} finally {
+			setWatchTransaction(null);
+		}
+	}
+	/** Owner-side entry for a batch a non-owning compiler observed. Serializes
+	*  behind any in-flight transaction — it has no other delivery. */
+	async ingestForwardedBatch(changes) {
+		if (!this.system) return;
+		for (;;) {
+			const inflight = getWatchTransaction();
+			if (!inflight) break;
+			await inflight;
+		}
+		const transaction = this.processWatchUpdate(changes);
+		setWatchTransaction(transaction);
+		try {
+			await transaction;
+		} finally {
+			setWatchTransaction(null);
+		}
+	}
+	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;
+		let systemHit;
+		try {
+			if (!changes.modifiedFiles && !changes.removedFiles) for (const [dep, hash] of this.systemDependencyHashes) {
+				let current = "";
+				try {
+					current = require_pipeline.contentHash((0, fs.readFileSync)(dep, "utf-8"));
+				} catch {}
+				if (current !== hash) {
+					systemHit = dep;
+					break;
+				}
+			}
+			else systemHit = changed.find((path$2) => require_pipeline.toWatchKeys(path$2).some((key) => this.systemDependencyKeys.has(key)));
+		} catch (err) {
+			this.warn(`HMR system-reload check failed: ${String(err)}`);
+		}
+		if (systemHit) {
+			this.log(`system reload: system dependency changed (${(0, path.relative)(rootDir, systemHit)})`);
+			this.resetForHmr();
+			try {
+				const promise = this.runFullPipeline(this.pendingFromBatch(changes));
+				setAnalysisStartedPromise(promise);
+				await promise;
+			} catch (err) {
+				try {
+					this.beginStatusAttempt();
+					this.writeAnalysisStatus("failed", this.pendingFromBatch(changes), String(err));
+				} catch (statusErr) {
+					this.warn(`failed-status write failed: ${String(statusErr)}`);
+				}
+				throw err;
+			}
+			return;
+		}
+		if (changed.some((path$3) => require_pipeline.toWatchKeys(path$3).some((key) => this.assetDependencyKeys.has(key)))) {
+			this.assetCopyCache.clear();
+			assetChanged = true;
+		}
+		const { excludeMatcher, extensionsSet } = this.resolveScanConfig();
+		const priorCacheEntries = /* @__PURE__ */ new Map();
+		const priorExternalFileOwners = { ...this.externalFileOwners };
+		const recordPrior = (key) => {
+			if (!priorCacheEntries.has(key)) priorCacheEntries.set(key, this.fileCache.get(key) ?? null);
+		};
+		const inventoryUpdates = [];
+		const ownerRemovals = [];
+		let removedAny = false;
+		if (changes.removedFiles) for (const removedPath of changes.removedFiles) {
+			let key;
+			let owningRoot = null;
+			if (require_pipeline.isPathWithinRoot(rootDir, removedPath)) key = (0, path.relative)(rootDir, removedPath);
+			else {
+				const resolved = this.sourceIdentity?.resolveDeletedSourceId(removedPath);
+				if (!resolved) continue;
+				key = resolved.sourceKey;
+				owningRoot = resolved.owningRoot;
+			}
+			recordPrior(key);
+			if (this.fileCache.delete(key)) {
+				removedAny = true;
+				if (owningRoot) {
+					inventoryUpdates.push({
+						root: owningRoot,
+						key,
+						hash: null,
+						abs: removedPath
+					});
+					ownerRemovals.push(key, key + ".tsx");
+				}
+			}
+		}
+		let targets;
+		if (changes.modifiedFiles) {
+			targets = [];
+			for (const modifiedPath of changes.modifiedFiles) {
+				const classified = this.classifyWatchPath(modifiedPath, {
+					excludeMatcher,
+					extensionsSet
+				});
+				if (classified) targets.push({
+					abs: modifiedPath,
+					...classified
+				});
+			}
+		} else targets = require_pipeline.discoverFiles(rootDir, rootDir, excludeMatcher, extensionsSet).map((abs) => ({
+			abs,
+			key: (0, path.relative)(rootDir, abs),
+			owningRoot: null
+		}));
+		const changedPaths = [];
+		for (const target of targets) {
+			const relPath = target.key;
+			let source;
+			try {
+				source = (0, fs.readFileSync)(target.abs, "utf-8");
+			} catch {
+				continue;
+			}
+			const rawHash = require_pipeline.contentHash(source);
+			const cached = this.fileCache.get(relPath);
+			const hash = rawHash;
+			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 pending = changedPaths.map((rel) => [rel, this.fileCache.get(rel).hash]);
+			let ingested;
+			try {
+				this.beginStatusAttempt();
+				ingested = await this.corpus.prepare({
+					fileCache: this.fileCache,
+					externalFileOwners: this.externalFileOwners
+				});
+				this.externalFileOwners = require_pipeline.projectExternalFileOwners(ingested, this.externalFileOwners);
+				resetAnalysisStartedPromise();
+				const promise = this.runIncrementalPipeline(ingested.analysisEntries, pending);
+				setAnalysisStartedPromise(promise);
+				await promise;
+			} catch (err) {
+				for (const [key, prior] of priorCacheEntries) if (prior === null) this.fileCache.delete(key);
+				else this.fileCache.set(key, prior);
+				this.externalFileOwners = priorExternalFileOwners;
+				if (this.statusAttemptOpen) {
+					this.debouncePending.clear();
+					this.writeAnalysisStatus("failed", pending, String(err));
+				}
+				throw err;
+			}
+			this.publishSourceIngestion(ingested);
+			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
+				});
+			}
+			for (const key of ownerRemovals) delete this.externalFileOwners[key];
+		} else if (this.statusAttemptOpen) {
+			this.debouncePending.clear();
+			this.writeAnalysisStatus("idle", []);
+		}
+	}
+	publishSourceIngestion(result) {
+		this.fileCache = new Map(result.originalEntries.map((entry) => [entry.path, {
+			hash: entry.hash,
+			source: entry.source
+		}]));
+		this.corpus.publish(result);
+	}
+	/** Full analysis + publication, registered in the one in-flight
+	*  transaction slot; a nested reload leaves the enclosing registration. */
+	async runFullPipeline(pending = []) {
+		if (this.releasePublicationClaim === null) {
+			const releaseOwner = claimExclusiveSessionOwner(`${this.driverLabel}:${this.sessionDir}`);
+			(0, fs.mkdirSync)(this.sessionDir, { recursive: true });
+			const releaseClaimRecord = holdDirectoryClaim(this.sessionDir);
+			this.releasePublicationClaim = () => {
+				releaseOwner();
+				releaseClaimRecord();
+			};
+		}
+		const priorSystem = this.system;
+		const nested = getWatchTransaction() !== null;
+		const transaction = this.runPipelineTransaction(pending);
+		if (!nested) setWatchTransaction(transaction);
+		try {
+			await transaction;
+		} catch (error) {
+			this.system = priorSystem;
+			throw error;
+		} finally {
+			if (!nested) setWatchTransaction(null);
+		}
+	}
+	async runPipelineTransaction(pending) {
+		const pipelineStart = this.now();
+		const bt = {};
+		this.runSessionStartHygiene();
+		setSessionArtifactDir(this.sessionDir);
+		const rootDir = this.rootDir;
+		const priorSourceState = this.snapshotSourceState();
+		const resolvedSystemPath = (0, path.resolve)(rootDir, this.options.system);
+		let t = this.now();
+		this.system = require_pipeline.loadSystemConfig(engineApi, {
+			systemPath: resolvedSystemPath,
+			rootDir,
+			prefix: this.options.prefix
+		});
+		this.systemVocabularyDiagnostics = require_pipeline.vocabularyWitnessDiagnostics(this.system.vocabularyWitnessesJson);
+		this.assetCopyCache.clear();
+		this.assetDependencyPaths.clear();
+		this.assetDependencyKeys.clear();
+		{
+			const deps = this.system.dependencies ?? [];
+			const keys = /* @__PURE__ */ new Set();
+			for (const key of require_pipeline.toWatchKeys(resolvedSystemPath)) keys.add(key);
+			for (const dep of deps) for (const key of require_pipeline.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, require_pipeline.contentHash((0, fs.readFileSync)(dep, "utf-8")));
+			} catch {
+				hashes.set(dep, "");
+			}
+			this.systemDependencyHashes = hashes;
+		}
+		bt.systemLoad = this.elapsed(t);
+		t = this.now();
+		const { excludeMatcher, extensionsSet } = this.resolveScanConfig();
+		const files = require_pipeline.discoverFiles(rootDir, rootDir, excludeMatcher, extensionsSet);
+		bt.fileDiscovery = this.elapsed(t);
+		t = this.now();
+		const rawEntries = [];
+		for (const filePath of files) {
+			const source = (0, fs.readFileSync)(filePath, "utf-8");
+			const relPath = (0, path.relative)(rootDir, filePath);
+			const hash = require_pipeline.contentHash(source);
+			rawEntries.push({
+				path: relPath,
+				source,
+				hash
+			});
+		}
+		bt.fileRead = this.elapsed(t);
+		t = this.now();
+		const packageNames = require_pipeline.extractSystemFilePackages(resolvedSystemPath);
+		const preResolved = resolvePackagesByName(rootDir, packageNames);
+		const rawExternalFiles = /* @__PURE__ */ new Map();
+		const ingestionFailures = [];
+		const collected = await require_pipeline.collectExternalPackageSources({
+			specifiers: packageNames,
+			resolveSpecifier: (name) => preResolved[name] ? (0, path.resolve)(rootDir, preResolved[name]) : null,
+			rootDir,
+			extensionsSet,
+			hasEntry: (relPath) => rawEntries.some((e) => e.path === relPath),
+			onSourceRead: (source, _relPath, absPath) => {
+				rawExternalFiles.set(absPath, require_pipeline.contentHash(source));
+			},
+			onUnreadable: (relPath, err) => ingestionFailures.push(require_pipeline.unreadableSourceDiagnostic(relPath, err)),
+			onPackageResolved: (_specifier, packageDir) => {
+				if (!this.onExternalRootResolved) return;
+				if (!this.sharesProjectVolume(rootDir, packageDir)) return;
+				let canonical = packageDir;
+				try {
+					canonical = (0, fs.realpathSync)(packageDir);
+				} catch {}
+				this.onExternalRootResolved(canonical);
+			}
+		});
+		this.lastExternalOutcomes = collected.outcomes;
+		this.ingestionFailureDiagnostics = ingestionFailures;
+		for (const record of collected.outcomes) if (record.outcome === "empty") this.warn(`include '${record.specifier}' resolved but discovered no component sources`);
+		const unresolvableMessage = require_pipeline.unresolvableIncludesMessage(collected.outcomes);
+		if (unresolvableMessage !== null) {
+			if (this.options.strict) throw new Error(unresolvableMessage);
+			this.warn(unresolvableMessage);
+		}
+		const staleDistMessage = require_pipeline.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(`[${this.driverLabel}] ${message}`);
+			this.stickyDiagnostics.set("cross-volume", message);
+		}
+		for (const message of this.stickyDiagnostics.values()) this.warn(message);
+		const admitted = require_pipeline.excludeCollectedPackages(collected, rejectedSpecifiers, rootDir);
+		try {
+			const identity = require_pipeline.createSourceIdentity(rootDir);
+			this.externalRootOwners = /* @__PURE__ */ new Map();
+			this.externalRootExtensions = /* @__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);
+				const exts = admitted.dirExtensions[dir];
+				if (exts) this.externalRootExtensions.set(canonical, new Set(exts));
+			}
+			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 = require_pipeline.firstOwners(admitted.dirOwnerSets);
+			this.externalFileOwners = admitted.fileOwners;
+			this.externalSourceEntries = admitted.sourceEntries;
+			for (const entry of admitted.entries) {
+				const hash = require_pipeline.contentHash(entry.source);
+				rawEntries.push({
+					path: entry.path,
+					source: entry.source,
+					hash
+				});
+			}
+			this.externalPackageDirs = admitted.packageDirs;
+			bt.packageResolve = this.elapsed(t);
+			this.beginStatusAttempt();
+			let accepted;
+			try {
+				accepted = await this.corpus.prepare(rawEntries);
+			} catch (err) {
+				this.debouncePending.clear();
+				this.writeAnalysisStatus("failed", pending, String(err));
+				throw err;
+			}
+			this.externalFileOwners = require_pipeline.projectExternalFileOwners(accepted, this.externalFileOwners);
+			bt.fileCount = accepted.analysisEntries.length;
+			require_pipeline.clearEngineCache(engineApi);
+			await this.analyzeAndEmit(accepted.analysisEntries, packageMap, false, bt, pipelineStart, pending);
+			this.publishSourceIngestion(accepted);
+			setSharedExternalDirs(admitted.packageDirs);
+			setSharedExternalEntries(admitted.sourceEntries);
+			this.onExternalRootsCommitted?.(this.externalWatchRoots);
+			setOwningWatchSession(this);
+		} catch (err) {
+			this.restoreSourceState(priorSourceState);
+			throw err;
+		}
+	}
+	/** Per-generation source state captured as ONE object so the restore
+	*  cannot omit a member; deep-copied fields are mutated in place. */
+	snapshotSourceState() {
+		return {
+			sourceIdentity: this.sourceIdentity,
+			externalRootOwners: new Map([...this.externalRootOwners].map(([root, owners]) => [root, new Set(owners)])),
+			externalRootExtensions: new Map(this.externalRootExtensions),
+			externalWatchRoots: [...this.externalWatchRoots],
+			externalInventory: new Map([...this.externalInventory].map(([root, inventory]) => [root, new Map(inventory)])),
+			lastPackageMap: this.lastPackageMap,
+			externalDirOwners: this.externalDirOwners,
+			externalFileOwners: this.externalFileOwners,
+			externalSourceEntries: this.externalSourceEntries,
+			externalPackageDirs: this.externalPackageDirs,
+			systemVocabularyDiagnostics: this.systemVocabularyDiagnostics,
+			ingestionFailureDiagnostics: this.ingestionFailureDiagnostics
+		};
+	}
+	restoreSourceState(snapshot) {
+		Object.assign(this, snapshot);
+	}
+	/** Release this session's publication claim so a successor may publish.
+	*  Idempotent, and scoped to this session's own claim. */
+	close() {
+		this.releasePublicationClaim?.();
+		this.releasePublicationClaim = null;
+	}
+	/** Reset analysis state for a system reload: write guards go back to null
+	*  and reseed from the disk envelopes on the next publication. */
+	resetForHmr() {
+		resetAnalysisStartedPromise();
+		this.artifactRecords = {
+			manifest: null,
+			inputs: null,
+			styles: null
+		};
+		this.lastSystemPropsHash = null;
+	}
+	/** The (sourceKey, observed hash) pairs of a watch batch — the status
+	*  file's pending set; loaders wait only on observed inputs. */
+	pendingFromBatch(changes) {
+		const { excludeMatcher, extensionsSet } = this.resolveScanConfig();
+		const pending = [];
+		for (const path$4 of changes.modifiedFiles ?? []) {
+			const classified = this.classifyWatchPath(path$4, {
+				excludeMatcher,
+				extensionsSet
+			});
+			if (!classified) continue;
+			try {
+				pending.push([classified.key, require_pipeline.contentHash((0, fs.readFileSync)(path$4, "utf-8"))]);
+			} catch {}
+		}
+		return pending;
+	}
+	/** Rewalk dirty external roots and diff the inventory into created,
+	*  edited and deleted deltas: a watcher may report only the directory. */
+	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$5) => {
+			const containing = identity.containingExternalRoot(path$5);
+			if (!containing) return null;
+			try {
+				return (0, fs.statSync)(path$5).isDirectory() ? containing : null;
+			} catch {
+				return identity.resolveDeletedSourceId(path$5) ? null : containing;
+			}
+		};
+		for (const path$6 of changes.modifiedFiles ?? []) {
+			const root = rootHitFor(path$6);
+			if (root) dirtyRoots.add(root);
+			else modified.add(path$6);
+		}
+		for (const path$7 of changes.removedFiles ?? []) {
+			const root = rootHitFor(path$7);
+			if (root) dirtyRoots.add(root);
+			else removed.add(path$7);
+		}
+		for (const root of dirtyRoots) {
+			const previous = this.externalInventory.get(root) ?? /* @__PURE__ */ new Map();
+			const seen = /* @__PURE__ */ new Set();
+			const walked = require_pipeline.walkPackageSources(root, this.externalRootExtensions.get(root) ?? extensionsSet);
+			if (walked.length === 0 && previous.size > 0) this.warn(`external root rewalk found no files under ${root} while its inventory holds ${previous.size} — reconciling as full deletion`);
+			for (const abs of walked) {
+				const resolved = identity.resolveSourceId(abs);
+				if (!resolved || resolved.owningRoot !== root) continue;
+				seen.add(resolved.sourceKey);
+				let rawHash;
+				try {
+					rawHash = require_pipeline.contentHash((0, fs.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 path: a project-root member (consumer excludes apply)
+	*  or an admitted external member (symlink escapes rejected). */
+	classifyWatchPath(absPath, scan) {
+		const ext = (0, path.extname)(absPath);
+		const rootDir = this.rootDir;
+		if (require_pipeline.isPathWithinRoot(rootDir, absPath)) {
+			if (!scan.extensionsSet.has(ext)) return null;
+			const rel = (0, path.relative)(rootDir, absPath);
+			if (scan.excludeMatcher.matches(absPath, rel)) return null;
+			return {
+				key: rel,
+				owningRoot: null
+			};
+		}
+		const resolved = this.sourceIdentity?.resolveSourceId(absPath);
+		if (!resolved) return null;
+		if (resolved.owningRoot === null) {
+			if (!scan.extensionsSet.has(ext)) return null;
+			if (scan.excludeMatcher.matches(resolved.sourceKey, resolved.sourceKey)) return null;
+			return {
+				key: resolved.sourceKey,
+				owningRoot: null
+			};
+		}
+		if (!(this.externalRootExtensions.get(resolved.owningRoot) ?? scan.extensionsSet).has(ext)) return null;
+		if (require_pipeline.isExcludedPackageRelativePath(resolved.pathInRoot)) return null;
+		return {
+			key: resolved.sourceKey,
+			owningRoot: resolved.owningRoot
+		};
+	}
+	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. `devMode` forks only
+	*  the report log and the system-props write guard. */
+	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.firstEmissionComplete = true;
+			this.writeAnalysisStatus("idle", []);
+		} catch (err) {
+			this.writeAnalysisStatus("failed", pending, String(err));
+			throw err;
+		}
+	}
+	/** An explicit `mode` wins over the pipeline path: a pinned-production
+	*  watch must not emit unpruned CSS on its first incremental republish. */
+	engineDevMode(pipelineDefault) {
+		if (this.options.mode !== void 0) return this.options.mode === "development";
+		return pipelineDefault;
+	}
+	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) => (0, path.relative)(this.rootDir, dir)),
+			devMode: this.engineDevMode(devMode)
+		};
+		this.writeAnalysisStatus("analyzing", pending);
+		const result = require_pipeline.runProjectAnalysis(engineApi, {
+			...analysisOptions,
+			warn: (message) => this.warn(message),
+			strict: this.options.strict,
+			extraDiagnostics: [...this.systemVocabularyDiagnostics, ...this.ingestionFailureDiagnostics]
+		});
+		require_pipeline.assertNoErrorDiagnostics(result.manifest?.diagnostics);
+		require_pipeline.enforceExternalTokenContracts({
+			diagnostics: result.manifest?.diagnostics,
+			fileOwners: this.externalFileOwners,
+			dirOwners: this.externalDirOwners,
+			sourceThemeManifestsJson: system.sourceThemeManifestsJson,
+			strict: this.options.strict,
+			prefix: `[${this.driverLabel}]`,
+			warn: (message) => this.warn(message)
+		});
+		bt.jsonSerialize = result.timings.serializeMs;
+		bt.rustExtract = result.timings.extractMs;
+		bt.jsonParse = result.timings.parseMs;
+		const manifest = result.manifest;
+		this.lastComponentCount = Object.keys(manifest?.components ?? {}).length;
+		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 || this.staleAssetPruning === "every-cycle");
+		const { declaration, variables, body } = require_pipeline.assembleStylesheet({
+			layers: this.options.layers,
+			variableCss: system.variableCss,
+			globalCss,
+			componentCss: result.componentCss,
+			split: true
+		});
+		if (this.lcssTargets === null) this.lcssTargets = require_pipeline.resolveLightningTargets(this.options.targets, this.rootDir);
+		const fullCss = [
+			declaration,
+			variables,
+			require_pipeline.postProcessCss(body, {
+				minify: this.options.minify ?? require_pipeline.resolveMode(this.options.mode, () => process.env.NODE_ENV === "production" ? "production" : "development").mode === "production",
+				targets: this.lcssTargets,
+				warnFn: (msg) => this.warn(msg)
+			})
+		].filter(Boolean).join("\n");
+		setSharedCss(fullCss);
+		const systemPropsContent = require_pipeline.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 = require_pipeline.hashReplacementPlans(require_pipeline.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 = require_pipeline.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. Terminal states
+	*  (idle/failed) close the attempt. */
+	writeAnalysisStatus(state, pending, diagnostic) {
+		const status = {
+			schema: 2,
+			sessionId: this.sessionId,
+			attemptId: this.statusAttemptId,
+			state,
+			pending,
+			deadlineAt: Date.now() + this.debounceCeilingMs + STATUS_WATCHDOG_MS
+		};
+		if (diagnostic !== void 0) status.diagnostic = diagnostic;
+		status.ready = this.firstEmissionComplete;
+		this.writeSessionArtifact(ANALYSIS_STATUS_ARTIFACT, JSON.stringify(status));
+		if (state === "idle" || state === "failed") this.statusAttemptOpen = false;
+	}
+	/** Record watch events observed during the debounce window so a loader
+	*  running ahead of the analysis has evidence to wait on. */
+	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;
+			try {
+				this.writeAnalysisStatus("debouncing", [...this.debouncePending.entries()]);
+			} catch (err) {
+				this.warn(`debounce status write failed: ${String(err)}`);
+			}
+		});
+	}
+	/** One pending microtask flushes a burst of debounce observations. */
+	debounceStatusWriteScheduled = false;
+	/** Write one enveloped payload artifact, rewritten only when the PAYLOAD
+	*  bytes changed; the recorded diskHash feeds the analysis-commit. */
+	publishPayloadArtifact(key, name, payload, epoch, generation, wrap) {
+		const payloadHash = require_pipeline.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: require_pipeline.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 = (0, fs.readFileSync)((0, path.join)(this.sessionDir, name), "utf-8");
+		} catch {
+			return null;
+		}
+		let envelope;
+		try {
+			envelope = key === "styles" ? readCssEnvelope(bytes) : readJsonEnvelope(bytes);
+		} catch {
+			return null;
+		}
+		if (!envelope || !isDiskString(envelope.payloadHash)) return null;
+		return {
+			payloadHash: envelope.payloadHash,
+			diskHash: require_pipeline.contentHash(bytes)
+		};
+	}
+	/** Last analysis-commit persisted in this session's directory, or null. */
+	seedCommitFromDisk() {
+		try {
+			const parsed = JSON.parse((0, fs.readFileSync)(analysisCommitPath(this.sessionDir), "utf-8"));
+			return parsed.schema === 1 && parsed.sessionId === this.sessionId && isDiskNumber(parsed.generation) ? parsed : null;
+		} catch {
+			return null;
+		}
+	}
+	/** Publish the analysis-commit: written after every payload and before the
+	*  epoch, skipped when the payload hashes and epoch are unchanged. */
+	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,
+			stylesHash
+		};
+		if (inputsHash !== void 0) commit.inputsHash = inputsHash;
+		this.writeSessionArtifact(ANALYSIS_COMMIT_ARTIFACT, JSON.stringify(commit));
+		this.lastCommit = commit;
+	}
+	/** Maintain the session's epoch witness, rewritten ONLY when the value
+	*  changes, then expose it through the singleton. */
+	publishReplacementEpoch(epoch) {
+		const onDisk = this.diskEpochValue();
+		if (this.lastEpochValue === null) this.lastEpochValue = onDisk;
+		if (epoch !== onDisk) this.writeSessionArtifact(REPLACEMENT_EPOCH_ARTIFACT, JSON.stringify({
+			schema: 1,
+			sessionId: this.sessionId,
+			epoch
+		}));
+		if (epoch !== this.lastEpochValue) {
+			this.lastEpochValue = epoch;
+			this.reconcileSiblingEpochs(epoch);
+		}
+		setReplacementEpoch(epoch);
+	}
+	/** 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;
+	/** Restored-module snapshots point at the epoch artifact of the session
+	*  that built them, so a moved epoch deletes every DISAGREEING sibling
+	*  artifact to invalidate them. Agreeing siblings stay byte-untouched so
+	*  warm restores keep working; a sibling with a live owner is exempt. */
+	reconcileSiblingEpochs(epoch) {
+		const rootPath = sessionsRootDir(this.rootDir);
+		let entries;
+		try {
+			const mtimeMs = (0, fs.statSync)(rootPath).mtimeMs;
+			if (this.siblingListing?.mtimeMs === mtimeMs) entries = this.siblingListing.entries;
+			else {
+				entries = (0, fs.readdirSync)(rootPath);
+				this.siblingListing = {
+					mtimeMs,
+					entries
+				};
+			}
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (entry === this.sessionId) continue;
+			const siblingDir = (0, path.join)(rootPath, entry);
+			const siblingEpochPath = (0, path.join)(siblingDir, REPLACEMENT_EPOCH_ARTIFACT);
+			try {
+				if (JSON.parse((0, fs.readFileSync)(siblingEpochPath, "utf-8")).epoch === epoch) continue;
+			} catch (err) {
+				if (err?.code === "ENOENT") continue;
+			}
+			const ownerPid = this.liveSiblingOwnerPid(siblingDir);
+			if (ownerPid !== null) {
+				this.warn(`sibling session ${entry} still has a live owner (pid ${ownerPid}) and its replacement epoch disagrees with this session's (${epoch}) — leaving its epoch artifact in place`);
+				continue;
+			}
+			try {
+				(0, fs.unlinkSync)(siblingEpochPath);
+			} catch {}
+		}
+	}
+	/** The pid of `siblingDir`'s live owner, or null when nothing proves one.
+	*  Our own pid is never one — publication is process-exclusive. A missing,
+	*  undecodable or unreadable claim all mean no owner: the opposite default
+	*  from the CLI lock check on purpose, so do not unify the two. */
+	liveSiblingOwnerPid(siblingDir) {
+		let claim;
+		try {
+			claim = readCliLockRecord(siblingDir);
+		} catch {
+			return null;
+		}
+		if (claim.kind !== "held") return null;
+		if (claim.record.pid === process.pid) return null;
+		return checkLockLiveness(claim.record).live ? claim.record.pid : null;
+	}
+	/** 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((0, fs.readFileSync)(replacementEpochPath(this.sessionDir), "utf-8"));
+			return parsed.schema === 1 && isDiskString(parsed.epoch) ? parsed.epoch : null;
+		} catch {
+			return null;
+		}
+	}
+	/** True when the flat `.animus/` advisory lock claims the tree. A lock that
+	*  exists but cannot be decoded claims it too — unknown is never absent. */
+	cliWriterHoldsLock(animusDir) {
+		const lock = readCliLockRecord(animusDir);
+		if (lock.kind === "none") return false;
+		return lock.kind === "indeterminate" || checkLockLiveness(lock.record).live;
+	}
+	/** Delete legacy flat artifacts and prune sibling session directories past
+	*  the retention window — never this session's own dir. */
+	runSessionStartHygiene() {
+		if (this.sessionStartHygieneDone) return;
+		this.sessionStartHygieneDone = true;
+		const animusDir = (0, path.join)(this.rootDir, ANIMUS_ARTIFACT_DIR);
+		const isCliPublishedSet = this.cliWriterHoldsLock(animusDir) || verifyCommitRecord(animusDir).length === 0;
+		const cliPublishedNames = [
+			MANIFEST_ARTIFACT,
+			STYLES_ARTIFACT,
+			SYSTEM_PROPS_ARTIFACT
+		];
+		for (const name of LEGACY_FLAT_ARTIFACTS) {
+			if (isCliPublishedSet && cliPublishedNames.includes(name)) continue;
+			try {
+				(0, fs.unlinkSync)((0, path.join)(animusDir, name));
+			} catch {}
+		}
+		if (!isCliPublishedSet) try {
+			(0, fs.unlinkSync)((0, path.join)(animusDir, CLI_COMMIT_ARTIFACT));
+		} catch {}
+		let entries;
+		try {
+			entries = (0, fs.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 = (0, path.join)(sessionsRootDir(this.rootDir), entry);
+			try {
+				if ((0, fs.statSync)(dir).mtimeMs >= cutoff) continue;
+				if (this.liveSiblingOwnerPid(dir) !== null) continue;
+				(0, fs.rmSync)(dir, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		}
+	}
+	/** Write one artifact write-then-rename, so a cross-process reader never
+	*  sees a torn file; the tmp name carries the pid to keep writers apart. */
+	writeSessionArtifact(name, content) {
+		const dir = this.sessionDir;
+		(0, fs.mkdirSync)(dir, { recursive: true });
+		const tmpPath = (0, path.join)(dir, `.${name}.${process.pid}.tmp`);
+		(0, fs.writeFileSync)(tmpPath, content);
+		(0, fs.renameSync)(tmpPath, (0, path.join)(dir, name));
+		this.onArtifactWrite?.(name, content);
+	}
+	/** Copy each asset() specifier's bytes into `assets/` under a
+	*  content-hashed name and substitute a url relative to styles.css. */
+	substituteAssetReferences(globalCss, pruneSuperseded) {
+		const specifiers = require_pipeline.findAssetSpecifiers(globalCss);
+		const assetsDir = (0, path.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 && (0, fs.existsSync)((0, path.join)(assetsDir, cached.fileName))) try {
+				const current = (0, fs.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(`[${this.driverLabel}] ${message}`);
+				this.warn(message);
+				urlBySpecifier.set(specifier, specifier);
+				continue;
+			}
+			const bytes = (0, fs.readFileSync)(resolvedPath);
+			const sourceStat = (0, fs.statSync)(resolvedPath);
+			this.trackAssetDependency(resolvedPath);
+			const ext = (0, path.extname)(resolvedPath);
+			const fileName = `${(0, path.basename)(resolvedPath, ext)}.${require_pipeline.contentHash(bytes).slice(0, 8)}${ext}`;
+			expected.add(fileName);
+			if (!(0, fs.existsSync)(assetsDir)) (0, fs.mkdirSync)(assetsDir, { recursive: true });
+			const assetPath = (0, path.join)(assetsDir, fileName);
+			if (!(0, fs.existsSync)(assetPath)) (0, fs.writeFileSync)(assetPath, bytes);
+			const url = `./${SESSION_ASSETS_DIR}/${fileName}`;
+			urlBySpecifier.set(specifier, url);
+			this.assetCopyCache.set(specifier, {
+				sourcePath: resolvedPath,
+				mtimeMs: sourceStat.mtimeMs,
+				size: sourceStat.size,
+				fileName,
+				url
+			});
+		}
+		if (pruneSuperseded) pruneStaleAssets(assetsDir, expected);
+		return require_pipeline.substituteAssetPlaceholders(globalCss, urlBySpecifier);
+	}
+	trackAssetDependency(path$8) {
+		this.assetDependencyPaths.add(path$8);
+		for (const key of require_pipeline.toWatchKeys(path$8)) this.assetDependencyKeys.add(key);
+	}
+	/** Resolve an asset specifier through the shared resolver, with one
+	*  last resort: a discovered source entry's package root. */
+	resolveAssetSpecifier(specifier) {
+		const resolved = require_pipeline.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 = (0, path.join)(require_pipeline.findPackageRoot(sourceEntry), subpath);
+			if ((0, fs.existsSync)(candidate)) return candidate;
+		}
+		return null;
+	}
+};
+/** Sync `assets/` to the current build's file set; per-entry failures are
+*  tolerated — a concurrent session may have removed the same file. */
+function pruneStaleAssets(assetsDir, expected) {
+	if (!(0, fs.existsSync)(assetsDir)) return;
+	let entries;
+	try {
+		entries = (0, fs.readdirSync)(assetsDir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (expected.has(entry)) continue;
+		try {
+			(0, fs.unlinkSync)((0, path.join)(assetsDir, entry));
+		} catch {}
+	}
+}
+//#endregion
+//#region session/turbopack-orchestrator.ts
+async function runSessionPipeline(session) {
+	session.systemPropsModuleId = TURBOPACK_SYSTEM_PROPS_ID;
+	session.persistAnalysisInputs = true;
+	await session.runFullPipeline();
+}
+const activeWatcherRoots = /* @__PURE__ */ new Set();
+const IGNORED_SEGMENTS = /* @__PURE__ */ new Set([
+	ANIMUS_ARTIFACT_DIR,
+	".next",
+	"node_modules"
+]);
+/** Registration failures meaning the OS is out of watch capacity: descriptor
+*  and inotify limits surface under all of these. */
+const CAPACITY_CODES = /* @__PURE__ */ new Set([
+	"EMFILE",
+	"ENFILE",
+	"ENOSPC",
+	"EPERM"
+]);
+function errnoCode(error) {
+	if (!(error instanceof Object) || !("code" in error)) return null;
+	const { code } = error;
+	return isIntrinsicString(code) ? code : null;
+}
+/** A primitive string, decided by the intrinsic tag. `Object(value) !== value`
+*  rejects boxed strings and a forged `Symbol.toStringTag`. */
+function isIntrinsicString(value) {
+	return Object(value) !== value && Object.prototype.toString.call(value) === "[object String]";
+}
+function startTurbopackWatcher(session, rootDir, options = {}) {
+	const { debounceMs = 75, watchFn = fs.watch, holdEvents = false } = options;
+	if (activeWatcherRoots.has(rootDir)) return { kind: "already-watched" };
+	activeWatcherRoots.add(rootDir);
+	session.debounceCeilingMs = debounceMs;
+	const pendingPaths = /* @__PURE__ */ new Set();
+	const watchers = /* @__PURE__ */ new Map();
+	let timer = null;
+	let updateChain = Promise.resolve();
+	let closed = false;
+	let died = false;
+	let holdingEvents = holdEvents;
+	const externalWatchers = /* @__PURE__ */ new Map();
+	let pendingOpened = /* @__PURE__ */ new Map();
+	let capturedDuringSnapshot = [];
+	const externalDiagnosticKey = (root) => `external-watch:${root}`;
+	const failureReason = (err) => {
+		const code = errnoCode(err);
+		if (code !== null && CAPACITY_CODES.has(code)) 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=${(0, path.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$1 of pendingPaths) ((0, fs.existsSync)(path$1) ? modifiedFiles : removedFiles).add(path$1);
+		pendingPaths.clear();
+		updateChain = updateChain.then(() => {
+			if (closed) return;
+			return session.handleWatchUpdate({
+				modifiedFiles,
+				removedFiles
+			}).catch((err) => {
+				console.warn(`[animus-extract] 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) => {
+		died = true;
+		closeAll();
+		console.warn(`[animus-extract] Turbopack dev watcher failed (${String(err)}); source edits require a dev-server restart`);
+		handle.onDied?.();
+	};
+	const enqueuePath = (abs) => {
+		pendingPaths.add(abs);
+		if (holdingEvents) return;
+		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 = (0, path.join)(baseDir, rel);
+		if (baseDir === rootDir && !watchers.has(abs)) try {
+			if ((0, fs.statSync)(abs).isDirectory()) addWatcher(abs, true);
+		} catch {}
+		enqueuePath(abs);
+	};
+	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 : (0, path.join)(root, rel);
+		}
+		if (isPending && !active) {
+			capturedDuringSnapshot.push(abs);
+			return;
+		}
+		enqueuePath(abs);
+	};
+	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 (0, fs.readdirSync)(rootDir, { withFileTypes: true })) {
+			if (!entry.isDirectory() || IGNORED_SEGMENTS.has(entry.name)) continue;
+			addWatcher((0, path.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 { kind: "unavailable" };
+	}
+	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);
+	};
+	const handle = {
+		close: closeAll,
+		get died() {
+			return died;
+		},
+		onDied: null,
+		deliverHeldEvents: () => {
+			holdingEvents = false;
+			if (pendingPaths.size > 0) flush();
+			return updateChain;
+		},
+		settle: () => updateChain
+	};
+	return {
+		kind: "started",
+		handle
+	};
+}
+//#endregion
+exports.ANIMUS_ARTIFACT_DIR = ANIMUS_ARTIFACT_DIR;
+exports.ANIMUS_CSS_MODULE_ID = ANIMUS_CSS_MODULE_ID;
+exports.CLI_COMMIT_ARTIFACT = CLI_COMMIT_ARTIFACT;
+exports.CLI_LOCK_ARTIFACT = CLI_LOCK_ARTIFACT;
+exports.CLI_LOCK_HEARTBEAT_INTERVAL_MS = CLI_LOCK_HEARTBEAT_INTERVAL_MS;
+exports.CLI_LOCK_STALE_AFTER_MS = CLI_LOCK_STALE_AFTER_MS;
+exports.ExtractionSession = ExtractionSession;
+exports.MANIFEST_ARTIFACT = MANIFEST_ARTIFACT;
+exports.SESSION_ASSETS_DIR = SESSION_ASSETS_DIR;
+exports.STYLES_ARTIFACT = STYLES_ARTIFACT;
+exports.SYSTEM_PROPS_ARTIFACT = SYSTEM_PROPS_ARTIFACT;
+exports.TURBOPACK_SYSTEM_PROPS_ID = TURBOPACK_SYSTEM_PROPS_ID;
+exports.analysisCommitPath = analysisCommitPath;
+exports.analysisInputsPath = analysisInputsPath;
+exports.analysisStatusPath = analysisStatusPath;
+exports.checkLockLiveness = checkLockLiveness;
+exports.collectSessionAssets = collectSessionAssets;
+exports.decodeCommitRecord = decodeCommitRecord;
+exports.engineApi = engineApi;
+exports.getAnalysisStartedPromise = getAnalysisStartedPromise;
+exports.getAnalyzedHashes = getAnalyzedHashes;
+exports.getManifestJson = getManifestJson;
+exports.getReplacementEpoch = getReplacementEpoch;
+exports.getSessionArtifactDir = getSessionArtifactDir;
+exports.getSharedCss = getSharedCss;
+exports.getSharedExternalDirs = getSharedExternalDirs;
+exports.getSharedExternalEntries = getSharedExternalEntries;
+exports.getSharedSystemProps = getSharedSystemProps;
+exports.holdDirectoryClaim = holdDirectoryClaim;
+exports.isLockHolderAlive = isLockHolderAlive;
+exports.lockRecordBytes = lockRecordBytes;
+exports.manifestPath = manifestPath;
+exports.pruneStaleAssets = pruneStaleAssets;
+exports.readCliLockRecord = readCliLockRecord;
+exports.readJsonEnvelope = readJsonEnvelope;
+exports.replacementEpochPath = replacementEpochPath;
+exports.runSessionPipeline = runSessionPipeline;
+exports.sessionArtifactDir = sessionArtifactDir;
+exports.setAnalysisStartedPromise = setAnalysisStartedPromise;
+exports.setSharedEngine = setSharedEngine;
+exports.startTurbopackWatcher = startTurbopackWatcher;
+exports.stylesPath = stylesPath;
+exports.systemPropsPath = systemPropsPath;
+exports.verifyCommitRecord = verifyCommitRecord;