@animus-ui/extract 0.1.25 → 0.1.27

package/dist/session.cjs

@@ -1,8 +1,151 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_pipeline = require("./pipeline-DOgKR4VZ.cjs");
+const require_pipeline = require("./pipeline-CPSPw522.cjs");
 let crypto = require("crypto");
 let fs = require("fs");
 let path = require("path");
+//#region session/coalescing-window.ts
+/**
+* The one coalescing window (SA19). It opens on the first pending event and
+* fires a fixed interval later: a later event joins the open window and never
+* pushes it back, so a steady stream of edits cannot starve the work it
+* coalesces. Builds, startup and explicit flushes bypass it through `flush`.
+* Hosts add no timers of their own.
+*/
+const COALESCING_WINDOW_MS = 75;
+const SYSTEM_CLOCK = {
+	schedule: (fn, ms) => {
+		const timer = setTimeout(fn, ms);
+		timer.unref?.();
+		return timer;
+	},
+	cancel: (timer) => clearTimeout(timer)
+};
+var CoalescingWindow = class {
+	fire;
+	windowMs;
+	clock;
+	timer = null;
+	constructor(fire, windowMs = 75, clock = SYSTEM_CLOCK) {
+		this.fire = fire;
+		this.windowMs = windowMs;
+		this.clock = clock;
+	}
+	/** A pending event: opens the window, or joins the open one. */
+	note() {
+		if (this.timer !== null) return;
+		this.timer = this.clock.schedule(() => {
+			this.timer = null;
+			return this.fire();
+		}, this.windowMs);
+	}
+	/** Fires now, closing any open window: the bypass. */
+	flush() {
+		this.cancel();
+		return this.fire();
+	}
+	/** Closes an open window without firing it. */
+	cancel() {
+		if (this.timer === null) return;
+		this.clock.cancel(this.timer);
+		this.timer = null;
+	}
+};
+//#endregion
+//#region session/environment-builds.ts
+/**
+* Each environment build that started and has not ended, by name. A host
+* that builds a shared plugin's environments in parallel (a Vite `buildApp`)
+* shares one build among them, retired by the last to end. A build under a
+* name whose build is open (a reused builder, or a second environment under
+* one name) waits for that build's end, so each build ends only its own
+* generation, once.
+*/
+var EnvironmentBuilds = class {
+	/** What a host without environments builds as. */
+	single = { name: "build" };
+	builds = /* @__PURE__ */ new Map();
+	/** Opens `environment`'s build once no build under its name is open;
+	*  whether another environment's build is open beside it. */
+	async open(environment) {
+		for (;;) {
+			const open = this.builds.get(environment.name);
+			if (open === void 0) break;
+			await open.ended;
+		}
+		let end = () => {};
+		const ended = new Promise((settle) => {
+			end = settle;
+		});
+		this.builds.set(environment.name, {
+			environment,
+			ended,
+			end
+		});
+		return this.builds.size > 1;
+	}
+	/** Ends `environment`'s build if this environment opened it; whether that
+	*  left none open. A host can end an environment it never opened (a dev
+	*  server ends every environment, started or not), which ends nothing. */
+	end(environment) {
+		const open = this.builds.get(environment.name);
+		if (open === void 0 || open.environment !== environment) return false;
+		this.builds.delete(environment.name);
+		open.end();
+		return this.builds.size === 0;
+	}
+};
+//#endregion
+//#region pipeline/system-instances.ts
+/**
+* The system and the analysis read one instance of each kit (spec §2.2
+* A4). Discovery asks the host which instance a kit specifier names; the
+* system loader resolves the system file's imports itself. Until the loader
+* takes the host's instance, a kit whose analysed instance differs from the
+* one the system evaluated is refused: its components would be extracted
+* against another instance's vocabulary.
+*/
+function realPath(path$39) {
+	try {
+		return (0, fs.realpathSync)(path$39);
+	} catch {
+		return path$39;
+	}
+}
+/**
+* One error for each system-file kit specifier whose analysed package
+* instance is not the one the system load evaluated: the file the loader's
+* own resolution names must be among the files the load read, and lie in
+* another package root than the instance discovery read for its package.
+*/
+function systemInstanceMismatches(input) {
+	const evaluated = new Set(input.evaluated.map(realPath));
+	const shown = (path$40) => (0, path.relative)(input.rootDir, path$40).split(path.sep).join("/");
+	const diagnostics = [];
+	for (const specifier of input.specifiers) {
+		if (!require_pipeline.isPackageSpecifier(specifier)) continue;
+		const analysed = input.instances[require_pipeline.bareSpecifierPackageName(specifier)];
+		if (analysed === void 0) continue;
+		let file;
+		try {
+			file = input.loaderResolve(specifier);
+		} catch {
+			continue;
+		}
+		if (file === null || !evaluated.has(realPath(file))) continue;
+		const system = realPath(require_pipeline.findPackageRoot(realPath(file)));
+		if (system === analysed) continue;
+		diagnostics.push({
+			file: specifier,
+			component: "kit",
+			kind: "error",
+			message: `the system evaluates '${specifier}' from ${shown(system)}, but the host bundler resolves it to ${shown(analysed)}, which extraction analyses, so its components would be extracted against another instance's vocabulary — make the bundler and the system resolve '${specifier}' to one instance`,
+			code: require_pipeline.SYSTEM_INSTANCE_MISMATCH,
+			severity: require_pipeline.severityFor(require_pipeline.SYSTEM_INSTANCE_MISMATCH)
+		});
+	}
+	return diagnostics;
+}
+//#endregion
 //#region session/session-paths.ts
 /**
 * Session artifact names, path derivations, and artifact shapes. Imports no
@@ -169,9 +312,11 @@ function readCliLockRecord(dir) {
 	if (!isPublishedSetRecord(candidate) || !isPublishedSetNumber(candidate.pid)) return { kind: "indeterminate" };
 	const startedAt = candidate.startedAt;
 	const heartbeatAt = candidate.heartbeatAt;
+	const build = candidate.build;
 	const record = { pid: candidate.pid };
 	if (isPublishedSetString(startedAt)) record.startedAt = startedAt;
 	if (isPublishedSetString(heartbeatAt)) record.heartbeatAt = heartbeatAt;
+	if (isPublishedSetString(build)) record.build = build;
 	return {
 		kind: "held",
 		record
@@ -202,17 +347,19 @@ function checkLockLiveness(record) {
 		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({
+function lockRecordBytes(startedAt, build) {
+	const record = {
 		pid: process.pid,
 		startedAt,
 		heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
-	});
+	};
+	if (build !== void 0) record.build = build;
+	return JSON.stringify(record);
 }
 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 path$38 = (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;
@@ -225,13 +372,13 @@ function holdDirectoryClaim(dir, options = {}) {
 	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));
+				(0, fs.writeFileSync)(tempPath, lockRecordBytes(startedAt, options.build));
+				(0, fs.renameSync)(tempPath, path$38);
+			} else (0, fs.writeFileSync)(path$38, lockRecordBytes(startedAt, options.build));
 		} catch (error) {
 			stop();
 			if (isMissingFile(error)) return;
-			console.error(`[animus] Could not write the directory claim ${path$9}: ${String(error)}`);
+			console.error(`[animus] Could not write the directory claim ${path$38}: ${String(error)}`);
 		}
 	};
 	stamp();
@@ -242,7 +389,7 @@ function holdDirectoryClaim(dir, options = {}) {
 	return () => {
 		stop();
 		if (rename) (0, fs.rmSync)(tempPath, { force: true });
-		(0, fs.rmSync)(path$9, { force: true });
+		(0, fs.rmSync)(path$38, { force: true });
 	};
 }
 /** Snapshot the session's copied asset() files, sorted, BEFORE the session
@@ -257,320 +404,395 @@ function collectSessionAssets(sessionDir) {
 	}));
 }
 //#endregion
-//#region session/resolve-packages.ts
-/** An exports target under the `import` condition, then `default`, as the
-*  system loader reads it; an array offers its targets in order. */
-function importTarget(value) {
-	if (require_pipeline.isJsonString(value)) return value;
-	if (Array.isArray(value)) {
-		for (const entry of value) {
-			const target = importTarget(entry);
-			if (target !== null) return target;
-		}
-		return null;
-	}
-	if (!require_pipeline.isJsonBlock(value)) return null;
-	return importTarget(value.import) ?? importTarget(value.default);
-}
-/** The exports entry for `subpath`: an exact key answers alone; otherwise
-*  the pattern with the longest prefix, then the longest suffix, wins. */
-function exportsTarget(exports, subpath) {
-	const map = require_pipeline.isJsonBlock(exports) && Object.keys(exports).some((k) => k.startsWith(".")) ? exports : { ".": exports };
-	if (subpath in map) return importTarget(map[subpath]);
-	let best = null;
-	for (const [pattern, value] of Object.entries(map)) {
-		const star = pattern.indexOf("*");
-		if (star === -1 || pattern.indexOf("*", star + 1) !== -1) continue;
-		const prefix = pattern.slice(0, star);
-		const suffix = pattern.slice(star + 1);
-		if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix) || subpath.length < prefix.length + suffix.length) continue;
-		if (!best || prefix.length > best.prefix.length || prefix.length === best.prefix.length && suffix.length > best.suffix.length) best = {
-			prefix,
-			suffix,
-			value
-		};
-	}
-	if (!best) return null;
-	const matched = subpath.slice(best.prefix.length, subpath.length - best.suffix.length);
-	return importTarget(best.value)?.replaceAll("*", matched) ?? null;
-}
-/** The entry an ES import of `name` resolves to through the package's
-*  `exports`, under the `import` condition, then `default`: what the Vite
-*  host and the system loader resolve. Null without an `exports` field, or
-*  when no target exists. */
-function resolveImportEntry(rootDir, name) {
-	const packageName = name.split("/").slice(0, name.startsWith("@") ? 2 : 1).join("/");
-	const subpath = `.${name.slice(packageName.length)}`;
-	for (let dir = rootDir;; dir = (0, path.dirname)(dir)) {
-		const manifest = (0, path.join)(dir, "node_modules", packageName, "package.json");
-		if ((0, fs.existsSync)(manifest)) {
-			let exports;
-			try {
-				const parsed = require_pipeline.parseInternalWire((0, fs.readFileSync)(manifest, "utf-8"), `${manifest} (a package manifest)`);
-				exports = require_pipeline.isJsonBlock(parsed) ? parsed.exports : void 0;
-			} catch {
-				return null;
-			}
-			if (exports === void 0 || exports === null) return null;
-			const target = exportsTarget(exports, subpath);
-			if (target === null) return null;
-			const entryPath = (0, path.resolve)((0, path.dirname)(manifest), target);
-			return (0, fs.existsSync)(entryPath) ? (0, fs.realpathSync)(entryPath) : null;
-		}
-		if (dir === (0, path.dirname)(dir)) return null;
-	}
-}
-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;
-		const importEntry = resolveImportEntry(rootDir, name);
-		if (importEntry !== null) {
-			packageMap[name] = (0, path.relative)(rootDir, importEntry);
-			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.
+* A build's shared state lives in one registry on `globalThis`, keyed by its
+* `SessionKey`, so the ESM plugin copy and the CJS webpack-loader copy of
+* this module find the same entry, and two builds of one root never share
+* one. A reader of a build no participant has joined gets the empty value;
+* a writer must have joined it.
 */
-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 SHARED_EXTERNAL_SIDE_EFFECTS_KEY = "__animus_external_side_effects__";
-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 joined(key) {
+	const state = findSession(key);
+	if (state === void 0) throw new Error(`[animus] no participant has joined build ${key.build} of ${key.root}`);
+	return state;
+}
+/** Commits the build's publication, the one write of everything below. */
+function setPublication(key, publication) {
+	joined(key).publication = publication;
 }
-function setManifestJson(json) {
-	singletonStore[MANIFEST_KEY] = json;
+function publicationOf(key) {
+	return findSession(key)?.publication ?? null;
+}
+function getManifestJson(key) {
+	return publicationOf(key)?.manifestJson ?? null;
 }
 /**
 * 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 getAnalysisStartedPromise(key) {
+	return findSession(key)?.analysisStarted ?? null;
 }
-function resetAnalysisStartedPromise() {
-	singletonStore[ANALYSIS_STARTED_KEY] = null;
+function setAnalysisStartedPromise(key, promise) {
+	joined(key).analysisStarted = promise;
 }
-function getSharedCss() {
-	return singletonStore[SHARED_CSS_KEY] || "";
+function resetAnalysisStartedPromise(key) {
+	const state = findSession(key);
+	if (state !== void 0) state.analysisStarted = null;
 }
-function setSharedCss(css) {
-	singletonStore[SHARED_CSS_KEY] = css;
+/** True for the build's first caller only: the one that reports its
+*  unmatched user excludes. */
+function claimUnmatchedExcludeReport(key) {
+	const state = joined(key);
+	if (state.unmatchedExcludesReported) return false;
+	state.unmatchedExcludesReported = true;
+	return true;
 }
-function getSharedSystemProps() {
-	return singletonStore[SHARED_SYSTEM_PROPS_KEY] || "";
+function getSharedCss(key) {
+	return publicationOf(key)?.styles ?? "";
 }
-function setSharedSystemProps(content) {
-	singletonStore[SHARED_SYSTEM_PROPS_KEY] = content;
+function getSharedSystemProps(key) {
+	return publicationOf(key)?.systemPropsModule ?? "";
 }
-function getSharedExternalDirs() {
-	return singletonStore[SHARED_EXTERNAL_DIRS_KEY] || [];
+function getSharedExternalDirs(key) {
+	return publicationOf(key)?.externalPackageDirs ?? [];
 }
-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 getSharedExternalEntries(key) {
+	return publicationOf(key)?.externalSourceEntries ?? /* @__PURE__ */ new Map();
 }
 /** Specifier → its source entry's side effects, published with the shared
 *  entries; absent leaves the bundler's own classification. */
-function getSharedExternalSideEffects() {
-	return singletonStore[SHARED_EXTERNAL_SIDE_EFFECTS_KEY] || /* @__PURE__ */ new Map();
-}
-function setSharedExternalSideEffects(sideEffects) {
-	singletonStore[SHARED_EXTERNAL_SIDE_EFFECTS_KEY] = sideEffects;
+function getSharedExternalSideEffects(key) {
+	return publicationOf(key)?.externalSourceSideEffects ?? /* @__PURE__ */ new Map();
 }
-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.
+* The only session of a build that can run watch analysis. A non-owning
+* session's observations queue for it; dropping them loses files only that
+* watcher sees.
 */
-function getOwningWatchSession() {
-	return owningWatchSessionSlot.get();
+function getOwningWatchSession(key) {
+	return findSession(key)?.authority ?? null;
 }
-function setOwningWatchSession(session) {
-	owningWatchSessionSlot.set(session);
+function setOwningWatchSession(key, session) {
+	joined(key).authority = 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 getAnalyzedHashes(key) {
+	return publicationOf(key)?.analyzedHashes ?? null;
 }
-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;
+/** What the build's last published analysis read of the discovered
+*  packages (spec §2.2 A4); null before one publishes. */
+function getSharedPackageReadRecord(key) {
+	return publicationOf(key)?.packageReadRecord ?? null;
 }
 /**
-* Two CONCURRENT drive loops in one process would share one session tree and
-* clobber each other; sequential claim/release cycles are legal.
+* One participant publishes a build's analysis, holding this claim until it
+* closes: a second publisher would clobber its artifacts. Two builds never
+* exclude each other; sequential claim and 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;
+function claimExclusiveSessionOwner(key, label) {
+	const state = joined(key);
+	const active = state.activeAttempt;
+	if (active !== null) throw new Error(`[animus] "${label}" started an analysis of build ${key.build} of ${key.root}, which "${active}" publishes. A build's participants share one analysis; run it once and let the others read its results.`);
+	state.activeAttempt = label;
 	return () => {
-		if (singletonStore[EXCLUSIVE_SESSION_OWNER_KEY] === label) delete singletonStore[EXCLUSIVE_SESSION_OWNER_KEY];
+		if (state.activeAttempt === label) state.activeAttempt = null;
 	};
 }
 /**
-* Absolute artifact directory of the OWNING session's last publication. The
+* Absolute artifact directory of the build's last publication. The
 * Turbopack loader runs out of process and receives it via options instead.
 */
-function getSessionArtifactDir() {
-	return sessionArtifactDirSlot.get();
+function getSessionArtifactDir(key) {
+	return findSession(key)?.artifactDir ?? null;
 }
-function setSessionArtifactDir(dir) {
-	sessionArtifactDirSlot.set(dir);
+function setSessionArtifactDir(key, dir) {
+	joined(key).artifactDir = 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);
+/** Replacement epoch of the last published analysis: committed in the same
+*  record as its manifest, so an epoch reader sees that generation's. */
+function getReplacementEpoch(key) {
+	return publicationOf(key)?.replacementEpoch ?? null;
 }
 /**
-* The one in-flight watch-analysis transaction: a compiler that did not start
-* it joins this promise rather than read a pre-transaction generation.
+* The build's one in-flight watch-analysis transaction: a participant that
+* did not start it joins this promise rather than read a pre-transaction
+* generation.
 */
-function getWatchTransaction() {
-	return watchTransactionSlot.get();
+function getWatchTransaction(key) {
+	return findSession(key)?.watchTransaction ?? null;
+}
+function observationQueue(key) {
+	return joined(key).observations;
 }
-function setWatchTransaction(transaction) {
-	watchTransactionSlot.set(transaction);
+function getSystemAuthority(key) {
+	return findSession(key)?.systemAuthority ?? null;
 }
-/** 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 setSystemAuthority(key, authority) {
+	joined(key).systemAuthority = authority;
 }
-function getSharedEngine() {
-	return singletonStore[ENGINE_KEY] || "v2";
+function setWatchTransaction(key, transaction) {
+	joined(key).watchTransaction = transaction;
 }
 /** 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");
 }
+const ENGINE_API_OVERRIDE_KEY = "__animus_engine_api_override__";
+const overrideGlobal = globalThis;
+/** The native engine module could not be loaded: an environment failure,
+*  never answered by another engine. */
+var EnvironmentFailure = class extends Error {
+	code = "EnvironmentFailure";
+	constructor(cause) {
+		super(`[animus] EnvironmentFailure: the native extraction engine could not be loaded: ${String(cause)}`, { cause });
+		this.name = "EnvironmentFailure";
+	}
+};
+let loadEngineFactory = requireEngine;
+/** The native factory, loaded once for every build in the process. A load
+*  failure is an EnvironmentFailure, and is not cached: the next use tries
+*  the load again. */
+function engineFactory() {
+	const registry = sessionRegistry();
+	if (registry.factory === null) try {
+		registry.factory = loadEngineFactory();
+	} catch (error) {
+		throw new EnvironmentFailure(error instanceof Error ? error : String(error));
+	}
+	return registry.factory;
+}
 /**
-* 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.
+* One engine-handle store (SA18): the engine API over `key`'s own engine
+* state, made once per key in the registry every module copy joins. The
+* native factory is shared; each key's engine instance, analyze-time
+* sources and drift flag are its own, and its build's retirement releases
+* them. A key need not be a joined build's: a Vite context or a Turbopack
+* worker keys its own.
 */
-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 engineHandle(key, options) {
+	const engines = sessionRegistry().engines;
+	const id = sessionKeyId(key);
+	let api = engines.get(id);
+	if (api === void 0) {
+		let engine = null;
+		let sentSources = null;
+		let driftWarned = false;
+		api = require_pipeline.createV2EngineApi({
+			...options,
+			isV2: () => true,
+			loadNativeEngine: engineFactory,
+			store: {
+				getEngine: () => engine,
+				setEngine: (next) => {
+					engine = next;
+				},
+				getSentSources: () => sentSources,
+				setSentSources: (sources) => {
+					sentSources = sources;
+				},
+				getDriftWarned: () => driftWarned,
+				setDriftWarned: (value) => {
+					driftWarned = value;
+				}
+			}
+		});
+		engines.set(id, api);
+	}
+	return api;
+}
+/** Releases a standalone handle, one no joined build retires: its host
+*  calls this when it closes. */
+function releaseEngineHandle(key) {
+	sessionRegistry().engines.delete(sessionKeyId(key));
+}
+/**
+* The build's engine API, from the one engine-handle store.
+*/
+function engineApi(key) {
+	const override = overrideGlobal[ENGINE_API_OVERRIDE_KEY];
+	if (override) return override();
+	joined(key);
+	return engineHandle(key, {
+		label: "animus",
+		passThroughUnknownPaths: true
+	})();
+}
+/** A fresh build id, created once by the owning host wrapper. */
+function createBuildId() {
+	return (0, crypto.randomUUID)();
+}
+/** The key of build `build` of `root`, by the root's canonical path. */
+function sessionKey(build, root) {
+	const absolute = (0, path.resolve)(root);
+	let canonical = absolute;
+	try {
+		canonical = (0, fs.realpathSync)(absolute);
+	} catch {}
+	return {
+		build,
+		root: canonical,
+		protocol: 1
+	};
+}
+function sessionKeyId(key) {
+	return JSON.stringify([
+		key.protocol,
+		key.build,
+		key.root
+	]);
+}
+/** A participant joined a session with semantic options that differ from
+*  those the session was created with. */
+var SessionConfigurationConflict = class extends Error {
+	key;
+	established;
+	joining;
+	differing;
+	code = "SessionConfigurationConflict";
+	constructor(key, established, joining, differing, requirement = "Every participant of one build must use the same Animus options.") {
+		super(`[animus] SessionConfigurationConflict: "${joining}" joined build ${key.build} of ${key.root} with ${differing.join(", ")} differing from "${established}". ${requirement}`);
+		this.key = key;
+		this.established = established;
+		this.joining = joining;
+		this.differing = differing;
+		this.name = "SessionConfigurationConflict";
+	}
+};
+function digestOf(field) {
+	return {
+		field,
+		text: (options) => {
+			const value = options[field];
+			return value === void 0 ? void 0 : require_pipeline.stableStringify(value);
 		}
+	};
+}
+/**
+* Every option, classified: one a build's analysis depends on, which every
+* participant must agree on, or one deliberately excluded. `verbose` changes
+* no output, and the root is the key's. The type checker rejects an option
+* added to `AnimusCoreOptions` until it is classified here.
+*/
+const OPTION_CLASSES = {
+	system: digestOf("system"),
+	exclude: digestOf("exclude"),
+	extensions: digestOf("extensions"),
+	strict: digestOf("strict"),
+	diagnostics: digestOf("diagnostics"),
+	verbose: "excluded",
+	prefix: digestOf("prefix"),
+	prefixContextualVars: digestOf("prefixContextualVars"),
+	targets: digestOf("targets"),
+	minify: digestOf("minify"),
+	staticCss: digestOf("staticCss"),
+	layers: digestOf("layers"),
+	engine: digestOf("engine"),
+	mode: digestOf("mode"),
+	runtimeImport: digestOf("runtimeImport"),
+	root: "excluded"
+};
+/** The options a build's analysis depends on, each as stable text; each is
+*  data by its type, so equal text is an equal value. A host's own options
+*  are not the build's. */
+function semanticOptions(options) {
+	const present = [];
+	for (const [name, digest] of Object.entries(OPTION_CLASSES)) {
+		if (digest === "excluded") continue;
+		const text = digest.text(options);
+		if (text !== void 0) present.push([name, text]);
+	}
+	return new Map(present);
+}
+const SESSION_REGISTRY = Symbol.for("animus.session-registry.v1");
+const registryGlobal = globalThis;
+function sessionRegistry() {
+	return registryGlobal[SESSION_REGISTRY] ??= {
+		sessions: /* @__PURE__ */ new Map(),
+		engines: /* @__PURE__ */ new Map(),
+		factory: null
+	};
+}
+/**
+* Joins `participant` to the session of `key`, creating it with `options` on
+* the first join. A later participant must bring the same semantic options.
+*/
+function joinSession(key, participant, options) {
+	const sessions = sessionRegistry().sessions;
+	const id = sessionKeyId(key);
+	const joining = semanticOptions(options);
+	const existing = sessions.get(id);
+	if (existing === void 0) {
+		const state = {
+			key,
+			established: participant,
+			options: joining,
+			participants: /* @__PURE__ */ new Set([participant]),
+			activeAttempt: null,
+			authority: null,
+			analysisStarted: null,
+			watchTransaction: null,
+			observations: {
+				revision: 0,
+				rescan: false,
+				untaken: /* @__PURE__ */ new Map(),
+				suppliedSources: /* @__PURE__ */ new Map(),
+				revisions: /* @__PURE__ */ new Map(),
+				active: null
+			},
+			systemAuthority: null,
+			claimRecord: null,
+			publication: null,
+			artifactDir: null,
+			unmatchedExcludesReported: false
+		};
+		sessions.set(id, state);
+		return state;
+	}
+	const differing = [.../* @__PURE__ */ new Set([...existing.options.keys(), ...joining.keys()])].filter((name) => existing.options.get(name) !== joining.get(name));
+	if (differing.length > 0) throw new SessionConfigurationConflict(key, existing.established, participant, differing.sort());
+	existing.participants.add(participant);
+	return existing;
+}
+/** The session of `key`, if a participant has joined it. */
+function findSession(key) {
+	return sessionRegistry().sessions.get(sessionKeyId(key));
+}
+/** The build's on-disk claim record, which stops another process pruning
+*  its tree: held once by the build, whichever participant publishes, and
+*  released only when the build retires. */
+function holdBuildClaimRecord(key, hold) {
+	const state = joined(key);
+	state.claimRecord ??= hold();
+}
+/** `participant` leaves the build of `key`. The build retires with its
+*  last participant, once no attempt is in flight: it leaves the registry
+*  and releases its claim record, so its tree is pruned once stale. */
+function leaveSession(key, participant) {
+	const state = findSession(key);
+	if (state === void 0) return;
+	state.participants.delete(participant);
+	retireIfUnused(sessionKeyId(key), state);
+}
+function retireIfUnused(id, state) {
+	if (state.participants.size > 0) return;
+	const inflight = state.watchTransaction;
+	if (inflight !== null) {
+		const retry = () => retireIfUnused(id, state);
+		inflight.then(retry, retry);
+		return;
 	}
-});
-function engineApi() {
-	const override = singletonStore[ENGINE_API_OVERRIDE_KEY];
-	return override ? override() : v2EngineApi();
+	const sessions = sessionRegistry().sessions;
+	if (sessions.get(id) !== state) return;
+	sessions.delete(id);
+	sessionRegistry().engines.delete(id);
+	state.claimRecord?.();
+	state.claimRecord = null;
 }
 //#endregion
 //#region session/timing.ts
@@ -606,6 +828,23 @@ function logBuildTimings(bt, rustTiming, log, verbose) {
 }
 //#endregion
 //#region session/extraction-session.ts
+/** An observation's state when its file is gone, or cannot be read; any
+*  other state is the content hash it was observed with. */
+const REMOVED_OBSERVATION = "removed";
+const UNREADABLE_OBSERVATION = "unreadable";
+/** A loaded system's identity: its evaluated modules and a fingerprint of
+*  the whole load. */
+function systemLoad(system) {
+	return {
+		identity: require_pipeline.contentHash(JSON.stringify(system)),
+		dependencies: system.dependencies ?? []
+	};
+}
+const CONSOLE_LOGGER = {
+	info: (line) => console.error(line),
+	warn: (line) => console.warn(line),
+	error: (line) => console.error(line)
+};
 const SESSION_DIR_MAX_AGE_MS = 864e5;
 const STATUS_WATCHDOG_MS = 2e3;
 const LEGACY_FLAT_ARTIFACTS = [
@@ -624,29 +863,120 @@ function isDiskString(value) {
 }
 /** Rejection of an attempt whose corpus holds an aborted parse. */
 var AbortedParseRejection = class extends Error {};
+/** A reload refused because its full read would replace host-supplied
+*  bytes with the disk's: a system reload a parse hold deferred, or a full
+*  read that reaches a host-supplied file only under another spelling (a
+*  case-insensitive volume). Like a hold, it keeps the prior publication
+*  and the observed sources. */
+var DeferredReloadRefusal = class extends Error {};
+/** The file's canonical path, or null when it cannot be resolved. */
+function canonicalPath(path$4) {
+	try {
+		return fs.realpathSync.native(path$4);
+	} catch {
+		return null;
+	}
+}
+/** The host sources a full read reaches only under another spelling: a key
+*  the read did not reach exactly, whose file is one the read reached by
+*  another path (a case-insensitive volume, a symlinked alias). A key with
+*  no such file is not read either way, and is left alone. */
+function misspelledHostSources(hostSources, readPaths) {
+	const misses = [...hostSources.keys()].filter((path$5) => !readPaths.has(path$5));
+	if (misses.length === 0) return [];
+	const readByCanonical = /* @__PURE__ */ new Map();
+	for (const readPath of readPaths) {
+		const canonical = canonicalPath(readPath);
+		if (canonical === null) continue;
+		readByCanonical.set(canonical, [...readByCanonical.get(canonical) ?? [], readPath]);
+	}
+	return misses.flatMap((path$6) => {
+		const canonical = canonicalPath(path$6);
+		const read = canonical === null ? void 0 : readByCanonical.get(canonical);
+		return read === void 0 ? [] : [{
+			path: path$6,
+			read
+		}];
+	});
+}
 function isDiskNumber(value) {
 	return Object(value) !== value && Object.prototype.toString.call(value) === "[object Number]";
 }
+/** The session's own system-props file, imported by absolute path: what a
+*  host that serves no system-props module (the CLI) delivers. */
+const SESSION_ARTIFACT = Symbol("animus.session-artifact");
+/** A file's content hash, or '' when it cannot be read. */
+function fileHashOrEmpty(path$7) {
+	try {
+		return require_pipeline.contentHash((0, fs.readFileSync)(path$7, "utf-8"));
+	} catch {
+		return "";
+	}
+}
+/** The first file whose content no longer has its recorded hash: an
+*  unreadable or deleted file reads as '', which mismatches a real one. */
+function firstChangedFile(hashes) {
+	for (const [path$8, hash] of hashes) if (fileHashOrEmpty(path$8) !== hash) return path$8;
+}
 /** Bundler-agnostic extraction pipeline: system load, source ingestion,
 *  analysis, emission, and watch-cycle diffing. Carries no bundler types. */
 var ExtractionSession = class {
 	host;
 	/** Set by the adapter before any pipeline run. */
 	rootDir = null;
+	/** A host that resolves imports itself (Vite's `this.resolve`): package
+	*  discovery asks it first, the loader only for a declared workspace it
+	*  cannot resolve. Null resolves through the loader alone. */
+	hostResolve = null;
+	/** Each file's alias comparison, kept by content hash across analyses. */
+	aliasCache = new require_pipeline.AliasAgreementCache();
 	/** Serialized path aliases, harvested by the adapter from bundler config. */
 	pathAliasesJson = null;
+	/** The host's aliases are the project's tsconfig `paths`: each full pass
+	*  re-reads them, so a tsconfig edit takes effect. */
+	aliasesFromTsconfig = false;
+	/** The root package.json and the tsconfig chain, absent files included:
+	*  a change to any is a configuration change, which runs the full pass. */
+	configInputPaths = [];
+	configInputKeys = /* @__PURE__ */ new Set();
+	/** Each configuration input's content hash at the last full pass, ''
+	*  for an absent one: the probe's basis when the host reports nothing. */
+	configInputHashes = /* @__PURE__ */ new Map();
 	/** The host's export conditions, in its order, for the system loader. */
 	conditions = [];
+	/** The host's extension order, as its adapter captured it; the built-in
+	*  policy where no host resolves. */
+	extensionPolicy = require_pipeline.BUILT_IN_EXTENSION_POLICY;
+	/** Which files the host serves as assets (spec §2.2 A8); the built-in
+	*  classification where no host's can be read. */
+	assetClassification = require_pipeline.builtInAssetClassification("noHost");
+	/** How the host's bundler expands computed loads (spec §6.3); without
+	*  one, every computed load keeps its widest reading. */
+	loadExpander;
 	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;
+	/** What generated code imports; a host that serves its own modules
+	*  declares them before planning. */
+	delivery = {
+		cssModuleId: ANIMUS_CSS_MODULE_ID,
+		systemPropsModuleId: SESSION_ARTIFACT
+	};
 	/** Whether the analysis-inputs hydration corpus is written to disk. Only
 	*  isolated loader workers replay it; an in-process loader reads memory. */
 	persistAnalysisInputs = false;
+	/** The host substitutes asset() URLs itself (Vite: dev copies, build
+	*  emitFile markers): the published sheets keep their placeholders, and
+	*  the session makes no copy and tracks no asset file. */
+	hostSubstitutesAssets = false;
+	/** Whether the session keeps its artifacts on disk: status, commit,
+	*  manifest, styles, the epoch witness, asset copies and its directory
+	*  claim, with the sibling reconciliation they need. A host that serves
+	*  every result from memory (Vite) turns it off; the shared state still
+	*  publishes. Such a host also substitutes assets (above): asset copies
+	*  are artifacts. */
+	persistArtifacts = true;
 	/** Whether this session serves development (a watch), where an error-level
 	*  diagnostic is reported and the session keeps running. Only a build
 	*  fails on one. */
@@ -694,29 +1024,90 @@ var ExtractionSession = class {
 	/** Fires exactly once per settled `handleWatchUpdate` — the failure cause,
 	*  or null when clean. Observation never alters delivery. */
 	onCycleSettled = null;
+	/** Fires once per published generation, and per held attempt. */
+	onOutcome = null;
+	/** The last published generation; null before the first. */
+	publication = null;
+	/** The original sources (raw, before adaptation) the session holds, by
+	*  root-relative path: the published generation's, plus any that an
+	*  attempt in flight or held by an aborted parse has read. */
+	get heldSources() {
+		return this.fileCache;
+	}
+	/** The generation an emit produced, until it commits with the
+	*  ingestion's ownership and the external package state it analysed. */
+	stagedPublication = null;
 	options;
 	staticCssJson;
 	system = null;
-	/** Configured external files that could not be read. Incremental passes
-	*  re-collect nothing, so they replay these instead of passing strict. */
+	/** Configured files that could not be read. Incremental passes replay
+	*  these instead of passing strict, and add a watched change they cannot
+	*  read. */
 	ingestionFailureDiagnostics = [];
 	/** Whether the corpus being analyzed left a file out, whose renders the
 	*  analysis cannot see. */
 	skippedSources = [];
+	/** Resolver calls ingestion ended under another spelling. */
+	ingestionOpenings = [];
+	/** The adapted originals of the ingestion being analysed: it publishes
+	*  only after its analysis does. */
+	ingestionAdapted = /* @__PURE__ */ new Map();
 	/** 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),
-		reportErrors: () => this.reportErrors()
-	});
+	/** Held sources whose bytes the host supplied (WatchChanges.sources),
+	*  by root-relative path; a read from disk drops the path. */
+	hostSuppliedKeys = /* @__PURE__ */ new Set();
+	corpus = require_pipeline.createSourceCorpus(this.corpusHost());
+	/** The corpus reads the driver label when it reports, so a host that
+	*  sets `driverLabel` after construction is named in its messages. */
+	corpusHost() {
+		const label = () => this.driverLabel;
+		return {
+			engineApi: () => this.engine(),
+			get prefix() {
+				return `[${label()}]`;
+			},
+			strict: () => !!this.options.strict,
+			warn: (message) => this.warn(message),
+			reportErrors: () => this.reportErrors(),
+			extensions: () => this.extensionPolicy,
+			rootDir: () => this.rootDir
+		};
+	}
 	systemDependencyKeys = /* @__PURE__ */ new Set();
+	/** What a host watches for this Session, one list for every host: the
+	*  files whose change it acts on (the system module and the modules it
+	*  read, asset() sources, the configuration inputs), the paths the system
+	*  load found absent, whose creation reloads it, and the external package
+	*  roots, watched recursively. An absent path inside `covered` (roots the
+	*  host already watches recursively) is left out: a host's recursive
+	*  watch reports its creation, and watching an absent file inside a
+	*  watched directory can stop that directory's events (inotify). */
+	watchPlan(covered = []) {
+		const system = this.rootDir === null ? [] : [(0, path.resolve)(this.rootDir, this.options.system)];
+		return {
+			files: [.../* @__PURE__ */ new Set([
+				...system,
+				...this.systemDependencyPaths,
+				...this.assetDependencyPaths,
+				...this.configInputPaths
+			])],
+			missing: this.systemMissingPaths.filter((path$9) => !covered.some((root) => require_pipeline.isPathWithinRoot(root, path$9))),
+			directories: [...this.externalWatchRoots]
+		};
+	}
+	/** Whether `path` is the system module, one of its dependencies, or a
+	*  path its load found absent: a change to it reloads the system. */
+	isSystemDependency(path$10) {
+		return require_pipeline.toWatchKeys(path$10).some((key) => this.systemDependencyKeys.has(key));
+	}
 	/** Loader-reported dependency paths for bundler watch registration. */
 	systemDependencyPaths = [];
+	/** Paths the system load looked for and found absent: a host registers
+	*  them for creation, which reloads the system. */
+	systemMissingPaths = [];
 	systemDependencyHashes = /* @__PURE__ */ new Map();
 	lastSystemPropsHash = null;
 	artifactRecords = {
@@ -730,9 +1121,20 @@ var ExtractionSession = class {
 	/** 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();
+	/** The build this session takes part in: every participant of one build
+	*  shares its artifact tree and state; another build of the root never
+	*  does. */
+	sessionId;
+	/** The log tier, from the option and `ANIMUS_DEBUG` at construction. */
+	verbosity;
+	/** The emission mode at construction: explicit, else `NODE_ENV`'s. It
+	*  defaults minify. */
+	startupMode;
+	joinedKey = null;
+	/** This instance as a participant of its build, once joined. */
+	participant = null;
+	/** Closed: it left its build and starts no attempt until it reattaches. */
+	detached = false;
 	/** Epoch of the last published analysis; null seeds from disk so a
 	*  same-session restart with unchanged plans rewrites no bytes. */
 	lastEpochValue = null;
@@ -747,10 +1149,23 @@ var ExtractionSession = class {
 	*  the cache keeps every observed source so the repair publishes them in
 	*  one generation; a successful publication clears it. */
 	heldRejection = null;
-	/** A system reload an aborted parse rejected. Its dependency hashes already
-	*  advanced, so the first batch that passes the parse check publishes
-	*  through the full pipeline, which loads the latest system. */
+	/** Reload debt: a full pass that failed with a committed system to
+	*  hold, in development or under an aborted parse, owed until one
+	*  succeeds. runFullPipeline alone sets and clears it. While it stands, every batch retries the full reload and
+	*  nothing publishes against the stale system. Under an aborted parse's
+	*  hold, the first batch that passes the parse check pays it instead. */
 	systemReloadOwed = false;
+	/** The system dependencies the last committed full pass recorded: a
+	*  failed reload watches these and its own, never an earlier failure's. */
+	lastGoodSystemDependencies = {
+		keys: /* @__PURE__ */ new Set(),
+		paths: [],
+		missing: [],
+		hashes: /* @__PURE__ */ new Map()
+	};
+	/** Whether the current full pass's system load recorded its
+	*  dependencies. */
+	attemptRecordedSystemDependencies = false;
 	/** Monotonic readiness witness: flips true on the first complete
 	*  publication and never regresses; every later status write carries it. */
 	firstEmissionComplete = false;
@@ -761,27 +1176,57 @@ var ExtractionSession = class {
 	constructor(options, host = {}) {
 		this.host = host;
 		this.options = options;
+		this.sessionId = host.build ?? createBuildId();
 		this.staticCssJson = require_pipeline.serializeStaticCss(options.staticCss);
+		this.verbosity = require_pipeline.resolveVerbosity(options.verbose, process.env.ANIMUS_DEBUG);
+		this.startupMode = require_pipeline.resolveMode(options.mode, () => process.env.NODE_ENV === "production" ? "production" : "development").mode;
 	}
 	/** Forgets that `relPath` could not be read once an incremental pass reads
-	*  or deletes it, so its cost stops holding pruning off. */
+	*  or deletes it, so its cost stops holding pruning off. Whether one was
+	*  recorded. */
 	clearIngestionFailure(relPath) {
+		const before = this.ingestionFailureDiagnostics.length;
 		this.ingestionFailureDiagnostics = this.ingestionFailureDiagnostics.filter((diagnostic) => diagnostic.file !== relPath);
+		return this.ingestionFailureDiagnostics.length !== before;
+	}
+	/** The module extracted terminals import their factories from. */
+	get runtimeImport() {
+		return this.options.runtimeImport ?? "@animus-ui/system/runtime";
 	}
 	get sessionDir() {
 		return sessionArtifactDir(this.rootDir, this.sessionId);
 	}
+	/** This session's build of its root, joined on first use: a participant
+	*  whose options differ from the build's fails with
+	*  `SessionConfigurationConflict`. */
+	get key() {
+		if (this.joinedKey === null) {
+			const key = sessionKey(this.sessionId, this.rootDir);
+			const participant = `${this.driverLabel}#${(0, crypto.randomUUID)()}`;
+			joinSession(key, participant, this.options);
+			this.participant = participant;
+			this.joinedKey = key;
+		}
+		return this.joinedKey;
+	}
 	get verbose() {
-		return require_pipeline.resolveVerbosity(this.options.verbose, process.env.ANIMUS_DEBUG) !== "quiet";
+		return this.verbosity !== "quiet";
+	}
+	/** The engine of this session's build. */
+	engine() {
+		return this.host.engine?.() ?? engineApi(this.key);
+	}
+	get logger() {
+		return this.host.logger ?? CONSOLE_LOGGER;
 	}
 	log(msg) {
-		if (this.verbose) console.error(`[animus] ${msg}`);
+		if (this.verbose) this.logger.info(`[animus] ${msg}`);
 	}
 	warn(msg) {
-		console.warn(`[animus] ${msg}`);
+		this.logger.warn(`[animus] ${msg}`);
 	}
 	reportErrors() {
-		return this.development ? (message) => console.error(message) : void 0;
+		return this.development ? (message) => this.logger.error(message) : void 0;
 	}
 	/** A build-strictness check that failed: a build throws `message`, and
 	*  development reports it at error level and takes the non-strict path. */
@@ -790,6 +1235,11 @@ var ExtractionSession = class {
 		if (!report) throw new Error(message);
 		report(message);
 	}
+	/** A finding `strict` turns into a strict failure; otherwise a warning. */
+	strictOrWarn(message, strictMessage = message) {
+		if (this.options.strict) this.strictFailure(strictMessage);
+		else this.warn(message);
+	}
 	now() {
 		return this.verbose ? performance.now() : 0;
 	}
@@ -804,6 +1254,11 @@ var ExtractionSession = class {
 	lastExternalOutcomes = [];
 	/** The analysed kits' descriptors, from the last discovery. */
 	kitDescriptors = [];
+	/** Package name → the real root of the instance discovery read. */
+	packageInstances = {};
+	/** What this attempt's analysis read of the discovered packages; the
+	*  build's shared record once the analysis publishes. */
+	packageReadRecord = null;
 	/** 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;
@@ -814,18 +1269,15 @@ var ExtractionSession = class {
 	/** 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. */
+	/** The host's output directories (`outputExclusion`): root-relative,
+	*  excluded as literal path prefixes from discovery and from package
+	*  collection, whatever the user's list. */
 	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() {
+	*  exclude/extension policy shared by the full and incremental pipelines,
+	*  and by a host classifying its own file events. */
+	get scanConfig() {
 		if (this.scanConfigMemo === null) {
 			const extensionsSet = new Set(this.options.extensions ?? require_pipeline.DEFAULT_EXTENSIONS);
 			this.scanConfigMemo = {
@@ -835,8 +1287,8 @@ var ExtractionSession = class {
 		}
 		return this.scanConfigMemo;
 	}
-	/** Concurrent entries wait for publication, then ingest their own batch;
-	*  content hashes coalesce observations the prior analysis covered. */
+	/** Records the batch before any await, so an attempt that rejects never
+	*  erases it, and settles with the attempt that takes it (SA20). */
 	async handleWatchUpdate(changes) {
 		try {
 			await this.routeWatchUpdate(changes);
@@ -847,36 +1299,131 @@ var ExtractionSession = class {
 		this.onCycleSettled?.(null);
 	}
 	async routeWatchUpdate(changes) {
-		const hasBatch = (changes.modifiedFiles?.size ?? 0) > 0 || (changes.removedFiles?.size ?? 0) > 0;
-		const inflight = getWatchTransaction();
+		if ((changes.modifiedFiles?.size ?? 0) > 0 || (changes.removedFiles?.size ?? 0) > 0) {
+			await this.awaitObservation(this.recordObservation(changes));
+			return;
+		}
+		const inflight = getWatchTransaction(this.key);
 		if (inflight) {
 			await inflight;
-			if (!hasBatch) return;
-		}
-		if (!this.system) {
-			const owner = getOwningWatchSession();
-			if (owner && owner !== this && hasBatch) await owner.ingestForwardedBatch(changes);
 			return;
 		}
-		await this.ingestForwardedBatch(changes);
+		if (this.system && !this.detached) await this.runWatchAttempt(changes);
+	}
+	/** Queues the batch's observations under a new revision, synchronously.
+	*  A batch equivalent to what the active attempt took joins that attempt:
+	*  a second compiler's report of the same edit never analyzes it twice. */
+	recordObservation(changes) {
+		const queue = observationQueue(this.key);
+		const observed = /* @__PURE__ */ new Map();
+		for (const path$11 of changes.modifiedFiles ?? []) {
+			let state;
+			try {
+				state = require_pipeline.contentHash(changes.sources?.get(path$11) ?? (0, fs.readFileSync)(path$11, "utf-8"));
+			} catch {
+				state = UNREADABLE_OBSERVATION;
+			}
+			observed.set(path$11, state);
+		}
+		for (const path$12 of changes.removedFiles ?? []) observed.set(path$12, REMOVED_OBSERVATION);
+		const revision = ++queue.revision;
+		const active = queue.active;
+		if (active !== null && [...observed].every(([path$13, state]) => !queue.untaken.has(path$13) && active.taken.get(path$13) === state)) {
+			queue.revisions.set(revision, active.transaction);
+			return revision;
+		}
+		for (const [path$14, state] of observed) {
+			queue.untaken.set(path$14, state);
+			const supplied = changes.sources?.get(path$14);
+			if (supplied === void 0) queue.suppliedSources.delete(path$14);
+			else queue.suppliedSources.set(path$14, supplied);
+		}
+		queue.revisions.set(revision, null);
+		return revision;
 	}
-	/** The shared owner gate for local and forwarded batches. Every waiter
-	*  rechecks the slot so distinct batches publish in arrival order. */
-	async ingestForwardedBatch(changes) {
-		if (!this.system) return;
+	/** Settles with the attempt that takes `revision`. Another attempt's
+	*  rejection is its own callers': this observation runs after it. */
+	async awaitObservation(revision) {
+		const queue = observationQueue(this.key);
 		for (;;) {
-			const inflight = getWatchTransaction();
-			if (!inflight) break;
-			await inflight;
-		}
-		const transaction = Promise.resolve().then(() => this.processWatchUpdate(changes));
-		setWatchTransaction(transaction);
-		try {
-			await transaction;
-		} finally {
-			setWatchTransaction(null);
+			const taken = queue.revisions.get(revision);
+			if (taken !== null && taken !== void 0) {
+				queue.revisions.delete(revision);
+				await taken;
+				return;
+			}
+			const inflight = getWatchTransaction(this.key);
+			if (inflight) {
+				await inflight.catch(() => void 0);
+				continue;
+			}
+			const owner = this.system && !this.detached ? this : getOwningWatchSession(this.key);
+			if (owner === null && !this.detached && getManifestJson(this.key) !== null) {
+				await this.runFullPipeline();
+				continue;
+			}
+			if (owner === null || !owner.startObservedAttempt()) {
+				queue.revisions.delete(revision);
+				return;
+			}
 		}
 	}
+	/** Starts one attempt over every untaken observation of the build. */
+	startObservedAttempt() {
+		if (!this.system || this.detached) return false;
+		const { taken, rescan, sources } = this.takeObservations();
+		const modifiedFiles = /* @__PURE__ */ new Set();
+		const removedFiles = /* @__PURE__ */ new Set();
+		for (const [path$15, state] of taken) (state === REMOVED_OBSERVATION ? removedFiles : modifiedFiles).add(path$15);
+		this.settleTaken(taken, this.runWatchAttempt({
+			modifiedFiles,
+			removedFiles,
+			sources
+		}, rescan));
+		return true;
+	}
+	/** Every untaken observation of the build, and whether a full rescan is
+	*  requested, which the caller's attempt now covers. */
+	takeObservations() {
+		const queue = observationQueue(this.key);
+		const taken = new Map(queue.untaken);
+		const rescan = queue.rescan;
+		const sources = new Map(queue.suppliedSources);
+		queue.untaken.clear();
+		queue.suppliedSources.clear();
+		queue.rescan = false;
+		return {
+			taken,
+			rescan,
+			sources
+		};
+	}
+	/** `transaction` settles every waiting revision, and is the active
+	*  attempt equivalent observations join until it settles. */
+	settleTaken(taken, transaction) {
+		const queue = observationQueue(this.key);
+		for (const [revision, attempt] of queue.revisions) if (attempt === null) queue.revisions.set(revision, transaction);
+		queue.active = {
+			taken,
+			transaction
+		};
+		const settle = () => {
+			if (queue.active?.transaction === transaction) queue.active = null;
+		};
+		transaction.then(settle, settle);
+	}
+	/** Registers one attempt in the build's single-flight slot before it
+	*  processes, so a nested full system reload inherits the gate rather
+	*  than clear it, and clears the slot when it settles either way. */
+	runWatchAttempt(changes, rescan = false) {
+		const transaction = Promise.resolve().then(() => rescan ? this.runFullPipeline([], changes.sources) : this.processWatchUpdate(changes));
+		setWatchTransaction(this.key, transaction);
+		const settle = () => {
+			if (getWatchTransaction(this.key) === transaction) setWatchTransaction(this.key, null);
+		};
+		transaction.then(settle, settle);
+		return transaction;
+	}
 	async processWatchUpdate(changes) {
 		const rootDir = this.rootDir;
 		try {
@@ -887,31 +1434,25 @@ var ExtractionSession = class {
 		const changed = [...changes.modifiedFiles ?? [], ...changes.removedFiles ?? []];
 		let assetChanged = false;
 		let systemHit;
+		let configHit;
 		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)));
+			if (changed.length === 0) {
+				systemHit = firstChangedFile(this.systemDependencyHashes);
+				if (systemHit === void 0) configHit = firstChangedFile(this.configInputHashes);
+			} else systemHit = changed.find((path$16) => this.isSystemDependency(path$16));
 		} 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)})`);
+		configHit ??= changed.find((path$17) => require_pipeline.toWatchKeys(path$17).some((key) => this.configInputKeys.has(key)));
+		const debtRetry = this.systemReloadOwed && this.heldRejection === null;
+		if (systemHit || configHit || debtRetry) {
+			this.log(systemHit ? `system reload: system dependency changed (${(0, path.relative)(rootDir, systemHit)})` : configHit ? `system reload: configuration changed (${(0, path.relative)(rootDir, configHit)})` : "system reload: retrying the reload a failure left owed");
 			this.resetForHmr();
 			try {
-				const promise = this.runFullPipeline(this.pendingFromBatch(changes));
-				setAnalysisStartedPromise(promise);
+				const promise = this.runFullPipeline(this.pendingFromBatch(changes), changes.sources);
+				setAnalysisStartedPromise(this.key, promise);
 				await promise;
-				this.systemReloadOwed = false;
 			} catch (err) {
-				if (err instanceof AbortedParseRejection) this.systemReloadOwed = true;
 				try {
 					this.beginStatusAttempt();
 					this.writeAnalysisStatus("failed", this.pendingFromBatch(changes), String(err));
@@ -922,18 +1463,20 @@ var ExtractionSession = class {
 			}
 			return;
 		}
-		if (changed.some((path$3) => require_pipeline.toWatchKeys(path$3).some((key) => this.assetDependencyKeys.has(key)))) {
+		if (changed.some((path$18) => require_pipeline.toWatchKeys(path$18).some((key) => this.assetDependencyKeys.has(key)))) {
 			this.assetCopyCache.clear();
 			assetChanged = true;
 		}
-		const { excludeMatcher, extensionsSet } = this.resolveScanConfig();
+		const { excludeMatcher, extensionsSet } = this.scanConfig;
 		const priorCacheEntries = /* @__PURE__ */ new Map();
 		const priorExternalFileOwners = { ...this.externalFileOwners };
+		const priorHostSuppliedKeys = new Set(this.hostSuppliedKeys);
 		const recordPrior = (key) => {
 			if (!priorCacheEntries.has(key)) priorCacheEntries.set(key, this.fileCache.get(key) ?? null);
 		};
 		const inventoryUpdates = [];
 		const ownerRemovals = [];
+		const removedProjectFiles = /* @__PURE__ */ new Map();
 		let removedAny = false;
 		if (changes.removedFiles) for (const removedPath of changes.removedFiles) {
 			let key;
@@ -947,8 +1490,10 @@ var ExtractionSession = class {
 			}
 			recordPrior(key);
 			this.clearIngestionFailure(key);
+			this.hostSuppliedKeys.delete(key);
 			if (this.fileCache.delete(key)) {
 				removedAny = true;
+				if (!owningRoot) removedProjectFiles.set(key, removedPath);
 				if (owningRoot) {
 					inventoryUpdates.push({
 						root: owningRoot,
@@ -979,15 +1524,29 @@ var ExtractionSession = class {
 			owningRoot: null
 		}));
 		const changedPaths = [];
+		const inOutput = require_pipeline.outputSourceGuard(rootDir, this.structuralExclude);
+		let readFailuresChanged = false;
 		for (const target of targets) {
 			const relPath = target.key;
+			const outputDir = inOutput(target.abs);
+			if (outputDir !== null) {
+				this.warn(require_pipeline.outputSourceMessage(relPath, outputDir));
+				continue;
+			}
 			let source;
 			try {
-				source = (0, fs.readFileSync)(target.abs, "utf-8");
-			} catch {
+				const supplied = changes.sources?.get(target.abs);
+				source = supplied ?? (0, fs.readFileSync)(target.abs, "utf-8");
+				if (supplied === void 0) this.hostSuppliedKeys.delete(relPath);
+				else this.hostSuppliedKeys.add(relPath);
+			} catch (err) {
+				if (require_pipeline.isDeletedSource(err)) continue;
+				this.clearIngestionFailure(relPath);
+				this.ingestionFailureDiagnostics = [...this.ingestionFailureDiagnostics, require_pipeline.unreadableSourceDiagnostic(relPath, err)];
+				readFailuresChanged = true;
 				continue;
 			}
-			this.clearIngestionFailure(relPath);
+			if (this.clearIngestionFailure(relPath)) readFailuresChanged = true;
 			const rawHash = require_pipeline.contentHash(source);
 			const cached = this.fileCache.get(relPath);
 			const hash = rawHash;
@@ -1010,7 +1569,7 @@ var ExtractionSession = class {
 				}
 			}
 		}
-		if (changedPaths.length > 0 || removedAny || assetChanged) {
+		if (changedPaths.length > 0 || removedAny || readFailuresChanged || assetChanged) {
 			const pending = changedPaths.map((rel) => [rel, this.fileCache.get(rel).hash]);
 			const commitObservedBatch = () => {
 				for (const update of inventoryUpdates) {
@@ -1036,24 +1595,32 @@ var ExtractionSession = class {
 				});
 				this.throwOnAbortedParse(ingested);
 				this.skippedSources = ingested.skippedOriginals ?? [];
+				this.ingestionOpenings = ingested.openings ?? [];
+				this.ingestionAdapted = require_pipeline.adaptedOriginals(ingested.ownership);
 				if (this.systemReloadOwed) {
 					this.log("system reload: publishing the reload a parse hold deferred");
+					const stale = this.staleHostSuppliedSources(changes.sources);
+					if (stale.length > 0) throw new DeferredReloadRefusal(`[${this.driverLabel}] system reload not published: its full read would take ${stale.join(", ")} from disk, which does not hold the bytes the host supplied; the last generation stays served, and the reload publishes with the next change once the disk holds them`);
 					this.resetForHmr();
-					await this.runFullPipeline(pending);
-					this.systemReloadOwed = false;
+					await this.runFullPipeline(pending, changes.sources);
 					return;
 				}
 				this.externalFileOwners = require_pipeline.projectExternalFileOwners(ingested, this.externalFileOwners);
-				resetAnalysisStartedPromise();
+				resetAnalysisStartedPromise(this.key);
 				const promise = this.runIncrementalPipeline(ingested.analysisEntries, pending);
-				setAnalysisStartedPromise(promise);
+				setAnalysisStartedPromise(this.key, promise);
 				await promise;
 			} catch (err) {
-				if (err instanceof AbortedParseRejection) commitObservedBatch();
+				if (err instanceof AbortedParseRejection || err instanceof DeferredReloadRefusal) commitObservedBatch();
 				else {
-					for (const [key, prior] of priorCacheEntries) if (prior === null) this.fileCache.delete(key);
-					else this.fileCache.set(key, prior);
+					for (const [key, prior] of priorCacheEntries) {
+						const removed = removedProjectFiles.get(key);
+						if (removed !== void 0 && !(0, fs.existsSync)(removed)) continue;
+						if (prior === null) this.fileCache.delete(key);
+						else this.fileCache.set(key, prior);
+					}
 					this.externalFileOwners = priorExternalFileOwners;
+					this.hostSuppliedKeys = priorHostSuppliedKeys;
 				}
 				if (this.statusAttemptOpen) {
 					this.debouncePending.clear();
@@ -1061,7 +1628,7 @@ var ExtractionSession = class {
 				}
 				throw err;
 			}
-			this.publishSourceIngestion(ingested);
+			this.publishSourceIngestion(ingested, "incremental", (path$19) => this.fileCache.get(path$19));
 			commitObservedBatch();
 		} else if (this.statusAttemptOpen) {
 			this.debouncePending.clear();
@@ -1076,88 +1643,251 @@ var ExtractionSession = class {
 		const rejection = this.corpus.rejection(prepared);
 		if (!rejection) return;
 		this.heldRejection = rejection.message;
+		this.onOutcome?.({
+			kind: "held",
+			abortedOriginals: rejection.originals
+		});
 		throw new AbortedParseRejection(rejection.message);
 	}
-	publishSourceIngestion(result) {
+	/** Holds a held full read's entries: what it read stays the held bytes,
+	*  never overwriting held host bytes with the disk's (a key the host
+	*  supplied before that this read took from disk keeps its bytes). */
+	holdObservedEntries(entries, supplied) {
+		for (const entry of entries) {
+			const fromHost = supplied.has(entry.path);
+			if (this.hostSuppliedKeys.has(entry.path) && !fromHost) continue;
+			this.fileCache.set(entry.path, {
+				hash: entry.hash,
+				source: entry.source
+			});
+			if (fromHost) this.hostSuppliedKeys.add(entry.path);
+		}
+	}
+	/** Held sources whose bytes the host supplied and which the disk no
+	*  longer matches: a full read not carrying them (`carried`) would
+	*  publish the disk's bytes in their place. */
+	staleHostSuppliedSources(carried) {
+		const stale = [];
+		for (const key of this.hostSuppliedKeys) {
+			const held = this.fileCache.get(key);
+			const abs = (0, path.resolve)(this.rootDir, key);
+			if (held === void 0 || carried?.has(abs)) continue;
+			let onDisk;
+			try {
+				onDisk = (0, fs.readFileSync)(abs, "utf-8");
+			} catch {
+				onDisk = null;
+			}
+			if (onDisk === null || require_pipeline.contentHash(onDisk) !== held.hash) stale.push(key);
+		}
+		return stale.sort();
+	}
+	/** `raw` is the attempt's input by original path, from which a
+	*  quarantined original stays held: every later pass re-ingests it, so it
+	*  keeps counting as skipped (nothing it renders is pruned) and its fix
+	*  edit compares against its bytes. */
+	publishSourceIngestion(result, pass, raw) {
+		const endedHold = this.heldRejection !== null;
+		const previousOwnership = this.corpus.published.ownership;
 		this.heldRejection = null;
-		this.fileCache = new Map(result.originalEntries.map((entry) => [entry.path, {
+		const held = new Map(result.originalEntries.map((entry) => [entry.path, {
 			hash: entry.hash,
 			source: entry.source
 		}]));
+		for (const path$20 of result.skippedOriginals ?? []) {
+			const entry = raw(path$20);
+			if (entry) held.set(path$20, {
+				hash: entry.hash ?? require_pipeline.contentHash(entry.source),
+				source: entry.source
+			});
+		}
+		this.fileCache = held;
 		this.corpus.publish(result);
+		const staged = this.stagedPublication;
+		if (staged === null) return;
+		this.stagedPublication = null;
+		const previous = this.publication;
+		const publication = {
+			...staged,
+			ownership: result.ownership,
+			externalPackageDirs: this.externalPackageDirs,
+			externalSourceEntries: this.externalSourceEntries,
+			externalSourceSideEffects: this.externalSourceSideEffects
+		};
+		this.publication = publication;
+		setPublication(this.key, publication);
+		this.onOutcome?.({
+			kind: "published",
+			publication,
+			pass,
+			planChanged: require_pipeline.diffFilePlans(require_pipeline.snapshotFilePlans(previous?.manifest ?? null), require_pipeline.snapshotFilePlans(publication.manifest)),
+			endedHold,
+			redeliver: endedHold ? Object.values(result.ownership).filter((owner) => previousOwnership[owner.originalPath]?.originalHash !== owner.originalHash).map((owner) => owner.originalPath) : []
+		});
 	}
 	/** Full analysis + publication, registered in the one in-flight
-	*  transaction slot; a nested reload leaves the enclosing registration. */
-	async runFullPipeline(pending = []) {
+	*  transaction slot; a nested reload leaves the enclosing registration.
+	*  `sources` are bytes a host already read (see WatchChanges.sources):
+	*  the full read uses them, and those of the observations it takes, in
+	*  place of the disk. */
+	async runFullPipeline(pending = [], sources = /* @__PURE__ */ new Map()) {
 		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 releaseOwner = claimExclusiveSessionOwner(this.key, `${this.driverLabel}:${this.sessionDir}`);
+			if (this.persistArtifacts) {
+				(0, fs.mkdirSync)(this.sessionDir, { recursive: true });
+				holdBuildClaimRecord(this.key, () => holdDirectoryClaim(this.sessionDir, { build: this.sessionId }));
+			}
+			this.releasePublicationClaim = releaseOwner;
 		}
 		const priorSystem = this.system;
-		const nested = getWatchTransaction() !== null;
-		const transaction = this.runPipelineTransaction(pending);
-		if (!nested) setWatchTransaction(transaction);
+		const priorRegistration = this.snapshotWatchRegistration();
+		this.attemptRecordedSystemDependencies = false;
+		const nested = getWatchTransaction(this.key) !== null;
+		const observations = nested ? null : this.takeObservations();
+		const taken = observations?.taken ?? null;
+		const transaction = this.runPipelineTransaction(pending, new Map([...observations?.sources ?? [], ...sources]));
+		if (taken !== null) {
+			setWatchTransaction(this.key, transaction);
+			this.settleTaken(taken, transaction);
+		}
 		try {
 			await transaction;
 		} catch (error) {
 			this.system = priorSystem;
+			this.restoreWatchRegistration(priorRegistration);
+			if (priorSystem !== null && (this.development || error instanceof AbortedParseRejection)) this.systemReloadOwed = true;
 			throw error;
 		} finally {
-			if (!nested) setWatchTransaction(null);
+			if (!nested) setWatchTransaction(this.key, null);
+		}
+		this.systemReloadOwed = false;
+		this.lastGoodSystemDependencies = {
+			keys: this.systemDependencyKeys,
+			paths: this.systemDependencyPaths,
+			missing: this.systemMissingPaths,
+			hashes: this.systemDependencyHashes
+		};
+		this.commitSystemAuthority();
+	}
+	/** This attempt's system dependencies: the files its load read, and the
+	*  paths it found absent, whose creation is a system change. */
+	recordSystemDependencies(systemPath, dependencies, missing) {
+		const keys = /* @__PURE__ */ new Set();
+		for (const path$21 of [
+			systemPath,
+			...dependencies,
+			...missing
+		]) for (const key of require_pipeline.toWatchKeys(path$21)) keys.add(key);
+		const hashes = /* @__PURE__ */ new Map();
+		for (const dep of dependencies.length > 0 ? dependencies : [systemPath]) try {
+			hashes.set(dep, require_pipeline.contentHash((0, fs.readFileSync)(dep, "utf-8")));
+		} catch {
+			hashes.set(dep, "");
+		}
+		for (const path$22 of missing) hashes.set(path$22, "");
+		this.systemDependencyKeys = keys;
+		this.systemDependencyPaths = dependencies;
+		this.systemMissingPaths = missing;
+		this.systemDependencyHashes = hashes;
+		this.attemptRecordedSystemDependencies = true;
+	}
+	/** Records the configuration inputs and, for a tsconfig-aliased host,
+	*  re-reads its aliases. */
+	readConfigInputs(rootDir) {
+		this.configInputPaths = [(0, path.join)(rootDir, "package.json"), ...require_pipeline.tsconfigChainPaths(rootDir)];
+		this.configInputKeys = new Set(this.configInputPaths.flatMap((path$23) => require_pipeline.toWatchKeys(path$23)));
+		this.configInputHashes = new Map(this.configInputPaths.map((path$24) => [path$24, fileHashOrEmpty(path$24)]));
+		if (this.aliasesFromTsconfig) this.pathAliasesJson = require_pipeline.buildPathAliasesJson(require_pipeline.readTsconfigAliasPairs(rootDir), rootDir)?.json ?? null;
+	}
+	/** What hosts watch for assets, and what the last-good generation
+	*  reported about its kits and packages, which a failed full pass must
+	*  leave in place. */
+	snapshotWatchRegistration() {
+		return {
+			assetDependencyPaths: new Set(this.assetDependencyPaths),
+			assetDependencyKeys: new Set(this.assetDependencyKeys),
+			kitDescriptors: this.kitDescriptors,
+			lastExternalOutcomes: this.lastExternalOutcomes
+		};
+	}
+	/** Restores the last-good registration. The system dependencies are the
+	*  last committed pass's and, when its load got that far, this failed
+	*  attempt's (spec §2.3): a fix to any of them must reach the owed reload,
+	*  and an earlier failure's are replaced, never accumulated. */
+	restoreWatchRegistration(prior) {
+		Object.assign(this, prior);
+		const lastGood = this.lastGoodSystemDependencies;
+		if (!this.attemptRecordedSystemDependencies) {
+			this.systemDependencyKeys = lastGood.keys;
+			this.systemDependencyPaths = lastGood.paths;
+			this.systemMissingPaths = lastGood.missing;
+			this.systemDependencyHashes = lastGood.hashes;
+			return;
 		}
+		this.systemMissingPaths = [.../* @__PURE__ */ new Set([...lastGood.missing, ...this.systemMissingPaths])];
+		this.systemDependencyKeys = /* @__PURE__ */ new Set([...lastGood.keys, ...this.systemDependencyKeys]);
+		this.systemDependencyPaths = [.../* @__PURE__ */ new Set([...lastGood.paths, ...this.systemDependencyPaths])];
+		this.systemDependencyHashes = new Map([...this.systemDependencyHashes, ...lastGood.hashes]);
+	}
+	/** The build's authority becomes the system this session committed, with
+	*  it and never before: a failed reload leaves the committed one, and the
+	*  context proofs made against it. A committed reload discards every
+	*  other context's proof, even for an unchanged system: the reload may
+	*  have changed what another context resolves, so each loads again. */
+	commitSystemAuthority() {
+		setSystemAuthority(this.key, {
+			...systemLoad(this.system),
+			context: this.resolutionContextText(),
+			label: this.resolutionContextLabel(),
+			others: /* @__PURE__ */ new Map()
+		});
 	}
-	async runPipelineTransaction(pending) {
+	async runPipelineTransaction(pending, hostSources) {
 		const pipelineStart = this.now();
 		const bt = {};
 		this.runSessionStartHygiene();
-		setSessionArtifactDir(this.sessionDir);
+		setSessionArtifactDir(this.key, this.sessionDir);
 		const rootDir = this.rootDir;
 		const priorSourceState = this.snapshotSourceState();
 		const resolvedSystemPath = (0, path.resolve)(rootDir, this.options.system);
+		this.readConfigInputs(rootDir);
+		const context = {
+			conditions: this.conditions,
+			workspaces: require_pipeline.declaredWorkspacePackages(rootDir),
+			extensions: this.extensionPolicy
+		};
+		this.log(`extension order: ${context.extensions.resolverVersion}`);
 		let t = this.now();
-		this.system = require_pipeline.loadSystemConfig(engineApi, {
-			systemPath: resolvedSystemPath,
-			rootDir,
-			prefix: this.options.prefix,
-			prefixContextualVars: this.options.prefixContextualVars,
-			conditions: this.conditions
-		});
+		try {
+			this.system = this.loadSystemUnder(context);
+		} catch (error) {
+			const reads = require_pipeline.systemLoadReads(error);
+			this.recordSystemDependencies(resolvedSystemPath, reads.dependencies, reads.missing);
+			throw error;
+		}
 		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;
-		}
+		this.recordSystemDependencies(resolvedSystemPath, this.system.dependencies ?? [], this.system.missing ?? []);
 		bt.systemLoad = this.elapsed(t);
 		t = this.now();
-		const { excludeMatcher, extensionsSet } = this.resolveScanConfig();
+		const { excludeMatcher, extensionsSet } = this.scanConfig;
 		const files = require_pipeline.discoverFiles(rootDir, rootDir, excludeMatcher, extensionsSet);
+		if (claimUnmatchedExcludeReport(this.key)) for (const line of require_pipeline.unmatchedExcludeLines(excludeMatcher)) this.logger.error(line);
 		bt.fileDiscovery = this.elapsed(t);
 		t = this.now();
 		const rawEntries = [];
 		const ingestionFailures = [];
+		const readPaths = /* @__PURE__ */ new Set();
+		const supplied = /* @__PURE__ */ new Set();
 		for (const filePath of files) {
 			const relPath = (0, path.relative)(rootDir, filePath);
+			readPaths.add(filePath);
 			let source;
 			try {
-				source = (0, fs.readFileSync)(filePath, "utf-8");
+				const hostSource = hostSources.get(filePath);
+				source = hostSource ?? (0, fs.readFileSync)(filePath, "utf-8");
+				if (hostSource !== void 0) supplied.add(relPath);
 			} catch (err) {
 				if (!require_pipeline.isDeletedSource(err)) ingestionFailures.push(require_pipeline.unreadableSourceDiagnostic(relPath, err));
 				continue;
@@ -1169,21 +1899,36 @@ var ExtractionSession = class {
 			});
 		}
 		bt.fileRead = this.elapsed(t);
+		const rawPaths = new Set(rawEntries.map((entry) => entry.path));
 		t = this.now();
-		const discoveryDiagnostics = [];
-		const packageNames = await require_pipeline.extractSystemFilePackages(resolvedSystemPath, require_pipeline.engineModuleParser(engineApi()), (diagnostic) => discoveryDiagnostics.push(diagnostic), (name) => {
-			const entry = resolvePackagesByName(rootDir, [name])[name];
-			return entry ? (0, path.resolve)(rootDir, entry) : null;
+		const resolver = require_pipeline.discoveryResolver(this.hostResolve, this.engine(), {
+			rootDir,
+			conditions: context.conditions,
+			workspaces: context.workspaces,
+			extensions: context.extensions
 		});
-		discoveryDiagnostics.push(...require_pipeline.importedKitDiagnostics(rawEntries, engineApi(), rootDir, packageNames));
-		const preResolved = resolvePackagesByName(rootDir, packageNames);
+		const discoveryDiagnostics = [];
+		const systemPackageRoot = require_pipeline.findPackageRoot(resolvedSystemPath);
+		const kitMembers = /* @__PURE__ */ new Map();
+		const packageNames = await require_pipeline.extractSystemFilePackages(resolvedSystemPath, { systemMembership: this.engine().systemMembership ?? requireEngine().systemMembership }, (diagnostic) => discoveryDiagnostics.push(diagnostic), (specifier, importer) => require_pipeline.findPackageRoot(importer) === systemPackageRoot ? resolver.resolveSpecifier(specifier) : resolver.loaderResolve(specifier, (0, path.dirname)(importer)), context.extensions, kitMembers);
+		discoveryDiagnostics.push(...require_pipeline.importedKitDiagnostics(rawEntries, this.engine(), rootDir, packageNames, (entries) => this.corpus.facts(entries)));
 		const rawExternalFiles = /* @__PURE__ */ new Map();
 		const collected = await require_pipeline.collectExternalPackageSources({
+			extensions: context.extensions,
+			kitSourceRoot: require_pipeline.nativeKitSourceRoot(this.engine(), rootDir, context.conditions, context.workspaces, require_pipeline.extensionPolicyJson(context.extensions)),
+			locatePackage: require_pipeline.nativePackageLocator(this.engine(), context.workspaces),
 			specifiers: packageNames,
-			resolveSpecifier: (name) => preResolved[name] ? (0, path.resolve)(rootDir, preResolved[name]) : null,
+			resolveSpecifier: async (specifier) => kitMembers.get(specifier) ?? await resolver.resolveSpecifier(specifier),
+			locateFrom: (specifier) => {
+				const file = kitMembers.get(specifier);
+				return file === void 0 ? rootDir : (0, path.dirname)(file);
+			},
+			unresolvedReason: resolver.unresolvedReason,
+			requireSourceEntry: resolver.requireSourceEntry,
 			rootDir,
 			extensionsSet,
-			hasEntry: (relPath) => rawEntries.some((e) => e.path === relPath),
+			hasEntry: (relPath) => rawPaths.has(relPath),
+			hostOutputDirs: this.structuralExclude.map((dir) => (0, path.resolve)(rootDir, dir)),
 			onSourceRead: (source, _relPath, absPath) => {
 				rawExternalFiles.set(absPath, require_pipeline.contentHash(source));
 			},
@@ -1202,21 +1947,22 @@ var ExtractionSession = class {
 		});
 		this.lastExternalOutcomes = collected.outcomes;
 		this.ingestionFailureDiagnostics = ingestionFailures;
+		if (resolver.hostFirst) discoveryDiagnostics.push(...systemInstanceMismatches({
+			rootDir,
+			specifiers: packageNames,
+			instances: collected.packageInstances,
+			evaluated: this.systemDependencyPaths,
+			loaderResolve: (specifier) => resolver.loaderResolve(specifier, (0, path.dirname)(resolvedSystemPath))
+		}));
 		require_pipeline.surfaceManifestDiagnostics({ diagnostics: [...discoveryDiagnostics, ...collected.diagnostics] }, (message) => this.warn(message), {
 			levels: this.options.diagnostics,
 			strict: this.options.strict,
 			reportErrors: this.reportErrors()
 		});
-		const unresolvableMessage = require_pipeline.unresolvableIncludesMessage(collected.outcomes);
-		if (unresolvableMessage !== null) {
-			if (this.options.strict) this.strictFailure(unresolvableMessage);
-			else this.warn(unresolvableMessage);
-		}
+		const unresolvableMessage = require_pipeline.unresolvableIncludesMessage(collected.outcomes, (0, path.relative)(rootDir, resolvedSystemPath));
+		if (unresolvableMessage !== null) this.strictOrWarn(unresolvableMessage);
 		const staleDistMessage = require_pipeline.staleDistIncludesMessage(collected.outcomes);
-		if (staleDistMessage !== null) {
-			if (this.options.strict) this.strictFailure(staleDistMessage);
-			else this.warn(staleDistMessage);
-		}
+		if (staleDistMessage !== null) this.strictOrWarn(staleDistMessage);
 		const rejectedSpecifiers = /* @__PURE__ */ new Set();
 		const crossVolumeDetails = [];
 		for (const [dir, specifiers] of Object.entries(collected.dirOwnerSets)) {
@@ -1233,6 +1979,7 @@ var ExtractionSession = class {
 		for (const message of this.stickyDiagnostics.values()) this.warn(message);
 		const admitted = require_pipeline.excludeCollectedPackages(collected, rejectedSpecifiers, rootDir);
 		this.kitDescriptors = admitted.kitDescriptors;
+		this.packageInstances = admitted.packageInstances;
 		try {
 			const identity = require_pipeline.createSourceIdentity(rootDir);
 			this.externalRootOwners = /* @__PURE__ */ new Map();
@@ -1268,43 +2015,62 @@ var ExtractionSession = class {
 			this.externalSourceEntries = admitted.sourceEntries;
 			this.externalSourceSideEffects = admitted.sourceEntrySideEffects;
 			for (const entry of admitted.entries) {
-				const hash = require_pipeline.contentHash(entry.source);
+				const entryPath = (0, path.resolve)(rootDir, entry.path);
+				readPaths.add(entryPath);
+				const hostSource = hostSources.get(entryPath);
+				if (hostSource !== void 0) supplied.add(entry.path);
+				const source = hostSource ?? entry.source;
 				rawEntries.push({
 					path: entry.path,
-					source: entry.source,
-					hash
+					source,
+					hash: require_pipeline.contentHash(source)
 				});
 			}
 			this.externalPackageDirs = admitted.packageDirs;
 			this.externalLinkedDirs = admitted.linkedDirs;
 			this.externalOutputDirs = admitted.outputDirs;
 			bt.packageResolve = this.elapsed(t);
+			const misspelled = misspelledHostSources(hostSources, readPaths).map(({ path: path$25, read }) => `${(0, path.relative)(rootDir, path$25)} (read as ${read.map((readPath) => (0, path.relative)(rootDir, readPath)).join(", ")})`);
+			if (misspelled.length > 0) throw new DeferredReloadRefusal(`[${this.driverLabel}] reload not published: the host supplied bytes for ${misspelled.join(", ")}, which the full read reaches only under another spelling; the last generation stays served`);
 			this.beginStatusAttempt();
 			let accepted;
+			const readEntries = this.withoutOutputSources(rawEntries);
 			try {
-				accepted = await this.corpus.prepare(rawEntries);
+				accepted = await this.corpus.prepare(readEntries);
 				this.throwOnAbortedParse(accepted);
 				this.skippedSources = accepted.skippedOriginals ?? [];
+				this.ingestionOpenings = accepted.openings ?? [];
+				this.ingestionAdapted = require_pipeline.adaptedOriginals(accepted.ownership);
 			} catch (err) {
+				if (err instanceof AbortedParseRejection) this.holdObservedEntries(readEntries, supplied);
 				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);
+			require_pipeline.clearEngineCache(() => this.engine());
 			await this.analyzeAndEmit(accepted.analysisEntries, packageMap, false, bt, pipelineStart, pending);
-			this.publishSourceIngestion(accepted);
-			setSharedExternalDirs(admitted.packageDirs);
-			setSharedExternalEntries(admitted.sourceEntries);
-			setSharedExternalSideEffects(admitted.sourceEntrySideEffects);
+			this.publishSourceIngestion(accepted, "full", (path$26) => rawEntries.find((entry) => entry.path === path$26));
+			this.hostSuppliedKeys = supplied;
 			this.onExternalRootsCommitted?.(this.externalWatchRoots);
-			setOwningWatchSession(this);
+			setOwningWatchSession(this.key, this);
 		} catch (err) {
 			this.restoreSourceState(priorSourceState);
 			throw err;
 		}
 	}
+	/** The full pass's analysis inputs, less any file whose real path lies in
+	*  an output directory, each reported. */
+	withoutOutputSources(entries) {
+		const inOutput = require_pipeline.outputSourceGuard(this.rootDir, this.structuralExclude);
+		return entries.filter((entry) => {
+			const outputDir = inOutput((0, path.resolve)(this.rootDir, entry.path));
+			if (outputDir === null) return true;
+			this.warn(require_pipeline.outputSourceMessage(entry.path, outputDir));
+			return false;
+		});
+	}
 	/** Per-generation source state captured as ONE object so the restore
 	*  cannot omit a member; deep-copied fields are mutated in place. */
 	snapshotSourceState() {
@@ -1326,16 +2092,93 @@ var ExtractionSession = class {
 	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. */
+	/** The system under `context`: the one load path for the build's
+	*  authority and for a participant checking its own context. */
+	loadSystemUnder(context) {
+		return require_pipeline.loadSystemConfig(() => this.engine(), {
+			systemPath: (0, path.resolve)(this.rootDir, this.options.system),
+			rootDir: this.rootDir,
+			prefix: this.options.prefix,
+			prefixContextualVars: this.options.prefixContextualVars,
+			conditions: context.conditions,
+			workspaces: context.workspaces,
+			extensions: context.extensions
+		});
+	}
+	/** What the system loader reads of this participant besides the root, as
+	*  stable text: its conditions and extension order. */
+	resolutionContextText() {
+		return JSON.stringify([this.conditions, require_pipeline.extensionPolicyJson(this.extensionPolicy)]);
+	}
+	resolutionContextLabel() {
+		return `${this.driverLabel} with conditions [${this.conditions.join(", ")}] and extension order ${this.extensionPolicy.resolverVersion}`;
+	}
+	/** One agreed system authority (SA5): a participant whose resolution
+	*  context differs from the one the build's system was loaded under loads
+	*  it once under its own, and proceeds only on the same system. Otherwise
+	*  it throws, naming both contexts, whichever participant came first. */
+	agreeWithSystemAuthority() {
+		const authority = getSystemAuthority(this.key);
+		if (authority === null) return;
+		const context = this.resolutionContextText();
+		if (context === authority.context) return;
+		let own = authority.others.get(context);
+		if (own === void 0) {
+			own = systemLoad(this.loadSystemUnder({
+				conditions: this.conditions,
+				workspaces: require_pipeline.declaredWorkspacePackages(this.rootDir),
+				extensions: this.extensionPolicy
+			}));
+			authority.others.set(context, own);
+		}
+		if (own.identity === authority.identity) return;
+		const shared = new Set(authority.dependencies);
+		const mine = new Set(own.dependencies);
+		const differing = [...authority.dependencies.filter((path$27) => !mine.has(path$27)), ...own.dependencies.filter((path$28) => !shared.has(path$28))].map((path$29) => (0, path.relative)(this.rootDir, path$29));
+		throw new SessionConfigurationConflict(this.key, authority.label, this.resolutionContextLabel(), differing.length > 0 ? [`system modules ${differing.join(", ")}`] : ["the evaluated system"], "Every participant of one build must evaluate the same system: give each compiler conditions that select the same system modules.");
+	}
+	/** Release this session's publication claim so a successor may publish,
+	*  and leave the build, which retires with its last participant.
+	*  Idempotent; `reattach` joins the build again. */
 	close() {
 		this.releasePublicationClaim?.();
 		this.releasePublicationClaim = null;
+		this.hostSuppliedKeys.clear();
+		if (this.joinedKey === null || this.participant === null) return;
+		if (getOwningWatchSession(this.joinedKey) === this) setOwningWatchSession(this.joinedKey, null);
+		leaveSession(this.joinedKey, this.participant);
+		this.participant = null;
+		this.detached = true;
+	}
+	/** A closed participant attaching again: its private analysis is stale,
+	*  so it is discarded, and it joins its build again. Idempotent. */
+	reattach() {
+		if (!this.detached) return;
+		this.detached = false;
+		this.system = null;
+		this.joinedKey = null;
+	}
+	/** Brings a reattached participant up to date with a full rescan of a
+	*  live build, which reconciles deletions too; true then. A retired build
+	*  is false: the host starts it as at first. */
+	async catchUp() {
+		if (getManifestJson(this.key) === null) return false;
+		await this.awaitObservation(this.recordRescan());
+		return true;
+	}
+	/** Queues a full rescan under a new revision. It is never equivalent to
+	*  an active attempt: only a full read covers it. */
+	recordRescan() {
+		const queue = observationQueue(this.key);
+		queue.rescan = true;
+		const revision = ++queue.revision;
+		queue.revisions.set(revision, null);
+		return revision;
 	}
 	/** 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();
+		resetAnalysisStartedPromise(this.key);
 		this.artifactRecords = {
 			manifest: null,
 			inputs: null,
@@ -1346,16 +2189,16 @@ var ExtractionSession = class {
 	/** 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 { excludeMatcher, extensionsSet } = this.scanConfig;
 		const pending = [];
-		for (const path$4 of changes.modifiedFiles ?? []) {
-			const classified = this.classifyWatchPath(path$4, {
+		for (const path$30 of changes.modifiedFiles ?? []) {
+			const classified = this.classifyWatchPath(path$30, {
 				excludeMatcher,
 				extensionsSet
 			});
 			if (!classified) continue;
 			try {
-				pending.push([classified.key, require_pipeline.contentHash((0, fs.readFileSync)(path$4, "utf-8"))]);
+				pending.push([classified.key, require_pipeline.contentHash(changes.sources?.get(path$30) ?? (0, fs.readFileSync)(path$30, "utf-8"))]);
 			} catch {}
 		}
 		return pending;
@@ -1367,28 +2210,28 @@ var ExtractionSession = class {
 		if (!identity) return changes;
 		if (!changes.modifiedFiles && !changes.removedFiles) return changes;
 		if (this.externalWatchRoots.length === 0) return changes;
-		const { extensionsSet } = this.resolveScanConfig();
+		const { extensionsSet } = this.scanConfig;
 		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);
+		const rootHitFor = (path$31) => {
+			const containing = identity.containingExternalRoot(path$31);
 			if (!containing) return null;
 			try {
-				return (0, fs.statSync)(path$5).isDirectory() ? containing : null;
+				return (0, fs.statSync)(path$31).isDirectory() ? containing : null;
 			} catch {
-				return identity.resolveDeletedSourceId(path$5) ? null : containing;
+				return identity.resolveDeletedSourceId(path$31) ? null : containing;
 			}
 		};
-		for (const path$6 of changes.modifiedFiles ?? []) {
-			const root = rootHitFor(path$6);
+		for (const path$32 of changes.modifiedFiles ?? []) {
+			const root = rootHitFor(path$32);
 			if (root) dirtyRoots.add(root);
-			else modified.add(path$6);
+			else modified.add(path$32);
 		}
-		for (const path$7 of changes.removedFiles ?? []) {
-			const root = rootHitFor(path$7);
+		for (const path$33 of changes.removedFiles ?? []) {
+			const root = rootHitFor(path$33);
 			if (root) dirtyRoots.add(root);
-			else removed.add(path$7);
+			else removed.add(path$33);
 		}
 		for (const root of dirtyRoots) {
 			const previous = this.externalInventory.get(root) ?? /* @__PURE__ */ new Map();
@@ -1405,13 +2248,14 @@ var ExtractionSession = class {
 				} catch {
 					continue;
 				}
-				if (previous.get(resolved.sourceKey)?.hash !== rawHash) modified.add(abs);
+				if (previous.get(resolved.sourceKey)?.hash !== rawHash || this.ingestionFailureDiagnostics.some((diagnostic) => diagnostic.file === resolved.sourceKey)) modified.add(abs);
 			}
 			for (const [key, entry] of previous) if (!seen.has(key)) removed.add(entry.abs);
 		}
 		return {
 			modifiedFiles: modified,
-			removedFiles: removed
+			removedFiles: removed,
+			sources: changes.sources
 		};
 	}
 	/** Route one watcher path: a project-root member (consumer excludes apply)
@@ -1478,33 +2322,40 @@ var ExtractionSession = class {
 			packageMap,
 			system,
 			emitter: {
-				runtimeImport: "@animus-ui/system/runtime",
-				cssModuleId: ANIMUS_CSS_MODULE_ID,
-				systemPropsModuleId: this.systemPropsModuleId ?? systemPropsPath(this.sessionDir)
+				runtimeImport: this.runtimeImport,
+				cssModuleId: this.delivery.cssModuleId,
+				systemPropsModuleId: this.delivery.systemPropsModuleId === SESSION_ARTIFACT ? systemPropsPath(this.sessionDir) : this.delivery.systemPropsModuleId
 			},
 			pathAliasesJson: this.pathAliasesJson,
 			staticCssJson: this.staticCssJson,
 			externalDirs: this.externalPackageDirs.map((dir) => (0, path.relative)(this.rootDir, dir)),
+			rootDir: this.rootDir,
+			assets: this.assetClassification,
+			adapted: this.ingestionAdapted,
+			loadExpander: this.loadExpander,
 			devMode: this.engineDevMode(devMode),
 			analysisContext: {
 				skippedSources: [...this.skippedSources, ...this.ingestionFailureDiagnostics.map((d) => d.file)].map((file) => (0, path.isAbsolute)(file) ? (0, path.relative)(this.rootDir, file) : file),
 				unbundledComputedImports: this.host.unbundledComputedImports,
+				openings: [...this.ingestionOpenings],
 				packageDirs: this.externalPackageDirs.map((dir) => (0, path.relative)(this.rootDir, dir)),
 				linkedDirs: this.externalLinkedDirs.map((dir) => (0, path.relative)(this.rootDir, dir)),
-				outputDirs: this.externalOutputDirs.map((dir) => (0, path.relative)(this.rootDir, dir))
+				outputDirs: this.externalOutputDirs.map((dir) => (0, path.relative)(this.rootDir, dir)),
+				extensions: this.extensionPolicy
 			}
 		};
 		this.writeAnalysisStatus("analyzing", pending);
-		const result = require_pipeline.runProjectAnalysis(engineApi, {
+		const result = require_pipeline.runProjectAnalysis(() => this.engine(), {
 			...analysisOptions,
 			warn: (message) => this.warn(message),
 			info: (message) => this.log(message),
 			strict: this.options.strict,
 			diagnostics: this.options.diagnostics,
 			reportErrors: this.reportErrors(),
-			extraDiagnostics: this.ingestionFailureDiagnostics,
+			extraDiagnostics: [...this.ingestionFailureDiagnostics, ...await this.compareAliasesWithHost(fileEntries)],
 			kitDescriptors: this.kitDescriptors
 		});
+		if (result.manifest) require_pipeline.assertRuntimeImportSuppliesTerminals(this.runtimeImport, result.manifest);
 		require_pipeline.enforceExternalTokenContracts({
 			diagnostics: result.manifest?.diagnostics,
 			fileOwners: this.externalFileOwners,
@@ -1539,12 +2390,12 @@ var ExtractionSession = class {
 			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",
+				minify: this.options.minify ?? this.startupMode === "production",
 				targets: this.lcssTargets,
 				warnFn: (msg) => this.warn(msg)
 			})
 		].filter(Boolean).join("\n");
-		require_pipeline.reportSurvivingAssetPlaceholders(fullCss, {
+		if (!this.hostSubstitutesAssets) require_pipeline.reportSurvivingAssetPlaceholders(fullCss, {
 			strict: this.options.strict,
 			warn: (message) => this.warn(message),
 			reportErrors: this.reportErrors(),
@@ -1557,7 +2408,6 @@ var ExtractionSession = class {
 			prefix: `[${this.driverLabel}]`,
 			surface: "generated runtime modules"
 		});
-		setSharedCss(fullCss);
 		const systemPropsContent = require_pipeline.buildSystemPropsModule({
 			systemPropMapJson: JSON.stringify(manifest?.system_prop_map ?? {}),
 			groupRegistryJson: system.groupRegistryJson,
@@ -1565,9 +2415,6 @@ var ExtractionSession = class {
 			admittedTransforms: manifest?.admitted_transforms ?? {},
 			typedSystemProps: manifest?.typed_system_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();
@@ -1587,6 +2434,19 @@ var ExtractionSession = class {
 		} else this.writeSessionArtifact(SYSTEM_PROPS_ARTIFACT, systemPropsContent);
 		this.publishAnalysisCommit(epoch, generation);
 		this.publishReplacementEpoch(epoch);
+		this.stagedPublication = {
+			manifest,
+			manifestJson: result.manifestJson,
+			analysisGlobalCss: sheets.globalCss,
+			analysisComponentCss: sheets.componentCss,
+			styles: fullCss,
+			systemPropsModule: systemPropsContent,
+			system,
+			packageMap,
+			analyzedHashes: new Map(fileEntries.map((entry) => [entry.path, entry.hash])),
+			packageReadRecord: this.packageReadRecord,
+			replacementEpoch: epoch
+		};
 		bt.total = this.elapsed(pipelineStart);
 		logBuildTimings(bt, manifest?.timing, (msg) => this.log(msg), this.verbose);
 	}
@@ -1600,6 +2460,86 @@ var ExtractionSession = class {
 	}
 	/** Write the session's analysis-status artifact. Terminal states
 	*  (idle/failed) close the attempt. */
+	/** Where the host resolves a path alias the analysis reads to another
+	*  file (spec §2.2 A7, report only), and how the two were compared. */
+	async compareAliasesWithHost(fileEntries) {
+		const record = require_pipeline.packageReadRecord({
+			rootDir: this.rootDir,
+			roots: this.packageInstances,
+			redirected: new Set(this.externalSourceEntries.keys()),
+			analysed: fileEntries.map((entry) => entry.path),
+			rendersBuilder: (file) => this.rendersBuilder(file)
+		});
+		this.packageReadRecord = record;
+		const { moduleSpecifiers } = this.engine();
+		if (this.host.noBundler) return [];
+		if (this.hostResolve === null || moduleSpecifiers === void 0) {
+			this.log("path aliases: no host resolver, comparison unavailable");
+			return [];
+		}
+		try {
+			const { findings, unavailable } = await require_pipeline.compareAliases({
+				rootDir: this.rootDir,
+				fileEntries,
+				pathAliasesJson: this.pathAliasesJson,
+				order: this.extensionPolicy,
+				readings: {
+					isAsset: this.assetClassification.isAsset,
+					adapted: this.ingestionAdapted
+				},
+				moduleSpecifiers,
+				resolve: this.hostResolve,
+				cache: this.aliasCache,
+				packages: record
+			});
+			for (const finding of findings) record.reported.add(`${finding.file}\0${finding.component}`);
+			if (unavailable > 0) this.log(`path aliases: ${unavailable} aliased import(s) the host's resolver failed on are unavailable, not agreeing`);
+			return findings;
+		} catch (error) {
+			this.log(`path aliases: comparison unavailable (${String(error)})`);
+			return [];
+		}
+	}
+	/** Whether the file at a real path declares builder chains, by the
+	*  engine's own parse: a module that does, served unread, renders with
+	*  empty classes. One the engine cannot read counts as one that does. */
+	rendersBuilder(file) {
+		if (!require_pipeline.isEngineTransformExtension(file)) return false;
+		const { extractFacts } = this.engine();
+		if (extractFacts === void 0) return true;
+		const path$34 = (0, path.relative)(this.rootDir, file);
+		try {
+			const facts = require_pipeline.parseInternalWire(extractFacts(JSON.stringify([{
+				path: path$34,
+				source: (0, fs.readFileSync)(file, "utf-8")
+			}])), "extractFacts").files[path$34];
+			return facts === void 0 || facts.parsePanicked || facts.chains.length > 0;
+		} catch {
+			return true;
+		}
+	}
+	/**
+	* An import the host resolved while bundling (spec §2.2 A4), reported as
+	* the comparison reports it: webpack resolves each module's requests with
+	* the resolve options of the rules that module matches, which its
+	* resolver, asked outside a compilation, does not apply. `importer` and
+	* `resolved` are absolute. A finding the comparison already reported is
+	* not repeated; an error-level one throws in a build.
+	*/
+	reportHostResolution(importer, request, resolved) {
+		const record = getSharedPackageReadRecord(this.key);
+		if (record === null) return;
+		const finding = require_pipeline.packageInstanceFinding(record, (0, path.relative)(record.rootDir, importer).split(path.sep).join(path.posix.sep), request, resolved);
+		if (finding === null) return;
+		const key = `${finding.file}\0${finding.component}`;
+		if (record.reported.has(key)) return;
+		record.reported.add(key);
+		require_pipeline.surfaceManifestDiagnostics({ diagnostics: [finding] }, (message) => this.warn(message), {
+			levels: this.options.diagnostics,
+			strict: this.options.strict,
+			reportErrors: this.reportErrors()
+		});
+	}
 	writeAnalysisStatus(state, pending, diagnostic) {
 		const status = {
 			schema: 2,
@@ -1709,6 +2649,10 @@ var ExtractionSession = class {
 	/** Maintain the session's epoch witness, rewritten ONLY when the value
 	*  changes, then expose it through the singleton. */
 	publishReplacementEpoch(epoch) {
+		if (!this.persistArtifacts) {
+			this.lastEpochValue = epoch;
+			return;
+		}
 		const onDisk = this.diskEpochValue();
 		if (this.lastEpochValue === null) this.lastEpochValue = onDisk;
 		if (epoch !== onDisk) this.writeSessionArtifact(REPLACEMENT_EPOCH_ARTIFACT, JSON.stringify({
@@ -1720,7 +2664,6 @@ var ExtractionSession = class {
 			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. */
@@ -1765,10 +2708,14 @@ var ExtractionSession = class {
 		}
 	}
 	/** 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. */
+	*  A tree whose build is registered in this process is ours and live,
+	*  claim or no claim: a publisher's close() releases the claim while the
+	*  build's other participants still serve from it. Otherwise a missing,
+	*  undecodable or unreadable claim, or one naming our own pid, means no
+	*  owner: the opposite default from the CLI lock check on purpose, so do
+	*  not unify the two. */
 	liveSiblingOwnerPid(siblingDir) {
+		if (findSession(sessionKey((0, path.basename)(siblingDir), this.rootDir)) !== void 0) return process.pid;
 		let claim;
 		try {
 			claim = readCliLockRecord(siblingDir);
@@ -1799,7 +2746,7 @@ var ExtractionSession = class {
 	/** Delete legacy flat artifacts and prune sibling session directories past
 	*  the retention window — never this session's own dir. */
 	runSessionStartHygiene() {
-		if (this.sessionStartHygieneDone) return;
+		if (this.sessionStartHygieneDone || !this.persistArtifacts) return;
 		this.sessionStartHygieneDone = true;
 		const animusDir = (0, path.join)(this.rootDir, ANIMUS_ARTIFACT_DIR);
 		const isCliPublishedSet = this.cliWriterHoldsLock(animusDir) || verifyCommitRecord(animusDir).length === 0;
@@ -1840,13 +2787,29 @@ var ExtractionSession = class {
 	/** 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));
+		if (this.persistArtifacts) {
+			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);
 	}
+	/** How an asset's bytes are fingerprinted, of a file or of bytes read:
+	*  the engine's fast fingerprint where it has both, the content hash
+	*  otherwise, so the two always agree. */
+	assetFingerprints() {
+		const { fingerprintFile, fingerprintBytes } = this.engine();
+		if (fingerprintFile && fingerprintBytes) return {
+			ofFile: (path$35) => fingerprintFile(path$35) ?? require_pipeline.contentHash((0, fs.readFileSync)(path$35)),
+			ofBytes: fingerprintBytes
+		};
+		return {
+			ofFile: (path$36) => require_pipeline.contentHash((0, fs.readFileSync)(path$36)),
+			ofBytes: require_pipeline.contentHash
+		};
+	}
 	/** Copy each asset() specifier's bytes, from every sheet, into `assets/`
 	*  under a content-hashed name and substitute a url relative to
 	*  styles.css. */
@@ -1856,12 +2819,12 @@ var ExtractionSession = class {
 		const expected = /* @__PURE__ */ new Set();
 		this.assetDependencyPaths.clear();
 		this.assetDependencyKeys.clear();
+		if (this.hostSubstitutesAssets) return sheets;
 		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) {
+				if (this.assetFingerprints().ofFile(cached.sourcePath) === cached.fingerprint) {
 					this.trackAssetDependency(cached.sourcePath);
 					expected.add(cached.fileName);
 					urlBySpecifier.set(specifier, cached.url);
@@ -1870,37 +2833,32 @@ var ExtractionSession = class {
 			} catch {}
 			const resolvedPath = this.resolveAssetSpecifier(specifier);
 			if (!resolvedPath) {
-				const message = `unresolvable asset() specifier: ${specifier}`;
-				if (this.options.strict) this.strictFailure(`[${this.driverLabel}] ${message}`);
-				else this.warn(message);
+				this.reportUnresolvableAsset(specifier);
 				urlBySpecifier.set(specifier, specifier);
 				continue;
 			}
-			const bytes = (0, fs.readFileSync)(resolvedPath);
-			const sourceStat = (0, fs.statSync)(resolvedPath);
+			const { fileName, bytes } = require_pipeline.writeAssetCopy(resolvedPath, assetsDir);
 			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,
+				fingerprint: this.assetFingerprints().ofBytes(bytes),
 				fileName,
 				url
 			});
 		}
-		if (pruneSuperseded) pruneStaleAssets(assetsDir, expected);
+		if (pruneSuperseded) require_pipeline.pruneStaleAssets(assetsDir, expected);
 		return require_pipeline.substituteSheetAssets(sheets, urlBySpecifier);
 	}
-	trackAssetDependency(path$8) {
-		this.assetDependencyPaths.add(path$8);
-		for (const key of require_pipeline.toWatchKeys(path$8)) this.assetDependencyKeys.add(key);
+	reportUnresolvableAsset(specifier) {
+		const message = `unresolvable asset() specifier: ${specifier}`;
+		this.strictOrWarn(message, `[${this.driverLabel}] ${message}`);
+	}
+	trackAssetDependency(path$37) {
+		this.assetDependencyPaths.add(path$37);
+		for (const key of require_pipeline.toWatchKeys(path$37)) this.assetDependencyKeys.add(key);
 	}
 	/** Resolve an asset specifier through the shared resolver, with one
 	*  last resort: a discovered source entry's package root. */
@@ -1919,30 +2877,17 @@ var ExtractionSession = class {
 		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.delivery = {
+		...session.delivery,
+		systemPropsModuleId: TURBOPACK_SYSTEM_PROPS_ID
+	};
 	session.persistAnalysisInputs = true;
 	await session.runFullPipeline();
 }
+/** Each build's watched root: another build of the root watches it too. */
 const activeWatcherRoots = /* @__PURE__ */ new Set();
 const IGNORED_SEGMENTS = /* @__PURE__ */ new Set([
 	ANIMUS_ARTIFACT_DIR,
@@ -1969,17 +2914,18 @@ function isIntrinsicString(value) {
 }
 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);
+	const watched = JSON.stringify([session.sessionId, rootDir]);
+	if (activeWatcherRoots.has(watched)) return { kind: "already-watched" };
+	activeWatcherRoots.add(watched);
 	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();
+	const dependencyWatchers = /* @__PURE__ */ new Map();
 	let pendingOpened = /* @__PURE__ */ new Map();
 	let capturedDuringSnapshot = [];
 	const externalDiagnosticKey = (root) => `external-watch:${root}`;
@@ -1998,24 +2944,28 @@ function startTurbopackWatcher(session, rootDir, options = {}) {
 		session.stickyDiagnostics?.set(externalDiagnosticKey(root), message);
 		console.warn(`[animus-extract] ${message}`);
 	};
+	let cyclesInFlight = 0;
 	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();
-			});
+		if (closed) return;
+		cyclesInFlight++;
+		const cycle = session.handleWatchUpdate({
+			modifiedFiles,
+			removedFiles
+		}).catch((err) => {
+			console.warn(`[animus-extract] watch update failed: ${String(err)}`);
+		}).finally(() => {
+			cyclesInFlight--;
+			if (cyclesInFlight > 0) return;
+			if (pendingOpened.size > 0 || capturedDuringSnapshot.length > 0) rollbackPendingExternal();
+			syncDependencyWatchers();
 		});
+		updateChain = updateChain.then(() => cycle);
 	};
+	const coalescing = new CoalescingWindow(flush, debounceMs);
 	const rollbackPendingExternal = () => {
 		for (const watcher of pendingOpened.values()) watcher.close();
 		pendingOpened = /* @__PURE__ */ new Map();
@@ -2024,16 +2974,17 @@ function startTurbopackWatcher(session, rootDir, options = {}) {
 	const closeAll = () => {
 		if (closed) return;
 		closed = true;
-		if (timer) clearTimeout(timer);
-		timer = null;
+		coalescing.cancel();
 		for (const watcher of watchers.values()) watcher.close();
 		watchers.clear();
+		for (const { watcher } of dependencyWatchers.values()) watcher.close();
+		dependencyWatchers.clear();
 		for (const watcher of externalWatchers.values()) watcher.close();
 		externalWatchers.clear();
 		rollbackPendingExternal();
 		session.onExternalRootResolved = null;
 		session.onExternalRootsCommitted = null;
-		activeWatcherRoots.delete(rootDir);
+		activeWatcherRoots.delete(watched);
 	};
 	const onWatcherError = (err) => {
 		died = true;
@@ -2049,10 +3000,7 @@ function startTurbopackWatcher(session, rootDir, options = {}) {
 		} catch (err) {
 			console.warn(`[animus-extract] Turbopack debounce status update failed: ${String(err)}`);
 		}
-		if (!timer) {
-			timer = setTimeout(flush, debounceMs);
-			timer.unref?.();
-		}
+		coalescing.note();
 	};
 	const onEvent = (baseDir, filename) => {
 		if (closed || !filename) return;
@@ -2096,6 +3044,57 @@ function startTurbopackWatcher(session, rootDir, options = {}) {
 			degradeExternalRoot(root, err);
 		}
 	};
+	/** Whether the root or an external root watcher already reports `path`. */
+	const watchedByRoot = (path$2) => {
+		if (require_pipeline.isPathWithinRoot(rootDir, path$2) && !(0, path.relative)(rootDir, path$2).split(/[\\/]/).some((segment) => IGNORED_SEGMENTS.has(segment))) return true;
+		return [...externalWatchers.keys()].some((root) => require_pipeline.isPathWithinRoot(root, path$2));
+	};
+	/** Watches the Session's plan (its files, and the absent paths whose
+	*  creation reloads the system) where no root watcher reports them, by
+	*  their directories, for those paths only. */
+	const syncDependencyWatchers = () => {
+		if (closed) return;
+		const wanted = /* @__PURE__ */ new Map();
+		const plan = session.watchPlan();
+		for (const path$3 of [...plan.files, ...plan.missing]) {
+			if (watchedByRoot(path$3)) continue;
+			const files = wanted.get((0, path.dirname)(path$3)) ?? /* @__PURE__ */ new Set();
+			files.add(path$3);
+			wanted.set((0, path.dirname)(path$3), files);
+		}
+		for (const [dir, { watcher }] of [...dependencyWatchers]) {
+			if (wanted.has(dir)) continue;
+			watcher.close();
+			dependencyWatchers.delete(dir);
+		}
+		for (const [dir, files] of wanted) {
+			const existing = dependencyWatchers.get(dir);
+			if (existing) {
+				existing.files = files;
+				continue;
+			}
+			try {
+				const watcher = watchFn(dir, { recursive: false }, (_event, name) => {
+					if (closed || !name) return;
+					const abs = (0, path.join)(dir, name.toString());
+					if (dependencyWatchers.get(dir)?.files.has(abs)) enqueuePath(abs);
+				});
+				watcher.on("error", (err) => {
+					watcher.close();
+					dependencyWatchers.delete(dir);
+					console.warn(`[animus-extract] dependency watch on ${dir} failed (${String(err)}); its changes require a dev-server restart`);
+				});
+				watcher.unref?.();
+				dependencyWatchers.set(dir, {
+					watcher,
+					files
+				});
+			} catch (err) {
+				if (errnoCode(err) === "ENOENT") continue;
+				console.warn(`[animus-extract] dependency watch on ${dir} unavailable (${String(err)}); its changes require a dev-server restart`);
+			}
+		}
+	};
 	const addWatcher = (dir, recursive) => {
 		const watcher = watchFn(dir, { recursive }, (_event, filename) => onEvent(dir, filename));
 		watcher.on("error", onWatcherError);
@@ -2114,6 +3113,7 @@ function startTurbopackWatcher(session, rootDir, options = {}) {
 		return { kind: "unavailable" };
 	}
 	for (const root of session.externalWatchRoots ?? []) openExternalWatcher(root, externalWatchers);
+	syncDependencyWatchers();
 	session.onExternalRootResolved = (root) => {
 		if (closed) return;
 		if (externalWatchers.has(root) || pendingOpened.has(root)) return;
@@ -2138,7 +3138,8 @@ function startTurbopackWatcher(session, rootDir, options = {}) {
 		onDied: null,
 		deliverHeldEvents: () => {
 			holdingEvents = false;
-			if (pendingPaths.size > 0) flush();
+			syncDependencyWatchers();
+			if (pendingPaths.size > 0) coalescing.flush();
 			return updateChain;
 		},
 		settle: () => updateChain
@@ -2155,19 +3156,29 @@ 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.COALESCING_WINDOW_MS = COALESCING_WINDOW_MS;
+exports.CoalescingWindow = CoalescingWindow;
+exports.EnvironmentBuilds = EnvironmentBuilds;
+exports.EnvironmentFailure = EnvironmentFailure;
 exports.ExtractionSession = ExtractionSession;
 exports.MANIFEST_ARTIFACT = MANIFEST_ARTIFACT;
+exports.SESSION_ARTIFACT = SESSION_ARTIFACT;
 exports.SESSION_ASSETS_DIR = SESSION_ASSETS_DIR;
 exports.STYLES_ARTIFACT = STYLES_ARTIFACT;
 exports.SYSTEM_PROPS_ARTIFACT = SYSTEM_PROPS_ARTIFACT;
+exports.SessionConfigurationConflict = SessionConfigurationConflict;
 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.createBuildId = createBuildId;
 exports.decodeCommitRecord = decodeCommitRecord;
 exports.engineApi = engineApi;
+exports.engineFactory = engineFactory;
+exports.engineHandle = engineHandle;
+exports.findSession = findSession;
 exports.getAnalysisStartedPromise = getAnalysisStartedPromise;
 exports.getAnalyzedHashes = getAnalyzedHashes;
 exports.getManifestJson = getManifestJson;
@@ -2180,17 +3191,20 @@ exports.getSharedExternalSideEffects = getSharedExternalSideEffects;
 exports.getSharedSystemProps = getSharedSystemProps;
 exports.holdDirectoryClaim = holdDirectoryClaim;
 exports.isLockHolderAlive = isLockHolderAlive;
+exports.joinSession = joinSession;
 exports.lockRecordBytes = lockRecordBytes;
 exports.manifestPath = manifestPath;
-exports.pruneStaleAssets = pruneStaleAssets;
+exports.pruneStaleAssets = require_pipeline.pruneStaleAssets;
 exports.readCliLockRecord = readCliLockRecord;
 exports.readJsonEnvelope = readJsonEnvelope;
+exports.releaseEngineHandle = releaseEngineHandle;
 exports.replacementEpochPath = replacementEpochPath;
+exports.requireEngine = requireEngine;
 exports.resetAnalysisStartedPromise = resetAnalysisStartedPromise;
 exports.runSessionPipeline = runSessionPipeline;
 exports.sessionArtifactDir = sessionArtifactDir;
+exports.sessionKey = sessionKey;
 exports.setAnalysisStartedPromise = setAnalysisStartedPromise;
-exports.setSharedEngine = setSharedEngine;
 exports.startTurbopackWatcher = startTurbopackWatcher;
 exports.stylesPath = stylesPath;
 exports.systemPropsPath = systemPropsPath;