@animus-ui/vite-plugin 0.1.24 → 0.1.26

package/dist/index.cjs

@@ -5,45 +5,119 @@ Object.defineProperties(exports, {
 let _animus_ui_extract_pipeline = require("@animus-ui/extract/pipeline");
 let path = require("path");
 let fs = require("fs");
+let _animus_ui_extract_session = require("@animus-ui/extract/session");
+let child_process = require("child_process");
+let vite = require("vite");
 let crypto = require("crypto");
+//#region src/asset-copy-dirs.ts
+/**
+* Each process's dev asset copies live in their own directory, named by its
+* pid and start time, so a sweep can tell an abandoned directory from a
+* live server's even when the pid has been reused.
+*/
+/** A directory left this long is swept unless its owner proves live. */
+const ABANDONED_AFTER_MS = 864e5;
+/** `ps` reports start times to the second. */
+const START_TIME_TOLERANCE_MS = 2e3;
+const processStartMs = Math.round(Date.now() - process.uptime() * 1e3);
+/** This process's copy directory name: `<pid>-<start ms>`. */
+function processCopyDir() {
+	return `${process.pid}-${processStartMs}`;
+}
+/** When `pid` started, as `ps` reports it: null where `ps` ran and could
+*  not say, `'unavailable'` where there is no `ps` (Windows). */
+function startTimeOf(pid) {
+	if (process.platform === "win32") return "unavailable";
+	try {
+		const started = Date.parse((0, child_process.execFileSync)("ps", [
+			"-o",
+			"lstart=",
+			"-p",
+			String(pid)
+		], {
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim());
+		return Number.isNaN(started) ? null : started;
+	} catch (error) {
+		if (error?.code === "ENOENT") return "unavailable";
+		return null;
+	}
+}
+/** Whether the process that named `entry` is still running. A young
+*  directory needs only a live pid; one past ABANDONED_AFTER_MS needs its
+*  recorded start time to match the running process too. */
+function ownerLive(copyRoot, entry) {
+	const match = /^(\d+)-(\d+)$/.exec(entry);
+	if (match === null) return false;
+	const pid = Number(match[1]);
+	const startMs = Number(match[2]);
+	if (!(0, _animus_ui_extract_session.isLockHolderAlive)(pid)) return false;
+	let ageMs;
+	try {
+		ageMs = Date.now() - (0, fs.statSync)((0, path.join)(copyRoot, entry)).mtimeMs;
+	} catch {
+		return false;
+	}
+	if (ageMs < ABANDONED_AFTER_MS) return true;
+	const started = startTimeOf(pid);
+	if (started === "unavailable") return true;
+	return started !== null && Math.abs(started - startMs) <= START_TIME_TOLERANCE_MS;
+}
+/** The copy roots this process has swept: once per process. */
+const sweptCopyRoots = /* @__PURE__ */ new Set();
+/** Removes every other process's copy directory whose owner is not live. */
+function sweepAbandonedCopyDirs(copyRoot) {
+	if (sweptCopyRoots.has(copyRoot)) return;
+	sweptCopyRoots.add(copyRoot);
+	let entries;
+	try {
+		entries = (0, fs.readdirSync)(copyRoot);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (entry === processCopyDir() || ownerLive(copyRoot, entry)) continue;
+		(0, fs.rmSync)((0, path.join)(copyRoot, entry), {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
 //#region src/build-start.ts
 /**
 * `resolveSpecifier` maps a specifier to an absolute id. `emitAsset` is
 * present in build only, where `asset()` files become Rollup assets.
 */
 async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
-	(0, _animus_ui_extract_pipeline.clearEngineCache)(ctx.engineApi);
 	ctx.assetPassComplete = false;
 	ctx.assetUrlBySpecifier.clear();
 	ctx.assetResolutionFailures.clear();
-	let t0 = performance.now();
-	ctx.loadSystem();
+	const t0 = performance.now();
 	if (ctx.options.layers) {
 		(0, _animus_ui_extract_pipeline.validateLayerOrder)(ctx.options.layers);
 		ctx.log(`Custom layers: [${ctx.options.layers.join(", ")}]`);
 	}
+	const session = ctx.session ?? ctx.createSession();
+	ctx.excludeMatcher = session.scanConfig.excludeMatcher;
+	ctx.extensionsSet = session.scanConfig.extensionsSet;
+	session.reattach();
+	session.hostResolve = resolveSpecifier;
+	if (ctx.isProd) await session.runFullPipeline();
+	else await ctx.runAttempt((started) => started.runFullPipeline());
 	if (ctx.verbose) {
 		const propCount = Object.keys(JSON.parse(ctx.system.propConfigJson)).length;
 		const groupCount = Object.keys(JSON.parse(ctx.system.groupRegistryJson)).length;
 		ctx.log(`System loaded: ${propCount} props, ${groupCount} groups (${Math.round(performance.now() - t0)}ms)`);
 	}
-	const discovered = await discoverSources(ctx, resolveSpecifier);
-	if (!ctx.isProd) ctx.rediscoverSources = async () => {
-		const rediscovered = await discoverSources(ctx, resolveSpecifier);
-		return {
-			...rediscovered,
-			rawEntries: rediscovered.rawEntries.map((entry) => {
-				const cached = ctx.fileCache.get(entry.path);
-				return cached ? {
-					path: entry.path,
-					...cached
-				} : entry;
-			})
-		};
-	};
-	t0 = performance.now();
-	await ctx.analyzeIngested(discovered);
 	const assetSpecifiers = ctx.sheetAssetSpecifiers();
+	ctx.assetSourceBySpecifier.clear();
+	if (ctx.assetCopyDir !== null) sweepAbandonedCopyDirs((0, path.dirname)(ctx.assetCopyDir));
 	for (const specifier of assetSpecifiers) {
 		const resolvedPath = await resolveSpecifier(specifier);
 		if (!resolvedPath) {
@@ -56,9 +130,12 @@ async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 		} catch (err) {
 			ctx.assetFallback(specifier, `[animus-extract] failed to emit asset() specifier ${specifier}: ${String(err)}`, err);
 		}
-		else ctx.assetUrlBySpecifier.set(specifier, ctx.devFsUrl(resolvedPath));
+		else try {
+			ctx.assetUrlBySpecifier.set(specifier, ctx.devAssetUrl(specifier, resolvedPath));
+		} catch (err) {
+			ctx.assetFallback(specifier, `[animus-extract] failed to copy asset() specifier ${specifier}: ${String(err)}`, err);
+		}
 	}
-	ctx.substituteSheets();
 	ctx.assetPassComplete = true;
 	if (ctx.storedManifest) {
 		const report = ctx.storedManifest.report;
@@ -69,7 +146,7 @@ async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 		else if (d.kind === "variant") ctx.trace(`${d.component} variant '${d.name}' pruned: ${d.reason}`);
 		else if (d.kind === "state") ctx.trace(`${d.component} state '${d.name}' pruned: ${d.reason}`);
 		ctx.log(`CSS: ${ctx.resolvedComponentCss.length} bytes (${Object.keys(ctx.storedManifest.components).length} components)`);
-		if (!ctx.isProd && ctx.storedSheets) {
+		if (!ctx.isProd) {
 			const staticSize = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
 				layers: ctx.options.layers,
 				variableCss: ctx.variableCss,
@@ -88,88 +165,6 @@ async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 	ctx.layerDeclaration = declaration;
 	if (ctx.options.verify) ctx.runSelfVerify();
 }
-/** Local and external discovery, publishing the package state on `ctx`, and
-*  the analysis input it yields. */
-async function discoverSources(ctx, resolveSpecifier) {
-	const t0 = performance.now();
-	ctx.excludeMatcher = (0, _animus_ui_extract_pipeline.createExcludeMatcher)(ctx.options.exclude);
-	const excludePatterns = ctx.excludeMatcher;
-	ctx.extensionsSet = new Set(ctx.options.extensions ?? _animus_ui_extract_pipeline.DEFAULT_EXTENSIONS);
-	const filePaths = (0, _animus_ui_extract_pipeline.discoverFiles)(ctx.rootDir, ctx.rootDir, excludePatterns, ctx.extensionsSet);
-	const rawEntries = [];
-	const ingestionFailures = [];
-	for (const filePath of filePaths) {
-		const relPath = (0, path.relative)(ctx.rootDir, filePath);
-		let source;
-		try {
-			source = (0, fs.readFileSync)(filePath, "utf-8");
-		} catch (err) {
-			if (!(0, _animus_ui_extract_pipeline.isDeletedSource)(err)) ingestionFailures.push((0, _animus_ui_extract_pipeline.unreadableSourceDiagnostic)(relPath, err));
-			continue;
-		}
-		const hash = !ctx.isProd ? (0, _animus_ui_extract_pipeline.contentHash)(source) : void 0;
-		rawEntries.push({
-			path: relPath,
-			source,
-			hash
-		});
-	}
-	const localFileCount = rawEntries.length;
-	const discoveryDiagnostics = [];
-	const packageSpecifiers = await (0, _animus_ui_extract_pipeline.extractSystemFilePackages)(ctx.resolvedSystemPath, (0, _animus_ui_extract_pipeline.engineModuleParser)(ctx.engineApi()), (diagnostic) => discoveryDiagnostics.push(diagnostic), resolveSpecifier);
-	discoveryDiagnostics.push(...(0, _animus_ui_extract_pipeline.importedKitDiagnostics)(rawEntries, ctx.engineApi(), ctx.rootDir, packageSpecifiers));
-	ctx.externalSourceEntries.clear();
-	const collected = await (0, _animus_ui_extract_pipeline.collectExternalPackageSources)({
-		specifiers: packageSpecifiers,
-		resolveSpecifier,
-		rootDir: ctx.rootDir,
-		extensionsSet: ctx.extensionsSet,
-		hasEntry: (relPath) => rawEntries.some((entry) => entry.path === relPath),
-		onUnreadable: (relPath, err) => {
-			if (!(0, _animus_ui_extract_pipeline.isDeletedSource)(err)) ingestionFailures.push((0, _animus_ui_extract_pipeline.unreadableSourceDiagnostic)(relPath, err));
-		}
-	});
-	ctx.ingestionFailureDiagnostics = ingestionFailures;
-	(0, _animus_ui_extract_pipeline.surfaceManifestDiagnostics)({ diagnostics: [...discoveryDiagnostics, ...collected.diagnostics] }, (message) => ctx.warn(message), {
-		levels: ctx.options.diagnostics,
-		strict: ctx.options.strict,
-		reportErrors: ctx.reportErrors()
-	});
-	ctx.packageMap = collected.packageMap;
-	ctx.externalPackageOutcomes = collected.outcomes;
-	ctx.kitDescriptors = collected.kitDescriptors;
-	ctx.externalDirOwners = (0, _animus_ui_extract_pipeline.firstOwners)(collected.dirOwnerSets);
-	ctx.externalFileOwners = collected.fileOwners;
-	ctx.enforceIncludeResolution();
-	for (const [specifier, srcEntry] of collected.sourceEntries) ctx.externalSourceEntries.set(specifier, srcEntry);
-	ctx.externalSourceSideEffects = collected.sourceEntrySideEffects;
-	for (const entry of collected.entries) {
-		const hash = !ctx.isProd ? (0, _animus_ui_extract_pipeline.contentHash)(entry.source) : void 0;
-		rawEntries.push({
-			path: entry.path,
-			source: entry.source,
-			hash
-		});
-	}
-	ctx.externalPackageDirs = collected.packageDirs;
-	ctx.externalLinkedDirs = collected.linkedDirs;
-	ctx.externalOutputDirs = collected.outputDirs;
-	ctx.registerSystemWatchPaths();
-	const packageFileCount = rawEntries.length - localFileCount;
-	ctx.log(`Discovered ${rawEntries.length} files (${packageFileCount} from packages) (${Math.round(performance.now() - t0)}ms)`);
-	return {
-		rawEntries,
-		afterIngestion: (accepted) => {
-			if (!ctx.isProd) ctx.mutateFileCache((cache) => {
-				cache.clear();
-				for (const entry of accepted.originalEntries) cache.set(entry.path, {
-					hash: entry.hash,
-					source: entry.source
-				});
-			});
-		}
-	};
-}
 //#endregion
 //#region src/config.ts
 function applyResolvedConfig(ctx, config) {
@@ -177,7 +172,19 @@ function applyResolvedConfig(ctx, config) {
 	ctx.development = !ctx.isProd || Boolean(config.build.watch);
 	ctx.emissionProd = (0, _animus_ui_extract_pipeline.resolveMode)(ctx.options.mode, () => config.command === "build" ? "production" : "development").mode === "production";
 	ctx.rootDir = config.root;
+	if (!ctx.isProd) {
+		const copyDir = (0, path.resolve)(config.cacheDir, "animus-assets", processCopyDir());
+		const served = (0, vite.isFileLoadingAllowed)(config, (0, path.join)(copyDir, "asset"));
+		ctx.assetCopyDir = served ? copyDir : null;
+		ctx.servesFile = (path$8) => (0, vite.isFileLoadingAllowed)(config, path$8);
+		if (!served) ctx.warn(`[animus-extract] asset() copies in ${copyDir} are not served under server.fs; serving the live files instead, so an edited asset keeps its URL`);
+	}
+	ctx.outputExcludes = (0, _animus_ui_extract_pipeline.outputExclusions)(config.root, (0, _animus_ui_extract_pipeline.viteOutputTargets)(config));
 	ctx.resolveConditions = config.resolve.conditions.map((condition) => condition === "development|production" ? config.isProduction ? "production" : "development" : condition);
+	ctx.extensionPolicy = (0, _animus_ui_extract_pipeline.viteExtensionPolicy)(config.resolve.extensions);
+	ctx.assetClassification = (0, _animus_ui_extract_pipeline.viteAssetClassification)(config.assetsInclude);
+	ctx.loadExpander = (0, _animus_ui_extract_pipeline.viteHostExpander)(config);
+	ctx.log(`extension order: ${ctx.extensionPolicy.resolverVersion}`);
 	ctx.logger = config.logger;
 	ctx.base = config.base ?? "/";
 	ctx.lcssTargets = (0, _animus_ui_extract_pipeline.resolveLightningTargets)(ctx.options.targets, ctx.rootDir);
@@ -196,6 +203,7 @@ function applyResolvedConfig(ctx, config) {
 		ctx.pathAliasesJson = built.json;
 		ctx.log(`Path aliases forwarded: ${built.count} entries`);
 	}
+	ctx.createSession();
 }
 //#endregion
 //#region src/constants.ts
@@ -277,80 +285,6 @@ function eventKey(file, timestamp) {
 	return `${file}\u0000${timestamp}`;
 }
 //#endregion
-//#region src/module-invalidation.ts
-/**
-* Completeness is load-bearing: the file-plan diff and the sources re-delivered
-* when a held publication ends are the only invalidation candidate sources, so
-* a node shape missed here stays stale for the session.
-*/
-function invalidateFileModules(ctx, relPaths) {
-	const server = ctx.devServer;
-	if (!server || relPaths.length === 0) return 0;
-	const graphs = server.environments ? Object.values(server.environments).map((env) => env?.moduleGraph).filter(Boolean) : [server.moduleGraph].filter(Boolean);
-	let total = 0;
-	for (const relPath of relPaths) {
-		const absPath = (0, path.resolve)(ctx.rootDir, relPath);
-		let fileCount = 0;
-		for (const graph of graphs) {
-			const nodes = /* @__PURE__ */ new Set();
-			const byFile = graph.getModulesByFile?.(absPath);
-			if (byFile) for (const mod of byFile) nodes.add(mod);
-			const byId = graph.getModuleById?.(absPath);
-			if (byId) nodes.add(byId);
-			for (const mod of nodes) {
-				graph.invalidateModule(mod);
-				fileCount++;
-			}
-		}
-		if (fileCount > 0) ctx.trace(`HMR invalidate: ${relPath} (plan changed, ${fileCount} nodes)`);
-		total += fileCount;
-	}
-	return total;
-}
-//#endregion
-//#region src/reset-coalescer.ts
-var ResetCoalescer = class {
-	run;
-	onError;
-	quietMs;
-	schedule;
-	cancel;
-	timer = null;
-	running = false;
-	dirty = false;
-	constructor(run, onError, quietMs = 60, schedule = (fn, ms) => setTimeout(fn, ms), cancel = (timer) => clearTimeout(timer)) {
-		this.run = run;
-		this.onError = onError;
-		this.quietMs = quietMs;
-		this.schedule = schedule;
-		this.cancel = cancel;
-	}
-	/** Ask for a reset; bursts within the quiescence window collapse. */
-	request() {
-		if (this.running) {
-			this.dirty = true;
-			return;
-		}
-		if (this.timer !== null) this.cancel(this.timer);
-		this.timer = this.schedule(async () => {
-			this.timer = null;
-			this.running = true;
-			try {
-				const result = this.run();
-				if (result instanceof Promise) await result;
-			} catch (err) {
-				this.onError(err);
-			} finally {
-				this.running = false;
-				if (this.dirty) {
-					this.dirty = false;
-					this.request();
-				}
-			}
-		}, this.quietMs);
-	}
-};
-//#endregion
 //#region src/context.ts
 function emptySystemConfig() {
 	return {
@@ -365,55 +299,14 @@ function emptySystemConfig() {
 		keyframesJson: null
 	};
 }
-const analysisChains = /* @__PURE__ */ new WeakMap();
-/** Runs `task` after every analysis transaction already scheduled for this
-*  context. Entry points only — a nested call waits on its own chain. */
-function runExclusiveAnalysis(ctx, task) {
-	const result = (analysisChains.get(ctx) ?? Promise.resolve()).then(task);
-	analysisChains.set(ctx, result.then(() => void 0, () => void 0));
-	return result;
-}
-function generateSystemPropsModule(ctx) {
-	return (0, _animus_ui_extract_pipeline.buildSystemPropsModule)({
-		systemPropMapJson: ctx.storedSystemPropMapJson,
-		groupRegistryJson: ctx.system.groupRegistryJson,
-		dynamicProps: JSON.parse(ctx.storedDynamicPropsJson),
-		admittedTransforms: JSON.parse(ctx.storedAdmittedTransformsJson),
-		typedSystemProps: JSON.parse(ctx.storedTypedSystemPropsJson)
-	});
-}
-/** Memoized on the inputs themselves, so no writer owes the memo a refresh
-*  and a stale memo cannot serve a module from a generation that is gone. */
-const systemPropsModules = /* @__PURE__ */ new WeakMap();
-/** NUL cannot appear in JSON text, so concatenation is injective. */
-function systemPropsModuleKey(ctx) {
-	return [
-		ctx.storedSystemPropMapJson,
-		ctx.system.groupRegistryJson,
-		ctx.storedDynamicPropsJson,
-		ctx.storedAdmittedTransformsJson,
-		ctx.storedTypedSystemPropsJson
-	].join("\0");
-}
-/** The exact source `virtual:animus/system-props` serves now — one definition,
-*  so the served bytes and the HMR change decision cannot diverge. */
-function systemPropsModuleSource(ctx) {
-	const key = systemPropsModuleKey(ctx);
-	const memo = systemPropsModules.get(ctx);
-	if (memo && memo.key === key) return memo.source;
-	const source = generateSystemPropsModule(ctx);
-	systemPropsModules.set(ctx, {
-		key,
-		source
-	});
-	return source;
-}
-/** Drop a deleted or renamed-away raw original from the dev file cache.
-*  Generated MDX/Svelte children live only in the published corpus. */
-function pruneFileCache(cache, rootDir, absPath) {
-	const rel = (0, path.relative)(rootDir, (0, path.resolve)(absPath));
-	return cache.delete(rel);
-}
+/** The system-props module before a first publication: no props. */
+const EMPTY_SYSTEM_PROPS_MODULE = (0, _animus_ui_extract_pipeline.buildSystemPropsModule)({
+	systemPropMapJson: "{}",
+	groupRegistryJson: emptySystemConfig().groupRegistryJson,
+	dynamicProps: {},
+	admittedTransforms: {},
+	typedSystemProps: []
+});
 const NO_SHEETS = {
 	variableCss: "",
 	globalCss: "",
@@ -424,7 +317,6 @@ var PluginContext = class {
 	verbose;
 	/** The higher tier: `verbose: 'trace'` or `ANIMUS_DEBUG=trace`. */
 	tracing;
-	staticCssJson;
 	isProd = false;
 	/** Serving or watching: an error-level diagnostic reports, and only a
 	*  one-shot build fails on one. */
@@ -435,145 +327,298 @@ var PluginContext = class {
 	rootDir = "";
 	logger = null;
 	system = emptySystemConfig();
-	/** Whether a system has loaded, so a failed reload has one to keep. */
-	systemLoaded = false;
 	lcssTargets = {};
 	pathAliasesJson = null;
 	/** Vite's export conditions, so the loader reads the files Vite serves. */
 	resolveConditions = [];
-	/** Development's repeat of buildStart's discovery, with its resolver. */
-	rediscoverSources = null;
+	/** Vite's resolved extension order; the built-in policy until
+	*  `configResolved`. */
+	extensionPolicy = _animus_ui_extract_pipeline.BUILT_IN_EXTENSION_POLICY;
+	/** Vite's asset classification, captured at `configResolved`. */
+	assetClassification = (0, _animus_ui_extract_pipeline.builtInAssetClassification)("noHost");
+	/** How Vite's build expands computed loads, captured at
+	*  `configResolved`; none where it cannot be reproduced exactly. */
+	loadExpander;
 	extensionsSet;
+	/** Built once per buildStart, before any discovery, from the user's
+	*  exclude list and the output directory. */
 	excludeMatcher;
+	/** Where Vite writes, every environment's output directories and files,
+	*  as structural exclusions; none outside the root. Set in
+	*  `configResolved`. */
+	outputExcludes = [];
 	storedManifest = null;
 	storedManifestJson = "";
-	globalCss = "";
-	resolvedComponentCss = "";
-	storedSheets = null;
+	/** The analysis sheets with their asset() placeholders. They are read
+	*  through `globalCss` and `resolvedComponentCss`, which substitute the
+	*  current asset URLs, so an edited asset changes its URL without
+	*  re-analysis. */
+	analysisGlobalCss = "";
+	analysisComponentCss = "";
+	get globalCss() {
+		return this.substitutedSheets().globalCss;
+	}
+	set globalCss(css) {
+		this.analysisGlobalCss = css;
+	}
+	get resolvedComponentCss() {
+		return this.substitutedSheets().componentCss;
+	}
+	set resolvedComponentCss(css) {
+		this.analysisComponentCss = css;
+	}
+	substitutedSheets() {
+		return (0, _animus_ui_extract_pipeline.substituteSheetAssets)({
+			...NO_SHEETS,
+			globalCss: this.analysisGlobalCss,
+			componentCss: this.analysisComponentCss
+		}, this.assetUrlBySpecifier);
+	}
 	layerDeclaration = "";
 	transformOutputHashes = /* @__PURE__ */ new Map();
 	recordTransformOutput(relativePath, code) {
 		this.transformOutputHashes.set(relativePath, (0, _animus_ui_extract_pipeline.contentHash)(code));
 	}
 	reverseProvenance = {};
-	storedSystemPropMapJson = "{}";
-	storedDynamicPropsJson = "{}";
-	storedAdmittedTransformsJson = "{}";
-	storedTypedSystemPropsJson = "[]";
-	fileCache = /* @__PURE__ */ new Map();
-	/** Mutation attempts against `fileCache`, for memos that must not key on
-	*  `size` — a delete plus an unrelated create leaves it unchanged. */
-	fileCacheGeneration = 0;
-	/** The one mutator of the raw-source cache: every add, replacement and
-	*  deletion goes through here so no write escapes the counter above. */
-	mutateFileCache(mutate) {
-		const cache = this.fileCache;
-		const result = mutate(cache);
-		this.fileCacheGeneration += 1;
-		return result;
-	}
-	/** Generated MDX/Svelte paths never enter `fileCache` — they live only in
-	*  this corpus's published projection. */
-	corpus = (0, _animus_ui_extract_pipeline.createSourceCorpus)({
-		engineApi: () => this.engineApi(),
-		prefix: "[animus-extract]",
-		strict: () => !!this.options.strict,
-		warn: (message) => this.warn(message),
-		reportErrors: () => this.reportErrors()
-	});
-	rawExtensionFallbacks = /* @__PURE__ */ new Set();
+	/** The exact source `virtual:animus/system-props` serves: the last
+	*  publication's, so the served bytes and the HMR change decision cannot
+	*  diverge. */
+	systemPropsModule = EMPTY_SYSTEM_PROPS_MODULE;
 	/** Original path → hash of bytes whose parse aborted in a rejected attempt;
 	*  non-empty while that rejection holds publication. Those bytes are served
 	*  raw so the host reports its own syntax error instead of receiving the
 	*  previous module from the retained engine. */
 	abortedParseHashes = /* @__PURE__ */ new Map();
-	/** A system reload is pending: the next analysis attempt loads the latest
-	*  system. A parse hold keeps it pending and the published system served;
-	*  new dependency watch keys stay registered meanwhile. */
-	systemReloadOwed = false;
-	/** The one mutator of a file's fallback state — every raw-serve exit of the
-	*  transform hook reports here, except aborted bytes, which never execute.
-	*  Production keeps the set empty. The
-	*  barrier's one-shot withhold release must not route through here: it
-	*  retires other files' records, no claim about their current serve. */
-	recordFallbackState(relativePath, isFallback) {
-		if (this.isProd) return;
-		if (isFallback) this.rawExtensionFallbacks.add(relativePath);
-		else this.rawExtensionFallbacks.delete(relativePath);
-	}
 	hotUpdateEvents = new HotUpdateEvents();
-	pendingReloadTimer = null;
-	packageMap = {};
+	/** Coalesces a burst of invalidations into one full reload. */
+	reloadWindow = new _animus_ui_extract_session.CoalescingWindow(() => {
+		this.devServer?.hot?.send({ type: "full-reload" });
+	});
 	base = "/";
 	assetUrlBySpecifier = /* @__PURE__ */ new Map();
+	/** Where dev asset() copies live, immutable and content-named; null in a
+	*  build, or when the dev server does not serve the directory, which
+	*  serves the live files instead. Set in `configResolved`. */
+	assetCopyDir = null;
+	/** specifier → the source file its dev copy was made from. */
+	assetSourceBySpecifier = /* @__PURE__ */ new Map();
+	/** source → its copies, oldest first: the current and the previous. */
+	assetCopyHistory = /* @__PURE__ */ new Map();
+	/** Specifiers whose copy the dev server does not serve, warned once. */
+	unservedAssetCopies = /* @__PURE__ */ new Set();
+	/** Whether the dev server serves `path`, by Vite's `server.fs` rule;
+	*  set in `configResolved`. */
+	servesFile = () => true;
 	assetResolutionFailures = /* @__PURE__ */ new Set();
 	assetPassComplete = false;
 	externalPackageDirs = [];
-	/** Those whose package is linked rather than installed. */
-	externalLinkedDirs = [];
-	/** Those read from their package's compiled output. */
-	externalOutputDirs = [];
-	externalDirOwners = {};
 	/** specifier → whether its redirected source entry has side effects, from
 	*  the owning package's `sideEffects`; absent leaves Vite's default. */
 	externalSourceSideEffects = /* @__PURE__ */ new Map();
-	externalFileOwners = {};
 	externalSourceEntries = /* @__PURE__ */ new Map();
 	externalPackageOutcomes = [];
-	/** The analysed kits' descriptors, from the last discovery. */
-	kitDescriptors = [];
-	/** Configured files buildStart or a late rediscovery could not read.
-	*  Later analyses read no files themselves, so they replay these until the
-	*  file is read into the cache or deleted. */
-	ingestionFailureDiagnostics = [];
 	devServer;
-	resolvedSystemPath = null;
-	systemDependencyKeys = /* @__PURE__ */ new Set();
-	systemDependencyPaths = [];
-	v2Engine = null;
-	v2SentSources = null;
-	v2DriftWarned = false;
+	/** The Session's path lists already registered with Vite's watcher; the
+	*  Session replaces a list when it changes. */
+	watchedPathLists = /* @__PURE__ */ new WeakSet();
 	/** Every native extraction call goes through this one accessor. */
 	engineApi;
+	/** The native module's stateless lookups, before the root resolves: the
+	*  shared factory, which registers no handle. */
+	kitEngine = _animus_ui_extract_session.engineFactory;
+	engineKey = null;
+	/** This context's build: one Vite config instance, one build. */
+	build = (0, _animus_ui_extract_session.createBuildId)();
+	/** The build's Session, created once the Vite root resolves. */
+	session = null;
+	/** The outcomes each in-flight `submitChanges` collects. */
+	outcomeCollectors = /* @__PURE__ */ new Set();
 	constructor(options, engineApiOverride) {
 		this.options = options;
-		this.staticCssJson = (0, _animus_ui_extract_pipeline.serializeStaticCss)(options.staticCss);
 		const verbosity = (0, _animus_ui_extract_pipeline.resolveVerbosity)(options.verbose, process.env.ANIMUS_DEBUG);
 		this.verbose = verbosity !== "quiet";
 		this.tracing = verbosity === "trace";
 		this.extensionsSet = new Set(options.extensions ?? _animus_ui_extract_pipeline.DEFAULT_EXTENSIONS);
-		this.excludeMatcher = (0, _animus_ui_extract_pipeline.createExcludeMatcher)(options.exclude);
 		if (engineApiOverride) {
 			this.engineApi = engineApiOverride;
+			this.kitEngine = engineApiOverride;
 			return;
 		}
-		const engineModuleId = "@animus-ui/extract";
-		this.engineApi = (0, _animus_ui_extract_pipeline.createV2EngineApi)({
-			label: "animus-extract",
-			isV2: () => true,
-			loadNativeEngine: () => require(engineModuleId),
-			rehydrateFilesJson: (filesJsonRaw) => {
-				if (!filesJsonRaw.includes("\"source\":\"\"")) return filesJsonRaw;
-				const entries = (0, _animus_ui_extract_pipeline.parseFilesJson)(filesJsonRaw, "animus-extract");
-				const analysisEntries = this.corpus.published.analysisEntries;
-				for (const entry of entries) if (entry.source === "") entry.source = analysisEntries.get(entry.path)?.source ?? "";
-				return JSON.stringify(entries);
-			},
-			store: {
-				getEngine: () => this.v2Engine,
-				setEngine: (engine) => {
-					this.v2Engine = engine;
-				},
-				getSentSources: () => this.v2SentSources,
-				setSentSources: (sources) => {
-					this.v2SentSources = sources;
-				},
-				getDriftWarned: () => this.v2DriftWarned,
-				setDriftWarned: (value) => {
-					this.v2DriftWarned = value;
-				}
+		const build = this.build;
+		const rehydrateFilesJson = (filesJsonRaw) => {
+			if (!filesJsonRaw.includes("\"source\":\"\"")) return filesJsonRaw;
+			const entries = (0, _animus_ui_extract_pipeline.parseFilesJson)(filesJsonRaw, "animus-extract");
+			const analysisEntries = this.session?.corpus.published.analysisEntries ?? /* @__PURE__ */ new Map();
+			for (const entry of entries) if (entry.source === "") entry.source = analysisEntries.get(entry.path)?.source ?? "";
+			return JSON.stringify(entries);
+		};
+		this.engineApi = () => {
+			if (!this.rootDir) throw new Error("[animus-extract] the engine was used before the Vite root resolved");
+			this.engineKey ??= (0, _animus_ui_extract_session.sessionKey)(build, this.rootDir);
+			return (0, _animus_ui_extract_session.engineHandle)(this.engineKey, {
+				label: "animus-extract",
+				rehydrateFilesJson
+			})();
+		};
+	}
+	/** Creates the build's Session from the resolved config: Vite's engine,
+	*  logger and core options, kept in memory. */
+	createSession() {
+		this.session?.close();
+		const options = this.options;
+		const session = new _animus_ui_extract_session.ExtractionSession({
+			system: options.system,
+			exclude: options.exclude,
+			extensions: options.extensions,
+			strict: options.strict,
+			diagnostics: options.diagnostics,
+			verbose: options.verbose,
+			prefix: options.prefix,
+			prefixContextualVars: options.prefixContextualVars,
+			targets: options.targets,
+			minify: options.minify,
+			staticCss: options.staticCss,
+			layers: options.layers,
+			engine: options.engine,
+			mode: this.emissionProd ? "production" : "development"
+		}, {
+			build: this.build,
+			unbundledComputedImports: true,
+			engine: () => this.engineApi(),
+			logger: {
+				info: (line) => (this.logger ?? console).info(line),
+				warn: (line) => (this.logger ?? console).warn(line),
+				error: (line) => (this.logger ?? console).error(line)
 			}
 		});
+		session.persistArtifacts = false;
+		session.hostSubstitutesAssets = true;
+		session.driverLabel = "animus-extract";
+		session.onOutcome = (outcome) => this.observeOutcome(session, outcome);
+		session.development = this.development;
+		session.rootDir = this.rootDir;
+		session.conditions = this.resolveConditions;
+		session.extensionPolicy = this.extensionPolicy;
+		session.assetClassification = this.assetClassification;
+		session.loadExpander = this.loadExpander;
+		session.pathAliasesJson = this.pathAliasesJson;
+		session.runtimeImport = options.runtimeImport ?? _animus_ui_extract_pipeline.DEFAULT_RUNTIME_IMPORT;
+		session.cssModuleId = VIRTUAL_CSS_ID;
+		session.systemPropsModuleId = VIRTUAL_SYSTEM_PROPS_ID;
+		session.structuralExclude = this.outputExcludes;
+		this.session = session;
+		return session;
+	}
+	/** Serves each publication as the Session makes it, so every reader in
+	*  between sees one generation. */
+	observeOutcome(session, outcome) {
+		let systemPropsChanged = false;
+		if (outcome.kind === "held") for (const [path$6, hash] of outcome.abortedOriginals) this.abortedParseHashes.set(path$6, hash);
+		else {
+			this.abortedParseHashes.clear();
+			const before = this.systemPropsModule;
+			this.adoptPublication(session);
+			systemPropsChanged = this.systemPropsModule !== before;
+		}
+		for (const collected of this.outcomeCollectors) collected.push({
+			outcome,
+			systemPropsChanged
+		});
+	}
+	/** Submits a dev change set to the Session. Until a first publication
+	*  there is no generation to update: the full read covers the change. */
+	submitChanges(changes) {
+		return this.runAttempt((session) => session.publication === null ? session.runFullPipeline([], changes.sources) : session.handleWatchUpdate(changes));
+	}
+	/** Runs one Session attempt and returns the outcomes that settle it. A
+	*  hold warns and resolves with its outcome (Vite reports the syntax
+	*  error itself); any other failure rejects. Either way the watcher
+	*  learns the paths the attempt's system load named. */
+	async runAttempt(attempt) {
+		const session = this.session ?? this.createSession();
+		const collected = [];
+		this.outcomeCollectors.add(collected);
+		try {
+			await attempt(session);
+		} catch (error) {
+			if (!collected.some(({ outcome }) => outcome.kind === "held")) throw error;
+			this.warn(error instanceof Error ? error.message : String(error));
+		} finally {
+			this.outcomeCollectors.delete(collected);
+			this.registerSystemWatchPaths();
+		}
+		return collected;
+	}
+	/** Serves the Session's last publication: the manifest, the analysis
+	*  sheets (asset placeholders kept; Vite substitutes them), the system,
+	*  the package map and the external-package state. */
+	adoptPublication(session) {
+		const publication = session.publication;
+		if (publication === null) return;
+		const manifest = publication.manifest;
+		this.system = publication.system;
+		this.storedManifest = manifest;
+		this.storedManifestJson = publication.manifestJson;
+		this.globalCss = publication.analysisGlobalCss;
+		this.resolvedComponentCss = publication.analysisComponentCss;
+		this.reverseProvenance = manifest.reverse_provenance;
+		this.systemPropsModule = publication.systemPropsModule;
+		this.externalPackageDirs = session.externalPackageDirs;
+		this.externalSourceEntries = session.externalSourceEntries;
+		this.externalSourceSideEffects = session.externalSourceSideEffects;
+		this.externalPackageOutcomes = session.lastExternalOutcomes;
+		this.applyAssetSubstitutions();
+	}
+	/** The environment a host without environments builds as. */
+	singleEnvironment = { name: "build" };
+	/** Each environment build that started and has not ended, by name. A
+	*  custom `buildApp` builds a shared plugin's environments in parallel, so
+	*  the context's build retires with the last of them, not the first. */
+	openBuilds = /* @__PURE__ */ new Map();
+	/** Opens `environment`'s build, after any open build under its name has
+	*  ended: a builder reused while an earlier build still runs, or a second
+	*  environment under one name, builds after it rather than beside it.
+	*  Each build then ends its own generation once, in `buildEnd`. */
+	async openBuild(environment) {
+		for (;;) {
+			const open = this.openBuilds.get(environment.name);
+			if (open === void 0) break;
+			await open.ended;
+		}
+		let end = () => {};
+		const ended = new Promise((settle) => {
+			end = settle;
+		});
+		this.openBuilds.set(environment.name, {
+			environment,
+			ended,
+			end
+		});
+	}
+	/** Ends `environment`'s open build; whether that left none open. Vite
+	*  ends each build once, in `buildEnd`, and a dev server ends only the
+	*  environments that started, so only the build that opened an entry
+	*  ends it. */
+	endBuild(environment) {
+		const open = this.openBuilds.get(environment.name);
+		if (open === void 0 || open.environment !== environment) return false;
+		this.openBuilds.delete(environment.name);
+		open.end();
+		return this.openBuilds.size === 0;
+	}
+	/** Retires this context's build when Vite closes it: the Session leaves
+	*  the registry (with its manifest and watch state) and the engine handle
+	*  is released, injected engine or not. The next build start rejoins. */
+	close() {
+		this.session?.close();
+		this.releaseEngine();
+	}
+	/** Releases this context's engine handle: a standalone one, which no
+	*  joined build retires. The next use makes a fresh one. */
+	releaseEngine() {
+		if (this.engineKey === null) return;
+		(0, _animus_ui_extract_session.releaseEngineHandle)(this.engineKey);
+		this.engineKey = null;
 	}
 	log(msg) {
 		if (this.verbose) (this.logger ?? console).info(`[animus] ${msg}`);
@@ -604,214 +649,57 @@ var PluginContext = class {
 		if (!report) throw new Error(message, cause === void 0 ? void 0 : { cause });
 		report(message);
 	}
-	/** Load the system into `this.system`. On failure the previous config is
-	*  kept; strict mode throws instead, and strict development reports the
-	*  failure once a system has loaded, since there is one to keep. */
-	loadSystem() {
-		this.resolvedSystemPath = (0, path.resolve)(this.rootDir, this.options.system);
-		for (const key of (0, _animus_ui_extract_pipeline.toWatchKeys)(this.resolvedSystemPath)) this.systemDependencyKeys.add(key);
-		try {
-			this.system = (0, _animus_ui_extract_pipeline.loadSystemConfig)(this.engineApi, {
-				systemPath: this.resolvedSystemPath,
-				rootDir: this.rootDir,
-				prefix: this.options.prefix,
-				prefixContextualVars: this.options.prefixContextualVars,
-				conditions: this.resolveConditions
-			});
-			const deps = this.system.dependencies ?? [];
-			const keys = /* @__PURE__ */ new Set();
-			for (const key of (0, _animus_ui_extract_pipeline.toWatchKeys)(this.resolvedSystemPath)) keys.add(key);
-			for (const dep of deps) for (const key of (0, _animus_ui_extract_pipeline.toWatchKeys)(dep)) keys.add(key);
-			this.systemDependencyKeys = keys;
-			this.systemDependencyPaths = deps;
-			this.registerSystemWatchPaths();
-			this.systemLoaded = true;
-		} catch (e) {
-			if (this.options.strict) {
-				const message = `[animus-extract] Failed to load system from ${this.resolvedSystemPath}: ${e}`;
-				if (!this.systemLoaded) throw new Error(message, { cause: e });
-				this.strictFailure(message, e);
-				return;
+	devFsUrl(absPath) {
+		return `${this.base.endsWith("/") ? this.base.slice(0, -1) : this.base}/@fs${absPath}`;
+	}
+	/** A dev asset() URL: an immutable content-named copy of `absPath`, so an
+	*  edit gets a new URL, or the live file where copies are not served. */
+	devAssetUrl(specifier, absPath) {
+		if (this.assetCopyDir === null) return this.devFsUrl(absPath);
+		const { fileName } = (0, _animus_ui_extract_pipeline.writeAssetCopy)(absPath, this.assetCopyDir);
+		const copyPath = (0, path.join)(this.assetCopyDir, fileName);
+		if (!this.servesFile(copyPath)) {
+			if (!this.unservedAssetCopies.has(specifier)) {
+				this.unservedAssetCopies.add(specifier);
+				this.warn(`[animus-extract] the copy of asset() ${specifier} is not served under server.fs; serving the live file instead, so an edit keeps its URL`);
 			}
-			console.warn(`[animus-extract] Failed to load system from ${this.resolvedSystemPath}:`, e);
+			return this.devFsUrl(absPath);
+		}
+		if (this.assetSourceBySpecifier.get(specifier) !== absPath) this.devServer?.watcher?.add(absPath);
+		this.assetSourceBySpecifier.set(specifier, absPath);
+		this.retainAssetCopy(absPath, fileName);
+		return this.devFsUrl(copyPath);
+	}
+	/** Keeps each source's current copy and the one before it; an asset
+	*  edit reloads the page, so an older URL is never fetched again. A copy
+	*  another source still keeps is never removed. */
+	retainAssetCopy(source, fileName) {
+		const history = this.assetCopyHistory.get(source) ?? [];
+		if (history[history.length - 1] !== fileName) history.push(fileName);
+		this.assetCopyHistory.set(source, history);
+		while (history.length > 2) {
+			const oldest = history.shift();
+			if (![...this.assetCopyHistory.values()].some((copies) => copies.includes(oldest)) && this.assetCopyDir !== null) (0, fs.rmSync)((0, path.join)(this.assetCopyDir, oldest), { force: true });
 		}
 	}
-	/** The read failures still standing: a file stops counting once the cache
-	*  holds a read of it or it is gone, as in the shared session, so it stops
-	*  warning and stops holding pruning off. */
-	unsettledIngestionFailures() {
-		return this.ingestionFailureDiagnostics.filter(({ file }) => {
-			if (this.fileCache.has(file)) return false;
+	/** Whether `absFile` is the source of a dev asset copy. */
+	isAssetSource(absFile) {
+		const keys = new Set((0, _animus_ui_extract_pipeline.toWatchKeys)(absFile));
+		return [...this.assetSourceBySpecifier.values()].some((source) => (0, _animus_ui_extract_pipeline.toWatchKeys)(source).some((key) => keys.has(key)));
+	}
+	/** Copies an edited asset under its new content name and redelivers the
+	*  stylesheet that names it. */
+	refreshAssetCopies(absFile) {
+		const keys = new Set((0, _animus_ui_extract_pipeline.toWatchKeys)(absFile));
+		for (const [specifier, source] of this.assetSourceBySpecifier) {
+			if (!(0, _animus_ui_extract_pipeline.toWatchKeys)(source).some((key) => keys.has(key))) continue;
 			try {
-				(0, fs.statSync)((0, path.resolve)(this.rootDir, file));
-				return true;
+				this.assetUrlBySpecifier.set(specifier, this.devAssetUrl(specifier, source));
 			} catch (err) {
-				return !(0, _animus_ui_extract_pipeline.isDeletedSource)(err);
-			}
-		});
-	}
-	/** Runs project analysis and updates every manifest-derived state. Returns
-	*  false when nothing published, and the caller must roll its cache back.
-	*  While a source is skipped or unreadable, its renders are unseen, so
-	*  nothing is pruned. */
-	runAnalysis(fileEntries, skippedOriginals = []) {
-		const ingestionFailures = this.unsettledIngestionFailures();
-		let result;
-		try {
-			result = (0, _animus_ui_extract_pipeline.runProjectAnalysis)(this.engineApi, {
-				fileEntries,
-				packageMap: this.packageMap,
-				system: this.system,
-				emitter: {
-					runtimeImport: this.options.runtimeImport ?? "@animus-ui/system",
-					cssModuleId: VIRTUAL_CSS_ID
-				},
-				pathAliasesJson: this.pathAliasesJson,
-				staticCssJson: this.staticCssJson,
-				externalDirs: this.externalPackageDirs.map((dir) => (0, path.relative)(this.rootDir, dir)),
-				devMode: !this.emissionProd,
-				analysisContext: {
-					skippedSources: [...skippedOriginals, ...ingestionFailures.map((d) => d.file)].map((file) => (0, path.isAbsolute)(file) ? (0, path.relative)(this.rootDir, file) : file),
-					unbundledComputedImports: true,
-					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))
-				},
-				warn: (m) => this.warn(m),
-				info: (m) => this.log(m),
-				strict: this.options.strict,
-				diagnostics: this.options.diagnostics,
-				reportErrors: this.reportErrors(),
-				extraDiagnostics: ingestionFailures,
-				kitDescriptors: this.kitDescriptors
-			});
-		} catch (e) {
-			const message = `[animus-extract] analyzeProject failed: ${e}`;
-			if (e instanceof _animus_ui_extract_pipeline.DiagnosticFailure) throw new Error(message, { cause: e });
-			if (this.options.strict) {
-				if (this.storedManifest === null) throw new Error(message, { cause: e });
-				this.strictFailure(message, e);
-				return false;
-			}
-			console.warn("[animus-extract] analyzeProject failed:", e);
-			return false;
-		}
-		this.assertRuntimeImportSuppliesTerminals(result.manifest);
-		(0, _animus_ui_extract_pipeline.reportSurvivingAssetPlaceholders)((0, _animus_ui_extract_pipeline.generatedModuleCode)(result.manifest), {
-			strict: this.options.strict,
-			warn: (message) => this.warn(message),
-			reportErrors: this.reportErrors(),
-			prefix: "[animus-extract]",
-			surface: "generated runtime modules"
-		});
-		this.storedManifest = result.manifest;
-		this.storedManifestJson = result.manifestJson;
-		this.ingestionFailureDiagnostics = ingestionFailures;
-		this.storedSystemPropMapJson = JSON.stringify(result.manifest.system_prop_map);
-		this.storedDynamicPropsJson = JSON.stringify(result.manifest.dynamic_props);
-		this.storedAdmittedTransformsJson = JSON.stringify(result.manifest.admitted_transforms);
-		this.storedTypedSystemPropsJson = JSON.stringify(result.manifest.typed_system_props);
-		this.reverseProvenance = result.manifest.reverse_provenance;
-		this.storedSheets = result.manifest.sheets;
-		this.globalCss = result.globalCss;
-		this.resolvedComponentCss = result.componentCss;
-		this.applyAssetSubstitutions();
-		return true;
-	}
-	assertRuntimeImportSuppliesTerminals(manifest) {
-		const override = this.options.runtimeImport;
-		if (!override || override === "@animus-ui/system") return;
-		const offenders = [];
-		for (const [id, descriptor] of Object.entries(manifest.components)) if (/\bcreateComponent\(|\bcreateComposedFamily\(/.test(descriptor.replacement)) offenders.push(id);
-		if (offenders.length === 0) return;
-		const shown = offenders.slice(0, 5).join(", ");
-		throw new Error(`[animus-extract] runtimeImport '${override}' is valid only when every extracted terminal is .asClass(), but ${offenders.length} component(s) need createComponent/createComposedFamily from the default '@animus-ui/system' runtime: ${shown}` + (offenders.length > 5 ? ", …" : "") + `. Remove the override or convert these terminals to .asClass().`);
-	}
-	/** The one ingest → quarantine → analyze → publish transaction. The corpus
-	*  publishes only on success. `afterIngestion` runs after quarantine even
-	*  when an aborted parse rejects the attempt; `beforeAnalysis` runs only
-	*  once the attempt will analyze. A rejection names its aborted originals
-	*  and holds publication: development callers keep their cache's latest
-	*  sources, valid edits included, for the repair to publish together. In
-	*  every strictness mode it fails a production build, which has no
-	*  generation to keep, and only warns in development: the host reports the
-	*  syntax error itself, and a throw would leave its client on the failed
-	*  module. The publication that ends a hold invalidates the modules of
-	*  every original whose admitted bytes changed meanwhile and returns them
-	*  as `redeliver`, for a hot update to push to the client. An owed system
-	*  reload loads the latest system for the attempt: a hold restores the
-	*  published one and keeps the reload owed, any other outcome completes
-	*  the reload's invalidation. */
-	async analyzeIngested(options) {
-		const holding = this.abortedParseHashes.size > 0;
-		const previous = this.corpus.published.ownership;
-		const reloadingSystem = this.systemReloadOwed;
-		const prevPlans = reloadingSystem ? (0, _animus_ui_extract_pipeline.snapshotFilePlans)(this.storedManifest) : null;
-		const publishedSystem = this.system;
-		let published = false;
-		try {
-			if (reloadingSystem) this.loadSystem();
-			const accepted = await this.corpus.prepare(options?.rawEntries ?? {
-				fileCache: this.fileCache,
-				externalFileOwners: this.externalFileOwners
-			});
-			options?.afterIngestion?.(accepted);
-			const rejection = this.corpus.rejection(accepted);
-			if (rejection) {
-				for (const [path$3, hash] of rejection.originals) this.abortedParseHashes.set(path$3, hash);
-				if (this.isProd) throw new Error(rejection.message);
-				this.warn(rejection.message);
-				return {
-					ok: false,
-					accepted,
-					abortedOriginals: rejection.originals,
-					endedHold: false,
-					redeliver: []
-				};
-			}
-			if (reloadingSystem) (0, _animus_ui_extract_pipeline.clearEngineCache)(this.engineApi);
-			options?.beforeAnalysis?.(accepted);
-			const ok = this.runAnalysis(accepted.analysisEntries, accepted.skippedOriginals) !== false;
-			if (!ok) return {
-				ok,
-				accepted,
-				endedHold: false,
-				redeliver: []
-			};
-			this.publishSourceIngestion(accepted);
-			published = true;
-			this.abortedParseHashes.clear();
-			if (!holding) return {
-				ok,
-				accepted,
-				endedHold: false,
-				redeliver: []
-			};
-			const redeliver = Object.values(accepted.ownership).filter((owner) => previous[owner.originalPath]?.originalHash !== owner.originalHash).map((owner) => owner.originalPath);
-			invalidateFileModules(this, redeliver);
-			return {
-				ok,
-				accepted,
-				endedHold: true,
-				redeliver
-			};
-		} finally {
-			const systemHeld = reloadingSystem && this.abortedParseHashes.size > 0;
-			if (systemHeld) this.system = publishedSystem;
-			else if (reloadingSystem) {
-				this.systemReloadOwed = false;
-				if (published && prevPlans) invalidateFileModules(this, (0, _animus_ui_extract_pipeline.diffFilePlans)(prevPlans, (0, _animus_ui_extract_pipeline.snapshotFilePlans)(this.storedManifest)));
+				this.warn(`[animus-extract] could not copy edited asset ${source}: ${String(err)}`);
 			}
-			if (reloadingSystem) this.invalidateSystemReloadModules(!systemHeld);
 		}
-	}
-	publishSourceIngestion(result) {
-		this.corpus.publish(result);
-		this.externalFileOwners = (0, _animus_ui_extract_pipeline.projectExternalFileOwners)(result, this.externalFileOwners);
-		this.enforceExternalTokenContracts();
-	}
-	devFsUrl(absPath) {
-		return `${this.base.endsWith("/") ? this.base.slice(0, -1) : this.base}/@fs${absPath}`;
+		this.invalidateSystemReloadModules(true);
 	}
 	assetFallback(specifier, message, cause) {
 		if (this.options.strict) this.strictFailure(message, cause);
@@ -823,8 +711,8 @@ var PluginContext = class {
 	sheetAssetSpecifiers() {
 		return (0, _animus_ui_extract_pipeline.findSheetAssetSpecifiers)({
 			variableCss: this.system.variableCss,
-			globalCss: this.globalCss,
-			componentCss: this.resolvedComponentCss
+			globalCss: this.analysisGlobalCss,
+			componentCss: this.analysisComponentCss
 		});
 	}
 	/** `system.variableCss` with its asset() placeholders substituted from
@@ -837,18 +725,6 @@ var PluginContext = class {
 			variableCss: this.system.variableCss
 		}, this.assetUrlBySpecifier).variableCss;
 	}
-	/** Substitutes the analysis sheets in place, through the same step as the
-	*  session; the theme's variable CSS is substituted on read
-	*  (`variableCss`). */
-	substituteSheets() {
-		const substituted = (0, _animus_ui_extract_pipeline.substituteSheetAssets)({
-			...NO_SHEETS,
-			globalCss: this.globalCss,
-			componentCss: this.resolvedComponentCss
-		}, this.assetUrlBySpecifier);
-		this.globalCss = substituted.globalCss;
-		this.resolvedComponentCss = substituted.componentCss;
-	}
 	/** Resolves asset specifiers a system reload introduced. Node-side only —
 	*  the plugin hook context is unavailable here, so results can differ. */
 	applyAssetSubstitutions() {
@@ -856,44 +732,9 @@ var PluginContext = class {
 			if (this.assetResolutionFailures.delete(specifier)) this.assetUrlBySpecifier.delete(specifier);
 			if (this.assetUrlBySpecifier.has(specifier)) continue;
 			const resolved = (0, _animus_ui_extract_pipeline.resolveAssetFile)(specifier, this.rootDir, this.pathAliasesJson);
-			if (resolved) this.assetUrlBySpecifier.set(specifier, this.devFsUrl(resolved));
+			if (resolved) this.assetUrlBySpecifier.set(specifier, this.devAssetUrl(specifier, resolved));
 			else this.assetFallback(specifier, `[animus-extract] unresolvable asset() specifier: ${specifier}`);
 		}
-		this.substituteSheets();
-	}
-	resetCoalescer = null;
-	requestSystemReload(trigger) {
-		this.log(`HMR system reload scheduled: ${trigger}`);
-		this.resetCoalescer ??= new ResetCoalescer(
-			async () => this.performSystemReload(),
-			/** The coalescer fires from a bare timer, outside Vite's error
-			*  handling, so an unhandled strict throw would exit the process. */
-			(err) => {
-				const display = String(err);
-				this.warn(`[animus-extract] system reload failed: ${display}`);
-				const message = err instanceof Error ? err.message : String(err);
-				const stack = err instanceof Error ? err.stack ?? "" : "";
-				this.devServer?.hot?.send({
-					type: "error",
-					err: {
-						message,
-						stack,
-						plugin: "animus-extract"
-					}
-				});
-			}
-		);
-		this.resetCoalescer.request();
-	}
-	async performSystemReload() {
-		return runExclusiveAnalysis(this, () => this.performSystemReloadExclusive());
-	}
-	async performSystemReloadExclusive() {
-		const resetStart = performance.now();
-		this.systemReloadOwed = true;
-		const { ok } = await this.analyzeIngested(await this.rediscoverSources?.());
-		if (!ok) return;
-		this.log(`HMR system reload complete: ${Math.round(performance.now() - resetStart)}ms`);
 	}
 	invalidateSystemReloadModules(reloadClient) {
 		const server = this.devServer;
@@ -909,15 +750,35 @@ var PluginContext = class {
 		if (reloadClient) server.hot?.send({ type: "full-reload" });
 	}
 	isSystemDependency(absFile) {
-		return (0, _animus_ui_extract_pipeline.toWatchKeys)(absFile).some((key) => this.systemDependencyKeys.has(key));
+		return this.session?.isSystemDependency(absFile) ?? false;
 	}
-	/** Watch every loader-reported dependency path. Vite hard-ignores
-	*  node_modules, so dependencies installed there produce no events. */
+	/** Watch every loader-reported dependency path, the external package
+	*  roots, and the paths the load found absent that no watched directory
+	*  covers (creating one reloads the system). Vite hard-ignores
+	*  node_modules, so dependencies installed there produce no events. A list
+	*  already registered is not added again. */
 	registerSystemWatchPaths() {
 		const watcher = this.devServer?.watcher;
-		if (!watcher) return;
-		if (this.systemDependencyPaths.length > 0) watcher.add(this.systemDependencyPaths);
-		if (this.externalPackageDirs.length > 0) watcher.add(this.externalPackageDirs);
+		const session = this.session;
+		if (!watcher || !session) return;
+		for (const paths of [
+			session.systemDependencyPaths,
+			session.systemMissingPaths,
+			session.externalPackageDirs
+		]) {
+			if (paths.length === 0 || this.watchedPathLists.has(paths)) continue;
+			this.watchedPathLists.add(paths);
+			const added = paths === session.systemMissingPaths ? this.uncoveredMissingPaths(paths, session.externalPackageDirs) : paths;
+			if (added.length > 0) watcher.add(added);
+		}
+	}
+	/** The absent paths no watched directory reports a creation for. Vite's
+	*  root watch and a package root's watch already do, and a watch on an
+	*  absent file inside a watched directory stops that directory's events
+	*  under inotify (chokidar's non-fsevents handler). */
+	uncoveredMissingPaths(paths, packageDirs) {
+		const watchedDirs = this.rootDir ? [this.rootDir, ...packageDirs] : packageDirs;
+		return paths.filter((path$7) => !watchedDirs.some((dir) => (0, _animus_ui_extract_pipeline.isPathWithinRoot)(dir, path$7)));
 	}
 	/** Invalidate the component CSS and system-props modules, then reload. The
 	*  reload alone rescues nothing: Vite keeps serving its cached transform.
@@ -930,33 +791,7 @@ var PluginContext = class {
 			const mod = server.moduleGraph.getModuleById(moduleId);
 			if (mod) server.moduleGraph.invalidateModule(mod);
 		}
-		if (this.pendingReloadTimer) return;
-		this.pendingReloadTimer = setTimeout(() => {
-			this.pendingReloadTimer = null;
-			this.devServer?.hot?.send({ type: "full-reload" });
-		}, 100);
-	}
-	/** An unresolvable `.includes()` specifier or a stale dist entry under an
-	*  extended package warns, and fails the build under `strict` (strict
-	*  development reports it). */
-	enforceIncludeResolution() {
-		for (const message of [(0, _animus_ui_extract_pipeline.unresolvableIncludesMessage)(this.externalPackageOutcomes), (0, _animus_ui_extract_pipeline.staleDistIncludesMessage)(this.externalPackageOutcomes)]) {
-			if (message === null) continue;
-			if (this.options.strict) this.strictFailure(message);
-			else this.warn(message);
-		}
-	}
-	enforceExternalTokenContracts() {
-		(0, _animus_ui_extract_pipeline.enforceExternalTokenContracts)({
-			diagnostics: this.storedManifest?.diagnostics,
-			fileOwners: this.externalFileOwners,
-			dirOwners: this.externalDirOwners,
-			sourceThemeManifestsJson: this.system.sourceThemeManifestsJson,
-			strict: this.options.strict,
-			prefix: "[animus-extract]",
-			warn: (message) => this.warn(message),
-			reportErrors: this.reportErrors()
-		});
+		this.reloadWindow.note();
 	}
 	runSelfVerify() {
 		const failures = (0, _animus_ui_extract_pipeline.runStructuralSelfCheck)({
@@ -981,131 +816,113 @@ var PluginContext = class {
 	}
 };
 //#endregion
-//#region src/rediscovery.ts
-/** The current manifest's unresolved-parent drops, parsed from diagnostics. */
-function unresolvedParentDrops(ctx) {
-	const drops = [];
-	const manifest = ctx.storedManifest;
-	if (!manifest) return drops;
-	for (const d of manifest.diagnostics) {
-		const parent = (0, _animus_ui_extract_pipeline.unresolvedParentName)(d);
-		if (parent !== null) drops.push({
-			file: d.file,
-			component: d.component,
-			parent
-		});
-	}
-	return drops;
-}
-const EMPTY_DROP_FILES = /* @__PURE__ */ new Set();
-const dropFilesByManifest = /* @__PURE__ */ new WeakMap();
-/** Files carrying an unresolved-parent drop in the current manifest. */
-function unresolvedDropFiles(ctx) {
-	const manifest = ctx.storedManifest;
-	if (!manifest) return EMPTY_DROP_FILES;
-	let files = dropFilesByManifest.get(manifest);
-	if (!files) {
-		const derived = /* @__PURE__ */ new Set();
-		for (const d of manifest.diagnostics) if ((0, _animus_ui_extract_pipeline.isUnresolvedParentDrop)(d)) derived.add(d.file);
-		files = derived;
-		dropFilesByManifest.set(manifest, files);
-	}
-	return files;
-}
+//#region src/module-invalidation.ts
 /**
-* Folds undiscovered on-disk files when the manifest reports an unresolved
-* parent, then re-analyzes; the iteration cap is containment, not semantics.
+* Completeness is load-bearing: the file-plan diff and the sources re-delivered
+* when a held publication ends are the only invalidation candidate sources, so
+* a node shape missed here stays stale for the session.
 */
-async function reconcileSourceCorpus(ctx) {
-	if (ctx.isProd) return false;
-	let reanalyzed = false;
-	for (let iteration = 0; iteration < 3; iteration++) {
-		if (unresolvedDropFiles(ctx).size === 0) {
-			warnedVerdicts.get(ctx)?.clear();
-			return reanalyzed;
-		}
-		const drops = unresolvedParentDrops(ctx);
-		const dropKey = drops.map((d) => `${d.file}\0${d.component}\0${d.parent}`).sort().join("\n");
-		const memo = barrenWalkMemos.get(ctx);
-		if (memo && memo.dropKey === dropKey && memo.cacheGeneration === ctx.fileCacheGeneration) return reanalyzed;
-		const recordedFailures = ctx.ingestionFailureDiagnostics.length;
-		const folded = foldUndiscoveredFiles(ctx);
-		const newlyUnreadable = ctx.ingestionFailureDiagnostics.length > recordedFailures;
-		if (folded.length === 0 && !newlyUnreadable) {
-			barrenWalkMemos.set(ctx, {
-				dropKey,
-				cacheGeneration: ctx.fileCacheGeneration
-			});
-			warnInadmissibleParents(ctx, drops);
-			return reanalyzed;
-		}
-		barrenWalkMemos.delete(ctx);
-		if (folded.length > 0) ctx.log(`rediscovery: folded ${folded.length} on-disk file(s) after unresolved-parent drop`);
-		reanalyzed = true;
-		let published = false;
-		let held = false;
-		try {
-			const analysis = await ctx.analyzeIngested();
-			published = analysis.ok;
-			held = analysis.abortedOriginals !== void 0;
-		} finally {
-			if (!published && !held) ctx.mutateFileCache((cache) => {
-				for (const key of folded) cache.delete(key);
-			});
+function invalidateFileModules(ctx, relPaths) {
+	const server = ctx.devServer;
+	if (!server || relPaths.length === 0) return 0;
+	const graphs = server.environments ? Object.values(server.environments).map((env) => env?.moduleGraph).filter(Boolean) : [server.moduleGraph].filter(Boolean);
+	let total = 0;
+	for (const relPath of relPaths) {
+		const absPath = (0, path.resolve)(ctx.rootDir, relPath);
+		let fileCount = 0;
+		for (const graph of graphs) {
+			const nodes = /* @__PURE__ */ new Set();
+			const byFile = graph.getModulesByFile?.(absPath);
+			if (byFile) for (const mod of byFile) nodes.add(mod);
+			const byId = graph.getModuleById?.(absPath);
+			if (byId) nodes.add(byId);
+			for (const mod of nodes) {
+				graph.invalidateModule(mod);
+				fileCount++;
+			}
 		}
-		if (!published) return reanalyzed;
+		if (fileCount > 0) ctx.trace(`HMR invalidate: ${relPath} (plan changed, ${fileCount} nodes)`);
+		total += fileCount;
 	}
-	if (unresolvedDropFiles(ctx).size > 0) ctx.warn("source-corpus rediscovery did not stabilize after bounded retries");
-	return reanalyzed;
+	return total;
 }
-/** Returns the cache keys this fold added: a failed analysis must restore
-*  the cache, or the content-hash gate suppresses the retry forever. A file
-*  it cannot read joins the context's ingestion failures instead. */
-function foldUndiscoveredFiles(ctx) {
-	const excludeMatcher = ctx.excludeMatcher;
-	const filePaths = (0, _animus_ui_extract_pipeline.discoverFiles)(ctx.rootDir, ctx.rootDir, excludeMatcher, ctx.extensionsSet);
-	const folded = [];
-	const pending = [];
-	for (const filePath of filePaths) {
-		if ((0, path.extname)(filePath) === ".mdx") continue;
-		const relPath = (0, path.relative)(ctx.rootDir, filePath);
-		if (ctx.fileCache.has(relPath)) continue;
-		let source;
-		try {
-			source = (0, fs.readFileSync)(filePath, "utf-8");
-		} catch (err) {
-			if (!(0, _animus_ui_extract_pipeline.isDeletedSource)(err) && !ctx.ingestionFailureDiagnostics.some((d) => d.file === relPath)) ctx.ingestionFailureDiagnostics.push((0, _animus_ui_extract_pipeline.unreadableSourceDiagnostic)(relPath, err));
-			continue;
-		}
-		pending.push([relPath, {
-			hash: (0, _animus_ui_extract_pipeline.contentHash)(source),
-			source
-		}]);
-		folded.push(relPath);
-	}
-	if (pending.length > 0) ctx.mutateFileCache((cache) => {
-		for (const [relPath, entry] of pending) cache.set(relPath, entry);
-	});
-	return folded;
+//#endregion
+//#region src/rediscovery.ts
+const NO_DROPS = /* @__PURE__ */ new Map();
+const dropsByManifest = /* @__PURE__ */ new WeakMap();
+/** The current manifest's extensions dropped over their parent, by file:
+*  the engine's typed missing-input evidence (spec §12.2 row 11). */
+function droppedExtensions(ctx) {
+	const manifest = ctx.storedManifest;
+	if (!manifest) return NO_DROPS;
+	let drops = dropsByManifest.get(manifest);
+	if (!drops) {
+		drops = (0, _animus_ui_extract_pipeline.servedFiles)(manifest).dropped;
+		dropsByManifest.set(manifest, drops);
+	}
+	return drops;
 }
-/** Per context: the drop tuple-set and the cache mutation generation at the
-*  last walk that folded nothing. */
-const barrenWalkMemos = /* @__PURE__ */ new WeakMap();
 /** Per-context (file, parent, condition) verdicts already warned — each
 *  condition warns once; cleared when the drops disappear. */
 const warnedVerdicts = /* @__PURE__ */ new WeakMap();
-const PARENT_PROBE_EXTENSIONS = /* @__PURE__ */ new Set([
-	".tsx",
-	".ts",
-	".jsx",
-	".js"
-]);
+/** Where a parent the analysis does not hold is on disk, probed from its
+*  base under the host's extension order: one no analysed module answers
+*  (`absent`), or one the host opens but the analysis never read
+*  (`incomplete`), such as a file the watcher has not reported yet. */
+function parentOnDisk(ctx, input) {
+	if (input.outcome !== "absent" && input.outcome !== "incomplete" || input.base === null) return { kind: "none" };
+	const probed = (0, _animus_ui_extract_pipeline.probeAbsolutePathSpecifier)((0, path.resolve)(ctx.rootDir, input.base), void 0, ctx.rootDir, ctx.extensionPolicy);
+	if (probed.kind === "absent") return { kind: "none" };
+	if (probed.kind === "case-mismatch") return {
+		kind: "inadmissible",
+		reason: `is unresolved: ${(0, _animus_ui_extract_pipeline.caseMismatchReason)(`the import '${input.specifier}'`, {
+			candidate: (0, path.relative)(ctx.rootDir, probed.candidate),
+			actual: (0, path.relative)(ctx.rootDir, probed.actual)
+		}, "spell the import as the file is spelled.")}`
+	};
+	const path$5 = probed.path;
+	const relPath = (0, path.relative)(ctx.rootDir, path$5);
+	const excludedBy = ctx.excludeMatcher.explain(path$5, relPath);
+	const reason = excludedBy ? `which is excluded by pattern '${excludedBy}'. Include that file in the extraction sources or remove this extension.` : !(0, _animus_ui_extract_pipeline.isPathWithinRoot)(ctx.rootDir, path$5) ? "outside the extraction root. Declare its package in the system includes or move it under the project root." : !ctx.extensionsSet.has((0, path.extname)(path$5)) ? `whose extension is not in the configured source extensions.` : (0, path.extname)(path$5) === ".mdx" || ctx.session?.heldSources.has(relPath) ? null : void 0;
+	if (reason === void 0) return {
+		kind: "fold",
+		path: path$5
+	};
+	if (reason === null) return { kind: "none" };
+	return {
+		kind: "inadmissible",
+		reason: `resolves to ${relPath}, ${reason}`
+	};
+}
 /**
-* Warns for parents that resolve on disk but cannot be admitted. Resolution
-* is a best-effort scan of the consumer's own relative import specifiers.
+* Folds the on-disk files the manifest's dropped extensions name as missing
+* parents into the Session, in one bounded pass, and returns the outcomes
+* of that attempt. A parent no file answers, or one that cannot be
+* admitted, leaves its drop standing: the transform then fails rather than
+* serving builder code (SA1).
 */
-function warnInadmissibleParents(ctx, drops) {
-	const excludeMatcher = ctx.excludeMatcher;
+async function reconcileSourceCorpus(ctx) {
+	if (ctx.isProd || ctx.session === null) return [];
+	const drops = [...droppedExtensions(ctx).values()];
+	if (drops.length === 0) {
+		warnedVerdicts.get(ctx)?.clear();
+		return [];
+	}
+	const folded = /* @__PURE__ */ new Set();
+	const inadmissible = [];
+	for (const drop of drops) {
+		const onDisk = parentOnDisk(ctx, drop);
+		if (onDisk.kind === "fold") folded.add(onDisk.path);
+		else if (onDisk.kind === "inadmissible") inadmissible.push([drop, onDisk.reason]);
+	}
+	warnInadmissibleParents(ctx, drops, inadmissible);
+	if (folded.size === 0) return [];
+	ctx.log(`rediscovery: folded ${folded.size} on-disk file(s) a dropped extension names as its parent`);
+	return ctx.submitChanges({ modifiedFiles: folded });
+}
+/** Warns, once per condition, for parents that resolve on disk but cannot
+*  be admitted. */
+function warnInadmissibleParents(ctx, drops, inadmissible) {
 	let warned = warnedVerdicts.get(ctx);
 	if (!warned) {
 		warned = /* @__PURE__ */ new Set();
@@ -1113,31 +930,51 @@ function warnInadmissibleParents(ctx, drops) {
 	}
 	const active = new Set(drops.map((d) => `${d.file}\0${d.parent}`));
 	for (const key of [...warned]) if (!active.has(key.slice(0, key.lastIndexOf("\0")))) warned.delete(key);
-	for (const drop of drops) {
-		const consumer = ctx.fileCache.get(drop.file);
-		if (!consumer) continue;
-		const specifier = importSpecifierFor(consumer.source, drop.parent);
-		if (!specifier || !specifier.startsWith(".")) continue;
-		const resolved = (0, _animus_ui_extract_pipeline.resolveAbsolutePathSpecifier)((0, path.resolve)(ctx.rootDir, (0, path.dirname)(drop.file), specifier), PARENT_PROBE_EXTENSIONS);
-		if (!resolved) continue;
-		const relPath = (0, path.relative)(ctx.rootDir, resolved);
-		const excludedBy = excludeMatcher.explain(resolved, relPath);
-		const reason = excludedBy ? `which is excluded by pattern '${excludedBy}'. Include that file in the extraction sources or remove this extension.` : !(0, _animus_ui_extract_pipeline.isPathWithinRoot)(ctx.rootDir, resolved) ? "outside the extraction root. Declare its package in the system includes or move it under the project root." : !ctx.extensionsSet.has((0, path.extname)(resolved)) ? `whose extension is not in the configured source extensions.` : null;
-		if (reason === null) continue;
+	for (const [drop, reason] of inadmissible) {
 		const verdictKey = `${drop.file}\0${drop.parent}\0${reason}`;
 		if (warned.has(verdictKey)) continue;
 		warned.add(verdictKey);
-		ctx.warn(`cannot extract '${drop.component}': parent '${drop.parent}' resolves to ${relPath}, ${reason}`);
+		ctx.warn(`cannot extract '${drop.component}': parent '${drop.parent}' ${reason}`);
 	}
 }
-function importSpecifierFor(source, binding) {
-	const importRe = /import\s+([^;]+?)\s+from\s+['"]([^'"]+)['"]/g;
-	let match;
-	while ((match = importRe.exec(source)) !== null) {
-		const clause = match[1];
-		if (new RegExp(`[{,\\s]${binding}[,\\s}]|^${binding}$`).test(clause)) return match[2];
+//#endregion
+//#region src/session-outcomes.ts
+/** The file event as a Session change set. */
+function changesOf(type, absFile) {
+	const files = /* @__PURE__ */ new Set([absFile]);
+	return type === "delete" ? { removedFiles: files } : { modifiedFiles: files };
+}
+/** What the published outcomes of one submission change, merged. */
+function mergePublished(outcomes) {
+	const merged = {
+		published: false,
+		full: false,
+		endedHold: false,
+		systemPropsChanged: false,
+		planChanged: /* @__PURE__ */ new Set(),
+		redeliver: /* @__PURE__ */ new Set()
+	};
+	for (const { outcome, systemPropsChanged } of outcomes) {
+		if (outcome.kind !== "published") continue;
+		merged.published = true;
+		merged.full ||= outcome.pass === "full";
+		merged.endedHold ||= outcome.endedHold;
+		merged.systemPropsChanged ||= systemPropsChanged;
+		for (const path of outcome.planChanged) merged.planChanged.add(path);
+		for (const path of outcome.redeliver) merged.redeliver.add(path);
+	}
+	return merged;
+}
+/** Acts on what every submission's publications owe the module graph: a
+*  publication that ends a hold re-delivers the originals whose bytes
+*  changed meanwhile, and a full pass (a system reload) reloads the
+*  client. */
+function applyPublished(ctx, merged) {
+	if (merged.redeliver.size > 0) invalidateFileModules(ctx, [...merged.redeliver]);
+	if (merged.full) {
+		invalidateFileModules(ctx, [...merged.planChanged]);
+		ctx.invalidateSystemReloadModules(true);
 	}
-	return null;
 }
 //#endregion
 //#region src/transform.ts
@@ -1154,7 +991,7 @@ function applyDevBridgeImport(code) {
 function extendingFiles(ctx, analysisPaths) {
 	const manifest = ctx.storedManifest;
 	const files = /* @__PURE__ */ new Set();
-	const queue = analysisPaths.flatMap((path$2) => manifest?.files[path$2] ?? []);
+	const queue = analysisPaths.flatMap((path$3) => manifest?.files[path$3] ?? []);
 	const seen = new Set(queue);
 	while (queue.length > 0) {
 		const id = queue.shift();
@@ -1168,12 +1005,11 @@ function extendingFiles(ctx, analysisPaths) {
 	}
 	return files;
 }
-function rawFallbackDescendants(ctx, relPath) {
-	return [...extendingFiles(ctx, [relPath])].filter((file) => file !== relPath && ctx.rawExtensionFallbacks.has(file)).sort();
-}
-async function transformSource(ctx, code, id) {
-	if (!ctx.storedManifest) return null;
-	if (id.startsWith("\0") || id.startsWith("virtual:animus/")) return null;
+async function transformSource(ctx, code, requestId) {
+	if (requestId.startsWith("\0") || requestId.startsWith("virtual:animus/")) return null;
+	const query = requestId.indexOf("?");
+	if (query !== -1 && !/^v=[\w-]+$/.test(requestId.slice(query + 1))) return null;
+	const id = query === -1 ? requestId : requestId.slice(0, query);
 	const isExternalPkg = ctx.externalPackageDirs.some((dir) => (0, _animus_ui_extract_pipeline.isPathWithinRoot)(dir, id));
 	const relativePath = (0, path.relative)(ctx.rootDir, id);
 	if (!isExternalPkg) {
@@ -1183,57 +1019,36 @@ async function transformSource(ctx, code, id) {
 	}
 	const abortedHash = ctx.abortedParseHashes.get(relativePath);
 	if (abortedHash !== void 0 && abortedHash === (0, _animus_ui_extract_pipeline.contentHash)(code)) return null;
+	if (!ctx.storedManifest) throw new Error(`[animus-extract] no analysis is available to transform ${relativePath}: the project analysis failed; see the error above.`);
+	let detectionFailed = false;
 	if (!ctx.storedManifest.files[relativePath]?.length) {
-		if (!ctx.isProd && !ctx.fileCache.has(relativePath)) await runExclusiveAnalysis(ctx, async () => {
-			if (ctx.fileCache.has(relativePath)) return;
-			if (isExternalPkg) {
-				const owner = Object.entries(ctx.externalDirOwners).find(([dir]) => (0, _animus_ui_extract_pipeline.isPathWithinRoot)(dir, id));
-				if (owner) ctx.externalFileOwners[relativePath] = owner[1];
-			}
-			const hash = (0, _animus_ui_extract_pipeline.contentHash)(code);
-			ctx.mutateFileCache((cache) => cache.set(relativePath, {
-				hash,
-				source: code
-			}));
-			const prevPlans = (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest);
-			let analysisOk = false;
-			let held = false;
+		const session = ctx.session;
+		if (!ctx.isProd && session !== null && !session.heldSources.has(relativePath)) {
+			let outcomes = [];
 			try {
-				const analysis = await ctx.analyzeIngested();
-				analysisOk = analysis.ok;
-				held = analysis.abortedOriginals !== void 0;
-			} finally {
-				if (!analysisOk && !held) ctx.mutateFileCache((cache) => cache.delete(relativePath));
+				outcomes = await ctx.submitChanges(changesOf("create", id));
+			} catch (error) {
+				ctx.warn(error instanceof Error ? error.message : String(error));
+				detectionFailed = true;
 			}
-			if (analysisOk) {
-				await reconcileSourceCorpus(ctx);
-				invalidateFileModules(ctx, (0, _animus_ui_extract_pipeline.diffFilePlans)(prevPlans, (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest), { exclude: relativePath }));
+			if (mergePublished(outcomes).published) {
+				const merged = mergePublished([...outcomes, ...await reconcileSourceCorpus(ctx)]);
+				applyPublished(ctx, merged);
+				if (!merged.full) invalidateFileModules(ctx, [...merged.planChanged].filter((path$4) => path$4 !== relativePath));
 				const compCount = ctx.storedManifest?.files[relativePath]?.length ?? 0;
 				ctx.info(`New file detected: ${relativePath} — ${compCount ? `${compCount} components extracted` : "no components"}`);
 				ctx.invalidateExtractedModules();
 			}
-		});
-		if (!ctx.storedManifest.files[relativePath]?.length) {
-			ctx.recordFallbackState(relativePath, unresolvedDropFiles(ctx).has(relativePath));
-			return null;
-		}
-	}
-	if (!ctx.isProd && ctx.rawExtensionFallbacks.size > 0) {
-		const conflicted = rawFallbackDescendants(ctx, relativePath);
-		if (conflicted.length > 0) {
-			invalidateFileModules(ctx, conflicted);
-			ctx.invalidateExtractedModules();
-			for (const file of conflicted) ctx.rawExtensionFallbacks.delete(file);
-			throw new Error(`ANIMUS_COMPOSITION_RECOVERING: '${relativePath}' extracted while extension consumer(s) ${conflicted.join(", ")} are still serving the runtime fallback — recovering via reload; this resolves on the next request.`);
 		}
+		if (detectionFailed) throw new Error(`[animus-extract] the analysis of the new file ${relativePath} failed; see the error above.`);
 	}
+	const drop = droppedExtensions(ctx).get(relativePath);
+	if (drop !== void 0) throw new Error((0, _animus_ui_extract_pipeline.droppedExtensionMessage)(drop));
+	if (!ctx.storedManifest.files[relativePath]?.length) return null;
 	try {
 		const { transformFile } = ctx.engineApi();
 		const result = transformFile(code, relativePath, ctx.storedManifestJson);
-		if (!result.hasComponents) {
-			ctx.recordFallbackState(relativePath, true);
-			return null;
-		}
+		if (!result.hasComponents) throw new Error(`the analysis extracted components from ${relativePath}, but its transform found none`);
 		if (ctx.tracing) {
 			const compCount = ctx.storedManifest.files[relativePath]?.length ?? 0;
 			ctx.trace(`transform ${relativePath}: ${compCount} components`);
@@ -1243,35 +1058,30 @@ async function transformSource(ctx, code, id) {
 			outputCode = applyDevBridgeImport(result.code);
 			ctx.recordTransformOutput(relativePath, outputCode);
 		}
-		ctx.recordFallbackState(relativePath, false);
 		return {
 			code: outputCode,
 			map: null
 		};
 	} catch (e) {
-		if (ctx.options.strict) ctx.strictFailure(`[animus-extract] Failed to transform ${id}: ${e}`, e);
-		else console.warn(`[animus-extract] Failed to transform ${id}:`, e);
-		ctx.recordFallbackState(relativePath, true);
-		return null;
+		throw new Error(`[animus-extract] Failed to transform ${id}: ${e}`, { cause: e });
 	}
 }
 //#endregion
 //#region src/hmr.ts
 /** Vite dispatches this hook once per environment for one file event: the
-*  analysis half is claimed by one dispatch, invalidation runs in each. */
-async function handleHotUpdate(ctx, environment, options) {
+*  dispatch that claims it submits the file to the Session, and invalidation
+*  runs in each. */
+async function handleHotUpdate(ctx, environment, { type, file, timestamp, modules, read }) {
 	if (ctx.isProd) return;
-	return runExclusiveAnalysis(ctx, () => handleHotUpdateExclusive(ctx, environment, options));
-}
-async function handleHotUpdateExclusive(ctx, environment, { type, file, timestamp, modules, read }) {
 	const ownsEvent = ctx.hotUpdateEvents.claim(environment.name, file, timestamp);
 	const absFile = (0, path.resolve)(file);
 	ctx.trace(`hotUpdate ${type} ${(0, path.relative)(ctx.rootDir, absFile)} env=${environment.name} owns=${ownsEvent}`);
 	if (ctx.isSystemDependency(absFile)) {
-		if (ownsEvent) {
-			await reconcileSourceEntry(ctx, absFile, type, read);
-			ctx.requestSystemReload((0, path.relative)(ctx.rootDir, absFile));
-		}
+		if (ownsEvent) requestSystemReload(ctx, absFile, type);
+		return [];
+	}
+	if (ctx.assetCopyDir !== null && ctx.isAssetSource(absFile)) {
+		if (ownsEvent && type !== "delete") ctx.refreshAssetCopies(absFile);
 		return [];
 	}
 	if (type === "delete") {
@@ -1295,31 +1105,74 @@ async function handleHotUpdateExclusive(ctx, environment, { type, file, timestam
 	}
 	return invalidateStaleModules(ctx, environment, modules, result);
 }
-/** Prefers Vite's `read`, which retries on the empty content an atomic save
-*  exposes; the direct read serves hosts that supply no `read`. */
-async function readChangedSource(absFile, read) {
-	return read ? await read() : (0, fs.readFileSync)(absFile, "utf-8");
-}
-/** Keeps the cache entry of a file that is both a system dependency and a
-*  discovered source; a file with no entry must never gain one here. */
-async function reconcileSourceEntry(ctx, absFile, type, read) {
-	if (type === "delete") {
-		ctx.mutateFileCache((cache) => pruneFileCache(cache, ctx.rootDir, absFile));
-		return;
+/** Each context's pending system-dependency events, and the window they
+*  wait out together. */
+const systemReloads = /* @__PURE__ */ new WeakMap();
+/** A system dependency's event waits out the coalescing window (SA19)
+*  before the Session reads it: a watcher can report a write as it starts
+*  and drop the event for its end, so an immediate read would load a
+*  half-written module. Events in one window reload once. */
+function requestSystemReload(ctx, absFile, type) {
+	let state = systemReloads.get(ctx);
+	if (state === void 0) {
+		const pending = /* @__PURE__ */ new Map();
+		state = {
+			pending,
+			window: new _animus_ui_extract_session.CoalescingWindow(() => {
+				if (pending.size === 0) return;
+				const taken = [...pending];
+				pending.clear();
+				return reloadSystem(ctx, taken);
+			})
+		};
+		systemReloads.set(ctx, state);
 	}
-	const relPath = (0, path.relative)(ctx.rootDir, absFile);
-	if (!ctx.fileCache.has(relPath)) return;
-	let source;
+	ctx.log(`HMR system reload scheduled: ${(0, path.relative)(ctx.rootDir, absFile)}`);
+	state.pending.set(absFile, type);
+	state.window.note();
+}
+/** Drops a pending system reload: the context is closing. */
+function cancelSystemReload(ctx) {
+	const state = systemReloads.get(ctx);
+	state?.window.cancel();
+	state?.pending.clear();
+}
+/** Reloads the system through the Session over the window's events. It
+*  runs from a timer, so it never throws: a failed reload keeps the last
+*  good system served and warns; under `strict` the client overlay reports
+*  it too. */
+async function reloadSystem(ctx, events) {
+	const reloadStart = performance.now();
+	const modifiedFiles = /* @__PURE__ */ new Set();
+	const removedFiles = /* @__PURE__ */ new Set();
+	for (const [path$1, type] of events) (type === "delete" ? removedFiles : modifiedFiles).add(path$1);
+	let outcomes;
 	try {
-		source = await readChangedSource(absFile, read);
-	} catch {
-		ctx.warn(`could not re-read ${relPath} after a system-dependency edit — system reloads will analyze its pre-edit text until a later edit is read successfully`);
+		outcomes = await ctx.submitChanges({
+			modifiedFiles,
+			removedFiles
+		});
+	} catch (err) {
+		ctx.warn(`[animus-extract] system reload failed: ${String(err)}`);
+		if (ctx.options.strict) {
+			const message = err instanceof Error ? err.message : String(err);
+			const stack = err instanceof Error ? err.stack ?? "" : "";
+			ctx.devServer?.hot?.send({
+				type: "error",
+				err: {
+					message,
+					stack,
+					plugin: "animus-extract"
+				}
+			});
+		}
+		ctx.invalidateSystemReloadModules(true);
 		return;
 	}
-	ctx.mutateFileCache((cache) => cache.set(relPath, {
-		hash: (0, _animus_ui_extract_pipeline.contentHash)(source),
-		source
-	}));
+	const merged = mergePublished(outcomes);
+	applyPublished(ctx, merged);
+	if (!merged.published) ctx.invalidateSystemReloadModules(false);
+	else ctx.log(`HMR system reload complete: ${Math.round(performance.now() - reloadStart)}ms`);
 }
 /** The once-per-event analysis half; its result is what the remaining
 *  environments act on. */
@@ -1327,76 +1180,47 @@ async function analyzeChangedFile(ctx, file, absFile, read) {
 	const ext = (0, path.extname)(file);
 	if (!ctx.extensionsSet.has(ext)) return { kind: "ignored" };
 	const excludeMatcher = ctx.excludeMatcher;
-	const isExternalPkg = ctx.externalPackageDirs.some((dir) => (0, _animus_ui_extract_pipeline.isPathWithinRoot)(dir, file));
-	if (!isExternalPkg && excludeMatcher.matches(file, (0, path.relative)(ctx.rootDir, file))) return { kind: "ignored" };
+	if (!ctx.externalPackageDirs.some((dir) => (0, _animus_ui_extract_pipeline.isPathWithinRoot)(dir, file)) && excludeMatcher.matches(file, (0, path.relative)(ctx.rootDir, file))) return { kind: "ignored" };
 	const relPath = (0, path.relative)(ctx.rootDir, absFile);
-	let source;
+	const outputDir = (0, _animus_ui_extract_pipeline.outputSourceGuard)(ctx.rootDir, ctx.outputExcludes)(absFile);
+	if (outputDir !== null) {
+		ctx.warn((0, _animus_ui_extract_pipeline.outputSourceMessage)(relPath, outputDir));
+		return { kind: "ignored" };
+	}
+	let settled;
 	try {
-		source = await readChangedSource(absFile, read);
+		settled = read ? await read() : void 0;
 	} catch {
 		return { kind: "ignored" };
 	}
-	const hash = (0, _animus_ui_extract_pipeline.contentHash)(source);
-	const cached = ctx.fileCache.get(relPath);
-	if (cached && cached.hash === hash) {
+	const hmrStart = performance.now();
+	const changes = changesOf("update", absFile);
+	const outcomes = await ctx.submitChanges(settled === void 0 ? changes : {
+		...changes,
+		sources: /* @__PURE__ */ new Map([[absFile, settled]])
+	});
+	const last = outcomes.at(-1)?.outcome;
+	if (last === void 0) {
 		ctx.trace(`HMR skip: ${relPath} (unchanged)`);
 		return { kind: "unchanged" };
 	}
-	const priorExternalOwner = ctx.externalFileOwners[relPath];
-	if (isExternalPkg && !priorExternalOwner) {
-		const owner = Object.entries(ctx.externalDirOwners).find(([dir]) => (0, _animus_ui_extract_pipeline.isPathWithinRoot)(dir, absFile));
-		if (owner) ctx.externalFileOwners[relPath] = owner[1];
-	}
-	ctx.mutateFileCache((cache) => cache.set(relPath, {
-		hash,
-		source
-	}));
-	const restoreEntry = () => {
-		ctx.mutateFileCache((cache) => {
-			if (cached) cache.set(relPath, cached);
-			else cache.delete(relPath);
-		});
-		if (priorExternalOwner) ctx.externalFileOwners[relPath] = priorExternalOwner;
-		else delete ctx.externalFileOwners[relPath];
-	};
-	const hmrStart = performance.now();
-	const prevPlans = (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest);
-	const analysisStart = performance.now();
-	const systemPropsBefore = systemPropsModuleSource(ctx);
-	let analysis;
-	try {
-		analysis = await ctx.analyzeIngested();
-	} catch (e) {
-		restoreEntry();
-		throw e;
-	}
-	if (!analysis.ok) {
-		if (analysis.abortedOriginals) return analysis.abortedOriginals.has(relPath) ? { kind: "ignored" } : { kind: "unchanged" };
-		restoreEntry();
-		return { kind: "ignored" };
-	}
-	try {
-		await reconcileSourceCorpus(ctx);
-	} catch (e) {
-		restoreEntry();
-		throw e;
-	}
-	const systemPropsChanged = systemPropsModuleSource(ctx) !== systemPropsBefore;
-	const analysisMs = Math.round(performance.now() - analysisStart);
-	const nativeEntry = ctx.corpus.published.analysisEntries.get(relPath);
-	const presentationOnly = nativeEntry && !analysis.endedHold ? isPresentationOnlyEdit(ctx, relPath, nativeEntry.source) : false;
-	const redelivered = presentationOnly ? [] : [relPath, ...analysis.redeliver];
+	if (last.kind === "held") return last.abortedOriginals.has(relPath) ? { kind: "ignored" } : { kind: "unchanged" };
+	const merged = mergePublished([...outcomes, ...await reconcileSourceCorpus(ctx)]);
+	applyPublished(ctx, merged);
+	const published = ctx.session.corpus.published;
+	const nativeEntry = published.analysisEntries.get(relPath);
+	const presentationOnly = nativeEntry && !merged.endedHold ? isPresentationOnlyEdit(ctx, relPath, nativeEntry.source) : false;
+	const redelivered = presentationOnly ? [] : [relPath, ...merged.redeliver];
 	const staleDefinitionFiles = [.../* @__PURE__ */ new Set([
-		...(0, _animus_ui_extract_pipeline.diffFilePlans)(prevPlans, (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest)),
-		...analysis.redeliver,
-		...extendingFiles(ctx, redelivered.flatMap((path$1) => ctx.corpus.published.ownership[path$1]?.analysisPaths ?? [path$1]))
+		...merged.planChanged,
+		...merged.redeliver,
+		...extendingFiles(ctx, redelivered.flatMap((path$2) => published.ownership[path$2]?.analysisPaths ?? [path$2]))
 	])].filter((defFile) => (0, path.resolve)(ctx.rootDir, defFile) !== absFile);
-	const hmrMs = Math.round(performance.now() - hmrStart);
-	ctx.log(`HMR update: ${relPath} — analysis ${analysisMs}ms, total ${hmrMs}ms${presentationOnly ? " (presentation-only)" : ""}`);
+	ctx.log(`HMR update: ${relPath} — total ${Math.round(performance.now() - hmrStart)}ms${presentationOnly ? " (presentation-only)" : ""}`);
 	return {
 		kind: "analyzed",
 		staleDefinitionFiles,
-		systemPropsChanged,
+		systemPropsChanged: merged.systemPropsChanged,
 		presentationOnly
 	};
 }
@@ -1415,17 +1239,14 @@ function isPresentationOnlyEdit(ctx, scannerRelPath, source) {
 		return false;
 	}
 }
-/** Prune a deleted file from the cache: a surviving entry is re-fed to the
-*  engine forever, so the deleted component's CSS never disappears. */
+/** A deleted file leaves the Session's corpus, so its CSS stops being
+*  re-emitted. */
 async function pruneDeletedFile(ctx, absFile) {
-	const relPath = (0, path.relative)(ctx.rootDir, absFile);
-	if (!ctx.fileCache.get(relPath)) return;
-	if (!ctx.mutateFileCache((cache) => pruneFileCache(cache, ctx.rootDir, absFile))) return;
-	const prevPlans = (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest);
-	const { ok } = await ctx.analyzeIngested();
-	if (!ok) return;
+	const merged = mergePublished(await ctx.submitChanges(changesOf("delete", absFile)));
+	if (!merged.published) return;
+	applyPublished(ctx, merged);
 	ctx.trace(`Deleted file pruned: ${(0, path.relative)(ctx.rootDir, absFile)}`);
-	invalidateFileModules(ctx, (0, _animus_ui_extract_pipeline.diffFilePlans)(prevPlans, (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest)));
+	if (!merged.full) invalidateFileModules(ctx, [...merged.planChanged]);
 	ctx.invalidateExtractedModules();
 }
 /** The per-environment invalidation half. Static CSS is left alone: it only
@@ -1534,7 +1355,7 @@ function loadVirtualModule(ctx, id) {
 		return css;
 	};
 	if (id === RESOLVED_CSS_ID) {
-		if (!ctx.isProd && ctx.storedSheets) {
+		if (!ctx.isProd && ctx.storedManifest) {
 			const { variables, body } = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
 				layers: ctx.options.layers,
 				variableCss: ctx.variableCss,
@@ -1604,24 +1425,26 @@ if (import.meta.hot) {
 }
 `;
 	}
-	if (id === RESOLVED_SYSTEM_PROPS_ID) return systemPropsModuleSource(ctx);
+	if (id === RESOLVED_SYSTEM_PROPS_ID) return ctx.systemPropsModule;
 	return null;
 }
 //#endregion
 //#region src/index.ts
-function sourceKitConfig(rootDir, serving) {
-	const kits = (0, _animus_ui_extract_pipeline.sourceKitDependencies)(rootDir).filter((kit) => kit.installed);
-	if (kits.length === 0) return void 0;
-	const names = kits.map((kit) => kit.name);
-	const config = { optimizeDeps: {
-		exclude: names,
-		include: kits.flatMap((kit) => kit.dependencies.map((dependency) => `${kit.name} > ${dependency}`))
-	} };
-	if (serving) config.ssr = { noExternal: names };
-	return config;
+async function sourceKitConfig(rootDir, systemPath, engine) {
+	const kits = /* @__PURE__ */ new Map();
+	for (const kit of [...(0, _animus_ui_extract_pipeline.sourceKitDependencies)(rootDir, engine), ...await (0, _animus_ui_extract_pipeline.systemKitDependencies)(rootDir, systemPath, engine)]) if (kit.installed && !kits.has(kit.name)) kits.set(kit.name, kit);
+	if (kits.size === 0) return void 0;
+	const names = [...kits.keys()];
+	return {
+		optimizeDeps: {
+			exclude: names,
+			include: [...kits.values()].flatMap((kit) => kit.dependencies.map((dependency) => `${kit.name} > ${dependency}`))
+		},
+		ssr: { noExternal: names }
+	};
 }
 function animusExtract(options) {
-	(0, _animus_ui_extract_pipeline.assertNoRetiredEngineSelection)(options.engine);
+	(0, _animus_ui_extract_pipeline.assertSupportedEngine)(options.engine);
 	(0, _animus_ui_extract_pipeline.assertKnownOptionKeys)(options, ["verify", "appearanceBootstrap"], [{
 		key: "root",
 		reason: "the Vite driver derives its root from the resolved Vite config"
@@ -1633,10 +1456,11 @@ function animusExtract(options) {
 	return {
 		name: "animus-extract",
 		enforce: "pre",
-		config(userConfig, env) {
+		async config(userConfig, env) {
 			const { mode } = (0, _animus_ui_extract_pipeline.resolveMode)(options.mode, () => env.command === "build" ? "production" : "development");
 			const define = { __ANIMUS_DEV__: mode === "development" };
-			const kits = sourceKitConfig((0, path.resolve)(userConfig.root ?? process.cwd()), env.command === "serve");
+			const root = (0, path.resolve)(userConfig.root ?? process.cwd());
+			const kits = await sourceKitConfig(root, (0, path.resolve)(root, options.system), ctx.kitEngine());
 			return kits ? {
 				define,
 				...kits
@@ -1649,9 +1473,15 @@ function animusExtract(options) {
 		configResolved(config) {
 			applyResolvedConfig(ctx, config);
 		},
+		buildEnd() {
+			if (!ctx.endBuild(this.environment ?? ctx.singleEnvironment)) return;
+			cancelSystemReload(ctx);
+			ctx.close();
+		},
 		async buildStart() {
-			await runBuildStart(ctx, async (specifier) => {
-				return (await this.resolve(specifier))?.id ?? null;
+			await ctx.openBuild(this.environment ?? ctx.singleEnvironment);
+			await runBuildStart(ctx, async (specifier, importer) => {
+				return (await this.resolve(specifier, importer))?.id ?? null;
 			}, ctx.isProd ? (fileName, source) => this.emitFile({
 				type: "asset",
 				name: fileName,