@animus-ui/vite-plugin 0.1.11 → 0.1.13

package/dist/index.cjs

@@ -8,12 +8,8 @@ let path = require("path");
 let crypto = require("crypto");
 //#region src/build-start.ts
 /**
-* buildStart: load the system, discover and ingest sources (local +
-* external packages), run whole-project analysis, and log the report.
-* `resolveSpecifier` is the bundler seam — Vite's `this.resolve` mapped to
-* an absolute id. `emitAsset` (build mode only) is Rollup's `this.emitFile`
-* for `asset()` placeholder substitution; absent in dev, where resolved
-* files are served via base + `/@fs/` instead.
+* `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);
@@ -50,7 +46,6 @@ async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 	const localFileCount = rawEntries.length;
 	const packageSpecifiers = (0, _animus_ui_extract_pipeline.extractSystemFilePackages)(ctx.resolvedSystemPath);
 	ctx.externalSourceEntries.clear();
-	ctx.externalKeyframesScanEntries.clear();
 	const collected = await (0, _animus_ui_extract_pipeline.collectExternalPackageSources)({
 		specifiers: packageSpecifiers,
 		resolveSpecifier,
@@ -65,7 +60,6 @@ async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 	ctx.externalFileOwners = collected.fileOwners;
 	ctx.enforceIncludeResolution();
 	for (const [specifier, srcEntry] of collected.sourceEntries) ctx.externalSourceEntries.set(specifier, srcEntry);
-	for (const [specifier, scanEntry] of collected.keyframesScanEntries) ctx.externalKeyframesScanEntries.set(specifier, scanEntry);
 	for (const entry of collected.entries) {
 		const hash = !ctx.isProd ? (0, _animus_ui_extract_pipeline.contentHash)(entry.source) : void 0;
 		rawEntries.push({
@@ -76,17 +70,19 @@ async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 	}
 	ctx.externalPackageDirs = collected.packageDirs;
 	ctx.registerSystemWatchPaths();
-	ctx.applyExternalKeyframes();
 	const packageFileCount = rawEntries.length - localFileCount;
 	ctx.log(`Discovered ${rawEntries.length} files (${packageFileCount} from packages) (${Math.round(performance.now() - t0)}ms)`);
 	t0 = performance.now();
 	await ctx.analyzeIngested({
 		rawEntries,
 		beforeAnalysis: (accepted) => {
-			if (!ctx.isProd) ctx.fileCache = new Map(accepted.originalEntries.map((entry) => [entry.path, {
-				hash: entry.hash,
-				source: entry.source
-			}]));
+			if (!ctx.isProd) ctx.mutateFileCache((cache) => {
+				cache.clear();
+				for (const entry of accepted.originalEntries) cache.set(entry.path, {
+					hash: entry.hash,
+					source: entry.source
+				});
+			});
 		}
 	});
 	const assetSpecifiers = (0, _animus_ui_extract_pipeline.findAssetSpecifiers)(ctx.globalCss);
@@ -108,17 +104,14 @@ async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 	ctx.assetPassComplete = true;
 	if (ctx.storedManifest) {
 		const report = ctx.storedManifest.report;
-		if (report) {
-			ctx.log(`Extracted ${report.components_extracted}/${report.components_total} components (${Math.round(performance.now() - t0)}ms)`);
-			ctx.logTimingWaterfall(ctx.storedManifest.timing ?? {});
-			ctx.log(`Reconciliation: ${report.components_extracted} kept, ${report.variants_eliminated} variants pruned, ${report.states_eliminated} states pruned`);
-			const details = report.eliminated_details || [];
-			for (const d of details) if (d.kind === "component") ctx.warn(`⚠ ${d.component} eliminated: ${d.reason}`);
-			else if (d.kind === "prospective_component") ctx.warn(`⚠ ${d.component} would be eliminated in production: ${d.reason}`);
-			else if (d.kind === "variant") ctx.warn(`⚠ ${d.component} variant '${d.name}' pruned: ${d.reason}`);
-			else if (d.kind === "state") ctx.warn(`⚠ ${d.component} state '${d.name}' pruned: ${d.reason}`);
-		}
-		ctx.log(`CSS: ${ctx.resolvedComponentCss.length} bytes (${Object.keys(ctx.storedManifest.components || {}).length} components)`);
+		ctx.log(`Extracted ${report.components_extracted}/${report.components_total} components (${Math.round(performance.now() - t0)}ms)`);
+		ctx.logTimingWaterfall(ctx.storedManifest.timing);
+		ctx.log(`Reconciliation: ${report.components_extracted} kept, ${report.variants_eliminated} variants pruned, ${report.states_eliminated} states pruned`);
+		for (const d of report.eliminated_details) if (d.kind === "component") ctx.warn(`⚠ ${d.component} eliminated: ${d.reason}`);
+		else if (d.kind === "prospective_component") ctx.warn(`⚠ ${d.component} would be eliminated in production: ${d.reason}`);
+		else if (d.kind === "variant") ctx.warn(`⚠ ${d.component} variant '${d.name}' pruned: ${d.reason}`);
+		else if (d.kind === "state") ctx.warn(`⚠ ${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) {
 			const staticSize = (0, _animus_ui_extract_pipeline.assembleStylesheet)({
 				layers: ctx.options.layers,
@@ -140,11 +133,6 @@ async function runBuildStart(ctx, resolveSpecifier, emitAsset) {
 }
 //#endregion
 //#region src/config.ts
-/**
-* configResolved: capture build mode, root, and logger; resolve Lightning
-* CSS targets; harvest resolve.alias into the Rust `pathAliasesJson`
-* contract via the shared encoder.
-*/
 function applyResolvedConfig(ctx, config) {
 	ctx.isProd = config.command === "build";
 	ctx.emissionProd = (0, _animus_ui_extract_pipeline.resolveMode)(ctx.options.mode, () => config.command === "build" ? "production" : "development").mode === "production";
@@ -153,35 +141,26 @@ function applyResolvedConfig(ctx, config) {
 	ctx.base = config.base ?? "/";
 	ctx.lcssTargets = (0, _animus_ui_extract_pipeline.resolveLightningTargets)(ctx.options.targets, ctx.rootDir);
 	ctx.log(`Lightning CSS targets resolved (${Object.keys(ctx.lcssTargets).length} browsers)`);
-	const rawAlias = config.resolve?.alias;
-	if (rawAlias) {
-		const pairs = [];
-		if (Array.isArray(rawAlias)) {
-			for (const entry of rawAlias) if (typeof entry.find === "string" && typeof entry.replacement === "string") pairs.push({
-				pattern: entry.find,
-				target: entry.replacement,
-				kind: "prefix"
-			});
-		} else if (typeof rawAlias === "object" && rawAlias !== null) {
-			for (const [key, value] of Object.entries(rawAlias)) if (typeof value === "string") pairs.push({
-				pattern: key,
-				target: value
-			});
-		}
-		const built = (0, _animus_ui_extract_pipeline.buildPathAliasesJson)(pairs, ctx.rootDir);
-		if (built) {
-			ctx.pathAliasesJson = built.json;
-			ctx.log(`Path aliases forwarded: ${built.count} entries`);
-		}
+	const pairs = [];
+	for (const entry of config.resolve.alias) {
+		if (entry.find instanceof RegExp) continue;
+		pairs.push({
+			pattern: entry.find,
+			target: entry.replacement,
+			kind: "prefix"
+		});
+	}
+	const built = (0, _animus_ui_extract_pipeline.buildPathAliasesJson)(pairs, ctx.rootDir);
+	if (built) {
+		ctx.pathAliasesJson = built.json;
+		ctx.log(`Path aliases forwarded: ${built.count} entries`);
 	}
 }
 //#endregion
 //#region src/constants.ts
 /**
-* The namespace every virtual module this plugin owns lives under. Exported so
-* the `transform` guard that keeps those modules out of source-file handling
-* matches on the same string the ids are built from — a rename of the
-* namespace cannot leave the guard behind.
+* The namespace every virtual module here lives under; the `transform` guard
+* matches on this same string so a rename cannot strand it.
 */
 const VIRTUAL_PREFIX = "virtual:animus/";
 const VIRTUAL_CSS_ID = `${VIRTUAL_PREFIX}styles.css`;
@@ -191,18 +170,8 @@ const RESOLVED_COMPONENTS_ID = `\0${VIRTUAL_COMPONENTS_ID}`;
 const VIRTUAL_BRIDGE_ID = `${VIRTUAL_PREFIX}hmr-bridge.js`;
 const RESOLVED_BRIDGE_ID = `\0${VIRTUAL_BRIDGE_ID}`;
 /**
-* Browser-addressable URL for the bridge, used as the `src` of the dev
-* `<script type="module">` (see index-html.ts). THE explanation of the `/@id/`
-* convention lives here; everything else points at it.
-*
-* Vite reserves `/@id/` for module ids that are not file paths. Its transform
-* middleware normalizes such a URL before serving it (`unwrapId`): strip the
-* prefix, then decode the `__x00__` placeholder back to a NUL byte. The
-* UNPREFIXED specifier is what travels here — `resolveVirtualId` is the hook
-* that answers it, and it answers with the `\0` form. (Vite's own `wrapId`
-* encodes an already-`\0`-prefixed id as `__x00__`; that form resolves too, but
-* it leans on the placeholder convention rather than on this plugin's own
-* `resolveId` contract.)
+* Vite reserves `/@id/` for module ids that are not file paths and strips the
+* prefix before `resolveId`, so the unprefixed specifier travels here.
 */
 const BRIDGE_SCRIPT_SRC = `/@id/${VIRTUAL_BRIDGE_ID}`;
 const VIRTUAL_SYSTEM_PROPS_ID = `${VIRTUAL_PREFIX}system-props`;
@@ -210,50 +179,56 @@ const RESOLVED_SYSTEM_PROPS_ID = `\0${VIRTUAL_SYSTEM_PROPS_ID}`;
 //#endregion
 //#region src/hot-update-events.ts
 /**
-* Once-per-file-event coordination across the `hotUpdate` dispatches.
-*
-* Vite 8 calls `hotUpdate` once per environment for a single file event — the
-* client environment first, then every non-client environment (see
-* `handleHMRUpdate` in vite/dist/node/chunks/node.js). Analysis work (cache
-* mutation, engine re-analysis, geological reset scheduling) must happen
-* exactly once per event; module invalidation must happen per environment
-* against that environment's own graph.
-*
-* The client dispatch always claims — it is dispatched first, so nothing can
-* have claimed the event before it, and claiming unconditionally keeps a
-* same-millisecond `(file, timestamp)` collision from ever costing a client
-* analysis. A non-client dispatch claims only when the event carries no
-* recorded claim at all, which happens when the plugin is filtered out of the
-* client environment.
-*
-* Keys are retained for a bounded number of recent events so that interleaved
-* file events (Vite does not serialize watcher handlers) still find their own
-* result.
+* Vite dispatches `hotUpdate` once per environment, client first: analysis
+* runs for one dispatch, invalidation for all, coordinated through these keys.
 */
 var HotUpdateEvents = class {
+	historyLimit;
 	results = /* @__PURE__ */ new Map();
+	/** Keys whose decision aged out of `results`, in eviction order. */
+	evicted = /* @__PURE__ */ new Set();
 	constructor(historyLimit = 16) {
 		this.historyLimit = historyLimit;
 	}
 	/** True when this environment dispatch owns the event's analysis work. */
 	claim(environmentName, file, timestamp) {
 		const key = eventKey(file, timestamp);
-		if (environmentName !== "client" && this.results.has(key)) return false;
+		if (environmentName !== "client" && (this.results.has(key) || this.evicted.has(key))) return false;
 		this.results.set(key, { kind: "ignored" });
-		while (this.results.size > this.historyLimit) {
-			const oldest = this.results.keys().next().value;
-			if (oldest === void 0) break;
-			this.results.delete(oldest);
-		}
+		this.evicted.delete(key);
+		this.retireOldest();
 		return true;
 	}
 	/** Publish the owning dispatch's decision to the other environments. */
 	record(file, timestamp, result) {
-		this.results.set(eventKey(file, timestamp), result);
+		const key = eventKey(file, timestamp);
+		this.results.set(key, result);
+		this.evicted.delete(key);
+		this.retireOldest();
 	}
-	/** The decision for this event — `ignored` when the event was evicted. */
+	/**
+	* The decision for this event — `evicted` once it aged out of the decision
+	* window, `ignored` only when no dispatch ever claimed it.
+	*/
 	resultOf(file, timestamp) {
-		return this.results.get(eventKey(file, timestamp)) ?? { kind: "ignored" };
+		const key = eventKey(file, timestamp);
+		const result = this.results.get(key);
+		if (result) return result;
+		return this.evicted.has(key) ? { kind: "evicted" } : { kind: "ignored" };
+	}
+	/** Hold both windows at `historyLimit`, oldest insertion first. */
+	retireOldest() {
+		while (this.results.size > this.historyLimit) {
+			const oldest = this.results.keys().next().value;
+			if (oldest === void 0) break;
+			this.results.delete(oldest);
+			this.evicted.add(oldest);
+		}
+		while (this.evicted.size > this.historyLimit) {
+			const oldest = this.evicted.values().next().value;
+			if (oldest === void 0) break;
+			this.evicted.delete(oldest);
+		}
 	}
 };
 /** A path can hold any character but NUL, so NUL is the safe separator. */
@@ -263,16 +238,8 @@ function eventKey(file, timestamp) {
 //#endregion
 //#region src/module-invalidation.ts
 /**
-* Evict every module node the dev server holds for each file — every
-* environment graph (client, ssr, and any custom environment), by-file node
-* sets (covers query-suffixed variants), plus the absolute-path id lookup.
-* Falls back to the mixed compat graph for hosts without environment
-* graphs. Returns the number of nodes invalidated.
-*
-* Completeness here is load-bearing: the file-plan diff is the ONLY
-* invalidation candidate source, so a node shape this enumeration misses
-* stays stale for the life of the server (openspec: dev-transform-coherence,
-* "Client and SSR nodes are both evicted").
+* Completeness is load-bearing: the file-plan diff is the only invalidation
+* candidate source, so a node shape missed here stays stale for the session.
 */
 function invalidateFileModules(ctx, relPaths) {
 	const server = ctx.devServer;
@@ -300,16 +267,12 @@ function invalidateFileModules(ctx, relPaths) {
 }
 //#endregion
 //#region src/reset-coalescer.ts
-/**
-* Coalesces bursts of system-dependency events into single geological
-* resets: a quiescence window before starting, at most one reset in
-* flight, and exactly one follow-up when requests arrive mid-reset. A
-* package build regenerating its dist fires one reset, not one per file.
-*
-* Timer functions are injected seams — `vi.mock` on node builtins silently
-* no-ops under vite-plus-test, so tests drive a manual scheduler instead.
-*/
 var ResetCoalescer = class {
+	run;
+	onError;
+	quietMs;
+	schedule;
+	cancel;
 	timer = null;
 	running = false;
 	dirty = false;
@@ -347,7 +310,6 @@ var ResetCoalescer = class {
 };
 //#endregion
 //#region src/context.ts
-/** Pre-load / failed-load defaults — the plugin's historical initial state. */
 function emptySystemConfig() {
 	return {
 		propConfigJson: "{}",
@@ -361,24 +323,14 @@ function emptySystemConfig() {
 		keyframesJson: null
 	};
 }
-/** Full raw originals for one adaptation attempt. */
-function buildRawEntriesFromCache(cache) {
-	return [...cache].map(([path$1, { hash, source }]) => ({
-		path: path$1,
-		source,
-		hash
-	}));
-}
 const analysisChains = /* @__PURE__ */ new WeakMap();
-/** Run `task` after every previously scheduled analysis transaction for
-*  this context. Entry points only (transform detection, hot update,
-*  geological reset); helpers they call internally must stay unlocked. */
+/** 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;
 }
-/** Generate the module from the four inputs the context currently holds. */
 function generateSystemPropsModule(ctx) {
 	return (0, _animus_ui_extract_pipeline.buildSystemPropsModule)({
 		systemPropMapJson: ctx.storedSystemPropMapJson,
@@ -387,52 +339,47 @@ function generateSystemPropsModule(ctx) {
 		transformsSource: ctx.storedTransformsSource
 	});
 }
-/**
-* The exact source `virtual:animus/system-props` serves for the current state.
-* One definition, so the served bytes and the change decision below can never
-* be computed from different inputs.
-*
-* A real context carries the module already generated (`systemPropsModuleMemo`,
-* refreshed wherever the four inputs move), so serving it and deciding whether
-* it changed are both reads. Contexts that publish those inputs by hand — the
-* behavioral test doubles — carry no memo and generate here instead.
-*/
+/** 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.storedTransformsSource
+	].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) {
-	return ctx.systemPropsModuleMemo ??= generateSystemPropsModule(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 in `analysisEntryCache` and disappear
-* atomically when the next source-ingestion result publishes. External
-* package entries are rootDir-relative too (with leading `..` segments).
-*/
+/** 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);
 }
-/**
-* Per-plugin-instance state and the pipeline operations over it. Hook
-* bodies live in their own modules (build-start, virtual-modules,
-* transform, hmr) and receive this context — the plugin factory in
-* index.ts only wires Vite hooks to those functions.
-*
-* A class rather than closure variables so each hook module names exactly
-* the state it touches, and the engine store (per-instance, never
-* module-level) is explicit.
-*/
 var PluginContext = class {
 	options;
 	verbose;
-	/** Serialized staticCss forced-emission declarations (stable key order). */
 	staticCssJson;
 	isProd = false;
-	/** Emission-mode signal (explicit `mode` option wins over the command);
-	*  feeds engine devMode and the minify default. Lifecycle stays on
-	*  `isProd`. */
+	/** Emission mode (the explicit `mode` option wins over the command); feeds
+	*  engine devMode and the minify default. Lifecycle stays on `isProd`. */
 	emissionProd = false;
 	rootDir = "";
 	logger = null;
-	/** System-derived config (shared SystemConfig shape). */
 	system = emptySystemConfig();
 	lcssTargets = {};
 	pathAliasesJson = null;
@@ -448,46 +395,43 @@ var PluginContext = class {
 	recordTransformOutput(relativePath, code) {
 		this.transformOutputHashes.set(relativePath, (0, _animus_ui_extract_pipeline.contentHash)(code));
 	}
-	/**
-	* The consumer system's OWN keyframes collections, captured at load time
-	* before any external merge touches `system.keyframesJson`. Every
-	* `applyExternalKeyframes` merge starts from this baseline, so repeated
-	* merges (a --watch rebuild's loadSystem + rediscovery, a geological
-	* reset) never compound prior external state — a removed include's
-	* keyframes disappear with it.
-	*/
-	consumerKeyframesJson = null;
-	/**
-	* Merge `Keyframes` collections from discovered external package entries
-	* into the system's collections (keyframes-only carve-out — the consumer
-	* system stays the singular config authority). Runs after buildStart
-	* discovery AND after every geological-reset system reload, since a reload
-	* rebuilds `this.system` from the consumer entry alone. Merges from the
-	* consumer-only baseline, never from the previously merged value.
-	*/
-	applyExternalKeyframes() {
-		if (this.externalKeyframesScanEntries.size === 0) {
-			this.system.keyframesJson = this.consumerKeyframesJson;
-			this.externalKeyframesDiagnostics = [];
-			return;
-		}
-		const merge = (0, _animus_ui_extract_pipeline.mergeExternalKeyframes)((entry, root) => this.engineApi().scanKeyframesExports(entry, root), this.consumerKeyframesJson, this.externalKeyframesScanEntries.values(), this.rootDir);
-		this.system.keyframesJson = merge.keyframesJson;
-		this.externalKeyframesDiagnostics = merge.diagnostics;
-	}
-	/** Discovery-time keyframes diagnostics awaiting the next analysis's
-	*  shared surfacing pass. */
-	externalKeyframesDiagnostics = [];
+	/** Vocabulary witnesses from the sealed system, awaiting the next analysis.
+	*  Surfacing happens only inside `runProjectAnalysis`. */
+	systemVocabularyDiagnostics = [];
 	reverseProvenance = {};
 	storedSystemPropMapJson = "{}";
 	storedDynamicPropsJson = "{}";
 	storedTransformsSource = "{}";
-	systemPropsModuleMemo = null;
 	fileCache = /* @__PURE__ */ new Map();
-	analysisEntryCache = /* @__PURE__ */ new Map();
-	sourceOwnership = {};
-	analysisOwnerByPath = /* @__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)
+	});
 	rawExtensionFallbacks = /* @__PURE__ */ new Set();
+	/** The one mutator of a file's fallback state — every raw-serve exit of the
+	*  transform hook reports here. 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 = {};
@@ -499,7 +443,6 @@ var PluginContext = class {
 	externalDirOwners = {};
 	externalFileOwners = {};
 	externalSourceEntries = /* @__PURE__ */ new Map();
-	externalKeyframesScanEntries = /* @__PURE__ */ new Map();
 	externalPackageOutcomes = [];
 	devServer;
 	resolvedSystemPath = null;
@@ -508,7 +451,7 @@ var PluginContext = class {
 	v2Engine = null;
 	v2SentSources = null;
 	v2DriftWarned = false;
-	/** Single engine choke-point for every native extraction call. */
+	/** Every native extraction call goes through this one accessor. */
 	engineApi;
 	constructor(options, engineApiOverride) {
 		this.options = options;
@@ -527,8 +470,9 @@ var PluginContext = class {
 			loadNativeEngine: () => require(engineModuleId),
 			rehydrateFilesJson: (filesJsonRaw) => {
 				if (!filesJsonRaw.includes("\"source\":\"\"")) return filesJsonRaw;
-				const entries = JSON.parse(filesJsonRaw);
-				for (const entry of entries) if (entry.source === "") entry.source = this.analysisEntryCache.get(entry.path)?.source ?? "";
+				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: {
@@ -550,12 +494,8 @@ var PluginContext = class {
 	log(msg) {
 		if (this.verbose) (this.logger ?? console).info(`[animus] ${msg}`);
 	}
-	/**
-	* Standard-level information — emitted whether or not `verbose` is on.
-	* Reserved for events a developer must see without opting in, e.g. a file
-	* created after buildStart being folded into the analysis (openspec:
-	* hmr-new-file-detection, "New file detection logging").
-	*/
+	/** Logs whether or not `verbose` is on — for events a developer must see
+	*  without opting in. */
 	info(msg) {
 		(this.logger ?? console).info(`[animus] ${msg}`);
 	}
@@ -569,11 +509,8 @@ var PluginContext = class {
 			labelWidth: 15
 		})) this.log(line);
 	}
-	/**
-	* Load a SystemInstance via Rust NAPI (rquickjs bundled eval) into
-	* `this.system`. On failure the previous config is kept (strict mode
-	* throws instead).
-	*/
+	/** Load the system into `this.system`. On failure the previous config is
+	*  kept; strict mode throws instead. */
 	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);
@@ -590,23 +527,14 @@ var PluginContext = class {
 			this.systemDependencyKeys = keys;
 			this.systemDependencyPaths = deps;
 			this.registerSystemWatchPaths();
-			this.consumerKeyframesJson = this.system.keyframesJson;
-			this.applyExternalKeyframes();
+			this.systemVocabularyDiagnostics = (0, _animus_ui_extract_pipeline.vocabularyWitnessDiagnostics)(this.system.vocabularyWitnessesJson);
 		} catch (e) {
 			if (this.options.strict) throw new Error(`[animus-extract] Failed to load system from ${this.resolvedSystemPath}: ${e}`, { cause: e });
 			console.warn(`[animus-extract] Failed to load system from ${this.resolvedSystemPath}:`, e);
 		}
-		this.systemPropsModuleMemo = generateSystemPropsModule(this);
 	}
-	/**
-	* Run project analysis via the shared `runProjectAnalysis` and update
-	* all manifest-derived state. Returns whether the analysis PUBLISHED —
-	* `false` means the previous manifest is still current, and callers that
-	* advanced the file cache for this attempt must roll that entry back or
-	* the content-hash gate will suppress the same-content retry forever
-	* (openspec: dev-transform-coherence, "Failed analyses do not suppress
-	* equal-content retries"). Strict mode still throws.
-	*/
+	/** Runs project analysis and updates every manifest-derived state. Returns
+	*  false when nothing published, and the caller must roll its cache back. */
 	runAnalysis(fileEntries) {
 		let result;
 		try {
@@ -624,81 +552,42 @@ var PluginContext = class {
 				devMode: !this.emissionProd,
 				warn: (m) => this.warn(m),
 				strict: this.options.strict,
-				extraDiagnostics: this.externalKeyframesDiagnostics
+				extraDiagnostics: this.systemVocabularyDiagnostics
 			});
 		} catch (e) {
 			if (this.options.strict) throw new Error(`[animus-extract] analyzeProject failed: ${e}`, { cause: e });
 			console.warn("[animus-extract] analyzeProject failed:", e);
 			return false;
 		}
-		(0, _animus_ui_extract_pipeline.assertNoErrorDiagnostics)(result.manifest?.diagnostics);
+		(0, _animus_ui_extract_pipeline.assertNoErrorDiagnostics)(result.manifest.diagnostics);
 		this.assertRuntimeImportSuppliesTerminals(result.manifest);
 		this.storedManifest = result.manifest;
 		this.storedManifestJson = result.manifestJson;
-		this.storedSystemPropMapJson = JSON.stringify(result.manifest?.system_prop_map ?? {});
-		this.storedDynamicPropsJson = JSON.stringify(result.manifest?.dynamic_props ?? {});
-		this.reverseProvenance = result.manifest?.reverse_provenance ?? {};
-		this.storedSheets = result.manifest?.sheets ?? null;
+		this.storedSystemPropMapJson = JSON.stringify(result.manifest.system_prop_map);
+		this.storedDynamicPropsJson = JSON.stringify(result.manifest.dynamic_props);
+		this.reverseProvenance = result.manifest.reverse_provenance;
+		this.storedSheets = result.manifest.sheets;
 		this.globalCss = result.globalCss;
 		this.resolvedComponentCss = result.componentCss;
-		this.systemPropsModuleMemo = generateSystemPropsModule(this);
 		this.applyAssetSubstitutions();
 		return true;
 	}
-	/**
-	* `runtimeImport` swaps ONE module specifier under every generated
-	* factory import, and the engine performs no export validation — an
-	* override that supplies only `createClassResolver` (the documented
-	* class-resolver entry contract) breaks the bundle at LOAD the moment any
-	* non-`.asClass()` terminal exists, with the error pointing at generated
-	* code. Guaranteed-broken output escalates in every mode, exactly like
-	* error diagnostics (extraction-diagnostics §Error diagnostics fail the
-	* build), naming the offending components instead of the import site.
-	*/
 	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 ?? {})) {
-			const replacement = String(descriptor?.replacement ?? "");
-			if (/\bcreateComponent\(|\bcreateComposedFamily\(/.test(replacement)) offenders.push(id);
-		}
+		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 shared ingestion policy point — capability guard, facts memo, and
-	*  warn-dedupe lifecycle all live in the pipeline, not per host. */
-	sourceIngestor = (0, _animus_ui_extract_pipeline.createSourceIngestor)({
-		engineApi: () => this.engineApi(),
-		prefix: "[animus-extract]",
-		strict: () => !!this.options.strict,
-		warn: (message) => this.warn(message)
-	});
-	/** Prepare one raw-source corpus through the shared adaptation boundary. */
-	async ingestRawSources(fileEntries) {
-		return this.sourceIngestor.ingest(fileEntries);
-	}
-	/** Surface adapter diagnostics under the shared strict/warn policy. */
-	surfaceSourceDiagnostics(diagnostics) {
-		return this.sourceIngestor.surfaceDiagnostics(diagnostics);
-	}
-	/**
-	* The one ingest → quarantine → analyze → publish transaction, shared by
-	* buildStart and every incremental path. Per-file quarantine: one invalid
-	* original warns and drops without aborting the rest of the corpus
-	* (strict mode throws from the shared policy). `runAnalysis(...) !==
-	* false` is the documented success contract (a `void` behavioral test
-	* double reads as success), and the accepted corpus publishes only on
-	* success. `beforeAnalysis` runs between quarantine and analysis for the
-	* two sites with a documented ordering constraint: buildStart's dev-cache
-	* seed must survive a strict analysis throw, and the geological reset
-	* clears the engine cache only after strict ingestion diagnostics had
-	* their chance to throw.
-	*/
+	/** The one ingest → quarantine → analyze → publish transaction. The corpus
+	*  publishes only on success; `beforeAnalysis` runs after quarantine. */
 	async analyzeIngested(options) {
-		const ingested = await this.ingestRawSources(options?.rawEntries ?? buildRawEntriesFromCache(this.fileCache));
-		const accepted = (0, _animus_ui_extract_pipeline.withoutInvalidOriginals)(ingested, this.surfaceSourceDiagnostics(ingested.diagnostics));
+		const accepted = await this.corpus.prepare(options?.rawEntries ?? {
+			fileCache: this.fileCache,
+			externalFileOwners: this.externalFileOwners
+		});
 		options?.beforeAnalysis?.(accepted);
 		const ok = this.runAnalysis(accepted.analysisEntries) !== false;
 		if (ok) this.publishSourceIngestion(accepted);
@@ -707,48 +596,22 @@ var PluginContext = class {
 			accepted
 		};
 	}
-	/** Publish every parser child and ownership edge atomically after analysis. */
 	publishSourceIngestion(result) {
-		this.sourceIngestor.markPublished(result);
-		const priorAnalysisPaths = new Set(this.analysisOwnerByPath.keys());
-		this.analysisEntryCache = new Map(result.analysisEntries.map((entry) => [entry.path, {
-			hash: entry.hash,
-			source: entry.source
-		}]));
-		this.sourceOwnership = result.ownership;
-		this.analysisOwnerByPath = /* @__PURE__ */ new Map();
-		for (const owner of Object.values(result.ownership)) for (const analysisPath of owner.analysisPaths) {
-			this.analysisOwnerByPath.set(analysisPath, owner.originalPath);
-			const externalOwner = this.externalFileOwners[owner.originalPath];
-			if (externalOwner) this.externalFileOwners[analysisPath] = externalOwner;
-		}
-		for (const stalePath of priorAnalysisPaths) if (!this.analysisOwnerByPath.has(stalePath)) delete this.externalFileOwners[stalePath];
+		this.corpus.publish(result);
+		this.externalFileOwners = (0, _animus_ui_extract_pipeline.projectExternalFileOwners)(result, this.externalFileOwners);
 		this.enforceExternalTokenContracts();
 	}
-	/** Base-prefixed dev URL for an absolute file (Vite mounts /@fs under base). */
 	devFsUrl(absPath) {
 		return `${this.base.endsWith("/") ? this.base.slice(0, -1) : this.base}/@fs${absPath}`;
 	}
-	/**
-	* The shared unresolvable-asset policy: fail the build under `strict`,
-	* else warn and record the identity mapping so the specifier emits
-	* literally.
-	*/
 	assetFallback(specifier, message, cause) {
 		if (this.options.strict) throw new Error(message, cause === void 0 ? void 0 : { cause });
 		this.warn(message);
 		this.assetUrlBySpecifier.set(specifier, specifier);
 		this.assetResolutionFailures.add(specifier);
 	}
-	/**
-	* The one asset-substitution pass per analysis. In dev, a specifier not
-	* already mapped by buildStart's bundler-resolved pass (a geological
-	* reset regenerates globalCss from an edited system, which may reference
-	* NEW assets) is resolved Node-side first — host aliases, then Node,
-	* then package root; bundler-only resolutions can differ, since the
-	* plugin hook context is unavailable on this path. Strict semantics
-	* match buildStart.
-	*/
+	/** Resolves asset specifiers a system reload introduced. Node-side only —
+	*  the plugin hook context is unavailable here, so results can differ. */
 	applyAssetSubstitutions() {
 		if (!this.isProd && this.assetPassComplete) for (const specifier of (0, _animus_ui_extract_pipeline.findAssetSpecifiers)(this.globalCss)) {
 			if (this.assetResolutionFailures.delete(specifier)) this.assetUrlBySpecifier.delete(specifier);
@@ -760,47 +623,33 @@ var PluginContext = class {
 		this.globalCss = (0, _animus_ui_extract_pipeline.substituteAssetPlaceholders)(this.globalCss, this.assetUrlBySpecifier);
 	}
 	resetCoalescer = null;
-	/**
-	* Schedule a geological reset through the burst coalescer. N dependency
-	* events within the quiescence window produce one reset; events during a
-	* running reset produce exactly one follow-up.
-	*/
-	requestGeologicalReset(trigger) {
-		this.log(`HMR geological reset scheduled: ${trigger}`);
-		this.resetCoalescer ??= new ResetCoalescer(async () => this.performGeologicalReset(), (err) => this.geologicalResetFailed(err));
-		this.resetCoalescer.request();
-	}
-	/**
-	* A failed reset must surface without killing the server: the coalescer
-	* fires from a bare timer, OUTSIDE Vite's handleHMRUpdate catch, so a
-	* strict-mode throw (asset resolution, token contracts, system load)
-	* would otherwise be an unhandled exception that exits the process.
-	* Strict-in-dev means the error overlay, matching the transform/HMR
-	* strict paths that Vite itself catches.
-	*/
-	geologicalResetFailed(err) {
-		this.warn(`[animus-extract] geological reset failed: ${err}`);
-		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"
+	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();
 	}
-	/**
-	* The geological reset: reload the system (refreshing the dependency
-	* set), clear the Rust per-file cache, re-analyze everything with full
-	* sources, then invalidate the static/component/system-prop virtual
-	* modules and reload the client.
-	*/
-	async performGeologicalReset() {
-		return runExclusiveAnalysis(this, () => this.performGeologicalResetExclusive());
+	async performSystemReload() {
+		return runExclusiveAnalysis(this, () => this.performSystemReloadExclusive());
 	}
-	async performGeologicalResetExclusive() {
+	async performSystemReloadExclusive() {
 		const resetStart = performance.now();
 		const prevPlans = (0, _animus_ui_extract_pipeline.snapshotFilePlans)(this.storedManifest);
 		try {
@@ -808,12 +657,12 @@ var PluginContext = class {
 			const { ok } = await this.analyzeIngested({ beforeAnalysis: () => (0, _animus_ui_extract_pipeline.clearEngineCache)(this.engineApi) });
 			if (!ok) return;
 			invalidateFileModules(this, (0, _animus_ui_extract_pipeline.diffFilePlans)(prevPlans, (0, _animus_ui_extract_pipeline.snapshotFilePlans)(this.storedManifest)));
-			this.log(`HMR geological reset complete: ${Math.round(performance.now() - resetStart)}ms`);
+			this.log(`HMR system reload complete: ${Math.round(performance.now() - resetStart)}ms`);
 		} finally {
-			this.invalidateGeologicalResetModules();
+			this.invalidateSystemReloadModules();
 		}
 	}
-	invalidateGeologicalResetModules() {
+	invalidateSystemReloadModules() {
 		const server = this.devServer;
 		if (!server) return;
 		for (const moduleId of [
@@ -826,49 +675,21 @@ var PluginContext = class {
 		}
 		server.hot?.send({ type: "full-reload" });
 	}
-	/**
-	* True when the file is a member of the system's evaluated module-file
-	* set. Tested BEFORE component-scan exclude filters: a system dependency
-	* edit invalidates the compiler registry regardless of what the user
-	* excluded from component scanning.
-	*/
 	isSystemDependency(absFile) {
 		return (0, _animus_ui_extract_pipeline.toWatchKeys)(absFile).some((key) => this.systemDependencyKeys.has(key));
 	}
-	/**
-	* Ask the dev watcher to watch every loader-reported dependency path.
-	* Covers system modules unreachable from app imports (workspace package
-	* config files). Vite's watcher hard-ignores `node_modules`, so
-	* node_modules-installed system dependencies produce no events — a
-	* documented limitation; workspace deps resolve to real paths outside
-	* node_modules and are watchable. No-ops without a dev server.
-	*/
+	/** Watch every loader-reported dependency path. Vite hard-ignores
+	*  node_modules, so dependencies installed there produce no events. */
 	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);
 	}
-	/**
-	* Invalidate the component CSS and system-props virtual modules, then
-	* reload the client. Shared by the two out-of-band re-analysis paths — a
-	* file created after buildStart (transform) and a file deleted during dev
-	* (the `hotUpdate` delete event) — which both mutate the cache, re-run
-	* analysis, and then need the client to pick up the regenerated CSS.
-	* No-ops outside dev.
-	*
-	* `devServer.moduleGraph` is Vite's back-compat mixed graph: its
-	* `getModuleById` searches the client AND ssr environment graphs and its
-	* `invalidateModule` invalidates both instances behind the returned node,
-	* which is exactly the reach this path wants. It stays the seam here.
-	*
-	* Both modules are invalidated unconditionally, and deliberately so: the
-	* appearance or disappearance of a whole component file is not the
-	* steady-state edit the change-gated path governs, and a client reload does
-	* NOT rescue a module that was never invalidated — Vite keeps serving its
-	* cached transform result across reloads (openspec: hmr-new-file-detection,
-	* "CSS invalidation after new file analysis").
-	*/
+	/** Invalidate the component CSS and system-props modules, then reload. The
+	*  reload alone rescues nothing: Vite keeps serving its cached transform.
+	*  `devServer.moduleGraph` is the mixed back-compat graph on purpose — it
+	*  reaches client and ssr at once; per-environment graphs do not. */
 	invalidateExtractedModules() {
 		const server = this.devServer;
 		if (!server) return;
@@ -882,16 +703,8 @@ var PluginContext = class {
 			this.devServer?.hot?.send({ type: "full-reload" });
 		}, 100);
 	}
-	/**
-	* The buildStart gate over include resolution
-	* (external-package-file-discovery: silence is never an outcome). An
-	* unresolvable `.includes()` specifier warns in non-strict mode and FAILS
-	* the build under `strict: true`, naming every offending specifier —
-	* a typo'd include must not ship a build missing its component CSS. A
-	* stale dist entry under an extended package (first-class-extension D13)
-	* rides the same seam: a merge against it would silently skew registry
-	* content the discovered sources no longer match.
-	*/
+	/** An unresolvable `.includes()` specifier or a stale dist entry under an
+	*  extended package warns, and fails the build under `strict`. */
 	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;
@@ -899,14 +712,6 @@ var PluginContext = class {
 			this.warn(message);
 		}
 	}
-	/**
-	* The post-analysis gate over cross-source token contracts
-	* (extraction-diagnostics): a discovered component referencing a token its
-	* OWN package defines but the consumer theme does not gets the teaching
-	* error naming the token, component, source package, and the missing
-	* `createTheme().extend(...)`. Wiring and severity routing live in the
-	* shared pipeline gate (next-plugin parity by construction).
-	*/
 	enforceExternalTokenContracts() {
 		(0, _animus_ui_extract_pipeline.enforceExternalTokenContracts)({
 			diagnostics: this.storedManifest?.diagnostics,
@@ -938,15 +743,16 @@ var PluginContext = class {
 };
 //#endregion
 //#region src/rediscovery.ts
-/** The current manifest's unresolved-parent drops, parsed from diagnostics
-*  (shared Rust-mirror matcher — the regex lives in manifest-diagnostics). */
+/** The current manifest's unresolved-parent drops, parsed from diagnostics. */
 function unresolvedParentDrops(ctx) {
 	const drops = [];
-	for (const d of ctx.storedManifest?.diagnostics ?? []) {
+	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: String(d.file ?? ""),
-			component: String(d.component ?? ""),
+			file: d.file,
+			component: d.component,
 			parent
 		});
 	}
@@ -954,39 +760,24 @@ function unresolvedParentDrops(ctx) {
 }
 const EMPTY_DROP_FILES = /* @__PURE__ */ new Set();
 const dropFilesByManifest = /* @__PURE__ */ new WeakMap();
-/** Files carrying an unresolved-parent drop in the CURRENT manifest —
-*  derived once per manifest publication, then a set lookup. */
+/** 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(String(d.file ?? ""));
+		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;
 }
 /**
-* Reconcile the discoverable on-disk source universe before an
-* unresolved-parent result is acted on (openspec: dev-transform-coherence,
-* "Source-universe reconciliation precedes unresolved-parent fallbacks").
-*
-* Drop-triggered: runs only when the current manifest reports `chain
-* dropped: could not resolve parent component`. One discovery walk (the
-* same walk and policy the server start uses) folds every eligible on-disk
-* file the cache does not know, then one re-analysis resolves the whole
-* extension graph — dependency depth never requires iteration depth, so the
-* loop re-enters only when a re-analysis leaves NEW drops and the previous
-* walk actually folded something (a changed discovery domain). The
-* iteration cap is containment, not semantics.
-*
-* Returns whether any re-analysis ran (callers diff plans across the WHOLE
-* transaction, so a fold-and-reanalyze is invisible to them beyond the
-* final manifest).
+* Folds undiscovered on-disk files when the manifest reports an unresolved
+* parent, then re-analyzes; the iteration cap is containment, not semantics.
 */
-async function stabilizeSourceUniverse(ctx) {
+async function reconcileSourceCorpus(ctx) {
 	if (ctx.isProd) return false;
 	let reanalyzed = false;
 	for (let iteration = 0; iteration < 3; iteration++) {
@@ -997,12 +788,12 @@ async function stabilizeSourceUniverse(ctx) {
 		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.cacheSize === ctx.fileCache.size) return reanalyzed;
+		if (memo && memo.dropKey === dropKey && memo.cacheGeneration === ctx.fileCacheGeneration) return reanalyzed;
 		const folded = foldUndiscoveredFiles(ctx);
 		if (folded.length === 0) {
 			barrenWalkMemos.set(ctx, {
 				dropKey,
-				cacheSize: ctx.fileCache.size
+				cacheGeneration: ctx.fileCacheGeneration
 			});
 			warnInadmissibleParents(ctx, drops);
 			return reanalyzed;
@@ -1014,26 +805,22 @@ async function stabilizeSourceUniverse(ctx) {
 		try {
 			published = (await ctx.analyzeIngested()).ok;
 		} finally {
-			if (!published) for (const key of folded) ctx.fileCache.delete(key);
+			if (!published) ctx.mutateFileCache((cache) => {
+				for (const key of folded) cache.delete(key);
+			});
 		}
 		if (!published) return reanalyzed;
 	}
-	if (unresolvedDropFiles(ctx).size > 0) ctx.warn("source-universe rediscovery did not stabilize after bounded retries");
+	if (unresolvedDropFiles(ctx).size > 0) ctx.warn("source-corpus rediscovery did not stabilize after bounded retries");
 	return reanalyzed;
 }
-/**
-* One discovery walk over the project root with the server-start policy;
-* folds every eligible file `fileCache` does not hold. Returns the fold
-* count.
-*/
-/** Returns the cache keys this fold ADDED, so a failed analysis can roll
-*  them back — `runAnalysis` requires callers that advanced the file cache to
-*  restore it, or the content-hash gate suppresses the equal-content retry
-*  forever. */
+/** Returns the cache keys this fold added: a failed analysis must restore
+*  the cache, or the content-hash gate suppresses the retry forever. */
 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);
@@ -1044,35 +831,32 @@ function foldUndiscoveredFiles(ctx) {
 		} catch {
 			continue;
 		}
-		ctx.fileCache.set(relPath, {
+		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;
 }
-/** Barren-walk memo per context: the drop tuple-set and cache size at the
-*  last walk that folded nothing (see stabilizeSourceUniverse). */
+/** 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();
-/** The narrow probe set is deliberate — NOT ctx.extensionsSet (conscious
-*  no-behavior-change choice: the teaching probe resolves what it always did). */
-const PARENT_PROBE_EXTENSIONS = new Set([
+const PARENT_PROBE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".tsx",
 	".ts",
 	".jsx",
 	".js"
 ]);
 /**
-* The teaching half for parents that RESOLVE on disk but cannot be admitted
-* (excluded by configuration, unsupported source type, outside the root).
-* Resolution is a best-effort scan of the consumer's own import statements
-* for the parent binding — enough for the relative-specifier case a
-* developer actually hits; a parent this scan cannot resolve keeps the
-* engine's own diagnostic.
+* 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.
 */
 function warnInadmissibleParents(ctx, drops) {
 	const excludeMatcher = ctx.excludeMatcher;
@@ -1092,7 +876,7 @@ function warnInadmissibleParents(ctx, drops) {
 		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 universe 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;
+		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;
 		const verdictKey = `${drop.file}\0${drop.parent}\0${reason}`;
 		if (warned.has(verdictKey)) continue;
@@ -1100,7 +884,6 @@ function warnInadmissibleParents(ctx, drops) {
 		ctx.warn(`cannot extract '${drop.component}': parent '${drop.parent}' resolves to ${relPath}, ${reason}`);
 	}
 }
-/** The module specifier a named import binds `binding` from, if scannable. */
 function importSpecifierFor(source, binding) {
 	const importRe = /import\s+([^;]+?)\s+from\s+['"]([^'"]+)['"]/g;
 	let match;
@@ -1113,25 +896,17 @@ function importSpecifierFor(source, binding) {
 //#endregion
 //#region src/transform.ts
 /**
-* The dev-mode bridge prepend, shared with the hot-update gate so both
-* compute byte-identical served output. The import goes AFTER the directive
-* prologue the engine hoists to byte 0 — prepending above it would demote
-* 'use client'/'use strict' to an ordinary expression statement, silently
-* un-marking client modules on exactly the RSC-capable hosts this delivery
-* path serves.
+* The import goes after the directive prologue: above it, 'use client'
+* becomes an ordinary expression and the module loses its client marking.
 */
 function applyDevBridgeImport(code) {
 	const prologue = /^(?:(['"])use [a-z -]+\1;?\r?\n)*/.exec(code)?.[0] ?? "";
 	return prologue + `import '${VIRTUAL_BRIDGE_ID}';\n` + code.slice(prologue.length);
 }
-/**
-* Live raw-fallback files reachable from `relPath`'s components through
-* extension provenance — the transitive closure, so a grandparent's serve is
-* withheld exactly like a direct parent's.
-*/
 function rawFallbackDescendants(ctx, relPath) {
+	const manifest = ctx.storedManifest;
 	const conflicted = /* @__PURE__ */ new Set();
-	const queue = [...ctx.storedManifest?.files?.[relPath] ?? []];
+	const queue = [...manifest?.files[relPath] ?? []];
 	const seen = new Set(queue);
 	while (queue.length > 0) {
 		const id = queue.shift();
@@ -1139,33 +914,23 @@ function rawFallbackDescendants(ctx, relPath) {
 			if (seen.has(childId)) continue;
 			seen.add(childId);
 			queue.push(childId);
-			const childFile = ctx.storedManifest?.components?.[childId]?.file;
+			const childFile = manifest?.components[childId]?.file;
 			if (childFile && childFile !== relPath && ctx.rawExtensionFallbacks.has(childFile)) conflicted.add(childFile);
 		}
 	}
 	return [...conflicted].sort();
 }
-/**
-* transform: replace builder chains with `createComponent()` calls using
-* the pre-built manifest; detect files created after buildStart and fold
-* them into the analysis.
-*
-* The HMR bridge is NOT injected here — `transformIndexHtml` delivers it as a
-* `<script type="module">` per served document (openspec:
-* dev-stylesheet-management, "HMR bridge auto-injected in dev mode"; "Transform
-* emitter unchanged" forbids the emitter importing it).
-*/
 async function transformSource(ctx, code, id) {
 	if (!ctx.storedManifest) return null;
 	if (id.startsWith("\0") || id.startsWith("virtual:animus/")) return null;
 	const isExternalPkg = ctx.externalPackageDirs.some((dir) => (0, _animus_ui_extract_pipeline.isPathWithinRoot)(dir, id));
 	const relativePath = (0, path.relative)(ctx.rootDir, id);
 	if (!isExternalPkg) {
-		if (!/\.[jt]sx?$/.test(id)) return null;
+		if (!(0, _animus_ui_extract_pipeline.isEngineTransformExtension)(id)) return null;
 		if (id.includes("node_modules")) return null;
 		if (!(0, _animus_ui_extract_pipeline.isPathWithinRoot)(ctx.rootDir, id)) return null;
 	}
-	if (!ctx.storedManifest.files?.[relativePath]?.length) {
+	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) {
@@ -1173,28 +938,27 @@ async function transformSource(ctx, code, id) {
 				if (owner) ctx.externalFileOwners[relativePath] = owner[1];
 			}
 			const hash = (0, _animus_ui_extract_pipeline.contentHash)(code);
-			ctx.fileCache.set(relativePath, {
+			ctx.mutateFileCache((cache) => cache.set(relativePath, {
 				hash,
 				source: code
-			});
+			}));
 			const prevPlans = (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest);
 			let analysisOk = false;
 			try {
 				analysisOk = (await ctx.analyzeIngested()).ok;
 			} finally {
-				if (!analysisOk) ctx.fileCache.delete(relativePath);
+				if (!analysisOk) ctx.mutateFileCache((cache) => cache.delete(relativePath));
 			}
 			if (analysisOk) {
-				await stabilizeSourceUniverse(ctx);
+				await reconcileSourceCorpus(ctx);
 				invalidateFileModules(ctx, (0, _animus_ui_extract_pipeline.diffFilePlans)(prevPlans, (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest), { exclude: relativePath }));
-				const compCount = ctx.storedManifest.files?.[relativePath]?.length ?? 0;
+				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) {
-			if (!ctx.isProd) if (unresolvedDropFiles(ctx).has(relativePath)) ctx.rawExtensionFallbacks.add(relativePath);
-			else ctx.rawExtensionFallbacks.delete(relativePath);
+		if (!ctx.storedManifest.files[relativePath]?.length) {
+			ctx.recordFallbackState(relativePath, unresolvedDropFiles(ctx).has(relativePath));
 			return null;
 		}
 	}
@@ -1210,17 +974,20 @@ async function transformSource(ctx, code, id) {
 	try {
 		const { transformFile } = ctx.engineApi();
 		const result = transformFile(code, relativePath, ctx.storedManifestJson);
-		if (!result.hasComponents) return null;
+		if (!result.hasComponents) {
+			ctx.recordFallbackState(relativePath, true);
+			return null;
+		}
 		if (ctx.verbose) {
-			const compCount = ctx.storedManifest.files?.[relativePath]?.length ?? 0;
+			const compCount = ctx.storedManifest.files[relativePath]?.length ?? 0;
 			ctx.log(`transform ${relativePath}: ${compCount} components`);
 		}
 		let outputCode = result.code;
 		if (!ctx.isProd) {
 			outputCode = applyDevBridgeImport(result.code);
 			ctx.recordTransformOutput(relativePath, outputCode);
-			ctx.rawExtensionFallbacks.delete(relativePath);
 		}
+		ctx.recordFallbackState(relativePath, false);
 		return {
 			code: outputCode,
 			map: null
@@ -1228,30 +995,14 @@ async function transformSource(ctx, code, id) {
 	} catch (e) {
 		if (ctx.options.strict) throw new Error(`[animus-extract] Failed to transform ${id}: ${e}`, { cause: e });
 		console.warn(`[animus-extract] Failed to transform ${id}:`, e);
+		ctx.recordFallbackState(relativePath, true);
 		return null;
 	}
 }
 //#endregion
 //#region src/hmr.ts
-/**
-* hotUpdate: the single dev file-event hook. Handles system-dependency
-* membership (geological reset), content-hash diffing with incremental
-* re-analysis, deleted-file cache pruning, and targeted module invalidation
-* (component CSS, system props, and definition files whose replacement
-* changed).
-*
-* Vite 8 dispatches this hook once per environment for ONE file event — the
-* client environment first, then every non-client environment (see
-* `handleHMRUpdate` in vite/dist/node/chunks/node.js). The analysis half is
-* therefore claimed by exactly one dispatch (`ctx.hotUpdateEvents`), while the
-* invalidation half runs in every environment against its own module graph —
-* what the mixed-graph `handleHotUpdate` used to achieve implicitly by
-* invalidating the client and SSR instance behind one module node.
-*
-* The hook fires for every watched file whether or not it has modules in any
-* graph, so system dependencies registered through `watcher.add` outside the
-* root still reach the reset branch, with an empty `modules` list.
-*/
+/** 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) {
 	if (ctx.isProd) return;
 	return runExclusiveAnalysis(ctx, () => handleHotUpdateExclusive(ctx, environment, options));
@@ -1263,7 +1014,7 @@ async function handleHotUpdateExclusive(ctx, environment, { type, file, timestam
 	if (ctx.isSystemDependency(absFile)) {
 		if (ownsEvent) {
 			await reconcileSourceEntry(ctx, absFile, type, read);
-			ctx.requestGeologicalReset((0, path.relative)(ctx.rootDir, absFile));
+			ctx.requestSystemReload((0, path.relative)(ctx.rootDir, absFile));
 		}
 		return [];
 	}
@@ -1274,47 +1025,30 @@ async function handleHotUpdateExclusive(ctx, environment, { type, file, timestam
 	if (ownsEvent) ctx.hotUpdateEvents.record(file, timestamp, await analyzeChangedFile(ctx, file, absFile, read));
 	const result = ctx.hotUpdateEvents.resultOf(file, timestamp);
 	if (result.kind === "ignored") return;
+	if (result.kind === "evicted") {
+		ctx.log(`HMR (${environment.name}): decision for ${(0, path.relative)(ctx.rootDir, absFile)} evicted — invalidating conservatively`);
+		return invalidateStaleModules(ctx, environment, modules, {
+			staleDefinitionFiles: [],
+			systemPropsChanged: true,
+			presentationOnly: false
+		});
+	}
 	if (result.kind === "unchanged") {
 		if (type === "create") return;
 		return [];
 	}
 	return invalidateStaleModules(ctx, environment, modules, result);
 }
-/**
-* The changed file's text.
-*
-* Editors save atomically — truncate, then rewrite — so a watcher event can
-* arrive while the path is momentarily EMPTY. Vite's `read()` helper retries on
-* empty content for exactly that reason; reading the path directly at the same
-* moment yields `''`, and since the corrective content produces no second
-* event, that empty source would be cached permanently.
-*
-* Vite always supplies `read`, so the direct read is NOT a fallback for Vite:
-* it exists for hosts that drive this hook without one. The dev-lane's adapter
-* contract is deliberately bundler-neutral, and a second runtime satisfying it
-* must not be forced to fabricate a helper to get correct behavior.
-*/
+/** 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");
 }
-/**
-* Reconcile the `fileCache` entry of a file that is BOTH a system dependency
-* and a discovered component source, since the dependency branch is terminal —
-* neither the edit path's cache write nor `pruneDeletedFile` runs for it.
-*
-* An edit refreshes the entry: `performGeologicalReset` rebuilds its
-* full-source analysis from this cache, so a stale entry would be re-analyzed
-* on every later reset. A delete prunes it, exactly as the ordinary delete path
-* would (openspec: hmr-new-file-detection, "Watcher deletion pruning") — a
-* surviving entry is a ghost source no watcher event can ever name again.
-*
-* Dependency-only files have no entry: `pruneFileCache` no-ops for them, and
-* the edit path must not create one — the cache is the component-source set,
-* and a phantom entry would feed the engine a file it never discovered.
-*/
+/** 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") {
-		pruneFileCache(ctx.fileCache, ctx.rootDir, absFile);
+		ctx.mutateFileCache((cache) => pruneFileCache(cache, ctx.rootDir, absFile));
 		return;
 	}
 	const relPath = (0, path.relative)(ctx.rootDir, absFile);
@@ -1323,19 +1057,16 @@ async function reconcileSourceEntry(ctx, absFile, type, read) {
 	try {
 		source = await readChangedSource(absFile, read);
 	} catch {
-		ctx.warn(`could not re-read ${relPath} after a system-dependency edit — geological resets will analyze its pre-edit text until a later edit is read successfully`);
+		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`);
 		return;
 	}
-	ctx.fileCache.set(relPath, {
+	ctx.mutateFileCache((cache) => cache.set(relPath, {
 		hash: (0, _animus_ui_extract_pipeline.contentHash)(source),
 		source
-	});
+	}));
 }
-/**
-* The once-per-event analysis half: gate the file, diff its content hash,
-* refresh the cache, and re-run project analysis. The returned result is what
-* the remaining environments act on.
-*/
+/** The once-per-event analysis half; its result is what the remaining
+*  environments act on. */
 async function analyzeChangedFile(ctx, file, absFile, read) {
 	const ext = (0, path.extname)(file);
 	if (!ctx.extensionsSet.has(ext)) return { kind: "ignored" };
@@ -1360,19 +1091,21 @@ async function analyzeChangedFile(ctx, file, absFile, read) {
 		const owner = Object.entries(ctx.externalDirOwners).find(([dir]) => (0, _animus_ui_extract_pipeline.isPathWithinRoot)(dir, absFile));
 		if (owner) ctx.externalFileOwners[relPath] = owner[1];
 	}
-	ctx.fileCache.set(relPath, {
+	ctx.mutateFileCache((cache) => cache.set(relPath, {
 		hash,
 		source
-	});
+	}));
 	const restoreEntry = () => {
-		if (cached) ctx.fileCache.set(relPath, cached);
-		else ctx.fileCache.delete(relPath);
+		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 directComponentIds = (ctx.sourceOwnership[relPath]?.analysisPaths ?? [relPath]).flatMap((analysisPath) => ctx.storedManifest?.files?.[analysisPath] ?? []);
+	const directComponentIds = (ctx.corpus.published.ownership[relPath]?.analysisPaths ?? [relPath]).flatMap((analysisPath) => ctx.storedManifest?.files[analysisPath] ?? []);
 	const invalidatedIds = new Set(directComponentIds);
 	const queue = [...directComponentIds];
 	while (queue.length > 0) {
@@ -1400,7 +1133,7 @@ async function analyzeChangedFile(ctx, file, absFile, read) {
 		return { kind: "ignored" };
 	}
 	try {
-		await stabilizeSourceUniverse(ctx);
+		await reconcileSourceCorpus(ctx);
 	} catch (e) {
 		restoreEntry();
 		throw e;
@@ -1408,7 +1141,7 @@ async function analyzeChangedFile(ctx, file, absFile, read) {
 	const systemPropsChanged = systemPropsModuleSource(ctx) !== systemPropsBefore;
 	const analysisMs = Math.round(performance.now() - analysisStart);
 	const staleDefinitionFiles = (0, _animus_ui_extract_pipeline.diffFilePlans)(prevPlans, (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest)).filter((defFile) => (0, path.resolve)(ctx.rootDir, defFile) !== absFile);
-	const nativeEntry = ctx.analysisEntryCache.get(relPath);
+	const nativeEntry = ctx.corpus.published.analysisEntries.get(relPath);
 	const presentationOnly = nativeEntry ? isPresentationOnlyEdit(ctx, relPath, nativeEntry.source) : false;
 	const hmrMs = Math.round(performance.now() - hmrStart);
 	ctx.log(`HMR update: ${relPath} — analysis ${analysisMs}ms, total ${hmrMs}ms${presentationOnly ? " (presentation-only)" : ""}`);
@@ -1420,23 +1153,12 @@ async function analyzeChangedFile(ctx, file, absFile, read) {
 		presentationOnly
 	};
 }
-/**
-* True when the changed file's transform output is byte-identical across the
-* edit — a presentation-only change (style values are not part of the emitted
-* replacement, whose class names hash `filename::binding`).
-*
-* Compares a POST-analysis re-transform of the file (the engine transforms
-* from its retained facts, so this runs against the just-updated analysis)
-* with the hash of what the module LAST SERVED (`recordTransformOutput` in
-* the transform hook, bridge import included). Comparing the full served
-* output — never replacement strings — is what keeps a mixed style+code edit
-* deliverable. Fails open: a transform error, a file the manifest does not
-* list, or a module that never served (no recorded hash) delivers normally.
-*/
+/** True when the file's transform output is byte-identical across the edit.
+*  Compares the full served bytes and fails open, so mixed edits deliver. */
 function isPresentationOnlyEdit(ctx, scannerRelPath, source) {
 	const servedHash = ctx.transformOutputHashes.get(scannerRelPath);
 	if (!servedHash || !ctx.storedManifestJson) return false;
-	if (!ctx.storedManifest?.files?.[scannerRelPath]?.length) return false;
+	if (!ctx.storedManifest?.files[scannerRelPath]?.length) return false;
 	try {
 		const { transformFile } = ctx.engineApi();
 		const fresh = transformFile(source, scannerRelPath, ctx.storedManifestJson);
@@ -1446,17 +1168,12 @@ function isPresentationOnlyEdit(ctx, scannerRelPath, source) {
 		return false;
 	}
 }
-/**
-* Reconcile a deleted file in dev.
-*
-* Without this the removed file's last-known source stays in `ctx.fileCache`,
-* and shared source ingestion re-feeds that ghost original to the engine on
-* every later re-analysis — the deleted component's CSS survives for the life
-* of the process.
-*/
+/** 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. */
 async function pruneDeletedFile(ctx, absFile) {
 	const relPath = (0, path.relative)(ctx.rootDir, absFile);
-	if (!ctx.fileCache.get(relPath) || !pruneFileCache(ctx.fileCache, ctx.rootDir, absFile)) return;
+	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;
@@ -1464,12 +1181,8 @@ async function pruneDeletedFile(ctx, absFile) {
 	invalidateFileModules(ctx, (0, _animus_ui_extract_pipeline.diffFilePlans)(prevPlans, (0, _animus_ui_extract_pipeline.snapshotFilePlans)(ctx.storedManifest)));
 	ctx.invalidateExtractedModules();
 }
-/**
-* The per-environment invalidation half: invalidate the modules this
-* environment serves and widen its update set with them. Static CSS
-* (virtual:animus/styles.css) is NOT invalidated here — it only changes on a
-* geological reset (vars/globals are stable during dev).
-*/
+/** The per-environment invalidation half. Static CSS is left alone: it only
+*  changes on a system reload, since vars and globals are stable in dev. */
 function invalidateStaleModules(ctx, environment, modules, analyzed) {
 	const graph = environment.moduleGraph;
 	const modulesToUpdate = analyzed.presentationOnly ? [] : [...modules];
@@ -1505,29 +1218,8 @@ function invalidateStaleModules(ctx, environment, modules, analyzed) {
 //#endregion
 //#region src/index-html.ts
 /**
-* transformIndexHtml: build the head-prepend tag set.
-*
-* Three independent tags, all delivery-only:
-* - the appearance bootstrap script, when the host build passed a
-*   pre-generated artifact via `appearanceBootstrap` (absent otherwise);
-* - the `@layer` declaration style, when `buildStart` computed one;
-* - the HMR bridge module script, in dev only.
-*
-* The two build-time branches are guarded on non-empty CONTENT, not on mere
-* presence: an artifact whose `code` is empty is a caller defect, and emitting
-* `<script data-animus-bootstrap><\/script>` for it would break the
-* unconfigured-parity contract in spirit (a tag that does nothing) while
-* hiding the defect. Symmetric with `layerDeclaration`. The bridge has no
-* content of its own — it is a `src` reference — so its only guard is the mode.
-*
-* Ordering: every descriptor rides the same `head-prepend` bucket, which Vite
-* serializes in array order (`serializeTags`) and splices in immediately after
-* `<head>`. The bootstrap script is therefore FIRST in the array so it runs
-* before the layer declaration and — since built stylesheet links are appended
-* at `</head>` — before any stylesheet reference.
-*
-* With neither build-time input set, a production build emits no tag,
-* attribute, or whitespace of its own.
+* Vite serializes one `head-prepend` bucket in array order, so the bootstrap
+* script precedes the layer declaration and every stylesheet reference.
 */
 function buildIndexHtmlTags(ctx) {
 	const tags = [];
@@ -1557,7 +1249,13 @@ function buildIndexHtmlTags(ctx) {
 }
 //#endregion
 //#region src/virtual-modules.ts
-/** resolveId: map virtual ids and redirect external DS package imports. */
+/**
+* Keyed on the whole option record: two instances sharing a key means the
+* later `replaceSync` erases the earlier one's component CSS.
+*/
+function sheetRegistryHash(ctx) {
+	return (0, crypto.createHash)("md5").update((0, _animus_ui_extract_pipeline.stableStringify)(ctx.options)).digest("hex").slice(0, 8);
+}
 function resolveVirtualId(ctx, id) {
 	if (id === VIRTUAL_CSS_ID) return RESOLVED_CSS_ID;
 	if (id === VIRTUAL_COMPONENTS_ID) return RESOLVED_COMPONENTS_ID;
@@ -1567,8 +1265,6 @@ function resolveVirtualId(ctx, id) {
 	if (srcEntry) return srcEntry;
 	return null;
 }
-/** load: serve the virtual stylesheet, components CSS, HMR bridge, and
-*  system-props modules from manifest-derived state. */
 function loadVirtualModule(ctx, id) {
 	const lcssOpts = {
 		minify: ctx.options.minify ?? ctx.emissionProd,
@@ -1597,19 +1293,22 @@ function loadVirtualModule(ctx, id) {
 		});
 		return [variables, (0, _animus_ui_extract_pipeline.postProcessCss)(body, lcssOpts)].filter(Boolean).join("\n");
 	}
-	if (id === RESOLVED_COMPONENTS_ID) return `export default \`${(0, _animus_ui_extract_pipeline.postProcessCss)((0, _animus_ui_extract_pipeline.stripLeadingLayerDeclaration)(ctx.resolvedComponentCss || ""), {
-		...lcssOpts,
-		minify: false
-	}).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;`;
-	if (id === RESOLVED_BRIDGE_ID) return `
+	if (id === RESOLVED_COMPONENTS_ID) {
+		const strippedCss = (0, _animus_ui_extract_pipeline.stripLeadingLayerDeclaration)(ctx.resolvedComponentCss || "");
+		return `export default \`${(0, _animus_ui_extract_pipeline.postProcessCss)(strippedCss, {
+			...lcssOpts,
+			minify: false
+		}).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;`;
+	}
+	if (id === RESOLVED_BRIDGE_ID) {
+		const sheetHash = sheetRegistryHash(ctx);
+		return `
 import css from '${VIRTUAL_COMPONENTS_ID}';
 
-const GLOBAL_KEY = '__animus_sheet_${(0, crypto.createHash)("md5").update(ctx.options.system).digest("hex").slice(0, 8)}__';
+const GLOBAL_KEY = '__animus_sheet_${sheetHash}__';
 let sheet = globalThis[GLOBAL_KEY] || null;
 
-// Server evaluation is a no-op: SSR hosts reach this module through the
-// bridge import prepended to transformed component modules, and only the
-// browser pass owns a document.
+// Server evaluation is a no-op: only the browser pass owns a document.
 if (typeof document !== 'undefined') {
   if (typeof CSSStyleSheet !== 'undefined' && 'adoptedStyleSheets' in document) {
     if (!sheet) {
@@ -1619,11 +1318,10 @@ if (typeof document !== 'undefined') {
     }
     sheet.replaceSync(css);
   } else {
-    // Fallback: inject or update <style> tag
-    let el = document.querySelector('style[data-animus-components]');
+    let el = document.querySelector('style[data-animus-components="${sheetHash}"]');
     if (!el) {
       el = document.createElement('style');
-      el.setAttribute('data-animus-components', '');
+      el.setAttribute('data-animus-components', '${sheetHash}');
       document.head.appendChild(el);
     }
     el.textContent = css;
@@ -1632,28 +1330,23 @@ if (typeof document !== 'undefined') {
 
 if (import.meta.hot) {
   import.meta.hot.accept('${VIRTUAL_COMPONENTS_ID}', (newModule) => {
-    // The server module runner has a hot channel too; only the browser
-    // pass owns a document to update.
+    // The server module runner has a hot channel too, but owns no document.
     if (typeof document === 'undefined') return;
     if (sheet) {
       sheet.replaceSync(newModule.default);
     } else {
-      const el = document.querySelector('style[data-animus-components]');
+      const el = document.querySelector('style[data-animus-components="${sheetHash}"]');
       if (el) el.textContent = newModule.default;
     }
   });
 }
 `;
+	}
 	if (id === RESOLVED_SYSTEM_PROPS_ID) return systemPropsModuleSource(ctx);
 	return null;
 }
 //#endregion
 //#region src/index.ts
-/**
-* Vite adapter for the extraction pipeline. State and pipeline operations
-* live in PluginContext; hook bodies live in their own modules — this
-* factory only validates options and wires Vite hooks to those functions.
-*/
 function animusExtract(options) {
 	(0, _animus_ui_extract_pipeline.assertNoRetiredEngineSelection)(options.engine);
 	(0, _animus_ui_extract_pipeline.assertKnownOptionKeys)(options, ["verify", "appearanceBootstrap"], [{