@animus-ui/extract 0.1.24 → 0.1.26

package/dist/{pipeline-Bl20tbu_.mjs → pipeline-BzMQ_Z0M.mjs}

@@ -1,9 +1,9 @@
 import { createRequire, isBuiltin } from "node:module";
-import path, { basename, dirname, extname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "node:path";
+import path, { basename, dirname, extname, isAbsolute, join, normalize, parse, posix, relative, resolve, sep } from "node:path";
 import { createHash } from "crypto";
-import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "fs";
-import { dirname as dirname$1, extname as extname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
-import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, statSync as statSync$1 } from "node:fs";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { existsSync as existsSync$1, mkdirSync, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, statSync as statSync$1, unlinkSync, writeFileSync } from "fs";
+import { basename as basename$1, dirname as dirname$1, extname as extname$1, isAbsolute as isAbsolute$1, join as join$1, normalize as normalize$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
 import { createRequire as createRequire$1 } from "module";
 import browserslist from "browserslist";
 import { browserslistToTargets, transform } from "lightningcss";
@@ -69,7 +69,7 @@ function assembleStylesheet(options) {
 //#endregion
 //#region pipeline/analyze-project-args.ts
 /** @internal */
-function buildAnalyzeProjectArgs(inputs) {
+function buildAnalyzeProjectArgs(inputs, probeEvidence) {
 	const args = [
 		inputs.filesJson,
 		inputs.scalesJson,
@@ -94,18 +94,15 @@ function buildAnalyzeProjectArgs(inputs) {
 	const tail = [
 		inputs.declarationScalesJson,
 		inputs.analysisContextJson,
-		inputs.generatedNamesJson
+		inputs.generatedNamesJson,
+		inputs.propertyRecordsJson
 	];
-	const last = tail.findLastIndex((slot) => slot !== void 0 && slot !== "");
+	const last = probeEvidence === void 0 ? tail.findLastIndex((slot) => slot !== void 0 && slot !== "") : tail.length - 1;
 	for (const slot of tail.slice(0, last + 1)) args.push(slot || void 0);
+	if (probeEvidence !== void 0) args.push(probeEvidence);
 	return args;
 }
 //#endregion
-//#region pipeline/content-hash.ts
-function contentHash(source) {
-	return createHash("md5").update(source).digest("hex");
-}
-//#endregion
 //#region pipeline/internal-wire.ts
 function parseInternalWire(json, wire) {
 	let parsed;
@@ -117,6 +114,160 @@ function parseInternalWire(json, wire) {
 	return parsed;
 }
 //#endregion
+//#region pipeline/content-hash.ts
+function contentHash(source) {
+	return createHash("md5").update(source).digest("hex");
+}
+//#endregion
+//#region pipeline/extension-policy.ts
+/**
+* The one extension policy: the order in which a relative or aliased
+* specifier's candidate files are tried. Source ingestion reads it here. The
+* system loader and the extractor read `extension_policy.json`, which
+* `node packages/extract/scripts/extension-policy.ts --write` generates from
+* it, so every resolver tries the same files in the same order.
+*
+* The order: the base itself, the base with each appended extension, its
+* `index` with each, then the sources an emitted NodeNext extension stands
+* for (`./x.js` for `x.ts`), spelled exactly.
+*/
+const EXTENSION_POLICY = {
+	/** Appended to the base, then to `{base}/index`. */
+	appended: [
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".mjs"
+	],
+	/** An emitted extension, and the source extensions it names, in order. */
+	nodeNext: [
+		[".js", [
+			".ts",
+			".tsx",
+			".jsx"
+		]],
+		[".jsx", [".tsx"]],
+		[".mjs", [".mts"]],
+		[".cjs", [".cts"]]
+	]
+};
+const BUILT_IN_ORDER = {
+	appended: EXTENSION_POLICY.appended,
+	nodeNext: EXTENSION_POLICY.nodeNext,
+	alias: []
+};
+/** The files `base` can name, in policy order: itself, with each appended
+*  extension, as a directory's index with each, then the sources its
+*  emitted NodeNext extension stands for (`x.js` names `x.ts`), spelled
+*  exactly. Given `sources`, only extensions in it are tried, and under the
+*  built-in order those it lacks (`.mdx`) follow its own. A configured
+*  alias of the base's suffix replaces all of these. `index` spells a
+*  directory's index path. */
+function policyCandidates(base, options = {}) {
+	const { sources, index = (directory, file) => `${directory}/${file}`, policy = BUILT_IN_ORDER } = options;
+	const alias = policy.alias.find(([from]) => base.endsWith(from));
+	if (alias !== void 0) {
+		const [from, sequence] = alias;
+		const stem = base.slice(0, base.length - from.length);
+		return sequence.map((to) => `${stem}${to}`);
+	}
+	const admitted = (extension) => !sources || sources.has(extension);
+	const appended = [...policy.appended.filter(admitted), ...sources && policy.appended === EXTENSION_POLICY.appended ? [...sources].filter((s) => !policy.appended.includes(s)) : []];
+	const name = base.slice(Math.max(base.lastIndexOf("/"), base.lastIndexOf("\\")) + 1);
+	const dot = name.lastIndexOf(".");
+	const emitted = dot === -1 ? "" : name.slice(dot);
+	const stem = base.slice(0, base.length - emitted.length);
+	const nodeNext = (policy.nodeNext.find(([from]) => from === emitted)?.[1] ?? []).filter(admitted);
+	return [
+		base,
+		...appended.map((extension) => `${base}${extension}`),
+		...appended.map((extension) => index(base, `index${extension}`)),
+		...nodeNext.map((source) => `${stem}${source}`)
+	];
+}
+/** The first of `candidates` that `see` finds, in order; a candidate found
+*  only under another case ends the probe as a mismatch. */
+function probeCandidates(candidates, see) {
+	for (const candidate of candidates) {
+		const seen = see(candidate);
+		if (seen.kind === "file") return {
+			kind: "found",
+			path: candidate
+		};
+		if (seen.kind === "case-only") return {
+			kind: "case-mismatch",
+			candidate,
+			actual: seen.actual
+		};
+	}
+	return { kind: "absent" };
+}
+const isFile = (path) => {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+};
+/** Whether `directory` lists an entry spelled exactly `name`. */
+function lists(directory, name) {
+	try {
+		return readdirSync(directory || ".").includes(name);
+	} catch {
+		return false;
+	}
+}
+/** `path`'s real path as the filesystem reports it; as given when it cannot
+*  be read. */
+const reported = (path) => {
+	try {
+		return realpathSync.native(path);
+	} catch {
+		return path;
+	}
+};
+/** What the filesystem holds at `candidate`: a file it opens under exactly
+*  that spelling, or one it opens although a directory below the one the
+*  candidate shares with `within` lists no entry spelled as the candidate
+*  spells it (a case- or normalization-insensitive filesystem opening
+*  another spelling). Nothing is folded: the filesystem decides what opens,
+*  and its listings decide the spelling, so a file a case-sensitive
+*  filesystem cannot open is simply missing. The shared directory is
+*  spelled as given, as a specifier spells only the path from its
+*  importer's directory and a manifest only the paths in its package. `..`
+*  is taken back lexically, as Node and the bundlers resolve a specifier
+*  before opening it. The system loader reads it alike. */
+function seeOnDisk(candidate, within) {
+	const path = normalize(candidate);
+	if (!isFile(path)) return { kind: "missing" };
+	const { root } = parse(path);
+	const names = path.slice(root.length).split(sep).filter(Boolean);
+	const baseNames = within === void 0 ? [] : normalize(within).slice(root.length).split(sep).filter(Boolean);
+	let shared = 0;
+	while (shared < baseNames.length && names[shared] === baseNames[shared] && names[shared] !== "..") shared++;
+	let directory = join(root, ...names.slice(0, shared));
+	for (const name of names.slice(shared)) {
+		if (!lists(directory, name)) return {
+			kind: "case-only",
+			actual: reported(path)
+		};
+		directory = join(directory, name);
+	}
+	return { kind: "file" };
+}
+/** The first of `candidates` the filesystem holds, spelled exactly below
+*  `within` when given. */
+function probeOnDisk(candidates, within) {
+	return probeCandidates(candidates, (candidate) => seeOnDisk(candidate, within));
+}
+/** Why `subject` names no file: the file it would load is spelled otherwise
+*  on disk. `remedy` says what to respell. The system loader words it
+*  alike. */
+function caseMismatchReason(subject, mismatch, remedy) {
+	return `${subject} names ${mismatch.candidate}, but the file on disk is ${mismatch.actual}, spelled differently: a case- or normalization-insensitive filesystem loads it and a sensitive one does not — ${remedy}`;
+}
+//#endregion
 //#region pipeline/asset-placeholders.ts
 const ASSET_PLACEHOLDER_PREFIX = "animus-asset:";
 const URL_OPEN_RE = /url\(\s*(['"]?)/gi;
@@ -294,15 +445,6 @@ function warnLine(diagnostic) {
 /** Stable code for selector forms with no substitutable subject; the
 *  extraction engine mints the same string. */
 const SELECTOR_UNSUPPORTED_SUBJECT = "animus.selector.unsupported-subject";
-/** The one matcher for the engine's unresolved-parent chain-drop message;
-*  consumers match through the exported helpers, never their own copy. */
-const UNRESOLVED_PARENT_RE = /chain dropped: could not resolve parent component '([^']+)'/;
-function isUnresolvedParentDrop(diagnostic) {
-	return UNRESOLVED_PARENT_RE.test(diagnostic.message);
-}
-function unresolvedParentName(diagnostic) {
-	return UNRESOLVED_PARENT_RE.exec(diagnostic.message)?.[1] ?? null;
-}
 const DIAGNOSTIC_LEVELS = /* @__PURE__ */ new Set([
 	"off",
 	"info",
@@ -420,11 +562,11 @@ function collectSelectorAliasDiagnostics(selectorAliasesJson) {
 const UNREADABLE_SOURCE_FILE = "animus.ingestion.unreadable-source-file";
 /** A kit the system extends resolved, yet discovery found none of its files. */
 const NO_KIT_FILES = "animus.discovery.no-kit-files";
-/** A kit with no `animus` export condition: discovery guesses its source
-*  from `src/`. */
+/** A kit with no `animus` export condition whose exports do not all target
+*  TypeScript source: discovery guesses its source from `src/`. */
 const KIT_WITHOUT_SOURCE_CONDITION = "animus.discovery.kit-without-source-condition";
 /** A kit's `animus` export condition names a file that is missing or outside
-*  its package, so that entry is not read from source. */
+*  its package, so that entry is read from its runtime target instead. */
 const INVALID_KIT_SOURCE_CONDITION = "animus.discovery.invalid-source-condition";
 /** A kit the application imports whose system the application's system
 *  does not include: its components are not extracted. */
@@ -432,10 +574,34 @@ const KIT_SYSTEM_NOT_INCLUDED = "animus.kit.system-not-included";
 /** A system file's `createSystem` binding that discovery could not follow to
 *  Animus's factory, so it is no root. */
 const UNPROVEN_ROOT_BINDING = "animus.discovery.unproven-root-binding";
+/** A system builder, a `createSystem` chain not yet built, leaves the
+*  bindings and chains discovery follows, so kits extended on it from there
+*  are not read as members. */
+const UNFOLLOWED_SYSTEM_BUILDER = "animus.discovery.unfollowed-system-builder";
 /** A system file calls `createSystem` with no import or local binding. The
 *  system loader evaluates the file without auto-imports, where the name is
 *  undefined, so the call is no root. */
 const UNIMPORTED_CREATE_SYSTEM = "animus.discovery.unimported-create-system";
+/** A tsconfig path alias the host bundler resolves to another file than
+*  analysis does (spec §2.2 A7): report only. */
+const ALIAS_MISMATCH = "animus.discovery.alias-mismatch";
+/** A package the host bundler resolves to a file in no package of its own,
+*  where discovery reads the installed package instead (spec §2.2 A4):
+*  report only. */
+const PACKAGE_MISMATCH = "animus.discovery.package-mismatch";
+/** A system-file kit whose analysed instance is not the one the system
+*  load evaluated (spec §2.2 A4): its components would be extracted
+*  against another instance's vocabulary. */
+const SYSTEM_INSTANCE_MISMATCH = "animus.discovery.system-instance-mismatch";
+/** An import the host resolves, from its importer, into another instance
+*  of a discovered package whose file is not analysed and that no source
+*  redirect covers: the importer would render unextracted builder code
+*  (spec §2.2 A4, SA1). */
+const UNREAD_PACKAGE_INSTANCE = "animus.discovery.unread-package-instance";
+/** An import the host resolves, from its importer, into another instance
+*  of a discovered package, which a request-keyed source redirect replaces
+*  with the instance discovery read (spec §2.2 A4). */
+const REPLACED_PACKAGE_INSTANCE = "animus.discovery.replaced-package-instance";
 /** What a skipped source file costs: the analysis never sees what it
 *  renders. */
 const SKIPPED_SOURCE_COST = "skipped: its renders are not seen, so nothing is pruned and every component, variant option and state is kept until it is analyzed";
@@ -521,6 +687,12 @@ const DIAGNOSTIC_SEVERITY = /* @__PURE__ */ new Map([
 	[KIT_STALE_DESCRIPTOR, "warn"],
 	[UNPROVEN_ROOT_BINDING, "warn"],
 	[UNIMPORTED_CREATE_SYSTEM, "warn"],
+	[UNFOLLOWED_SYSTEM_BUILDER, "warn"],
+	[ALIAS_MISMATCH, "warn"],
+	[PACKAGE_MISMATCH, "warn"],
+	[SYSTEM_INSTANCE_MISMATCH, "error"],
+	[UNREAD_PACKAGE_INSTANCE, "error"],
+	[REPLACED_PACKAGE_INSTANCE, "warn"],
 	[VOCABULARY_COLLISION, "warn"],
 	[VOCABULARY_LEGACY_VERB, "warn"],
 	[INVALID_PROPERTY_REGISTRATION, "error"],
@@ -722,6 +894,135 @@ async function preprocessMdx(source, filename) {
 	}
 }
 //#endregion
+//#region pipeline/host-expansions.ts
+/**
+* The host's expansion of each listed load the expander reproduces, with
+* each file read as the analysis and the host read it: a module the
+* analysis holds, loaded as code without a query; a file the host loads as
+* an opaque value (spec §2.2 A8); otherwise a file the analysis does not
+* read. A query can select other code than the module (a plugin's
+* transform), so a queried file that is not opaque is never the analysed
+* module, and it keeps its query.
+*/
+function hostExpansions(loads, rootDir, analysed, expander, isAsset) {
+	const expansions = [];
+	for (const load of loads) {
+		const expanded = expander.expand(load, rootDir);
+		if (expanded === void 0) continue;
+		const files = /* @__PURE__ */ new Map();
+		for (const { path, query } of expanded) {
+			const opaque = isAsset?.(join(rootDir, path), query) ?? false;
+			const status = query === "" && analysed.has(path) ? "analysed" : opaque ? "opaque" : "unanalysed";
+			const key = `${path}${query}`;
+			files.set(key, {
+				path: status === "analysed" ? path : key,
+				status
+			});
+		}
+		expansions.push({
+			importer: load.importer,
+			start: load.start,
+			closed: true,
+			files: [...files.values()]
+		});
+	}
+	return expansions;
+}
+//#endregion
+//#region pipeline/probe-evidence.ts
+let generations = 0;
+/** `rootDir` at its real path, where the filesystem reports spellings. */
+function realRoot(rootDir) {
+	try {
+		return realpathSync.native(rootDir);
+	} catch {
+		return rootDir;
+	}
+}
+/**
+* What the host's filesystem opens for `base` (spec §2.2 A2, A8): the first
+* of its candidates, in the host's order, that the host opens. The
+* filesystem decides what opens, and each name below the session root is
+* checked against its own directory's listing (`seeOnDisk`); nothing is
+* folded. Null where no candidate opens.
+*
+* A candidate the analysis holds answers before the filesystem is asked: an
+* adapted original's analysis child need not exist on disk. A file the host
+* opens that the analysis holds no module for is read as an adapted
+* original (analysed as its first later child), an asset, or a file
+* analysis never reads.
+*/
+function hostCandidate(rootDir, base, analysed, order, readings = {}, root = realRoot(rootDir)) {
+	const at = base.indexOf("?");
+	const query = at === -1 ? "" : base.slice(at);
+	const candidates = policyCandidates(at === -1 ? base : base.slice(0, at), { policy: order });
+	for (const [index, file] of candidates.entries()) {
+		const candidate = `${file}${query}`;
+		const opaque = () => readings.isAsset?.(join(rootDir, file), query);
+		if (analysed.has(file)) return query !== "" && opaque() ? {
+			candidate,
+			actual: null,
+			analysedAs: null,
+			reading: "asset"
+		} : {
+			candidate,
+			actual: null,
+			analysedAs: file
+		};
+		const seen = seeOnDisk(join(rootDir, file), rootDir);
+		if (seen.kind === "missing") continue;
+		if (seen.kind === "case-only") return {
+			candidate,
+			actual: relative(root, seen.actual),
+			analysedAs: null
+		};
+		const children = readings.adapted?.get(file);
+		if (children !== void 0) return {
+			candidate,
+			actual: null,
+			analysedAs: candidates.slice(index + 1).find((later) => children.includes(later)) ?? null,
+			reading: "adapted"
+		};
+		return {
+			candidate,
+			actual: null,
+			analysedAs: null,
+			reading: opaque() ? "asset" : "unanalysed"
+		};
+	}
+	return null;
+}
+/**
+* The session's host-candidate evidence for one analysis (spec §2.3): each
+* probe base the engine's `prepare` names, as `hostCandidate` reads it, and
+* the host's expansion of each computed load it lists (spec §6.3). The
+* evidence carries the input identity `prepare` reported, and each call is a
+* new ingest generation, so no evidence is read for other files.
+*/
+function gatherProbeEvidence(rootDir, analysed, order, readings = {}) {
+	const root = realRoot(rootDir);
+	return (bases, identity, loads = []) => {
+		const byBase = {};
+		for (const base of bases) {
+			const host = hostCandidate(rootDir, base, analysed, order, readings, root);
+			if (host !== null) byBase[base] = host;
+		}
+		const expansions = readings.expander === void 0 ? [] : hostExpansions(loads, rootDir, analysed, readings.expander, readings.isAsset);
+		generations += 1;
+		return JSON.stringify({
+			generation: generations,
+			identity,
+			bases: byBase,
+			...expansions.length > 0 && { expansions }
+		});
+	};
+}
+/** Each adapted original and its analysis children, from ingestion's
+*  ownership: an original whose children are other paths than its own. */
+function adaptedOriginals(ownership) {
+	return new Map(Object.entries(ownership).filter(([original, { analysisPaths }]) => !(analysisPaths.length === 1 && analysisPaths[0] === original)).map(([original, { analysisPaths }]) => [original, analysisPaths]));
+}
+//#endregion
 //#region pipeline/svelte-source-adapter.ts
 const isCompilerReference = (value) => Object(value) === value;
 const isCompilerCallable = (value) => {
@@ -819,14 +1120,14 @@ function sourceLocation(source, node) {
 function createsNestedBindingScope(node) {
 	return node.type === "BlockStatement" || node.type === "CatchClause" || node.type === "ClassBody" || node.type === "ClassDeclaration" || node.type === "ClassExpression" || node.type === "ForInStatement" || node.type === "ForOfStatement" || node.type === "ForStatement" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "StaticBlock" || node.type === "SwitchStatement" || node.type === "TSModuleBlock";
 }
-function walk(node, visit, nestedScopeDepth = 0) {
+function walk$1(node, visit, nestedScopeDepth = 0) {
 	visit(node, nestedScopeDepth);
 	const childScopeDepth = nestedScopeDepth + (createsNestedBindingScope(node) ? 1 : 0);
 	for (const [key, value] of Object.entries(node)) {
 		if (key === "loc" || key === "start" || key === "end") continue;
 		if (Array.isArray(value)) {
-			for (const item of value) if (isNode(item)) walk(item, visit, childScopeDepth);
-		} else if (isNode(value)) walk(value, visit, childScopeDepth);
+			for (const item of value) if (isNode(item)) walk$1(item, visit, childScopeDepth);
+		} else if (isNode(value)) walk$1(value, visit, childScopeDepth);
 	}
 }
 /**
@@ -1028,7 +1329,7 @@ function isJsxAttributeName(name) {
 }
 function tsxIncompatibleValue(value) {
 	let incompatible = null;
-	walk(value, (node) => {
+	walk$1(value, (node) => {
 		if (incompatible) return;
 		if (node.type === "TSTypeAssertion" || node.type === "ArrowFunctionExpression" && childNode(node.typeParameters) !== null) incompatible = node;
 	});
@@ -1125,7 +1426,7 @@ function projectScope(script, scope, source, originalPath, options, inherited, p
 	const bindings = inherited ? new Map([...inherited.bindings, ...ownBindings]) : ownBindings;
 	const witnesses = [];
 	const diagnostics = [];
-	if (bindings.size > 0) walk(script.content, (node, nestedScopeDepth) => {
+	if (bindings.size > 0) walk$1(script.content, (node, nestedScopeDepth) => {
 		const site = resolverCallSite(node, bindings);
 		if (!site) return;
 		const { access, form } = site;
@@ -1290,17 +1591,6 @@ function parseFilesJson(filesJson, context) {
 function isAdvisorySourceDiagnostic(diagnostic) {
 	return diagnostic.code === "SOURCE_NATIVE_PARSE_ERROR";
 }
-const RELATIVE_PROBE_SUFFIXES = [
-	"",
-	".ts",
-	".tsx",
-	".js",
-	".jsx",
-	"/index.ts",
-	"/index.tsx",
-	"/index.js",
-	"/index.jsx"
-];
 function extension(path) {
 	const basename = posix.basename(path);
 	const dot = basename.lastIndexOf(".");
@@ -1309,27 +1599,40 @@ function extension(path) {
 function canonicalResolverPath(path) {
 	return posix.normalize(path.replaceAll("\\", "/"));
 }
-const NODE_NEXT_EXTENSION_MAP = {
-	".js": [
-		".ts",
-		".tsx",
-		".jsx"
-	],
-	".jsx": [".tsx"],
-	".mjs": [".mts"],
-	".cjs": [".cts"]
-};
-/** The paths a relative specifier can name from `importerPath`, in probe
-*  order: as written with each source suffix, then a NodeNext emitted
-*  extension's sources. Empty for a non-relative specifier. */
-function relativeSourceCandidates(importerPath, specifier) {
+/** The paths a relative specifier can name from `importerPath`, in the
+*  extension policy's probe order. Empty for a non-relative specifier. */
+function relativeSourceCandidates(importerPath, specifier, policy) {
 	if (!specifier.startsWith(".")) return [];
-	const base = posix.normalize(posix.join(posix.dirname(canonicalResolverPath(importerPath)), specifier));
-	const explicitExtension = extension(base);
-	return [...RELATIVE_PROBE_SUFFIXES.map((suffix) => `${base}${suffix}`), ...(NODE_NEXT_EXTENSION_MAP[explicitExtension] ?? []).map((sourceExtension) => `${base.slice(0, -explicitExtension.length)}${sourceExtension}`)];
-}
-function resolveRelativeSource(importerPath, specifier, files) {
-	for (const candidate of relativeSourceCandidates(importerPath, specifier)) {
+	return policyCandidates(posix.normalize(posix.join(posix.dirname(canonicalResolverPath(importerPath)), specifier)), { policy });
+}
+function resolveRelativeSource(importerPath, specifier, files, analysed, opened, policy, host) {
+	if (host !== void 0 && specifier.startsWith(".")) {
+		const first = hostCandidate(host.rootDir, posix.normalize(posix.join(posix.dirname(canonicalResolverPath(importerPath)), specifier)), analysed, policy, { adapted: host.adapted });
+		if (first !== null) {
+			if (first.actual) {
+				opened({
+					candidate: first.candidate,
+					opened: first.actual,
+					why: "case-mismatch"
+				});
+				return null;
+			}
+			if (first.reading === "unanalysed") {
+				const candidates = relativeSourceCandidates(importerPath, specifier, policy);
+				const later = candidates.slice(candidates.indexOf(first.candidate) + 1).find((candidate) => files.has(candidate));
+				const opening = {
+					candidate: first.candidate,
+					opened: first.candidate,
+					why: "skipped"
+				};
+				if (later !== void 0) opening.later = later;
+				opened(opening);
+				return null;
+			}
+			return first.analysedAs === null ? null : files.get(first.analysedAs) ?? null;
+		}
+	}
+	for (const candidate of relativeSourceCandidates(importerPath, specifier, policy)) {
 		const actualPath = files.get(candidate);
 		if (actualPath !== void 0) return actualPath;
 	}
@@ -1337,15 +1640,22 @@ function resolveRelativeSource(importerPath, specifier, files) {
 }
 var ResolverExportIndex = class {
 	facts;
+	extensions;
+	host;
 	collisions;
 	files;
+	analysed;
+	/** Each resolver call that ended Incomplete, once. */
+	openings = /* @__PURE__ */ new Map();
 	resolverBindings = /* @__PURE__ */ new Map();
 	/** Both memos live for one ingest only — the index is rebuilt per call,
 	*  so neither needs invalidation. */
 	attributionMemo = /* @__PURE__ */ new Map();
 	resolveMemo = /* @__PURE__ */ new Map();
-	constructor(facts, analysisPaths) {
+	constructor(facts, analysisPaths, extensions, host) {
 		this.facts = facts;
+		this.extensions = extensions;
+		this.host = host;
 		const pathsByCanonical = /* @__PURE__ */ new Map();
 		for (const path of analysisPaths) {
 			const canonicalPath = canonicalResolverPath(path);
@@ -1370,6 +1680,7 @@ var ResolverExportIndex = class {
 			if (paths.length === 1 && factPaths.length === 1) files.set(canonicalPath, factPaths[0]);
 		}
 		this.files = files;
+		this.analysed = new Set(files.keys());
 		for (const [path, file] of Object.entries(facts.files)) this.resolverBindings.set(path, new Set(file.chains.filter((chain) => chain.descriptor.terminal === "asClass" && chain.descriptor.extractable && chain.fatalError === null).map((chain) => chain.descriptor.binding)));
 	}
 	attribute(importerPath, request) {
@@ -1390,7 +1701,11 @@ var ResolverExportIndex = class {
 		const key = `${importerPath}\0${specifier}`;
 		let resolved = this.resolveMemo.get(key);
 		if (resolved === void 0) {
-			resolved = resolveRelativeSource(importerPath, specifier, this.files);
+			resolved = resolveRelativeSource(importerPath, specifier, this.files, this.analysed, (opening) => this.openings.set(key, {
+				importer: importerPath,
+				specifier,
+				...opening
+			}), this.extensions, this.host);
 			this.resolveMemo.set(key, resolved);
 		}
 		return resolved;
@@ -1512,7 +1827,10 @@ async function ingestSourceEntries(rawEntries, options) {
 			messages: file.parseDiagnostics
 		});
 	}
-	const resolvers = new ResolverExportIndex(facts, analysisEntries.map((entry) => entry.path));
+	const resolvers = new ResolverExportIndex(facts, analysisEntries.map((entry) => entry.path), options.extensions, options.rootDir === void 0 ? void 0 : {
+		rootDir: options.rootDir,
+		adapted: adaptedOriginals(ownership)
+	});
 	for (const { canonicalPath, paths } of resolvers.collisions) for (let index = 0; index < paths.length; index += 1) {
 		const path = paths[index];
 		const conflictingPath = paths[(index + 1) % paths.length];
@@ -1547,13 +1865,14 @@ async function ingestSourceEntries(rawEntries, options) {
 		diagnostics
 	};
 	if (abortedParses.length > 0) result.abortedParses = abortedParses;
+	if (resolvers.openings.size > 0) result.openings = [...resolvers.openings.values()];
 	return result;
 }
 /**
 * `parseCount` counts the parses performed by THIS call, so a fully-memoized
 * pass reports zero.
 */
-function collectFileFacts(analysisEntries, options) {
+function collectFileFacts(analysisEntries, options, evict = true) {
 	const cache = options.factsCache;
 	if (!cache) return JSON.parse(options.extractFacts(JSON.stringify(analysisEntries)));
 	const pending = analysisEntries.filter((entry) => cache.get(entry.path)?.hash !== entry.hash);
@@ -1570,8 +1889,10 @@ function collectFileFacts(analysisEntries, options) {
 			else cache.delete(entry.path);
 		}
 	}
-	const currentPaths = new Set(analysisEntries.map((entry) => entry.path));
-	for (const path of [...cache.keys()]) if (!currentPaths.has(path)) cache.delete(path);
+	if (evict) {
+		const currentPaths = new Set(analysisEntries.map((entry) => entry.path));
+		for (const path of [...cache.keys()]) if (!currentPaths.has(path)) cache.delete(path);
+	}
 	const files = {};
 	for (const entry of analysisEntries) {
 		const cached = cache.get(entry.path);
@@ -1621,15 +1942,26 @@ function createSourceIngestor(host) {
 	/** Non-strict dedupe: a quarantined original re-ingests on every later
 	*  corpus pass, so re-warning it on each save is noise. */
 	const warnedByOriginal = /* @__PURE__ */ new Map();
+	const extractFacts = () => {
+		const extract = host.engineApi().extractFacts;
+		if (extract === void 0) throw new Error(`${host.prefix} native engine does not expose extractFacts required for source adaptation`);
+		return extract;
+	};
 	return {
 		async ingest(entries) {
-			const extractFacts = host.engineApi().extractFacts;
-			if (extractFacts === void 0) throw new Error(`${host.prefix} native engine does not expose extractFacts required for source adaptation`);
 			return ingestSourceEntries(entries, {
-				extractFacts,
-				factsCache
+				extractFacts: extractFacts(),
+				factsCache,
+				extensions: host.extensions?.(),
+				rootDir: host.rootDir?.()
 			});
 		},
+		facts(entries) {
+			return collectFileFacts(entries, {
+				extractFacts: extractFacts(),
+				factsCache
+			}, false);
+		},
 		surfaceDiagnostics(diagnostics) {
 			const fatal = diagnostics.filter((diagnostic) => !isAdvisorySourceDiagnostic(diagnostic));
 			const invalidOriginals = new Set(fatal.map((diagnostic) => diagnostic.originalPath));
@@ -1677,9 +2009,16 @@ function createV2EngineApi(deps) {
 		return {
 			loadSystemModule: (...args) => native.loadSystemModule(...args),
 			extractFacts: (filesJson) => native.extractFacts(filesJson),
-			moduleSpecifiers: (filesJson) => native.moduleSpecifiers(filesJson),
+			moduleSpecifiers: (filesJson, pathAliasesJson) => native.moduleSpecifiers(filesJson, pathAliasesJson),
+			systemMembership: (inputsJson) => native.systemMembership(inputsJson),
 			diagnosticCodes: () => native.diagnosticCodes(),
-			analyzeProject: (filesJsonRaw, scalesJson, variableMapJson, contextualVarsJson, propConfigJson, groupRegistryJson, packageResolutionJson, devMode, emitterConfigJson, selectorAliasesJson, _selectorOrderJson, globalStyleBlocksJson, pathAliasesJson, keyframesJson, staticCssJson, conditionAliasesJson, externalDirsJson, transformSourcesJson, transformProvenanceJson, declarationScalesJson, analysisContextJson, generatedNamesJson) => {
+			resolveSpecifier: native.resolveSpecifier === void 0 ? void 0 : (specifier, fromDir, conditions, workspaces, extensionPolicyJson) => native.resolveSpecifier(specifier, fromDir, conditions, workspaces, extensionPolicyJson),
+			fingerprintFile: native.fingerprintFile === void 0 ? void 0 : (path) => native.fingerprintFile(path) ?? null,
+			fingerprintBytes: native.fingerprintBytes === void 0 ? void 0 : (bytes) => native.fingerprintBytes(bytes),
+			declaresKitSource: native.declaresKitSource === void 0 ? void 0 : (packageDir) => native.declaresKitSource(packageDir),
+			locatePackage: native.locatePackage === void 0 ? void 0 : (name, fromDir, workspaces) => native.locatePackage(name, fromDir, workspaces) ?? null,
+			resolveKitSourceRoot: native.resolveKitSourceRoot === void 0 ? void 0 : (specifier, fromDir, conditions, workspaces, extensionPolicyJson, hostEntry, packageDir) => native.resolveKitSourceRoot(specifier, fromDir, conditions, workspaces, extensionPolicyJson, hostEntry, packageDir),
+			analyzeProject: (filesJsonRaw, scalesJson, variableMapJson, contextualVarsJson, propConfigJson, groupRegistryJson, packageResolutionJson, devMode, emitterConfigJson, selectorAliasesJson, _selectorOrderJson, globalStyleBlocksJson, pathAliasesJson, keyframesJson, staticCssJson, conditionAliasesJson, externalDirsJson, transformSourcesJson, transformProvenanceJson, declarationScalesJson, analysisContextJson, generatedNamesJson, propertyRecordsJson, probeEvidence) => {
 				const filesJson = deps.rehydrateFilesJson ? deps.rehydrateFilesJson(filesJsonRaw) : filesJsonRaw;
 				const sent = /* @__PURE__ */ new Map();
 				for (const entry of parseFilesJson(filesJson, label)) sent.set(entry.path, entry.source);
@@ -1708,11 +2047,17 @@ function createV2EngineApi(deps) {
 					declarationScalesJson,
 					analysisContextJson,
 					generatedNamesJson,
+					propertyRecordsJson,
 					devMode
 				};
 				const engine = new native.ExtractEngine(config);
 				store.setEngine(engine);
-				return engine.analyze(filesJson);
+				let evidence;
+				if (probeEvidence !== void 0) {
+					const prepared = parseInternalWire(engine.prepare(filesJson), "ExtractEngine.prepare");
+					evidence = probeEvidence(prepared.bases, prepared.identity, prepared.loads);
+				}
+				return engine.analyze(filesJson, evidence);
 			},
 			transformFile: (source, path, _manifest) => {
 				const engine = store.getEngine();
@@ -1738,10 +2083,112 @@ function createV2EngineApi(deps) {
 	};
 }
 //#endregion
-//#region pipeline/engine-retirement.ts
-const RETIRED_ENGINE_MESSAGE = "animus: the 'v1' extraction engine is no longer supported, and v2 is the only engine. Remove the engine option from your Animus config and unset the ANIMUS_ENGINE environment variable.";
-function assertNoRetiredEngineSelection(engineOption) {
-	if (engineOption === "v1" || process.env.ANIMUS_ENGINE === "v1") throw new Error(RETIRED_ENGINE_MESSAGE);
+//#region pipeline/source-identity.ts
+/**
+* One derivation of source identity for discovery, watch ingestion, ownership
+* and deletion: event paths are lookup INPUTS only and never fork identity.
+*/
+/**
+* True when `target` is `root` or a descendant, decided by `relative()`
+* shape: string prefixing would let `/ui` claim `/ui-old`.
+*/
+function isPathWithinRoot(root, target, pathApi = path) {
+	const rel = pathApi.relative(root, target);
+	return rel === "" || !pathApi.isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + pathApi.sep);
+}
+/**
+* True when two paths share a platform root (win32 drive letter or UNC
+* share; always true on posix). Drive letters compare case-insensitively.
+*/
+function sharesVolumeRoot(a, b, pathApi = path) {
+	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
+	return volumeOf(a) === volumeOf(b);
+}
+function canonicalize(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return null;
+	}
+}
+function createSourceIdentity(rootDir) {
+	const normalizedRootDir = path.normalize(rootDir);
+	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
+	const roots = [];
+	const aliases = /* @__PURE__ */ new Map();
+	const owningRecord = (canonicalPath) => {
+		let owner = null;
+		for (const record of roots) {
+			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
+			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+		}
+		return owner;
+	};
+	return {
+		rootDir: normalizedRootDir,
+		canonicalRootDir,
+		registerExternalRoot(root) {
+			const asRegistered = path.normalize(root);
+			const canonical = canonicalize(asRegistered) ?? asRegistered;
+			const existing = roots.find((record) => record.canonical === canonical);
+			if (existing) return existing.canonical;
+			roots.push({
+				asRegistered,
+				canonical
+			});
+			return canonical;
+		},
+		externalRoots() {
+			return roots.map((record) => record.canonical);
+		},
+		resolveSourceId(inputPath) {
+			const lexical = path.normalize(inputPath);
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			const owner = owningRecord(canonical);
+			const ownedBy = (record) => {
+				const pathInRoot = path.relative(record.canonical, canonical);
+				return {
+					sourceKey: path.relative(normalizedRootDir, path.join(record.asRegistered, pathInRoot)),
+					owningRoot: record.canonical,
+					pathInRoot
+				};
+			};
+			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
+			let resolved;
+			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
+				const key = path.relative(canonicalRootDir, canonical);
+				resolved = {
+					sourceKey: key,
+					owningRoot: null,
+					pathInRoot: key
+				};
+			} else if (owner) resolved = ownedBy(owner);
+			else return null;
+			aliases.set(lexical, resolved);
+			aliases.set(canonical, resolved);
+			return resolved;
+		},
+		resolveDeletedSourceId(inputPath) {
+			return aliases.get(path.normalize(inputPath)) ?? null;
+		},
+		containingExternalRoot(inputPath) {
+			const lexical = path.normalize(inputPath);
+			let owner = null;
+			for (const record of roots) {
+				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			if (owner) return owner.canonical;
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			for (const record of roots) {
+				if (!isPathWithinRoot(record.canonical, canonical)) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			return owner?.canonical ?? null;
+		}
+	};
 }
 //#endregion
 //#region pipeline/core-options.ts
@@ -1850,6 +2297,11 @@ const CORE_VALUE_GATES = [
 		ok: isString,
 		expected: "a string path"
 	},
+	{
+		key: "root",
+		ok: isString,
+		expected: "a string path"
+	},
 	{
 		key: "exclude",
 		ok: isStringArray,
@@ -1968,30 +2420,101 @@ function globToRegExp(glob) {
 	}
 	return new RegExp(`^${out}$`);
 }
+/** Whether a root-relative path is `dir` or lies under it, a literal path
+*  prefix: an output name is never a pattern. */
+function compileOutputDir(dir) {
+	return (_full, rel) => {
+		const normalized = rel.split("\\").join("/");
+		return normalized === dir || normalized.startsWith(`${dir}/`);
+	};
+}
 /**
-* A user list replaces only the replaceable defaults. Driver-owned
-* invariants belong in `extraStructural`; a user list would replace those.
+* A user list replaces only the replaceable defaults. A host's output
+* directories (`outputExclusion`) always apply, whatever the user's list.
 */
-function createExcludeMatcher(userPatterns, extraStructural = []) {
-	const merged = [...STRUCTURAL_EXCLUDE];
-	for (const pattern of extraStructural) if (!merged.includes(pattern)) merged.push(pattern);
-	for (const pattern of userPatterns ?? REPLACEABLE_DEFAULT_EXCLUDE) if (!merged.includes(pattern)) merged.push(pattern);
-	const compiled = merged.map((pattern) => [pattern, compilePattern(pattern)]);
-	const hits = new Map(merged.map((p) => [p, 0]));
+function createExcludeMatcher(userPatterns, outputDirs = []) {
+	const userList = userPatterns ?? REPLACEABLE_DEFAULT_EXCLUDE;
+	const compiled = [];
+	for (const pattern of STRUCTURAL_EXCLUDE) compiled.push({
+		pattern,
+		test: compilePattern(pattern),
+		isUser: userList.includes(pattern)
+	});
+	for (const dir of outputDirs) compiled.push({
+		pattern: dir,
+		test: compileOutputDir(dir),
+		isUser: false
+	});
+	for (const pattern of userList) {
+		if (STRUCTURAL_EXCLUDE.includes(pattern)) continue;
+		compiled.push({
+			pattern,
+			test: compilePattern(pattern),
+			isUser: true
+		});
+	}
+	const hits = new Map(compiled.map((c) => [c.pattern, 0]));
 	const explain = (full, rel) => {
-		for (const [pattern, test] of compiled) if (test(full, rel)) {
+		let excludedBy = null;
+		for (const { pattern, test, isUser } of compiled) {
+			if (excludedBy !== null && !isUser) continue;
+			if (!test(full, rel)) continue;
 			hits.set(pattern, (hits.get(pattern) ?? 0) + 1);
-			return pattern;
+			excludedBy ??= pattern;
 		}
-		return null;
+		return excludedBy;
 	};
 	return {
-		patterns: merged,
+		patterns: compiled.map((c) => c.pattern),
 		matches: (full, rel) => explain(full, rel) !== null,
 		explain,
-		stats: () => hits
+		stats: () => hits,
+		unmatched: () => (userPatterns ?? []).filter((pattern) => hits.get(pattern) === 0)
+	};
+}
+/** One line per user pattern that matched nothing, which every host
+*  prints to stderr after its first discovery, as the CLI always has. */
+function unmatchedExcludeLines(matcher) {
+	return matcher.unmatched().map((pattern) => `[animus] exclude pattern '${pattern}' matched nothing`);
+}
+/**
+* A host's output directory as an exclusion: root-relative with `/`
+* separators, matched as a literal path prefix, so a user list, which
+* replaces the defaults, never re-admits output. Null when the directory is
+* outside the root or is the root itself.
+*/
+function outputExclusion(root, outDir) {
+	if (!isPathWithinRoot(root, outDir)) return null;
+	const rel = relative$1(root, outDir);
+	return rel === "" ? null : rel.split(sep$1).join("/");
+}
+/**
+* The output directory a source file's real path lies in, or null. Applied
+* where a host assembles its analysis inputs: a file reached under another
+* spelling, through a source-tree link or a package's entry, is output too.
+*/
+function outputSourceGuard(root, outputDirs) {
+	if (outputDirs.length === 0) return () => null;
+	const realDirs = outputDirs.map((dir) => ({
+		dir,
+		real: realPathOf(resolve$1(root, dir))
+	}));
+	return (absPath) => {
+		const real = realPathOf(absPath);
+		return realDirs.find((o) => isPathWithinRoot(o.real, real))?.dir ?? null;
 	};
 }
+/** The warning for a source a host refused as output. */
+function outputSourceMessage(relPath, outputDir) {
+	return `${relPath} resolves into the output directory '${outputDir}', which is never source; it is not analysed`;
+}
+function realPathOf(path) {
+	try {
+		return realpathSync$1(path);
+	} catch {
+		return path;
+	}
+}
 function resolveMode(explicit, driverDefault) {
 	if (explicit === "development" || explicit === "production") return {
 		mode: explicit,
@@ -2003,18 +2526,92 @@ function resolveMode(explicit, driverDefault) {
 	};
 }
 //#endregion
-//#region pipeline/discover-files.ts
-function pathCharRank(code) {
-	return code === 47 || code === 92 ? -1 : code;
-}
-function compareDiscoveryOrder(a, b) {
-	const shared = Math.min(a.length, b.length);
-	for (let i = 0; i < shared; i++) {
-		const left = pathCharRank(a.charCodeAt(i));
-		const right = pathCharRank(b.charCodeAt(i));
-		if (left !== right) return left - right;
+//#region pipeline/engine-retirement.ts
+const RETIRED_ENGINE_MESSAGE = "animus: the 'v1' extraction engine is no longer supported, and v2 is the only engine. Remove the engine option from your Animus config and unset the ANIMUS_ENGINE environment variable.";
+/**
+* v2 is the only engine (SA2): the option and `ANIMUS_ENGINE`, a startup
+* input a worker may pass as captured, accept `v2` or nothing. Hosts call
+* this before the native module loads, so another selection never reaches
+* it; either fails as a configuration error naming its source.
+*/
+function assertSupportedEngine(engineOption, environmentSelection = process.env.ANIMUS_ENGINE) {
+	const selections = [[engineOption, "the engine option"], [environmentSelection || void 0, "ANIMUS_ENGINE"]];
+	for (const [selection, source] of selections) {
+		if (selection === void 0 || selection === "v2") continue;
+		if (selection === "v1") throw new AnimusConfigError(`${RETIRED_ENGINE_MESSAGE} (from ${source})`);
+		throw new AnimusConfigError(`animus: unknown extraction engine "${selection}" from ${source}: v2 is the only engine.`);
 	}
-	return a.length - b.length;
+}
+//#endregion
+//#region pipeline/asset-copies.ts
+/**
+* Immutable asset copies: one binding from an `asset()` source file to a
+* content-digested name, shared by every host that serves copies.
+*/
+/** Copies `sourcePath` into `assetsDir` under its content-digested name,
+*  once: a copy is never overwritten, so a URL naming it always serves the
+*  bytes it named. */
+function writeAssetCopy(sourcePath, assetsDir) {
+	const bytes = readFileSync$1(sourcePath);
+	const digest = contentHash(bytes);
+	const ext = extname$1(sourcePath);
+	const fileName = `${basename$1(sourcePath, ext)}.${digest.slice(0, 8)}${ext}`;
+	if (!existsSync$1(assetsDir)) mkdirSync(assetsDir, { recursive: true });
+	const copyPath = join$1(assetsDir, fileName);
+	if (!existsSync$1(copyPath)) writeFileSync(copyPath, bytes);
+	return {
+		fileName,
+		digest,
+		bytes
+	};
+}
+/** Sync `assets/` to the current build's file set; per-entry failures are
+*  tolerated — a concurrent session may have removed the same file. */
+function pruneStaleAssets(assetsDir, expected) {
+	if (!existsSync$1(assetsDir)) return;
+	let entries;
+	try {
+		entries = readdirSync$1(assetsDir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (expected.has(entry)) continue;
+		try {
+			unlinkSync(join$1(assetsDir, entry));
+		} catch {}
+	}
+}
+//#endregion
+//#region pipeline/runtime-import.ts
+/** The runtime every adapter emits by default (spine row 1). */
+const DEFAULT_RUNTIME_IMPORT = "@animus-ui/system/runtime";
+/** The entries that supply every terminal: an override naming another must
+*  extract only `.asClass()` terminals. */
+const FULL_RUNTIME_IMPORTS = /* @__PURE__ */ new Set([DEFAULT_RUNTIME_IMPORT, "@animus-ui/system"]);
+/** Throws when `runtimeImport` names a module that cannot supply a
+*  terminal the manifest extracted. */
+function assertRuntimeImportSuppliesTerminals(runtimeImport, manifest) {
+	if (!runtimeImport || FULL_RUNTIME_IMPORTS.has(runtimeImport)) 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 '${runtimeImport}' is valid only when every extracted terminal is .asClass(), but ${offenders.length} component(s) need createComponent/createComposedFamily from the default '${DEFAULT_RUNTIME_IMPORT}' runtime: ${shown}` + (offenders.length > 5 ? ", …" : "") + `. Remove the override or convert these terminals to .asClass().`);
+}
+//#endregion
+//#region pipeline/discover-files.ts
+function pathCharRank(code) {
+	return code === 47 || code === 92 ? -1 : code;
+}
+function compareDiscoveryOrder(a, b) {
+	const shared = Math.min(a.length, b.length);
+	for (let i = 0; i < shared; i++) {
+		const left = pathCharRank(a.charCodeAt(i));
+		const right = pathCharRank(b.charCodeAt(i));
+		if (left !== right) return left - right;
+	}
+	return a.length - b.length;
 }
 function discoverFiles(dir, rootDir, exclude, extensionsSet) {
 	return walkFiles(dir, rootDir, exclude, extensionsSet).sort(compareDiscoveryOrder);
@@ -2023,7 +2620,7 @@ function walkFiles(dir, rootDir, exclude, extensionsSet) {
 	const results = [];
 	let entries;
 	try {
-		entries = readdirSync(dir, { encoding: "utf8" });
+		entries = readdirSync$1(dir, { encoding: "utf8" });
 	} catch {
 		return results;
 	}
@@ -2033,7 +2630,7 @@ function walkFiles(dir, rootDir, exclude, extensionsSet) {
 		if (isExcluded(fullPath, relative$1(rootDir, fullPath))) continue;
 		let stat;
 		try {
-			stat = statSync(fullPath);
+			stat = statSync$1(fullPath);
 		} catch {
 			continue;
 		}
@@ -2043,6 +2640,161 @@ function walkFiles(dir, rootDir, exclude, extensionsSet) {
 	return results;
 }
 //#endregion
+//#region pipeline/host-extensions.ts
+/** Animus's own order, where no host resolver configuration exists. */
+const BUILT_IN_EXTENSION_POLICY = {
+	appended: EXTENSION_POLICY.appended,
+	nodeNext: EXTENSION_POLICY.nodeNext,
+	alias: [],
+	resolverVersion: "built-in"
+};
+/** The TypeScript output a source compiles to, as a host that resolves an
+*  emitted extension to its TypeScript source reads it. */
+const TYPESCRIPT_OUTPUTS = [
+	[".js", [".ts", ".tsx"]],
+	[".jsx", [".tsx"]],
+	[".mjs", [".mts"]],
+	[".cjs", [".cts"]]
+];
+/** esbuild's rewritten file extensions, which also let `.jsx` name `.ts`. */
+const ESBUILD_OUTPUTS = [
+	[".js", [".ts", ".tsx"]],
+	[".jsx", [".ts", ".tsx"]],
+	[".mjs", [".mts"]],
+	[".cjs", [".cts"]]
+];
+/** Documented defaults, for a host whose resolved order is not readable. */
+const HOST_DEFAULT_EXTENSIONS = {
+	vite: [
+		".mjs",
+		".js",
+		".mts",
+		".ts",
+		".jsx",
+		".tsx",
+		".json"
+	],
+	webpack: [
+		".js",
+		".json",
+		".wasm"
+	],
+	/** Rspack 1's documented default; later versions document another. */
+	rspack1: [
+		".js",
+		".json",
+		".wasm"
+	],
+	turbopack: [
+		".tsx",
+		".ts",
+		".jsx",
+		".js",
+		".mjs",
+		".json"
+	],
+	esbuild: [
+		".tsx",
+		".ts",
+		".jsx",
+		".js",
+		".css",
+		".json"
+	]
+};
+function label(host, version, how) {
+	return `${version ? `${host}@${version}` : host} ${how}`;
+}
+/** Vite's `resolve.extensions`, which `configResolved` holds with its
+*  defaults applied. A TypeScript importer's `./x.js` names `x.ts` too.
+*  Only the default order is captured, as a real build resolves it. A
+*  configured list does not describe Vite's effective resolution: Vite 8's
+*  resolver falls back past it (`['.js']` still loads `./only` as
+*  `only.tsx`), so it is unreadable. */
+function viteExtensionPolicy(extensions, version) {
+	if (extensions.length !== HOST_DEFAULT_EXTENSIONS.vite.length || extensions.some((ext, i) => ext !== HOST_DEFAULT_EXTENSIONS.vite[i])) return {
+		...BUILT_IN_EXTENSION_POLICY,
+		resolverVersion: "built-in (hostOptionUnreadable: vite configured extensions)"
+	};
+	return {
+		appended: [...extensions],
+		nodeNext: TYPESCRIPT_OUTPUTS,
+		alias: [],
+		resolverVersion: label("vite", version, "captured")
+	};
+}
+/** webpack's or Rspack's resolved order for an ESM import: the root
+*  `resolve` with `byDependency.esm` merged over it as the bundler merges
+*  it, a `...` standing for what it extends. `extensionAlias` is kept whole
+*  and in order. Where neither sets extensions, the bundler's documented
+*  default stands in; for Rspack only version 1's is known. */
+function webpackExtensionPolicy(host, resolve, version) {
+	const esm = resolve.byDependency?.esm;
+	const unset = resolve.extensions === void 0 && esm?.extensions === void 0;
+	const defaults = !(host === "rspack") ? HOST_DEFAULT_EXTENSIONS.webpack : version?.startsWith("1.") ? HOST_DEFAULT_EXTENSIONS.rspack1 : null;
+	if ([...Object.values(resolve.extensionAlias ?? {}), ...Object.values(esm?.extensionAlias ?? {})].some((value) => !Array.isArray(value))) return {
+		...BUILT_IN_EXTENSION_POLICY,
+		resolverVersion: "built-in (hostOptionUnreadable: string extensionAlias)"
+	};
+	const extendsBase = (list) => list === void 0 || list.includes("...");
+	if (defaults === null && extendsBase(esm?.extensions) && extendsBase(resolve.extensions)) return {
+		...BUILT_IN_EXTENSION_POLICY,
+		resolverVersion: `built-in (hostOptionUnreadable: ${host}${version ? `@${version}` : ""} defaults)`
+	};
+	const extend = (list, base) => list === void 0 ? base : list.flatMap((extension) => extension === "..." ? base : [extension]);
+	const root = extend(resolve.extensions, defaults ?? []);
+	const sequence = (value) => Array.isArray(value) ? value : [value];
+	const alias = new Map(Object.entries(resolve.extensionAlias ?? {}).map(([emitted, value]) => [emitted, sequence(value).filter((extension) => extension !== "...")]));
+	for (const [emitted, value] of Object.entries(esm?.extensionAlias ?? {})) {
+		const base = alias.get(emitted) ?? [];
+		alias.set(emitted, sequence(value).flatMap((extension) => extension === "..." ? base : [extension]));
+	}
+	return {
+		appended: [...extend(esm?.extensions, root)],
+		nodeNext: [],
+		alias: [...alias].map(([emitted, extensions]) => [emitted, [...extensions]]),
+		resolverVersion: label(host, version, unset ? "default" : "captured")
+	};
+}
+/** Turbopack's `turbopack.resolveExtensions`, or its documented default
+*  when the Next config sets none. It substitutes no source: under Next
+*  16.3, `./x.js` beside only `x.ts` names no module. */
+function turbopackExtensionPolicy(resolveExtensions, nextVersion) {
+	return {
+		appended: [...resolveExtensions ?? HOST_DEFAULT_EXTENSIONS.turbopack],
+		nodeNext: [],
+		alias: [],
+		resolverVersion: label("turbopack", nextVersion, resolveExtensions === void 0 ? "default" : "captured")
+	};
+}
+/** esbuild's `resolveExtensions`, or its default when the build sets none. */
+function esbuildExtensionPolicy(resolveExtensions, version) {
+	return {
+		appended: [...resolveExtensions ?? HOST_DEFAULT_EXTENSIONS.esbuild],
+		nodeNext: ESBUILD_OUTPUTS,
+		alias: [],
+		resolverVersion: label("esbuild", version, resolveExtensions === void 0 ? "default" : "captured")
+	};
+}
+/** Rollup leaves the extension order to its resolver plugins, which keep
+*  their options private: a TypeScript build sets `@rollup/plugin-node-resolve`'s
+*  `extensions`, which no documented default matches. The built-in policy
+*  answers, with the reason. */
+function rollupExtensionPolicy(usesNodeResolve) {
+	return {
+		...BUILT_IN_EXTENSION_POLICY,
+		resolverVersion: usesNodeResolve ? "built-in (hostOptionUnreadable: rollup-node-resolve)" : "built-in (hostOptionUnreadable: rollup resolver plugins)"
+	};
+}
+/** The policy as the system loader reads it (`ExtensionPolicy`). */
+function extensionPolicyJson(policy) {
+	return JSON.stringify({
+		appended: policy.appended,
+		nodeNext: policy.nodeNext,
+		alias: policy.alias
+	});
+}
+//#endregion
 //#region pipeline/tsconfig-paths.ts
 /**
 * tsconfig `paths` → alias pairs, for drivers with no live bundler config.
@@ -2129,7 +2881,7 @@ function decodeExtends(value) {
 function readConfig(path) {
 	let raw;
 	try {
-		raw = readFileSync(path, "utf-8");
+		raw = readFileSync$1(path, "utf-8");
 	} catch {
 		return null;
 	}
@@ -2148,16 +2900,27 @@ function readConfig(path) {
 		extends: decodeExtends(root.extends)
 	};
 }
-function resolveExtendsTarget(specifier, fromDir) {
+/** Where an `extends` specifier can name a config: a relative one as
+*  written, with `.json`, or as a directory's tsconfig; a package's under
+*  each ancestor's `node_modules`. Resolution takes the first that exists. */
+function extendsCandidates(specifier, fromDir) {
 	if (specifier.startsWith(".") || isAbsolute$1(specifier)) {
 		const base = resolve$1(fromDir, specifier);
-		for (const candidate of [
+		return [
 			base,
 			`${base}.json`,
 			join$1(base, "tsconfig.json")
-		]) if (existsSync(candidate)) return candidate;
-		return null;
+		];
+	}
+	const target = specifier.endsWith(".json") ? specifier : `${specifier}/tsconfig.json`;
+	const candidates = [];
+	for (let dir = resolve$1(fromDir);; dir = dirname$1(dir)) {
+		candidates.push(join$1(dir, "node_modules", target));
+		if (dirname$1(dir) === dir) return candidates;
 	}
+}
+function resolveExtendsTarget(specifier, fromDir) {
+	if (specifier.startsWith(".") || isAbsolute$1(specifier)) return extendsCandidates(specifier, fromDir).find((candidate) => existsSync$1(candidate)) ?? null;
 	try {
 		return __require.resolve(specifier.endsWith(".json") ? specifier : `${specifier}/tsconfig.json`, { paths: [fromDir] });
 	} catch {
@@ -2169,9 +2932,8 @@ function resolveExtendsTarget(specifier, fromDir) {
 	}
 }
 /** Child-first flattened extends chain starting at `entryPath`. */
-function loadChain(entryPath) {
+function loadChain(entryPath, visited = /* @__PURE__ */ new Set(), absent = /* @__PURE__ */ new Set()) {
 	const chain = [];
-	const visited = /* @__PURE__ */ new Set();
 	const queue = [entryPath];
 	while (queue.length > 0) {
 		const path = queue.shift();
@@ -2184,10 +2946,20 @@ function loadChain(entryPath) {
 		for (const parent of node.extends) {
 			const resolved = resolveExtendsTarget(parent, node.dir);
 			if (resolved) queue.push(resolved);
+			else for (const candidate of extendsCandidates(parent, node.dir)) absent.add(candidate);
 		}
 	}
 	return chain;
 }
+/** Every tsconfig file the project's alias chain reads or looks for, absent
+*  ones included, an unresolved `extends` target's candidates among them:
+*  an edit, creation or deletion of any changes the aliases. */
+function tsconfigChainPaths(rootDir) {
+	const visited = /* @__PURE__ */ new Set();
+	const absent = /* @__PURE__ */ new Set();
+	loadChain(join$1(rootDir, "tsconfig.json"), visited, absent);
+	return [...visited, ...absent];
+}
 /**
 * The project's tsconfig path aliases as `buildPathAliasesJson` pairs; empty
 * when no readable tsconfig, or no usable `paths`, exists.
@@ -2252,11 +3024,11 @@ function buildKitDescriptor(manifest) {
 /** Reads the descriptor at a kit's package root; `null` when it has none. */
 function readKitDescriptor(pkgRoot, rootDir) {
 	const path = join(pkgRoot, KIT_DESCRIPTOR_FILE);
-	if (!existsSync$1(path)) return null;
+	if (!existsSync(path)) return null;
 	const packageRoot = posixPath$1(relative(rootDir, pkgRoot));
 	let wire;
 	try {
-		wire = JSON.parse(readFileSync$1(path, "utf-8"));
+		wire = JSON.parse(readFileSync(path, "utf-8"));
 	} catch {
 		return {
 			packageRoot,
@@ -2327,118 +3099,48 @@ function kitDescriptorDiagnostics(records, manifest) {
 	return diagnostics;
 }
 //#endregion
-//#region pipeline/source-identity.ts
-/**
-* One derivation of source identity for discovery, watch ingestion, ownership
-* and deletion: event paths are lookup INPUTS only and never fork identity.
-*/
-/**
-* True when `target` is `root` or a descendant, decided by `relative()`
-* shape: string prefixing would let `/ui` claim `/ui-old`.
-*/
-function isPathWithinRoot(root, target, pathApi = path) {
-	const rel = pathApi.relative(root, target);
-	return rel === "" || !pathApi.isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + pathApi.sep);
-}
-/**
-* True when two paths share a platform root (win32 drive letter or UNC
-* share; always true on posix). Drive letters compare case-insensitively.
-*/
-function sharesVolumeRoot(a, b, pathApi = path) {
-	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
-	return volumeOf(a) === volumeOf(b);
-}
-function canonicalize(p) {
+//#region pipeline/workspace-packages.ts
+/** The parsed `package.json` in `dir`, or null when it cannot be read. */
+function readManifest(dir) {
 	try {
-		return realpathSync$1(p);
+		return JSON.parse(readFileSync$1(join$1(dir, "package.json"), "utf-8"));
 	} catch {
 		return null;
 	}
 }
-function createSourceIdentity(rootDir) {
-	const normalizedRootDir = path.normalize(rootDir);
-	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
-	const roots = [];
-	const aliases = /* @__PURE__ */ new Map();
-	const owningRecord = (canonicalPath) => {
-		let owner = null;
-		for (const record of roots) {
-			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
-			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-		}
-		return owner;
-	};
-	return {
-		rootDir: normalizedRootDir,
-		canonicalRootDir,
-		registerExternalRoot(root) {
-			const asRegistered = path.normalize(root);
-			const canonical = canonicalize(asRegistered) ?? asRegistered;
-			const existing = roots.find((record) => record.canonical === canonical);
-			if (existing) return existing.canonical;
-			roots.push({
-				asRegistered,
-				canonical
-			});
-			return canonical;
-		},
-		externalRoots() {
-			return roots.map((record) => record.canonical);
-		},
-		resolveSourceId(inputPath) {
-			const lexical = path.normalize(inputPath);
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			const owner = owningRecord(canonical);
-			const ownedBy = (record) => {
-				const pathInRoot = path.relative(record.canonical, canonical);
-				return {
-					sourceKey: path.relative(normalizedRootDir, path.join(record.asRegistered, pathInRoot)),
-					owningRoot: record.canonical,
-					pathInRoot
-				};
-			};
-			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
-			let resolved;
-			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
-				const key = path.relative(canonicalRootDir, canonical);
-				resolved = {
-					sourceKey: key,
-					owningRoot: null,
-					pathInRoot: key
-				};
-			} else if (owner) resolved = ownedBy(owner);
-			else return null;
-			aliases.set(lexical, resolved);
-			aliases.set(canonical, resolved);
-			return resolved;
-		},
-		resolveDeletedSourceId(inputPath) {
-			return aliases.get(path.normalize(inputPath)) ?? null;
-		},
-		containingExternalRoot(inputPath) {
-			const lexical = path.normalize(inputPath);
-			let owner = null;
-			for (const record of roots) {
-				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
-				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-			}
-			if (owner) return owner.canonical;
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			for (const record of roots) {
-				if (!isPathWithinRoot(record.canonical, canonical)) continue;
-				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-			}
-			return owner?.canonical ?? null;
+/**
+* The packages the session root's `package.json` declares as workspaces, by
+* name, at their real directories, so a linked workspace is one package. The
+* system loader consults them after a `node_modules` lookup misses. Only
+* literal entries name a package; a glob entry (`packages/*`) names none
+* yet. None when the manifest is absent or declares none.
+*/
+function declaredWorkspacePackages(rootDir) {
+	const rootPkg = readManifest(rootDir);
+	if (!isJsonBlock(rootPkg)) return {};
+	const workspaces = rootPkg.workspaces;
+	const declared = isJsonBlock(workspaces) ? workspaces.packages : workspaces;
+	if (!Array.isArray(declared)) return {};
+	const packages = /* @__PURE__ */ new Map();
+	for (const entry of declared) {
+		if (!isJsonString(entry)) continue;
+		let dir;
+		try {
+			dir = realpathSync$1(resolve$1(rootDir, entry));
+		} catch {
+			continue;
 		}
-	};
+		const manifest = readManifest(dir);
+		const name = isJsonBlock(manifest) ? manifest.name : void 0;
+		if (isJsonString(name) && name !== "" && !packages.has(name)) packages.set(name, dir);
+	}
+	return Object.fromEntries(packages);
 }
 //#endregion
 //#region pipeline/discover-packages.ts
 function findPackageRoot(absEntryPath) {
 	let pkgRoot = dirname$1(absEntryPath);
-	while (pkgRoot !== dirname$1(pkgRoot) && !existsSync(join$1(pkgRoot, "package.json"))) pkgRoot = dirname$1(pkgRoot);
+	while (pkgRoot !== dirname$1(pkgRoot) && !existsSync$1(join$1(pkgRoot, "package.json"))) pkgRoot = dirname$1(pkgRoot);
 	return pkgRoot;
 }
 const PACKAGE_SRC_EXCLUDES = [
@@ -2460,39 +3162,36 @@ const PACKAGE_OUTPUT_EXCLUDES = [
 	".d.ts",
 	".map"
 ];
-const isFile$1 = (path) => {
-	try {
-		return statSync(path).isFile();
-	} catch {
-		return false;
-	}
-};
-function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
-	return [
-		absSpecifier,
-		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
-		...Array.from(extensionsSet, (ext) => join$1(absSpecifier, `index${ext}`))
-	].find(isFile$1) ?? null;
+/** The file an absolute path specifier names, through the extension
+*  policy, spelled exactly below the directory it shares with `within`
+*  when given; a file differing only in case is a mismatch. */
+function probeAbsolutePathSpecifier(absSpecifier, extensionsSet, within, policy) {
+	return probeOnDisk(policyCandidates(normalize$1(absSpecifier), {
+		sources: extensionsSet,
+		index: join$1,
+		policy
+	}), within);
 }
 /** The package a bare specifier names: `@scope/name` or `name`. */
 function bareSpecifierPackageName(specifier) {
 	const segments = specifier.split("/");
 	return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
 }
-function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
+function sourceEntryForSpecifier(specifier, srcDir, extensionsSet, rootDir, policy) {
 	if (isAbsolute$1(specifier)) {
-		const resolved = resolveAbsolutePathSpecifier(specifier, extensionsSet);
-		if (!resolved) return null;
-		return isPathWithinRoot(srcDir, resolved) ? resolved : null;
+		const probed = probeAbsolutePathSpecifier(specifier, extensionsSet, rootDir, policy);
+		if (probed.kind !== "found") return null;
+		return isPathWithinRoot(srcDir, probed.path) ? probed.path : null;
 	}
 	const packageName = bareSpecifierPackageName(specifier);
 	const subpath = specifier.slice(packageName.length + 1);
-	return resolveAbsolutePathSpecifier(join$1(srcDir, subpath || "index"), extensionsSet);
+	const probed = probeAbsolutePathSpecifier(join$1(srcDir, subpath || "index"), extensionsSet, srcDir, policy);
+	return probed.kind === "found" ? probed.path : null;
 }
 /** The package's parsed `package.json`, or null when it cannot be read. */
 function readPackageManifest(pkgRoot) {
 	try {
-		return JSON.parse(readFileSync(join$1(pkgRoot, "package.json"), "utf-8"));
+		return JSON.parse(readFileSync$1(join$1(pkgRoot, "package.json"), "utf-8"));
 	} catch {
 		return null;
 	}
@@ -2512,53 +3211,52 @@ function exportsSubpaths(manifest) {
 * its source in every host, and the system loader prefers it.
 */
 const KIT_SOURCE_CONDITION = "animus";
-/** The package's kit source condition, or null when no exact `exports`
-*  entry declares it: the package is no source kit. */
-function readKitSourceCondition(pkgRoot) {
-	const condition = {
-		entries: [],
-		invalid: [],
-		root: null
+/** The system loader's package locator under the session's declared
+*  `workspaces`: the first `node_modules/<name>` up the tree, then the
+*  workspace of that name. */
+function nativePackageLocator(engine, workspaces) {
+	const native = engine.locatePackage;
+	return (name, fromDir) => {
+		if (native === void 0) throw new Error("the native engine does not expose locatePackage, which kit discovery needs — rebuild @animus-ui/extract");
+		return native(name, fromDir, workspaces);
 	};
-	for (const [subpath, value] of exportsSubpaths(readPackageManifest(pkgRoot))) {
-		if (subpath.includes("*") || !isJsonBlock(value)) continue;
-		const target = value[KIT_SOURCE_CONDITION];
-		if (!isJsonString(target)) continue;
-		const file = resolve$1(pkgRoot, target);
-		if (isPathWithinRoot(pkgRoot, file) && isFile$1(file)) condition.entries.push([subpath, file]);
-		else condition.invalid.push([subpath, target]);
-	}
-	if (condition.entries.length === 0 && condition.invalid.length === 0) return null;
-	condition.root = condition.entries.reduce((root, [, file]) => root === null ? dirname$1(file) : commonDirectory(root, dirname$1(file)), null);
-	return condition;
-}
-function commonDirectory(a, b) {
-	let dir = a;
-	while (!isPathWithinRoot(dir, b)) dir = dirname$1(dir);
-	return dir;
-}
-/** Whether the manifest at `dir` names the package `name`. */
-function isPackageNamed(dir, name) {
+}
+/** The native table's kit source roots under one resolution context. */
+function nativeKitSourceRoot(engine, fromDir, conditions, workspaces, policyJson) {
+	const native = engine.resolveKitSourceRoot;
+	return (specifier, packageDir, hostEntry) => {
+		if (native === void 0) throw new Error("the native engine does not expose resolveKitSourceRoot, which kit discovery needs — rebuild @animus-ui/extract");
+		const answer = parseInternalWire(native(specifier, fromDir, [...conditions], workspaces, policyJson, hostEntry ?? void 0, packageDir), "resolveKitSourceRoot");
+		if (answer.rule === void 0) return null;
+		return {
+			rule: answer.rule,
+			root: answer.root ?? null,
+			entries: answer.entries ?? [],
+			invalid: answer.invalid ?? [],
+			unresolved: answer.unresolved ?? null
+		};
+	};
+}
+/**
+* Whether `dir`, the nearest manifest above a host's answer, is a package
+* the host resolved into: its manifest names a package, and it is not the
+* project or a directory holding it. A host answer from a dependency cache
+* (`node_modules/.vite/deps`), or from a file outside every package, finds
+* the application's own manifest, which is no package root. The name need
+* not be the specifier's: a host alias resolves one package to another,
+* and the host's package is the one the bundle renders (spec §2.2 A4).
+*/
+function isHostPackageRoot(dir, rootDir) {
 	const manifest = readPackageManifest(dir);
-	return isJsonBlock(manifest) && manifest.name === name;
+	return isJsonBlock(manifest) && isJsonString(manifest.name) && manifest.name !== "" && !isPathWithinRoot(realPath(dir), realPath(rootDir));
 }
 function realPath(path) {
 	try {
-		return realpathSync(path);
+		return realpathSync$1(path);
 	} catch {
 		return path;
 	}
 }
-/** The root of the installed package `name` as Node finds it from `fromDir`,
-*  the first `node_modules/<name>` up the directory tree, at its real path,
-*  as host resolvers report a linked package. */
-function locatePackageRoot(name, fromDir) {
-	for (let dir = fromDir;; dir = dirname$1(dir)) {
-		const candidate = join$1(dir, "node_modules", name);
-		if (existsSync(join$1(candidate, "package.json"))) return realPath(candidate);
-		if (dir === dirname$1(dir)) return null;
-	}
-}
 /**
 * A package's `sideEffects` field, decoded the way Vite reads it: a boolean
 * as written, or the list's globs, one with no `/` matching the basename
@@ -2683,7 +3381,7 @@ function packageExportEntries(pkgRoot) {
 function isInstalledPackage(pkgRoot) {
 	let realRoot = pkgRoot;
 	try {
-		realRoot = realpathSync(pkgRoot);
+		realRoot = realpathSync$1(pkgRoot);
 	} catch {}
 	return realRoot.split(/[\\/]/).includes("node_modules");
 }
@@ -2691,25 +3389,32 @@ function distEntryIsStale(absEntry, srcDir, srcFiles) {
 	if (isPathWithinRoot(srcDir, absEntry)) return false;
 	let distMtime;
 	try {
-		distMtime = statSync(absEntry).mtimeMs;
+		distMtime = statSync$1(absEntry).mtimeMs;
 	} catch {
 		return false;
 	}
 	let newestSrcMtime = -Infinity;
 	for (const srcFile of srcFiles) try {
-		newestSrcMtime = Math.max(newestSrcMtime, statSync(srcFile).mtimeMs);
+		newestSrcMtime = Math.max(newestSrcMtime, statSync$1(srcFile).mtimeMs);
 	} catch {}
 	return distMtime < newestSrcMtime;
 }
 async function collectExternalPackageSources(opts) {
-	const { specifiers, resolveSpecifier, rootDir, extensionsSet, hasEntry, onSourceRead, onUnreadable, onPackageResolved } = opts;
+	const { specifiers, unresolvedReason, kitSourceRoot, locatePackage, rootDir, extensionsSet, hasEntry, onSourceRead, onUnreadable, onPackageResolved, requireSourceEntry, extensions, hostOutputDirs = [] } = opts;
+	const answers = /* @__PURE__ */ new Map();
+	const resolveSpecifier = (specifier) => {
+		let answer = answers.get(specifier);
+		if (answer === void 0) {
+			answer = Promise.resolve().then(() => opts.resolveSpecifier(specifier));
+			answers.set(specifier, answer);
+		}
+		return answer;
+	};
 	const entries = [];
 	const pushed = /* @__PURE__ */ new Set();
 	const packageMap = {};
 	const sourceEntries = /* @__PURE__ */ new Map();
 	const sourceEntrySideEffects = /* @__PURE__ */ new Map();
-	/** `replaced` names the entry the redirect stands in for; it is only
-	*  needed, and so only resolved, for a glob list. */
 	/** The entry `subpath` of the package resolves to without the redirect.
 	*  A resolver with no `import` condition, as Node's `require` has none,
 	*  finds no ESM-only entry, so the manifest's own target answers then. */
@@ -2720,6 +3425,8 @@ async function collectExternalPackageSources(opts) {
 		} catch {}
 		return packageExportEntries(pkgRoot).find(([entry]) => entry === subpath)?.[1] ?? null;
 	};
+	/** `replaced` names the entry the redirect stands in for; it is only
+	*  needed, and so only resolved, for a glob list. */
 	const redirect = async (specifier, srcEntry, pkgRoot, replaced) => {
 		sourceEntries.set(specifier, srcEntry);
 		const field = readPackageSideEffects(pkgRoot);
@@ -2749,7 +3456,7 @@ async function collectExternalPackageSources(opts) {
 		if (alreadyIngested(relPath)) return true;
 		let source;
 		try {
-			source = readFileSync(file, "utf-8");
+			source = readFileSync$1(file, "utf-8");
 		} catch (err) {
 			onUnreadable(relPath, err);
 			return false;
@@ -2764,8 +3471,18 @@ async function collectExternalPackageSources(opts) {
 		return true;
 	};
 	const diagnostics = [];
-	const reportedPackages = /* @__PURE__ */ new Set();
+	const reported = /* @__PURE__ */ new Set();
+	const report = (packageName, pkgRoot, condition) => {
+		const copy = realPath(pkgRoot);
+		for (const finding of sourceConditionDiagnostics(packageName, condition)) {
+			const key = `${copy}\0${finding.code}\0${finding.message}`;
+			if (reported.has(key)) continue;
+			reported.add(key);
+			diagnostics.push(finding);
+		}
+	};
 	const kitDescriptors = [];
+	const packageInstances = {};
 	const describedRoots = /* @__PURE__ */ new Set();
 	for (const specifier of specifiers) {
 		let absEntry;
@@ -2774,23 +3491,78 @@ async function collectExternalPackageSources(opts) {
 		} catch {
 			absEntry = null;
 		}
-		if (!absEntry && isAbsolute$1(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		let caseMismatch;
+		if (isAbsolute$1(specifier)) {
+			const own = probeAbsolutePathSpecifier(specifier, extensionsSet, rootDir, extensions);
+			const hosted = absEntry === null ? null : normalize$1(absEntry);
+			const seen = hosted === null ? null : seeOnDisk(hosted, rootDir);
+			const probed = own.kind === "case-mismatch" || hosted === null || seen === null ? own : seen.kind === "case-only" ? {
+				kind: "case-mismatch",
+				candidate: hosted,
+				actual: seen.actual
+			} : {
+				kind: "found",
+				path: hosted
+			};
+			absEntry = probed.kind === "found" ? probed.path : null;
+			if (probed.kind === "case-mismatch") caseMismatch = caseMismatchReason(`'${specifier}'`, probed, "spell the include as the file is spelled");
+		}
 		const packageName = isAbsolute$1(specifier) ? null : bareSpecifierPackageName(specifier);
-		const resolvedRoot = absEntry ? findPackageRoot(absEntry) : null;
-		const locatedRoot = packageName && locatePackageRoot(packageName, rootDir);
-		const pkgRoot = resolvedRoot && (!locatedRoot || isPackageNamed(resolvedRoot, packageName) || realPath(resolvedRoot) === locatedRoot) ? resolvedRoot : locatedRoot || resolvedRoot;
-		const condition = packageName && pkgRoot ? readKitSourceCondition(pkgRoot) : null;
+		let resolvedRoot = absEntry ? findPackageRoot(absEntry) : null;
+		const locatedRoot = packageName && locatePackage(packageName, opts.locateFrom?.(specifier) ?? rootDir);
+		if (resolvedRoot && locatedRoot && absEntry && realPath(resolvedRoot) !== locatedRoot && isPathWithinRoot(locatedRoot, realPath(absEntry))) {
+			while (realPath(resolvedRoot) !== locatedRoot && resolvedRoot !== dirname$1(resolvedRoot)) resolvedRoot = dirname$1(resolvedRoot);
+			if (realPath(resolvedRoot) !== locatedRoot) resolvedRoot = locatedRoot;
+		}
+		const pkgRoot = resolvedRoot && (!locatedRoot || isHostPackageRoot(resolvedRoot, rootDir) || realPath(resolvedRoot) === locatedRoot) ? resolvedRoot : locatedRoot || resolvedRoot;
+		if (absEntry && packageName && locatedRoot && pkgRoot === locatedRoot && !isPathWithinRoot(locatedRoot, realPath(absEntry)) && !realPath(absEntry).split(sep$1).includes("node_modules")) diagnostics.push(packageMismatchDiagnostic(specifier, relative$1(rootDir, absEntry), relative$1(rootDir, locatedRoot)));
+		const selection = packageName && pkgRoot ? kitSourceRoot(specifier, pkgRoot, absEntry) : null;
+		if (selection?.unresolved) {
+			absEntry = null;
+			caseMismatch = selection.unresolved;
+		}
+		const condition = selection && (selection.rule === "animus" || selection.rule === "source-exports" || selection.invalid.length > 0) ? {
+			entries: selection.entries,
+			invalid: selection.invalid,
+			root: selection.rule === "compiled" ? null : selection.root
+		} : null;
+		if (selection?.unresolved && condition && packageName && pkgRoot) report(packageName, pkgRoot, condition);
 		const entryKey = packageName && `.${specifier.slice(packageName.length)}`;
 		absEntry ??= condition?.entries.find(([entry]) => entry === entryKey)?.[1] ?? null;
 		if (!absEntry || !pkgRoot) {
-			outcomes.push({
+			const record = {
 				specifier,
 				outcome: "unresolvable",
 				fileCount: 0
+			};
+			const reason = caseMismatch ?? unresolvedReason?.(specifier);
+			if (reason !== void 0) record.reason = reason;
+			outcomes.push(record);
+			continue;
+		}
+		const hostOutput = hostOutputDirs.find((dir) => isPathWithinRoot(dir, pkgRoot) || isPathWithinRoot(realPath(dir), realPath(pkgRoot)));
+		if (hostOutput !== void 0) {
+			outcomes.push({
+				specifier,
+				outcome: "unresolvable",
+				fileCount: 0,
+				reason: `the package lies inside the host's output directory ${hostOutput}, which is never source`
 			});
 			continue;
 		}
+		if (requireSourceEntry?.(specifier)) {
+			if (!(condition && packageName ? condition.entries.some(([entry]) => entry === entryKey) : selection?.rule === "src" && sourceEntryForSpecifier(specifier, join$1(pkgRoot, "src"), extensionsSet, rootDir, extensions) !== null)) {
+				outcomes.push({
+					specifier,
+					outcome: "unresolvable",
+					fileCount: 0,
+					reason: "the host does not resolve it, and the system loader finds only compiled output that no source entry redirects to — link the package into node_modules, or give it an \"animus\" source condition"
+				});
+				continue;
+			}
+		}
 		const realRoot = realPath(pkgRoot);
+		if (packageName) packageInstances[packageName] ??= realRoot;
 		if (!describedRoots.has(realRoot)) {
 			describedRoots.add(realRoot);
 			const described = readKitDescriptor(pkgRoot, rootDir);
@@ -2800,10 +3572,24 @@ async function collectExternalPackageSources(opts) {
 		const srcDir = join$1(pkgRoot, "src");
 		let fileCount = 0;
 		let staleDist = false;
-		if (packageName && !reportedPackages.has(packageName)) {
-			reportedPackages.add(packageName);
-			diagnostics.push(...sourceConditionDiagnostics(packageName, condition));
-		}
+		if (packageName) report(packageName, pkgRoot, condition);
+		const ingestOutput = (entryFile) => {
+			const outputDir = dirname$1(entryFile);
+			packageDirs.push(outputDir);
+			if (linked) linkedDirs.push(outputDir);
+			outputDirs.push(outputDir);
+			claimDir(outputDir, specifier);
+			onPackageResolved?.(specifier, outputDir);
+			const outputExtensions = new Set(extensionsSet);
+			outputExtensions.add(extname$1(entryFile));
+			dirExtensions[outputDir] = [...outputExtensions];
+			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
+				const relToOutput = relative$1(outputDir, file);
+				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
+			});
+			if (!outputFiles.includes(entryFile)) outputFiles.unshift(entryFile);
+			for (const outputFile of outputFiles) if (ingest(outputFile, specifier)) fileCount++;
+		};
 		if (condition && packageName) {
 			for (const [entry, target] of condition.entries) {
 				const entrySpecifier = packageName + entry.slice(1);
@@ -2811,6 +3597,7 @@ async function collectExternalPackageSources(opts) {
 				await redirect(entrySpecifier, target, pkgRoot, () => shippedEntry(entrySpecifier, pkgRoot, entry));
 			}
 			packageMap[specifier] ??= relative$1(rootDir, absEntry);
+			if (!condition.entries.some(([entry]) => entry === entryKey)) ingestOutput(absEntry);
 			if (condition.root) {
 				packageDirs.push(condition.root);
 				if (linked) linkedDirs.push(condition.root);
@@ -2819,13 +3606,13 @@ async function collectExternalPackageSources(opts) {
 				onPackageResolved?.(specifier, condition.root);
 				for (const file of walkPackageSources(condition.root, extensionsSet)) if (ingest(file, specifier)) fileCount++;
 			}
-		} else if (existsSync(srcDir)) {
+		} else if (selection === null ? existsSync$1(srcDir) : selection.rule === "src") {
 			packageDirs.push(srcDir);
 			if (linked) linkedDirs.push(srcDir);
 			claimDir(srcDir, specifier);
 			dirExtensions[srcDir] = [...extensionsSet];
 			onPackageResolved?.(specifier, srcDir);
-			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
+			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet, rootDir, extensions);
 			if (srcEntry) {
 				packageMap[specifier] = relative$1(rootDir, srcEntry);
 				const replaced = absEntry;
@@ -2833,7 +3620,7 @@ async function collectExternalPackageSources(opts) {
 			} else packageMap[specifier] = relative$1(rootDir, absEntry);
 			if (packageName) {
 				if (packageName !== specifier && !(packageName in packageMap)) {
-					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
+					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet, rootDir, extensions);
 					if (rootEntry) {
 						packageMap[packageName] = relative$1(rootDir, rootEntry);
 						await redirect(packageName, rootEntry, pkgRoot, () => shippedEntry(packageName, pkgRoot, "."));
@@ -2844,22 +3631,8 @@ async function collectExternalPackageSources(opts) {
 			staleDist = linked && distEntryIsStale(absEntry, srcDir, pkgFiles);
 			for (const pkgFile of pkgFiles) if (ingest(pkgFile, specifier)) fileCount++;
 		} else {
-			const outputDir = dirname$1(absEntry);
-			packageDirs.push(outputDir);
-			if (linked) linkedDirs.push(outputDir);
-			outputDirs.push(outputDir);
-			claimDir(outputDir, specifier);
-			onPackageResolved?.(specifier, outputDir);
 			packageMap[specifier] = relative$1(rootDir, absEntry);
-			const outputExtensions = new Set(extensionsSet);
-			outputExtensions.add(extname$1(absEntry));
-			dirExtensions[outputDir] = [...outputExtensions];
-			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
-				const relToOutput = relative$1(outputDir, file);
-				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
-			});
-			if (!outputFiles.includes(absEntry)) outputFiles.unshift(absEntry);
-			for (const outputFile of outputFiles) if (ingest(outputFile, specifier)) fileCount++;
+			ingestOutput(absEntry);
 		}
 		if (packageName) for (const [subpath, target] of packageExportEntries(pkgRoot)) {
 			const entrySpecifier = packageName + subpath.slice(1);
@@ -2867,6 +3640,16 @@ async function collectExternalPackageSources(opts) {
 			if (entrySpecifier in packageMap || !alreadyIngested(targetRelPath)) continue;
 			packageMap[entrySpecifier] = targetRelPath;
 		}
+		const ownManifest = readPackageManifest(pkgRoot);
+		const hostName = isJsonBlock(ownManifest) ? ownManifest.name : void 0;
+		if (packageName && locatedRoot && realPath(pkgRoot) !== locatedRoot && isJsonString(hostName) && hostName !== "" && hostName !== packageName) for (const [key, entry] of [...sourceEntries]) {
+			if (key !== packageName && !key.startsWith(`${packageName}/`)) continue;
+			const hostKey = hostName + key.slice(packageName.length);
+			if (sourceEntries.has(hostKey)) continue;
+			sourceEntries.set(hostKey, entry);
+			const sideEffects = sourceEntrySideEffects.get(key);
+			if (sideEffects !== void 0) sourceEntrySideEffects.set(hostKey, sideEffects);
+		}
 		outcomes.push({
 			specifier,
 			outcome: staleDist ? "stale-dist" : fileCount > 0 ? "resolved" : "empty",
@@ -2886,7 +3669,8 @@ async function collectExternalPackageSources(opts) {
 		fileOwners,
 		outcomes,
 		diagnostics: [...diagnostics, ...noKitFilesDiagnostics(outcomes)],
-		kitDescriptors
+		kitDescriptors,
+		packageInstances
 	};
 }
 /** The dependency names a manifest lists in `fields`. */
@@ -2899,14 +3683,22 @@ function dependencyNames(manifest, fields) {
 	}
 	return [...names];
 }
+/** Whether the package at `pkgRoot` declares the kit source condition, as
+*  the system loader's table reads its manifest: an `animus` key anywhere in
+*  its `exports`, on any entry, subpath or pattern, valid or not. */
+function declaresKitSource(engine, pkgRoot) {
+	if (engine.declaresKitSource === void 0) throw new Error("the native engine does not expose declaresKitSource, which kit discovery needs — rebuild @animus-ui/extract");
+	return engine.declaresKitSource(pkgRoot);
+}
 /** The source kits the application at `rootDir` declares as dependencies.
 *  A bundler serves an installed one as compiled code unless told
 *  otherwise: Next keeps it external on the server unless it is in
 *  `transpilePackages`, and Vite's optimizer prebundles it. */
-function sourceKitDependencies(rootDir) {
+function sourceKitDependencies(rootDir, engine) {
+	const locatePackage = nativePackageLocator(engine, declaredWorkspacePackages(rootDir));
 	return dependencyNames(readPackageManifest(rootDir), ["dependencies", "devDependencies"]).flatMap((name) => {
-		const pkgRoot = locatePackageRoot(name, rootDir);
-		if (pkgRoot === null || readKitSourceCondition(pkgRoot) === null) return [];
+		const pkgRoot = locatePackage(name, rootDir);
+		if (pkgRoot === null || !declaresKitSource(engine, pkgRoot)) return [];
 		return [{
 			name,
 			installed: isInstalledPackage(pkgRoot),
@@ -2914,6 +3706,34 @@ function sourceKitDependencies(rootDir) {
 		}];
 	});
 }
+/**
+* The installed packages a system's membership reaches: each is a kit,
+* whether or not it declares the source condition, and so is every kit its
+* own system extends or includes. Read before any host resolves (a
+* bundler's config), so the application's modules import as the system
+* loader resolves them from the root, and a kit's from its own directory.
+*/
+async function systemKitDependencies(rootDir, systemPath, engine) {
+	const workspaces = declaredWorkspacePackages(rootDir);
+	const resolveSpecifier = engine.resolveSpecifier;
+	const systemPackageRoot = findPackageRoot(systemPath);
+	const kitMembers = /* @__PURE__ */ new Map();
+	const members = await extractSystemFilePackages(systemPath, engine, void 0, (specifier, importer) => resolveSpecifier?.(specifier, findPackageRoot(importer) === systemPackageRoot ? rootDir : dirname$1(importer), [], workspaces, extensionPolicyJson(BUILT_IN_EXTENSION_POLICY))?.path ?? null, void 0, kitMembers);
+	const locatePackage = nativePackageLocator(engine, workspaces);
+	const roots = /* @__PURE__ */ new Map();
+	for (const member of members) {
+		if (!isPackageSpecifier(member)) continue;
+		const name = bareSpecifierPackageName(member);
+		const file = kitMembers.get(member);
+		const pkgRoot = file ? findPackageRoot(file) : locatePackage(name, rootDir);
+		if (pkgRoot !== null && !roots.has(name)) roots.set(name, pkgRoot);
+	}
+	return [...roots].map(([name, pkgRoot]) => ({
+		name,
+		installed: isInstalledPackage(pkgRoot),
+		dependencies: dependencyNames(readPackageManifest(pkgRoot), ["dependencies"])
+	}));
+}
 /** A specifier that names a package: not relative or absolute, and no URL,
 *  scheme (`node:`, `virtual:`), subpath import or virtual id. */
 function isPackageSpecifier(specifier) {
@@ -2929,16 +3749,13 @@ function isPackageSpecifier(specifier) {
 * file the engine parses as it is; an adapted source (`.svelte`, `.mdx`)
 * reaches the engine only as its generated children.
 */
-function importedKitDiagnostics(files, engine, rootDir, systemKits) {
-	const { extractFacts } = engine;
+function importedKitDiagnostics(files, engine, rootDir, systemKits, factsOf) {
 	const parsed = files.filter(({ path }) => isEngineTransformExtension(path));
-	if (!extractFacts || parsed.length === 0) return [];
+	if (parsed.length === 0) return [];
+	const locatePackage = nativePackageLocator(engine, declaredWorkspacePackages(rootDir));
 	let facts;
 	try {
-		facts = parseInternalWire(extractFacts(JSON.stringify(parsed.map(({ path, source }) => ({
-			path,
-			source
-		})))), "extractFacts");
+		facts = factsOf(parsed);
 	} catch {
 		return [];
 	}
@@ -2952,8 +3769,8 @@ function importedKitDiagnostics(files, engine, rootDir, systemKits) {
 			const name = bareSpecifierPackageName(specifier);
 			if (seen.has(name)) continue;
 			seen.add(name);
-			const pkgRoot = locatePackageRoot(name, dirname$1(resolve$1(rootDir, path)));
-			if (pkgRoot && readKitSourceCondition(pkgRoot)) diagnostics.push({
+			const pkgRoot = locatePackage(name, dirname$1(resolve$1(rootDir, path)));
+			if (pkgRoot && declaresKitSource(engine, pkgRoot)) diagnostics.push({
 				file: path,
 				component: name,
 				kind: "warn",
@@ -2966,7 +3783,19 @@ function importedKitDiagnostics(files, engine, rootDir, systemKits) {
 	return diagnostics;
 }
 /** A kit without the source condition, warned once, or each condition entry
-*  whose target is missing or outside the package. */
+*  the loader does not read as source: missing, spelled otherwise on disk,
+*  no package target Node accepts (each read from its runtime target), or
+*  percent-escaped (refused, failing the load). */
+function packageMismatchDiagnostic(specifier, hostEntry, located) {
+	return {
+		file: specifier,
+		component: "kit",
+		kind: "warn",
+		message: `the host bundler resolves '${specifier}' to ${hostEntry}, which lies in no package, so discovery reads the installed package at ${located} instead and the bundle may render another module than the one analysed — make the bundler resolve '${specifier}' to a package`,
+		code: PACKAGE_MISMATCH,
+		severity: severityFor(PACKAGE_MISMATCH)
+	};
+}
 function sourceConditionDiagnostics(packageName, condition) {
 	if (condition === null) return [{
 		file: packageName,
@@ -2976,11 +3805,11 @@ function sourceConditionDiagnostics(packageName, condition) {
 		code: KIT_WITHOUT_SOURCE_CONDITION,
 		severity: severityFor(KIT_WITHOUT_SOURCE_CONDITION)
 	}];
-	return condition.invalid.map(([subpath, target]) => ({
+	return condition.invalid.map(([subpath, target, why]) => ({
 		file: packageName,
 		component: "kit",
 		kind: "warn",
-		message: `exports["${subpath}"].${KIT_SOURCE_CONDITION} names ${target}, which is missing or outside the package, so that entry is not read from source`,
+		message: why.includes("percent-escape unsupported") ? `exports["${subpath}"].${KIT_SOURCE_CONDITION} names ${target}, which ${why}, so the system loader fails to load that entry` : `exports["${subpath}"].${KIT_SOURCE_CONDITION} names ${target}, which ${why}, so that entry is read from its runtime target instead of source`,
 		code: INVALID_KIT_SOURCE_CONDITION,
 		severity: severityFor(INVALID_KIT_SOURCE_CONDITION)
 	}));
@@ -3037,13 +3866,16 @@ function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
 		fileOwners,
 		outcomes: collected.outcomes,
 		diagnostics: collected.diagnostics,
-		kitDescriptors: collected.kitDescriptors.filter((record) => !rejectedDirs.some((dir) => isPathWithinRoot(resolve$1(rootDir, record.packageRoot), dir)))
+		kitDescriptors: collected.kitDescriptors.filter((record) => !rejectedDirs.some((dir) => isPathWithinRoot(resolve$1(rootDir, record.packageRoot), dir))),
+		packageInstances: Object.fromEntries(Object.entries(collected.packageInstances).filter(([, root]) => !rejectedDirs.some((dir) => isPathWithinRoot(root, dir))))
 	};
 }
-function unresolvableIncludesMessage(outcomes) {
-	const unresolvable = outcomes.filter((record) => record.outcome === "unresolvable").map((record) => record.specifier);
+/** Every unresolvable include, with why where the resolver said, and the
+*  system file that includes them when the caller knows it. */
+function unresolvableIncludesMessage(outcomes, importer) {
+	const unresolvable = outcomes.filter((record) => record.outcome === "unresolvable").map((record) => record.reason === void 0 ? record.specifier : `${record.specifier} (${record.reason})`);
 	if (unresolvable.length === 0) return null;
-	return `[animus-extract] unresolvable include specifier(s): ${unresolvable.join(", ")}`;
+	return `[animus-extract] unresolvable include specifier(s)${importer === void 0 ? "" : ` in ${importer}`}: ${unresolvable.join(", ")}`;
 }
 /** A stale dist silently skews merged registry content while discovery
 *  compiles the fresh sources; null when no specifier is stale. */
@@ -3060,192 +3892,38 @@ function engineModuleParser(engine) {
 	if (!extractFacts) return void 0;
 	return (source, path) => {
 		try {
-			const facts = parseInternalWire(extractFacts(JSON.stringify([{
-				path,
-				source
-			}])), "extractFacts").files[path];
-			return facts && !facts.parsePanicked ? {
-				imports: facts.imports,
-				exports: facts.exports,
-				unboundCreateSystemCalls: facts.unboundCreateSystemCalls ?? []
-			} : null;
-		} catch {
-			return null;
-		}
-	};
-}
-const ANIMUS_SYSTEM_SPECIFIER = /^@animus-ui\/system(?:\/.*)?$/;
-/** The file a specifier names from `importer`: a relative one by the
-*  ingestion's probe order, a bare one by the host's package resolution. */
-async function resolveModuleFile(importer, specifier, resolvePackage) {
-	if (specifier.startsWith(".")) return relativeSourceCandidates(importer, specifier).find(isFile$1) ?? null;
-	try {
-		return await resolvePackage?.(specifier) ?? null;
-	} catch {
-		return null;
-	}
-}
-const escapeRegExp$1 = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-/**
-* Follows `name`, exported by the module `specifier` names from `importer`,
-* through re-exports to its declaration. It is Animus's factory only when
-* that is `createSystem` of `@animus-ui/system`, and another identity only
-* when a module is shown to declare it; anything discovery cannot follow is
-* unknown.
-*/
-async function exportIdentity(importer, specifier, name, following, seen) {
-	if (ANIMUS_SYSTEM_SPECIFIER.test(specifier)) return name === "createSystem" ? { kind: "animus" } : {
-		kind: "other",
-		what: `'${name}' of ${specifier}`
-	};
-	const file = await resolveModuleFile(importer, specifier, following.resolvePackage);
-	if (file === null) return {
-		kind: "unknown",
-		why: `'${specifier}' could not be resolved`
-	};
-	const key = `${file}#${name}`;
-	if (seen.has(key)) return {
-		kind: "unknown",
-		why: `'${specifier}' re-exports it in a cycle`
-	};
-	seen.add(key);
-	let source;
-	try {
-		source = readFileSync(file, "utf-8");
-	} catch {
-		return {
-			kind: "unknown",
-			why: `'${specifier}' could not be read`
-		};
-	}
-	const record = following.parseModule(source, file);
-	if (record === null) return {
-		kind: "unknown",
-		why: `'${specifier}' could not be parsed`
-	};
-	const exported = record.exports.find((entry) => entry.exported === name);
-	if (exported?.source) return exportIdentity(file, exported.source, exported.original ?? name, following, seen);
-	const local = exported?.local ?? name;
-	const imported = record.imports.find((entry) => entry.local === local);
-	if (exported && imported) return exportIdentity(file, imported.source, imported.imported, following, seen);
-	if (exported || new RegExp(`\\bexport\\s+(?:async\\s+)?(?:function\\*?|class|const|let|var)\\s+${escapeRegExp$1(name)}\\b`).test(source)) return {
-		kind: "other",
-		what: `the '${name}' that '${specifier}' declares`
-	};
-	const stars = [];
-	for (const match of source.matchAll(/\bexport\s*\*\s*from\s*['"]([^'"]+)['"]/g)) stars.push(await exportIdentity(file, match[1], name, following, seen));
-	const definite = stars.filter((identity) => identity.kind !== "unknown");
-	if (definite.length === 1) return definite[0];
-	if (definite.length > 1) return {
-		kind: "unknown",
-		why: `more than one \`export *\` of '${specifier}' provides '${name}'`
-	};
-	return stars.find((identity) => identity.kind === "unknown") ?? {
-		kind: "unknown",
-		why: `'${specifier}' has no export '${name}' discovery can read`
-	};
-}
-/** 1-based line and column of `offset` in `source`. */
-function locationIn(source, offset) {
-	const before = source.slice(0, offset);
-	const lineStart = before.lastIndexOf("\n") + 1;
-	return {
-		line: before.split("\n").length,
-		column: offset - lineStart + 1
-	};
-}
-const NAMESPACE_IMPORT = /\bimport\s+(?:[a-zA-Z_$][a-zA-Z0-9_$]*\s*,\s*)?\*\s*as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s+from\s+['"]([^'"]+)['"]/g;
-/**
-* The callees that are Animus's `createSystem` in a parsed system file. A
-* binding counts once its identity is followed to the factory: a named
-* import, through local and package re-exports; a namespace import's
-* member; or a property destructured from a namespace import, `require` or
-* `import()` of a module. A binding named `createSystem` shown to be
-* something else is no root. One whose identity discovery cannot follow
-* keeps the admission spelling gave it, so a resolution limit never drops a
-* kit. Both are reported. A call of the bare name, which the file neither
-* imports nor declares, is no root: the system loader evaluates the file
-* without auto-imports, where the name is undefined. It is reported once.
-*/
-async function systemRoots(systemFilePath, source, record, following) {
-	const { imports } = record;
-	const roots = /* @__PURE__ */ new Set();
-	const identityOf = (specifier, name) => exportIdentity(systemFilePath, specifier, name, following, /* @__PURE__ */ new Set());
-	const called = (callee) => callOf(callee).test(source);
-	/** Admits a binding named `createSystem` by its identity: an unknown one
-	*  keeps `spellingAdmits`, and every unproven one is reported. */
-	const admit = (local, offset, identity, spellingAdmits) => {
-		if (identity.kind === "animus") {
-			roots.add(local);
-			return;
-		}
-		if (identity.kind === "unknown" && spellingAdmits) roots.add(local);
-		const shown = identity.kind === "other" ? `it is ${identity.what}, so it is not read as a system root` : `discovery cannot follow what it is bound to (${identity.why}), so it is ${spellingAdmits ? "still read" : "not read"} as a system root by its name alone`;
-		following.report?.({
-			file: systemFilePath,
-			component: local,
-			kind: "warn",
-			message: `'${local}' is not proven to be Animus's createSystem: ${shown} — import createSystem from '@animus-ui/system', directly or through a re-export discovery can follow`,
-			code: UNPROVEN_ROOT_BINDING,
-			severity: severityFor(UNPROVEN_ROOT_BINDING),
-			...locationIn(source, offset)
-		});
-	};
-	for (const binding of imports) {
-		if (binding.imported === "createSystem" || binding.local === "createSystem") {
-			const statement = new RegExp(`\\bimport\\b[^;]*?\\bfrom\\s*['"]${escapeRegExp$1(binding.source)}['"]`, "g");
-			let offset = 0;
-			for (const match of source.matchAll(statement)) {
-				const at = match[0].search(new RegExp(`(?<![a-zA-Z0-9_$])${escapeRegExp$1(binding.local)}\\b`));
-				if (at !== -1) {
-					offset = match.index + at;
-					break;
-				}
-			}
-			admit(binding.local, offset, await identityOf(binding.source, binding.imported), binding.imported === "createSystem");
-			continue;
+			const facts = parseInternalWire(extractFacts(JSON.stringify([{
+				path,
+				source
+			}])), "extractFacts").files[path];
+			return facts && !facts.parsePanicked ? {
+				imports: facts.imports,
+				exports: facts.exports,
+				unboundCreateSystemCalls: facts.unboundCreateSystemCalls ?? []
+			} : null;
+		} catch {
+			return null;
 		}
-		if (binding.source.startsWith(".") && called(binding.local) && (await identityOf(binding.source, binding.imported)).kind === "animus") roots.add(binding.local);
-	}
-	const namespaces = /* @__PURE__ */ new Map();
-	for (const [, namespace, specifier] of source.matchAll(NAMESPACE_IMPORT)) {
-		namespaces.set(namespace, specifier);
-		const member = `${namespace}.createSystem`;
-		if (ANIMUS_SYSTEM_SPECIFIER.test(specifier) || specifier.startsWith(".") && called(member) && (await identityOf(specifier, "createSystem")).kind === "animus") roots.add(member);
-	}
-	const destructuredFrom = (initializer) => {
-		const loaded = /^\(?\s*(?:(?:await\s+)?import|require)\(\s*['"]([^'"]+)['"]\s*\)\s*\)?$/.exec(initializer);
-		if (loaded) return identityOf(loaded[1], "createSystem");
-		const namespace = namespaces.get(initializer);
-		if (namespace !== void 0) return identityOf(namespace, "createSystem");
-		return Promise.resolve({
-			kind: "unknown",
-			why: `it is destructured from '${initializer}', which is not a module namespace`
-		});
 	};
-	for (const { local, offset, initializer } of destructuredCreateSystems(source)) admit(local, offset, await destructuredFrom(initializer), local === "createSystem");
-	const unimported = unimportedCreateSystemCall(systemFilePath, record);
-	if (unimported) following.report?.(unimported);
-	return roots;
-}
-/** A call of `callee` as a whole name, not a member. */
-function callOf(callee) {
-	return new RegExp(`(?<![a-zA-Z0-9_$.])${escapeRegExp$1(callee)}\\s*\\(`);
-}
-/** Each `createSystem` property a declaration destructures: its local name,
-*  its offset in `source`, and the destructured initializer. */
-function* destructuredCreateSystems(source) {
-	for (const match of source.matchAll(/\b(?:const|let|var)\s*\{([^}]*)\}\s*=\s*([^;\n]+)/g)) {
-		const [whole, pattern, initializer] = match;
-		for (const property of pattern.split(",")) {
-			const binding = /^\s*createSystem\s*(?::\s*([a-zA-Z_$][a-zA-Z0-9_$]*))?\s*(?:=[\s\S]*)?$/.exec(property);
-			if (!binding) continue;
-			yield {
-				local: binding[1] ?? "createSystem",
-				offset: match.index + whole.indexOf("createSystem"),
-				initializer: initializer.trim()
-			};
-		}
+}
+/** The file a specifier names from `importer`, or why it names none: a
+*  relative one by the ingestion's probe order, spelled exactly, a bare one
+*  by the host's package resolution. */
+async function resolveModuleFile(importer, specifier, resolvePackage, extensions) {
+	const unresolved = { why: `'${specifier}' could not be resolved` };
+	if (specifier.startsWith(".")) {
+		const probed = probeOnDisk(relativeSourceCandidates(importer, specifier, extensions), dirname$1(importer));
+		if (probed.kind === "found") return { file: probed.path };
+		return probed.kind === "case-mismatch" ? {
+			why: caseMismatchReason(`'${specifier}'`, probed, "spell the import as the file is spelled"),
+			caseMismatch: true
+		} : unresolved;
+	}
+	try {
+		const file = await resolvePackage?.(specifier, importer);
+		return file ? { file: file.split("?")[0] } : unresolved;
+	} catch {
+		return unresolved;
 	}
 }
 /** The warning for a `createSystem` call that the parser's scopes leave
@@ -3265,229 +3943,427 @@ function unimportedCreateSystemCall(systemFilePath, record) {
 		column: call[1]
 	};
 }
-/** A pattern matching a call of any of `callees` as a whole name, or null
-*  when there is none to anchor on. */
-function rootCallPattern(callees) {
-	if (callees.length === 0) return null;
-	return `(?<![a-zA-Z0-9_$.])(?:${callees.map((callee) => callee.replace(/[.$]/g, "\\$&")).join("|")})`;
-}
-async function extractSystemFilePackages(systemFilePath, parseModule, report, resolvePackage) {
-	let source;
+/** The rounds a membership read resolves the modules it asks for: each
+*  reads the modules the last one's identities stopped at, one re-export
+*  hop further. Past it, what is still asked for is finalized as
+*  unresolved and read once more, so an identity it could not follow keeps
+*  the admission its name gives it, with a finding. */
+const MEMBERSHIP_ROUNDS = 256;
+/**
+* The packages and local modules a system file's roots extend or include,
+* from the engine's own read of it (spec §2.3 step 5): a bare specifier as
+* its import spells it, a relative one resolved against the system file.
+* The engine follows each root binding's identity through the modules this
+* supplies on request: a relative one by the host's extension order,
+* spelled exactly, a bare one by the host's package resolution.
+*/
+async function extractSystemFilePackages(systemFilePath, engine, report, resolvePackage, extensions, kitMembers) {
+	const { systemMembership } = engine;
+	if (systemMembership === void 0) throw new Error("the native engine does not expose systemMembership, which discovery needs — rebuild @animus-ui/extract");
+	const files = {};
 	try {
-		source = readFileSync(systemFilePath, "utf-8");
+		files[systemFilePath] = readFileSync$1(systemFilePath, "utf-8");
 	} catch {
 		return [];
 	}
-	const parsed = parseModule?.(source, systemFilePath) ?? null;
-	let rootCall = "createSystem";
-	if (parseModule && parsed) rootCall = rootCallPattern([...await systemRoots(systemFilePath, source, parsed, {
-		parseModule,
-		resolvePackage,
-		report
-	})]);
-	const identifiers = /* @__PURE__ */ new Set();
-	const constructorRegex = rootCall === null ? null : new RegExp(`${rootCall}\\s*\\(\\s*\\{[^}]*?\\bincludes\\s*:\\s*\\[([^\\]]*)\\]`, "gs");
-	const chainRegex = /\.includes\s*\(\s*\[([^\]]*)\]\s*\)/gs;
-	const collectIdentifiers = (regex) => {
-		let match;
-		while ((match = regex.exec(source)) !== null) {
-			const inner = match[1];
-			for (const token of inner.split(",")) {
-				const id = token.trim();
-				if (id && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(id)) identifiers.add(id);
-			}
+	const resolved = {};
+	let answer;
+	for (let round = 0;; round++) {
+		answer = parseInternalWire(systemMembership(JSON.stringify({
+			system: systemFilePath,
+			files,
+			resolved
+		})), "systemMembership");
+		if (answer.needs.length === 0) break;
+		for (const [importer, specifier] of answer.needs) {
+			const key = `${importer}\0${specifier}`;
+			const found = round >= MEMBERSHIP_ROUNDS ? { why: `following '${specifier}' stopped after ${MEMBERSHIP_ROUNDS} re-exports` } : await resolveModuleFile(importer, specifier, resolvePackage, extensions);
+			if ("file" in found) {
+				resolved[key] = { file: found.file };
+				if (!(found.file in files)) try {
+					files[found.file] = readFileSync$1(found.file, "utf-8");
+				} catch {}
+			} else resolved[key] = {
+				why: found.why,
+				caseMismatch: found.caseMismatch
+			};
 		}
-	};
-	if (constructorRegex) collectIdentifiers(constructorRegex);
-	collectIdentifiers(chainRegex);
-	const IDENT_START_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*/;
-	const skipTrivia = (from) => {
-		let pos = from;
-		for (;;) {
-			while (pos < source.length && /\s/.test(source[pos])) pos++;
-			if (source.startsWith("//", pos)) {
-				const newline = source.indexOf("\n", pos);
-				pos = newline === -1 ? source.length : newline + 1;
-				continue;
-			}
-			if (source.startsWith("/*", pos)) {
-				const close = source.indexOf("*/", pos + 2);
-				pos = close === -1 ? source.length : close + 2;
-				continue;
-			}
-			return pos;
+	}
+	if (!answer.parsed) return [];
+	const reportedUnimported = /* @__PURE__ */ new Set();
+	for (const finding of answer.findings) {
+		if (finding.kind === "unimported") {
+			if (reportedUnimported.has(finding.file)) continue;
+			reportedUnimported.add(finding.file);
+			report?.({
+				file: finding.file,
+				component: "createSystem",
+				kind: "warn",
+				message: `'createSystem' is called with no import or local binding, so it is not read as a system root: the system loader evaluates this file without auto-imports, where the name is undefined — import createSystem from '@animus-ui/system'`,
+				code: UNIMPORTED_CREATE_SYSTEM,
+				severity: severityFor(UNIMPORTED_CREATE_SYSTEM),
+				line: finding.line,
+				column: finding.column
+			});
+			continue;
+		}
+		if (finding.kind === "escapes") {
+			report?.({
+				file: finding.file,
+				component: "createSystem",
+				kind: "warn",
+				message: `a system builder leaves what discovery follows here (${finding.how}), so a kit extended on it from there is not read as a member and its components are not extracted — extend it in the chain that creates it, or through a variable`,
+				code: UNFOLLOWED_SYSTEM_BUILDER,
+				severity: severityFor(UNFOLLOWED_SYSTEM_BUILDER),
+				line: finding.line,
+				column: finding.column
+			});
+			continue;
 		}
+		const shown = finding.what !== null ? `it is ${finding.what}, so it is not read as a system root` : `discovery cannot follow what it is bound to (${finding.why}), so it is ${finding.admitted ? "still read" : "not read"} as a system root by its name alone`;
+		report?.({
+			file: finding.file,
+			component: finding.local,
+			kind: "warn",
+			message: `'${finding.local}' is not proven to be Animus's createSystem: ${shown} — import createSystem from '@animus-ui/system', directly or through a re-export discovery can follow`,
+			code: UNPROVEN_ROOT_BINDING,
+			severity: severityFor(UNPROVEN_ROOT_BINDING),
+			line: finding.line,
+			column: finding.column
+		});
+	}
+	const systemPackageRoot = findPackageRoot(systemFilePath);
+	for (const { specifier, importer } of answer.members) {
+		const file = resolved[`${importer}\0${specifier}`]?.file;
+		if (file !== void 0 && !specifier.startsWith(".") && findPackageRoot(importer) !== systemPackageRoot && !kitMembers?.has(specifier)) kitMembers?.set(specifier, file);
+	}
+	return [...new Set(answer.members.map(({ specifier, importer }) => specifier.startsWith(".") ? resolve$1(dirname$1(importer), specifier) : specifier))];
+}
+//#endregion
+//#region pipeline/alias-agreement.ts
+/** A file's identity on disk: its real path, which follows links and
+*  takes the case the filesystem lists; the path itself where it is not
+*  there. */
+function physical(file) {
+	try {
+		return realpathSync.native(file);
+	} catch {
+		return resolve(file);
+	}
+}
+/** What a host's module id names: a file on disk, its query dropped and a
+*  dev server's `/@fs/` prefix removed; a virtual id as written; or no
+*  file, where the id names a path nothing is at (an alias applied to a
+*  missing module). */
+function hostTarget(id) {
+	const path = id.split("?")[0];
+	const file = path.startsWith("/@fs/") ? path.slice(4) : path;
+	if (id.startsWith("\0") || !isAbsolute(file)) return { virtual: id };
+	return existsSync(file) ? { file } : null;
+}
+/** What a session's comparisons keep between analyses (spec §2.2 A7):
+*  each file's result by its content hash, while the aliases and the file
+*  set are the same. A new alias set, or a file added or removed, compares
+*  every file again. */
+var AliasAgreementCache = class {
+	scope = "";
+	byFile = /* @__PURE__ */ new Map();
+};
+function packageReadRecord(input) {
+	let analysed = null;
+	const rendered = /* @__PURE__ */ new Map();
+	return {
+		rootDir: input.rootDir,
+		roots: input.roots,
+		redirected: input.redirected,
+		holds(file) {
+			analysed ??= new Set(input.analysed.map((path) => physical(join(input.rootDir, path))));
+			return analysed.has(file);
+		},
+		rendersBuilder(file) {
+			let renders = rendered.get(file);
+			if (renders === void 0) {
+				renders = input.rendersBuilder(file);
+				rendered.set(file, renders);
+			}
+			return renders;
+		},
+		reported: /* @__PURE__ */ new Set()
 	};
-	/** The index after the string literal opening at `from`. */
-	const skipString = (from) => {
-		const quote = source[from];
-		let pos = from + 1;
-		while (pos < source.length && source[pos] !== quote) pos += source[pos] === "\\" ? 2 : 1;
-		return pos + 1;
+}
+/**
+* An import of a discovered package that the host resolves, from its
+* importer, to `resolved` (spec §2.2 A4). None where the analysis holds
+* that file, or the request is not a discovered package's. Otherwise the
+* importer would render a file extraction never read:
+* - another instance's: unextracted builder code
+*   (`animus.discovery.unread-package-instance`), or, where a source
+*   redirect serves the instance read in its place, that instance
+*   (`animus.discovery.replaced-package-instance`);
+* - a file of the instance read that the analysis does not hold, and no
+*   redirect covers, which declares builder chains (a compiled subpath):
+*   `animus.discovery.unread-package-instance`.
+*/
+function packageInstanceFinding(record, importer, specifier, resolved) {
+	const readRoot = isPackageSpecifier(specifier) ? record.roots[bareSpecifierPackageName(specifier)] : void 0;
+	if (readRoot === void 0) return null;
+	const file = physical(resolved);
+	if (record.holds(file)) return null;
+	const instance = physical(findPackageRoot(file));
+	const redirected = record.redirected.has(specifier);
+	const shown = (path) => relative(record.rootDir, path).split(sep).join(posix.sep);
+	const finding = (code, message) => ({
+		file: importer,
+		component: `import '${specifier}'`,
+		kind: code === "animus.discovery.replaced-package-instance" ? "warn" : "error",
+		message,
+		code,
+		severity: severityFor(code)
+	});
+	if (instance === readRoot) {
+		if (redirected || !record.rendersBuilder(file)) return null;
+		return finding(UNREAD_PACKAGE_INSTANCE, `'${specifier}' in ${importer} resolves through the host bundler to ${shown(file)}, a file of the package extraction reads (${shown(readRoot)}) that it does not analyse, and which declares builder chains, so this importer would render unextracted builder code — import the package by an entry extraction reads, or give this entry an "animus" source condition`);
+	}
+	const where = `'${specifier}' in ${importer} resolves through the host bundler to ${shown(file)}, in another instance of the package (${shown(instance)}) than extraction reads (${shown(readRoot)})`;
+	return redirected ? finding(REPLACED_PACKAGE_INSTANCE, `${where}; the source redirect serves the instance read in its place, so this importer renders that one, not its own — resolve the package to one instance`) : finding(UNREAD_PACKAGE_INSTANCE, `${where}, which is not analysed, so this importer would render unextracted builder code — resolve the package to one instance`);
+}
+/**
+* Where the analysis and the host disagree on a path alias (spec §2.2 A7,
+* report only: resolution never changes). Each analysed import whose
+* specifier, as the parser decodes it, an alias the analysis reads names
+* (tsconfig paths, or the host's own aliases) is resolved as the analysis
+* resolves it (the alias's expansion through the host's extension order)
+* and by the host's own resolver. A different physical file, or a file
+* only one of them finds, is `animus.discovery.alias-mismatch`. A request
+* the host's resolver fails on is unavailable for that request alone.
+*
+* Each import of a discovered package is resolved by the host from its
+* importer too (spec §2.2 A4): an answer in another instance than the one
+* read, in a file the analysis does not hold, is
+* `animus.discovery.unread-package-instance` (the importer would render
+* unextracted builder code), or `animus.discovery.replaced-package-instance`
+* where a source redirect serves the instance read in its place.
+*/
+async function compareAliases(input) {
+	const { cache, packages } = input;
+	const scope = JSON.stringify([
+		input.pathAliasesJson,
+		input.fileEntries.map((entry) => entry.path).sort(),
+		packages?.roots ?? {},
+		[...packages?.redirected ?? []].sort()
+	]);
+	if (cache.scope !== scope) {
+		cache.scope = scope;
+		cache.byFile.clear();
+	}
+	if (!(input.pathAliasesJson !== null && JSON.parse(input.pathAliasesJson).aliases.length > 0) && Object.keys(packages?.roots ?? {}).length === 0) return {
+		findings: [],
+		unavailable: 0
 	};
-	/** The index after the bracketed span opening at `from`, balanced across
-	*  `<>`, `()`, `[]` and `{}`, or -1 when it never closes. An arrow type's
-	*  `=>` closes nothing. */
-	const skipBalanced = (from) => {
-		let depth = 0;
-		let pos = from;
-		while (pos < source.length) {
-			const ch = source[pos];
-			if (ch === "'" || ch === "\"" || ch === "`") {
-				pos = skipString(pos);
-				continue;
-			}
-			if (source.startsWith("//", pos) || source.startsWith("/*", pos)) {
-				pos = skipTrivia(pos);
-				continue;
-			}
-			if ("<([{".includes(ch)) depth++;
-			else if (")]}".includes(ch) || ch === ">" && source[pos - 1] !== "=") {
-				depth--;
-				if (depth === 0) return pos + 1;
-			}
-			pos++;
+	const changed = input.fileEntries.filter((entry) => cache.byFile.get(entry.path)?.hash !== entry.hash);
+	const { files, bases } = changed.length === 0 ? { files: {} } : JSON.parse(input.moduleSpecifiers(JSON.stringify(changed.map(({ path, source }) => ({
+		path,
+		source
+	}))), input.pathAliasesJson ?? void 0));
+	const analysed = new Set(input.fileEntries.map((entry) => entry.path));
+	const packageAnswers = /* @__PURE__ */ new Map();
+	const comparePackage = async (record, importer, specifier) => {
+		const key = `${posix.dirname(importer)}\0${specifier}`;
+		let answer = packageAnswers.get(key);
+		if (answer === void 0) {
+			answer = input.resolve(specifier, join(input.rootDir, importer));
+			packageAnswers.set(key, answer);
 		}
-		return -1;
-	};
-	const consumeChainLinks = (from) => {
-		let pos = from;
-		for (;;) {
-			let cursor = skipTrivia(pos);
-			if (source[cursor] !== ".") return pos;
-			cursor = skipTrivia(cursor + 1);
-			const method = IDENT_START_RE.exec(source.slice(cursor))?.[0];
-			if (method !== "extend" && method !== "from") return pos;
-			cursor = skipTrivia(cursor + method.length);
-			if (source[cursor] === "<") {
-				const afterTypeArguments = skipBalanced(cursor);
-				if (afterTypeArguments === -1) return pos;
-				cursor = skipTrivia(afterTypeArguments);
-			}
-			if (source[cursor] !== "(") return pos;
-			cursor = skipTrivia(cursor + 1);
-			const base = IDENT_START_RE.exec(source.slice(cursor))?.[0];
-			if (!base) return pos;
-			cursor = skipTrivia(cursor + base.length);
-			while (source[cursor] === ".") {
-				const afterDot = skipTrivia(cursor + 1);
-				const segment = IDENT_START_RE.exec(source.slice(afterDot))?.[0];
-				if (!segment) break;
-				cursor = skipTrivia(afterDot + segment.length);
-			}
-			if (source[cursor] === ",") cursor = skipTrivia(cursor + 1);
-			if (source[cursor] !== ")") return pos;
-			identifiers.add(base);
-			pos = cursor + 1;
+		let id;
+		try {
+			id = await answer;
+		} catch {
+			return "unavailable";
 		}
+		const host = id === null ? null : hostTarget(id);
+		if (host === null || "virtual" in host) return null;
+		return packageInstanceFinding(record, importer, specifier, host.file);
 	};
-	const bindingAt = /* @__PURE__ */ new Map();
-	const aliasOf = /* @__PURE__ */ new Map();
-	const declarationRe = /\b(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
-	let declaration;
-	while ((declaration = declarationRe.exec(source)) !== null) {
-		const name = declaration[1];
-		let cursor = skipTrivia(declaration.index + declaration[0].length);
-		if (source[cursor] === ":") {
-			cursor++;
-			while (cursor < source.length) {
-				const ch = source[cursor];
-				if (ch === ";" || ch === ",") break;
-				if (ch === "\n" && /^\s*(?:export\s+)?(?:const|let|var|function|class|type|interface|import)\b/.test(source.slice(cursor + 1, cursor + 80))) break;
-				if (ch === "=" && source[cursor + 1] !== ">") break;
-				if ("<([{".includes(ch) || ch === "'" || ch === "\"" || ch === "`") {
-					const after = "<([{".includes(ch) ? skipBalanced(cursor) : skipString(cursor);
-					if (after === -1) break;
-					cursor = after;
-					continue;
-				}
-				cursor = ch === "=" ? cursor + 2 : cursor + 1;
-			}
+	const compare = async (importer, specifier, base) => {
+		const candidate = hostCandidate(input.rootDir, base, analysed, input.order, input.readings);
+		const analysis = candidate === null ? null : candidate.analysedAs ?? candidate.candidate.split("?")[0];
+		let id;
+		try {
+			id = await input.resolve(specifier, join(input.rootDir, importer));
+		} catch {
+			return "unavailable";
 		}
-		if (source[cursor] !== "=" || source[cursor + 1] === "=") continue;
-		const initializer = skipTrivia(cursor + 1);
-		bindingAt.set(initializer, name);
-		const target = IDENT_START_RE.exec(source.slice(initializer))?.[0];
-		if (!target) continue;
-		const rest = source.slice(initializer + target.length);
-		if (/^[ \t]*(?:(?:as|satisfies)\s[^;\n]*)?(?:\/\/[^\n]*)?(?:;|\r?\n(?!\s*[.([?`])|$)/.test(rest)) aliasOf.set(name, target);
-	}
-	const boundIdentifierBefore = (index) => {
-		const declared = bindingAt.get(index);
-		if (declared) return declared;
-		const match = /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*$/.exec(source.slice(0, index));
-		return match ? match[1] : null;
+		const host = id === null ? null : hostTarget(id);
+		if (analysis === null || host === null ? analysis === host : "file" in host && physical(join(input.rootDir, analysis)) === physical(host.file)) return null;
+		const shown = host === null ? "no file" : "virtual" in host ? host.virtual : relative(input.rootDir, host.file).split(sep).join(posix.sep);
+		return {
+			file: importer,
+			component: `alias '${specifier}'`,
+			kind: "warn",
+			message: `'${specifier}' in ${importer} resolves to ${analysis ?? "no file"} through the path aliases analysis reads, but the host bundler resolves it to ${shown}, so the analysis may read another module than the one the bundle renders — make the bundler's resolution and the aliases (tsconfig paths) agree`,
+			code: ALIAS_MISMATCH,
+			severity: severityFor(ALIAS_MISMATCH)
+		};
 	};
-	const chainRootIdentifiers = /* @__PURE__ */ new Set();
-	const createSystemAnchor = rootCall === null ? null : new RegExp(`${rootCall}\\s*\\(`, "g");
-	let anchorMatch;
-	while ((anchorMatch = createSystemAnchor?.exec(source) ?? null) !== null) {
-		let pos = anchorMatch.index + anchorMatch[0].length;
-		let depth = 1;
-		while (pos < source.length && depth > 0) {
-			const ch = source[pos];
-			if (ch === "(") depth++;
-			else if (ch === ")") depth--;
-			pos++;
-		}
-		consumeChainLinks(pos);
-		const bound = boundIdentifierBefore(anchorMatch.index);
-		if (bound) chainRootIdentifiers.add(bound);
-	}
-	const scannedRoots = /* @__PURE__ */ new Set();
-	for (;;) {
-		const pendingRoots = [...chainRootIdentifiers].filter((root) => !scannedRoots.has(root));
-		if (pendingRoots.length === 0) break;
-		for (const root of pendingRoots) {
-			scannedRoots.add(root);
-			const rootUse = new RegExp(`(?<![a-zA-Z0-9_$])${root.replace(/\$/g, "\\$")}(?![a-zA-Z0-9_$])`, "g");
-			let useMatch;
-			while ((useMatch = rootUse.exec(source)) !== null) {
-				const afterIdentifier = useMatch.index + useMatch[0].length;
-				if (consumeChainLinks(afterIdentifier) === afterIdentifier) continue;
-				const bound = boundIdentifierBefore(useMatch.index);
-				if (bound) chainRootIdentifiers.add(bound);
-			}
-		}
+	await Promise.all(changed.map(async ({ path, hash }) => {
+		const results = await Promise.all((files[path] ?? []).flatMap((specifier) => {
+			const base = bases?.[path]?.[specifier];
+			if (base !== void 0) return [compare(path, specifier, base)];
+			return packages !== void 0 && isPackageSpecifier(specifier) && packages.roots[bareSpecifierPackageName(specifier)] !== void 0 ? [comparePackage(packages, path, specifier)] : [];
+		}));
+		cache.byFile.set(path, {
+			hash,
+			findings: results.filter((result) => result !== null && result !== "unavailable"),
+			unavailable: results.filter((result) => result === "unavailable").length
+		});
+	}));
+	const kept = input.fileEntries.flatMap((entry) => cache.byFile.get(entry.path) ?? []);
+	return {
+		findings: kept.flatMap((file) => file.findings),
+		unavailable: kept.reduce((total, file) => total + file.unavailable, 0)
+	};
+}
+//#endregion
+//#region pipeline/host-package-resolver.ts
+/**
+* Package resolution for discovery: one resolver, whose answers are the
+* host's where it resolves imports itself (spec §2.2 A4), and the system
+* loader's otherwise, and for a declared workspace the host cannot resolve.
+*/
+/**
+* A declared workspace that nothing links into `node_modules` is no package
+* to the host, though the system loader resolves it: where the host finds
+* nothing, discovery asks the loader.
+*/
+function discoveryResolver(hostResolve, engine, context) {
+	const load = (specifier, fromDir) => {
+		const native = engine.resolveSpecifier;
+		if (native === void 0) throw new Error("the native engine does not expose resolveSpecifier, which package resolution needs — rebuild @animus-ui/extract");
+		return native(specifier, fromDir, [...context.conditions], context.workspaces, extensionPolicyJson(context.extensions));
+	};
+	const loaderResolve = (specifier, fromDir) => load(specifier, fromDir).path ?? null;
+	if (hostResolve === null) {
+		const unresolved = /* @__PURE__ */ new Map();
+		return {
+			hostFirst: false,
+			async resolveSpecifier(specifier) {
+				const entry = load(specifier, context.rootDir);
+				if (entry.path) return entry.path;
+				unresolved.set(specifier, entry.unresolved ?? "it names no file");
+				return null;
+			},
+			unresolvedReason: (specifier) => unresolved.get(specifier),
+			requireSourceEntry: () => false,
+			loaderResolve
+		};
 	}
-	if (identifiers.size === 0) return [];
-	const importMap = /* @__PURE__ */ new Map();
-	for (const binding of parsed?.imports ?? []) importMap.set(binding.local, binding.source);
-	const importRegex = /^\s*import\s+(?:([a-zA-Z_$][a-zA-Z0-9_$]*)\s*,\s*)?(?:\{([^}]*)\}|([a-zA-Z_$][a-zA-Z0-9_$]*))\s+from\s+['"]([^'"]+)['"]/gm;
-	if (!parsed) {
-		let importMatch;
-		while ((importMatch = importRegex.exec(source)) !== null) {
-			const [, comboDefault, namedImports, defaultImport, specifier] = importMatch;
-			if (comboDefault) importMap.set(comboDefault, specifier);
-			if (defaultImport) importMap.set(defaultImport, specifier);
-			if (namedImports) for (const binding of namedImports.split(",")) {
-				const parts = binding.trim().split(/\s+as\s+/);
-				const localName = (parts[1] || parts[0]).trim();
-				if (localName) importMap.set(localName, specifier);
+	const loaderOnly = /* @__PURE__ */ new Set();
+	const rootImporter = join$1(context.rootDir, "__animus_discovery__.js");
+	return {
+		hostFirst: true,
+		async resolveSpecifier(specifier) {
+			let hosted;
+			try {
+				hosted = await hostResolve(specifier, rootImporter);
+			} catch {
+				hosted = null;
 			}
-		}
-	}
-	const systemFileDir = dirname$1(systemFilePath);
-	const packages = /* @__PURE__ */ new Set();
-	/** The import a local alias chain ends at, or the identifier itself. */
-	const throughAliases = (id) => {
-		const seen = /* @__PURE__ */ new Set();
-		let current = id;
-		while (!importMap.has(current) && !seen.has(current)) {
-			seen.add(current);
-			const target = aliasOf.get(current);
-			if (!target) break;
-			current = target;
-		}
-		return current;
+			if (hosted !== null || !Object.hasOwn(context.workspaces, bareSpecifierPackageName(specifier))) return hosted;
+			const loaded = loaderResolve(specifier, context.rootDir);
+			if (loaded) loaderOnly.add(specifier);
+			return loaded;
+		},
+		unresolvedReason: () => void 0,
+		requireSourceEntry: (specifier) => loaderOnly.has(specifier),
+		loaderResolve
 	};
-	for (const id of identifiers) {
-		const specifier = importMap.get(throughAliases(id));
-		if (!specifier) continue;
-		if (specifier.startsWith(".")) packages.add(resolve$1(systemFileDir, specifier));
-		else packages.add(specifier);
-	}
-	return Array.from(packages);
+}
+//#endregion
+//#region pipeline/output-targets.ts
+/**
+* Where a bundler writes, as one model: the directories it fills and the
+* files it writes by exact name. Discovery excludes both, and the Rollup
+* family's render check reads both, so the two never classify output
+* differently.
+*/
+function noOutputTargets() {
+	return {
+		dirs: [],
+		files: []
+	};
+}
+/** Each output's named directory or file; one naming neither writes to
+*  `fallbackDir` when there is one. */
+function targetsOf(base, outputs, fallbackDir) {
+	const targets = noOutputTargets();
+	for (const output of outputs) if (output.dir !== void 0) targets.dirs.push(resolve$1(base, output.dir));
+	else if (output.file !== void 0) targets.files.push(resolve$1(base, output.file));
+	else if (fallbackDir !== void 0) targets.dirs.push(resolve$1(base, fallbackDir));
+	return targets;
+}
+/** The targets of Rollup's or Rolldown's output options at render. */
+function rollupOutputTargets(output) {
+	return targetsOf(process.cwd(), [output]);
+}
+/** Every Vite environment's outputs, as Vite's own `getResolvedOutDirs`
+*  reads them: each output's `dir`, else the environment's `outDir`. */
+function viteOutputTargets(config) {
+	return mergeOutputTargets([config.build, ...Object.values(config.environments ?? {}).flatMap((environment) => environment.build === void 0 ? [] : [environment.build])].map((build) => {
+		const output = build.rolldownOptions?.output ?? build.rollupOptions?.output;
+		const outputs = output === void 0 ? [{}] : Array.isArray(output) ? output : [output];
+		return targetsOf(config.root, outputs, build.outDir);
+	}));
+}
+/** esbuild's `outdir`, or its exact `outfile`. */
+function esbuildOutputTargets(options) {
+	return targetsOf(options.absWorkingDir ?? process.cwd(), [{
+		dir: options.outdir,
+		file: options.outfile
+	}]);
+}
+/** webpack's `output.path`, up to its first segment holding a template
+*  placeholder (`out/[fullhash]` writes under `out`). */
+function webpackOutputTargets(outputPath) {
+	if (outputPath === void 0) return noOutputTargets();
+	const segments = outputPath.split(sep$1);
+	const placeholder = segments.findIndex((segment) => segment.includes("["));
+	const fixed = placeholder === -1 ? outputPath : segments.slice(0, placeholder).join(sep$1);
+	return {
+		dirs: fixed === "" ? [] : [fixed],
+		files: []
+	};
+}
+function mergeOutputTargets(all) {
+	return {
+		dirs: [...new Set(all.flatMap((targets) => targets.dirs))],
+		files: [...new Set(all.flatMap((targets) => targets.files))]
+	};
+}
+/** The Session's structural exclusions: every target inside the root. A
+*  directory that is the root excludes nothing; its files still can. */
+function outputExclusions(root, targets) {
+	return [...targets.dirs, ...targets.files].flatMap((target) => {
+		const exclusion = outputExclusion(root, target);
+		return exclusion === null ? [] : [exclusion];
+	});
+}
+/** The analysed files a build's targets hold, as the render check reports
+*  them: a file target the analysis read is the build's own earlier
+*  output; a file inside a directory target is earlier output or a source
+*  the bundler writes beside, which the check cannot tell apart. */
+function analysedOutputs(root, targets, analyzed) {
+	const earlier = analyzed.filter((file) => targets.files.includes(file));
+	const inside = targets.dirs.flatMap((dir) => {
+		const exclusion = outputExclusion(root, dir);
+		const held = analyzed.filter((file) => !earlier.includes(file) && isPathWithinRoot(dir, file));
+		return exclusion === null || held.length === 0 ? [] : [{
+			exclusion,
+			held
+		}];
+	});
+	const rel = (file) => relative$1(root, file);
+	const parts = [...earlier.length === 0 ? [] : [`it analysed its own earlier output: ${earlier.map(rel).join(", ")}. Add ${earlier.map((file) => `'${rel(file)}'`).join(", ")} to the plugin's \`exclude\` option`], ...inside.map(({ exclusion, held }) => `it analysed files inside its output directory '${exclusion}': ${held.map(rel).join(", ")}. If they are earlier output, add '${exclusion}' to the plugin's \`exclude\` option; if they are sources, write the output outside the source tree`)];
+	return parts.length === 0 ? null : `[animus] this build ${parts.join("; and ")}.`;
 }
 //#endregion
 //#region pipeline/source-corpus.ts
@@ -3508,6 +4384,7 @@ function createSourceCorpus(host, ingestor = createSourceIngestor(host)) {
 		ownership: {}
 	};
 	return {
+		facts: (entries) => ingestor.facts(entries),
 		async prepare(input) {
 			const rawEntries = "fileCache" in input ? assembleRawEntries(input) : input;
 			const ingested = await ingestor.ingest(rawEntries);
@@ -3556,7 +4433,7 @@ function requireAnchoredAt(rootDir) {
 function packageRootFromEntry(entry) {
 	let current = dirname$1(entry);
 	while (true) {
-		if (existsSync(join$1(current, "package.json"))) return current;
+		if (existsSync$1(join$1(current, "package.json"))) return current;
 		const parent = dirname$1(current);
 		if (parent === current) return null;
 		current = parent;
@@ -3588,7 +4465,7 @@ function resolveThroughPathAliases(specifier, rootDir, pathAliasesJson) {
 		} else if (specifier.startsWith(alias.pattern)) mapped = alias.replacement + specifier.slice(alias.pattern.length);
 		if (mapped === null) continue;
 		const absolute = isAbsolute$1(mapped) ? mapped : join$1(rootDir, mapped);
-		if (existsSync(absolute)) return absolute;
+		if (existsSync$1(absolute)) return absolute;
 	}
 	return null;
 }
@@ -3609,15 +4486,15 @@ function resolveAssetFile(specifier, rootDir, pathAliasesJson) {
 	if (!subpath) return null;
 	for (const modulesDir of requireFromRoot.resolve.paths(packageName) ?? []) {
 		const packageRoot = join$1(modulesDir, packageName);
-		if (!existsSync(join$1(packageRoot, "package.json"))) continue;
+		if (!existsSync$1(join$1(packageRoot, "package.json"))) continue;
 		const candidate = join$1(packageRoot, subpath);
-		if (existsSync(candidate)) return candidate;
+		if (existsSync$1(candidate)) return candidate;
 	}
 	try {
 		const packageRoot = packageRootFromEntry(requireFromRoot.resolve(packageName));
 		if (!packageRoot) return null;
 		const candidate = join$1(packageRoot, subpath);
-		return existsSync(candidate) ? candidate : null;
+		return existsSync$1(candidate) ? candidate : null;
 	} catch {
 		return null;
 	}
@@ -3642,12 +4519,12 @@ function buildSourceTokenIndex(opts) {
 	for (const [dir, specifier] of Object.entries(opts.dirOwners)) {
 		let real = dir;
 		try {
-			real = realpathSync(dir);
+			real = realpathSync$1(dir);
 		} catch {}
 		addOwnerDir(real, specifier);
 		let packageRoot = real;
-		while (packageRoot !== dirname$1(packageRoot) && !existsSync(join$1(packageRoot, "package.json"))) packageRoot = dirname$1(packageRoot);
-		if (existsSync(join$1(packageRoot, "package.json"))) addOwnerDir(packageRoot, specifier);
+		while (packageRoot !== dirname$1(packageRoot) && !existsSync$1(join$1(packageRoot, "package.json"))) packageRoot = dirname$1(packageRoot);
+		if (existsSync$1(join$1(packageRoot, "package.json"))) addOwnerDir(packageRoot, specifier);
 	}
 	for (const [modulePath, exports] of Object.entries(manifests)) {
 		const owner = realDirOwners.find(({ dir }) => isPathWithinRoot(dir, modulePath));
@@ -4325,15 +5202,28 @@ function buildAnalysisInputs(opts) {
 	};
 	if (opts.system.declarationScalesJson) inputs.declarationScalesJson = opts.system.declarationScalesJson;
 	if (opts.system.generatedNamesJson) inputs.generatedNamesJson = opts.system.generatedNamesJson;
-	const context = opts.analysisContext;
-	if (context?.skippedSources?.length || context?.unbundledComputedImports || context?.packageDirs?.length) inputs.analysisContextJson = JSON.stringify({
+	if (opts.system.propertyRecordsJson) inputs.propertyRecordsJson = opts.system.propertyRecordsJson;
+	const context = analysisContextJson(opts.analysisContext);
+	if (context !== void 0) inputs.analysisContextJson = context;
+	return inputs;
+}
+/** The engine's wire for what the host knows; present only when the host
+*  knows something, so a host that knows nothing persists unchanged inputs. */
+function analysisContextJson(context) {
+	if (!(context?.skippedSources?.length || context?.unbundledComputedImports || context?.packageDirs?.length || context?.extensions || context?.openings?.length)) return;
+	return JSON.stringify({
 		skippedSources: context.skippedSources ?? [],
 		unbundledComputedImports: context.unbundledComputedImports ?? false,
 		packageDirs: context.packageDirs ?? [],
 		linkedDirs: context.linkedDirs ?? [],
-		outputDirs: context.outputDirs ?? []
+		outputDirs: context.outputDirs ?? [],
+		...context.extensions && { extensions: {
+			appended: context.extensions.appended,
+			nodeNext: context.extensions.nodeNext,
+			alias: context.extensions.alias
+		} },
+		...context.openings?.length && { openings: context.openings }
 	});
-	return inputs;
 }
 function hasSourceThemeManifests(system) {
 	const json = system.sourceThemeManifestsJson ?? "";
@@ -4367,7 +5257,11 @@ function runProjectAnalysis(engineApi, opts) {
 	const inputs = buildAnalysisInputs(opts);
 	const serializeMs = Math.round(performance.now() - t);
 	t = performance.now();
-	const manifestJson = analyzeProject(...buildAnalyzeProjectArgs(inputs));
+	const manifestJson = analyzeProject(...buildAnalyzeProjectArgs(inputs, opts.rootDir === void 0 ? void 0 : gatherProbeEvidence(opts.rootDir, new Set(opts.fileEntries.map((entry) => entry.path)), opts.analysisContext?.extensions, {
+		isAsset: opts.assets?.isAsset,
+		adapted: opts.adapted,
+		expander: opts.loadExpander
+	})));
 	const extractMs = Math.round(performance.now() - t);
 	t = performance.now();
 	const manifest = JSON.parse(manifestJson);
@@ -4603,16 +5497,24 @@ function renameDeclarationRecords(declarationScalesJson, rename) {
 }
 //#endregion
 //#region pipeline/system-config.ts
+function systemLoadReads(error) {
+	const thrown = error;
+	const carrier = thrown?.dependencies ? thrown : thrown?.cause;
+	return {
+		dependencies: carrier?.dependencies ?? [],
+		missing: carrier?.missing ?? []
+	};
+}
 /** The loader's evaluation of the system file. A failure on a file that
 *  calls `createSystem` with no binding leads with discovery's warning line
 *  for it, then keeps the loader's own error. */
-function evaluateSystemModule(engine, systemPath, rootDir, conditions) {
+function evaluateSystemModule(engine, systemPath, rootDir, conditions, workspaces, extensions) {
 	try {
-		return engine.loadSystemModule(systemPath, rootDir, void 0, conditions);
+		return engine.loadSystemModule(systemPath, rootDir, void 0, conditions, workspaces, extensions && extensionPolicyJson(extensions));
 	} catch (error) {
 		let source;
 		try {
-			source = readFileSync(systemPath, "utf-8");
+			source = readFileSync$1(systemPath, "utf-8");
 		} catch {
 			throw error;
 		}
@@ -4627,7 +5529,7 @@ function evaluateSystemModule(engine, systemPath, rootDir, conditions) {
 * variable name. Error handling stays at the call site.
 */
 function loadSystemConfig(engineApi, opts) {
-	const config = evaluateSystemModule(engineApi(), opts.systemPath, opts.rootDir, opts.conditions);
+	const config = evaluateSystemModule(engineApi(), opts.systemPath, opts.rootDir, opts.conditions, opts.workspaces, opts.extensions);
 	let scalesJson = config.scalesJson;
 	let variableMapJson = config.variableMapJson;
 	const registrations = splitInvalidPropertyRegistrations(config.variableCss);
@@ -4677,6 +5579,7 @@ function loadSystemConfig(engineApi, opts) {
 		keyframesJson: config.keyframesBlocks || null,
 		vocabularyWitnessesJson: config.vocabularyWitnesses || null,
 		dependencies: config.dependencies ?? [],
+		missing: config.missing ?? [],
 		sourceThemeManifestsJson: config.sourceThemeManifests || null
 	};
 	if (declarationScalesJson) system.declarationScalesJson = declarationScalesJson;
@@ -4796,13 +5699,6 @@ const CODE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".mjs",
 	".cjs"
 ]);
-const isFile = (path) => {
-	try {
-		return statSync$1(path).isFile();
-	} catch {
-		return false;
-	}
-};
 const posixPath = (path) => path.split(sep).join("/");
 /**
 * The package-relative files `npm pack` publishes, read with npm's own rules
@@ -4868,7 +5764,7 @@ function animusTargets(manifest) {
 /** Every file in the package outside `node_modules` and `.git`,
 *  package-relative. */
 function packageFiles(pkgRoot, dir = "") {
-	return readdirSync$1(join(pkgRoot, dir), { withFileTypes: true }).flatMap((entry) => {
+	return readdirSync(join(pkgRoot, dir), { withFileTypes: true }).flatMap((entry) => {
 		const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
 		if (entry.isDirectory()) return entry.name === "node_modules" || entry.name === ".git" ? [] : packageFiles(pkgRoot, path);
 		return entry.isFile() ? [path] : [];
@@ -4892,7 +5788,7 @@ function targetPattern(target) {
 function kitPublicationFailures(pkgRoot, engine, artifactDir) {
 	let manifest;
 	try {
-		manifest = JSON.parse(readFileSync$1(join(pkgRoot, "package.json"), "utf-8"));
+		manifest = JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf-8"));
 	} catch (error) {
 		return [`package.json: cannot be read: ${String(error)}`];
 	}
@@ -4931,8 +5827,14 @@ function kitPublicationFailures(pkgRoot, engine, artifactDir) {
 			const matched = files.filter((file) => pattern.test(file));
 			if (matched.length === 0) failures.push(`package.json: the "animus" target of exports["${subpath}"], ${target}, matches no file in the package`);
 			for (const file of matched) admit(subpath, file);
-		} else if (!isFile(resolve(pkgRoot, target))) failures.push(`package.json: the "animus" target of exports["${subpath}"], ${target}, does not exist in the package`);
-		else admit(subpath, relPath);
+		} else {
+			const seen = seeOnDisk(resolve(pkgRoot, target), pkgRoot);
+			if (seen.kind === "file") admit(subpath, relPath);
+			else failures.push(seen.kind === "case-only" ? `package.json: ${caseMismatchReason(`the "animus" target of exports["${subpath}"]`, {
+				candidate: target,
+				actual: rel(seen.actual)
+			}, "spell the target as the file is spelled")}` : `package.json: the "animus" target of exports["${subpath}"], ${target}, does not exist in the package`);
+		}
 	}
 	const visited = /* @__PURE__ */ new Set();
 	while (queue.length > 0) {
@@ -4941,12 +5843,17 @@ function kitPublicationFailures(pkgRoot, engine, artifactDir) {
 		visited.add(file);
 		const specifiers = parseInternalWire(moduleSpecifiers(JSON.stringify([{
 			path: file,
-			source: readFileSync$1(file, "utf-8")
+			source: readFileSync(file, "utf-8")
 		}])), "moduleSpecifiers").files[file] ?? [];
 		for (const specifier of specifiers) {
 			if (specifier.startsWith(".")) {
-				const target = relativeSourceCandidates(file, specifier).find(isFile);
-				if (target === void 0) failures.push(`${rel(file)}: import '${specifier}' resolves to no file in the package`);
+				const probed = probeOnDisk(relativeSourceCandidates(file, specifier), dirname(file));
+				const target = probed.kind === "found" ? probed.path : void 0;
+				if (probed.kind === "case-mismatch") failures.push(`${rel(file)}: ${caseMismatchReason(`import '${specifier}'`, {
+					candidate: rel(probed.candidate),
+					actual: rel(probed.actual)
+				}, "spell the import as the file is spelled")}`);
+				else if (target === void 0) failures.push(`${rel(file)}: import '${specifier}' resolves to no file in the package`);
 				else if (outside(rel(target))) failures.push(`${rel(file)}: import '${specifier}' resolves to ${rel(target)}, outside the package`);
 				else if (!published(rel(target))) failures.push(`${rel(file)}: import '${specifier}' resolves to ${rel(target)}, which is not in the published files`);
 				else if (CODE_EXTENSIONS.has(extname(target))) queue.push(target);
@@ -5030,7 +5937,7 @@ function toWatchKeys(input) {
 *  ancestor. A symlink retargeted after load fails open: no match. */
 function realpathThroughNearestExistingAncestor(path) {
 	try {
-		return realpathSync$1(path);
+		return realpathSync(path);
 	} catch {}
 	const suffix = [];
 	let current = path;
@@ -5040,9 +5947,644 @@ function realpathThroughNearestExistingAncestor(path) {
 		suffix.unshift(basename(current));
 		current = parent;
 		try {
-			return join(realpathSync$1(current), ...suffix);
+			return join(realpathSync(current), ...suffix);
 		} catch {}
 	}
 }
 //#endregion
-export { discoverFiles as $, fileSideEffects as A, surfaceManifestDiagnostics as At, unresolvableIncludesMessage as B, substituteSheetAssets as Bt, resolveAssetFile as C, DiagnosticFailure as Ct, engineModuleParser as D, isDeletedSource as Dt, collectExternalPackageSources as E, VOCABULARY_LEGACY_VERB as Et, keepsKitSourceEffects as F, findAssetSpecifiers as Ft, KIT_DESCRIPTOR_FILE as G, assembleStylesheet as Gt, createSourceIdentity as H, contentHash as Ht, kitSourceModuleSideEffects as I, findSheetAssetSpecifiers as It, readKitDescriptor as J, __require as Jt, buildKitDescriptor as K, stripLeadingLayerDeclaration as Kt, resolveAbsolutePathSpecifier as L, generatedModuleCode as Lt, firstOwners as M, unreadableSourceDiagnostic as Mt, importedKitDiagnostics as N, unresolvedParentName as Nt, excludeCollectedPackages as O, isUnresolvedParentDrop as Ot, isExcludedPackageRelativePath as P, vocabularyWitnessDiagnostics as Pt, compareDiscoveryOrder as Q, sourceKitDependencies as R, reportSurvivingAssetPlaceholders as Rt, enforceExternalTokenContracts as S, DIAGNOSTIC_LEVELS as St, createSourceCorpus as T, VOCABULARY_COLLISION as Tt, isPathWithinRoot as U, buildAnalyzeProjectArgs as Ut, walkPackageSources as V, parseInternalWire as Vt, sharesVolumeRoot as W, ANIMUS_LAYERS as Wt, isJsonString as X, isJsonBlock as Y, readTsconfigAliasPairs as Z, runProjectAnalysis as _, adaptSvelteSource as _t, kitPublicationFailures as a, STRUCTURAL_EXCLUDE as at, resolveLightningTargets as b, isEngineTransformExtension as bt, buildDynamicPropConfig as c, resolveMode as ct, applyPrefix as d, assertNoRetiredEngineSelection as dt, AnimusConfigError as et, serializeStaticCss as f, createV2EngineApi as ft, clearEngineCache as g, projectExternalFileOwners as gt, buildAnalysisInputs as h, parseFilesJson as ht, snapshotFilePlans as i, REPLACEABLE_DEFAULT_EXCLUDE as it, findPackageRoot as j, systemLoadDiagnostics as jt, extractSystemFilePackages as k, noKitFilesDiagnostics as kt, runStructuralSelfCheck as l, resolveVerbosity as lt, stableStringify as m, isAdvisorySourceDiagnostic as mt, diffFilePlans as n, DEFAULT_EXCLUDE as nt, assertNoErrorDiagnostics as o, assertKnownOptionKeys as ot, camelToKebab as p, ingestSourceEntries as pt, kitDescriptorDiagnostics as q, validateLayerOrder as qt, hashReplacementPlans as r, DRIVER_NAMESPACES as rt, buildSystemPropsModule as s, createExcludeMatcher as st, toWatchKeys as t, CORE_OPTION_KEYS as tt, loadSystemConfig as u, RETIRED_ENGINE_MESSAGE as ut, applyUnitFallback as v, DEFAULT_EXTENSIONS as vt, resolveThroughPathAliases as w, INVALID_PROPERTY_REGISTRATION as wt, buildPathAliasesJson as x, preprocessMdx as xt, postProcessCss as y, ENGINE_TRANSFORM_EXTENSIONS as yt, staleDistIncludesMessage as z, substituteAssetPlaceholders as zt };
+//#region pipeline/built-in-asset-types.ts
+/** The Vite version the built-in types come from. */
+const BUILT_IN_ASSET_SOURCE = "vite@8.2.2";
+/** Asset extensions, as regular-expression alternatives, a session with no
+*  readable host classification reads as assets (spec §2.2 A8). */
+const BUILT_IN_ASSET_TYPES = [
+	"apng",
+	"bmp",
+	"png",
+	"jpe?g",
+	"jfif",
+	"pjpeg",
+	"pjp",
+	"gif",
+	"svg",
+	"ico",
+	"webp",
+	"avif",
+	"cur",
+	"jxl",
+	"mp4",
+	"webm",
+	"ogg",
+	"mp3",
+	"wav",
+	"flac",
+	"aac",
+	"opus",
+	"mov",
+	"m4a",
+	"vtt",
+	"woff2?",
+	"eot",
+	"ttf",
+	"otf",
+	"webmanifest",
+	"pdf",
+	"txt"
+];
+/** Stylesheet extensions, as regular-expression alternatives, a session
+*  with no readable host classification reads as stylesheets. */
+const BUILT_IN_STYLESHEET_TYPES = [
+	"css",
+	"less",
+	"sass",
+	"scss",
+	"styl",
+	"stylus",
+	"pcss",
+	"postcss",
+	"sss"
+];
+//#endregion
+//#region pipeline/host-assets.ts
+const BUILT_IN_ASSET_RE = new RegExp(`\\.(?:${BUILT_IN_ASSET_TYPES.join("|")})$`, "i");
+/** Vite's stylesheet test (`isCSSRequest`), on the final extension only: a
+*  `x.css.ts` is a module. Exact case, as Vite reads it. */
+const STYLESHEET_RE = new RegExp(`\\.(?:${BUILT_IN_STYLESHEET_TYPES.join("|")})$`);
+/** JSON, as Vite's json plugin, webpack's `json` type, esbuild's `json`
+*  loader and Turbopack read it: the final extension, exact case. */
+const JSON_RE = /\.json$/;
+/** The queries Vite answers with a string whatever the file holds: `?url`
+*  and `?raw`. Any other query keeps the file's own reading. */
+const VITE_OPAQUE_QUERY_RE = /[?&](?:url|raw)\b/;
+/** The built-in classification, where no host's can be read or is not
+*  modelled (webpack's and Rspack's rules, as a conditional rule may never
+*  apply): Vite's known asset types, `svg` included, its CSS languages
+*  (`BUILT_IN_ASSET_SOURCE`) and JSON, read with Vite's queries. */
+function builtInAssetClassification(reason, detail) {
+	return {
+		isAsset: (file, query) => VITE_OPAQUE_QUERY_RE.test(query) || BUILT_IN_ASSET_RE.test(file) || STYLESHEET_RE.test(file) || JSON_RE.test(file),
+		resolverVersion: `built-in (${reason}${detail ? `: ${detail}` : ""}; ${BUILT_IN_ASSET_SOURCE})`
+	};
+}
+/** Vite's own classification: `?url` and `?raw`, its known asset types and
+*  the user's `assetsInclude`, as `ResolvedConfig.assetsInclude` answers,
+*  its CSS languages (`isCSSRequest`), and its json plugin's JSON. */
+function viteAssetClassification(assetsInclude, version) {
+	return {
+		isAsset: (file, query) => VITE_OPAQUE_QUERY_RE.test(query) || assetsInclude(file) || STYLESHEET_RE.test(file) || JSON_RE.test(file),
+		resolverVersion: `${version ? `vite@${version}` : "vite"} captured`
+	};
+}
+/** esbuild's built-in loaders, which a configured `loader` map extends. */
+const ESBUILD_DEFAULT_LOADERS = {
+	"": "js",
+	".js": "js",
+	".mjs": "js",
+	".cjs": "js",
+	".jsx": "jsx",
+	".ts": "ts",
+	".cts": "ts",
+	".mts": "ts",
+	".tsx": "tsx",
+	".css": "css",
+	".module.css": "local-css",
+	".json": "json",
+	".txt": "text"
+};
+/** esbuild loaders whose module is an opaque value: a URL, the file's bytes
+*  or text, a stylesheet, or JSON. `copy` keeps the file as code. */
+const ESBUILD_OPAQUE_LOADERS = /* @__PURE__ */ new Set([
+	"file",
+	"dataurl",
+	"base64",
+	"binary",
+	"text",
+	"css",
+	"local-css",
+	"global-css",
+	"json"
+]);
+/** esbuild's classification, from its `loader` map: the loader esbuild
+*  picks for a file is the longest extension of its name the map holds,
+*  exact case. */
+function esbuildAssetClassification(loader) {
+	const loaders = new Map(Object.entries({
+		...ESBUILD_DEFAULT_LOADERS,
+		...loader
+	}));
+	return {
+		isAsset: (file) => {
+			let name = file.slice(Math.max(file.lastIndexOf("/"), file.lastIndexOf("\\")) + 1);
+			let picked = name.includes(".") ? void 0 : loaders.get("");
+			for (let dot = name.indexOf("."); dot !== -1; dot = name.indexOf(".")) {
+				picked = loaders.get(name.slice(dot));
+				if (picked !== void 0) break;
+				name = name.slice(dot + 1);
+			}
+			return picked !== void 0 && ESBUILD_OPAQUE_LOADERS.has(picked);
+		},
+		resolverVersion: "esbuild captured"
+	};
+}
+/** Turbopack's classification under Next: Next's static-image table
+*  (`nextImageLoaderRegex`), unless `images.disableStaticImages`, and its
+*  stylesheets (`regexLikeCss`), as the installed `next` declares them,
+*  and JSON. Built-in where Next cannot be read. */
+function nextImageAssetClassification(rootDir, disableStaticImages) {
+	try {
+		const require = createRequire(`${rootDir}/package.json`);
+		const { version } = require("next/package.json");
+		const { nextImageLoaderRegex } = require("next/dist/build/webpack-config");
+		const { regexLikeCss } = require("next/dist/build/webpack/config/blocks/css");
+		if (!(nextImageLoaderRegex instanceof RegExp) || !(regexLikeCss instanceof RegExp)) return builtInAssetClassification("hostOptionUnreadable", `next@${version} image and stylesheet types`);
+		return {
+			isAsset: (file) => JSON_RE.test(file) || regexLikeCss.test(file) || !disableStaticImages && nextImageLoaderRegex.test(file),
+			resolverVersion: `from next@${version}`
+		};
+	} catch {
+		return builtInAssetClassification("hostOptionUnreadable", "next");
+	}
+}
+//#endregion
+//#region pipeline/vite-expansions.ts
+/** The glob syntax read here: literal characters, `*` and a whole-segment
+*  `**`, and a `{a,b}` group of literal alternatives. Anything else (`?`,
+*  classes, extglobs, nested groups) is not reproduced. */
+const UNREAD_SYNTAX = /[?[\]()!+@\\]/;
+function segmentOf(text) {
+	if (text === "**") return { kind: "globstar" };
+	if (UNREAD_SYNTAX.test(text) || text.includes("**")) return void 0;
+	let source = "";
+	for (const part of text.split(/(\{[^{}]*\}|\*)/)) if (part === "*") source += "[^/]*";
+	else if (part.startsWith("{") && part.endsWith("}")) {
+		const options = part.slice(1, -1).split(",");
+		if (options.some((option) => /[{}*]/.test(option))) return void 0;
+		source += `(?:${options.map(escape).join("|")})`;
+	} else if (/[{}]/.test(part)) return void 0;
+	else source += escape(part);
+	return {
+		kind: "match",
+		test: new RegExp(`^${source}$`),
+		dotted: text.startsWith(".")
+	};
+}
+function escape(text) {
+	return text.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
+/**
+* A pattern as Vite resolves it (`toAbsoluteGlob`): relative to the
+* importer's directory, or with `/` to the Vite root. A pattern in another
+* form (an alias, a bare name) or with syntax not read here is undefined.
+*/
+function resolveGlob(pattern, importerDir, viteRoot) {
+	const negated = pattern.startsWith("!");
+	const body = negated ? pattern.slice(1) : pattern;
+	const start = body.startsWith("/") ? viteRoot : body.startsWith("./") || body.startsWith("../") ? importerDir : void 0;
+	if (start === void 0) return void 0;
+	const parts = body.split("/").filter((part) => part !== "" && part !== ".");
+	let base = start;
+	let index = 0;
+	if (parts.some((part) => part !== ".." && UNREAD_SYNTAX.test(part))) return;
+	while (index < parts.length - 1 && !/[*{}]/.test(parts[index])) {
+		base = parts[index] === ".." ? dirname(base) : resolve(base, parts[index]);
+		index += 1;
+	}
+	const segments = [];
+	for (const part of parts.slice(index)) {
+		if (part === "..") return void 0;
+		const segment = segmentOf(part);
+		if (segment === void 0) return void 0;
+		segments.push(segment);
+	}
+	return {
+		negated,
+		base,
+		segments
+	};
+}
+/** Whether `names`, a path below a glob's base, matches its segments. A
+*  wildcard never matches a dot-led name unless `dot`. */
+function matches(segments, names, dot) {
+	const [segment, ...rest] = segments;
+	if (segment === void 0) return names.length === 0;
+	if (segment.kind === "globstar") {
+		if (matches(rest, names, dot)) return true;
+		const [name, ...more] = names;
+		if (name === void 0 || !dot && name.startsWith(".")) return false;
+		return matches(segments, more, dot);
+	}
+	const [name, ...more] = names;
+	if (name === void 0) return false;
+	if (!dot && name.startsWith(".") && !segment.dotted) return false;
+	return segment.test.test(name) && matches(rest, more, dot);
+}
+/** Every file below `dir`, following symbolic links as Vite does, each
+*  directory once by its real path. A read the walk cannot finish throws:
+*  the expansion would not be every file. */
+function walk(dir, prefix = [], visited = /* @__PURE__ */ new Set()) {
+	const real = realpathSync(dir);
+	if (visited.has(real)) return [];
+	const inside = new Set(visited).add(real);
+	const files = [];
+	for (const name of readdirSync(dir)) {
+		const path = `${dir}${sep}${name}`;
+		const names = [...prefix, name];
+		const stat = statSync(path);
+		if (stat.isDirectory()) files.push(...walk(path, names, inside));
+		else if (stat.isFile()) files.push({
+			names,
+			path,
+			real: realpathSync(path)
+		});
+	}
+	return files;
+}
+/** The files a set of Vite globs selects: in any affirmed glob and no
+*  negated one, `node_modules` and dot-led names left out unless
+*  `exhaustive`, the importer itself never. */
+function expandGlobs(globs, importer, exhaustive) {
+	const affirmed = globs.filter((glob) => !glob.negated);
+	const negated = globs.filter((glob) => glob.negated);
+	const inside = (glob, file) => {
+		const rel = relative(glob.base, file);
+		if (isAbsolute(rel) || rel.split(sep)[0] === "..") return false;
+		return matches(glob.segments, rel.split(sep), exhaustive);
+	};
+	const selected = /* @__PURE__ */ new Set();
+	for (const glob of affirmed) for (const { names, path, real } of walk(glob.base)) {
+		if (!exhaustive && names.includes("node_modules")) continue;
+		if (path === importer || !inside(glob, path)) continue;
+		if (negated.some((other) => inside(other, path))) continue;
+		selected.add(real);
+	}
+	return [...selected].sort();
+}
+/** The queries a glob's `query` option is read as: Vite's opaque ones,
+*  with or without the `?` it adds. */
+const GLOB_QUERIES = /* @__PURE__ */ new Map([
+	[void 0, ""],
+	["raw", "?raw"],
+	["?raw", "?raw"],
+	["url", "?url"],
+	["?url", "?url"]
+]);
+/** The boolean an option is written as; absent, `false`. */
+const GLOB_FLAGS = /* @__PURE__ */ new Map([
+	[void 0, false],
+	[true, true],
+	[false, false]
+]);
+/** A glob's options as Vite reads them (`parseGlobOptions`): the query each
+*  file is imported with and whether the glob is exhaustive. `import`
+*  selects an export, not files. Undefined for an option set not
+*  reproduced here: another query, `base`, `caseSensitive`, or the
+*  deprecated `as`, which a Vite 8 build does not apply as a query. */
+function globOptions(options) {
+	if (options === null) return {
+		query: "",
+		exhaustive: false
+	};
+	for (const key of Object.keys(options)) if (![
+		"eager",
+		"import",
+		"exhaustive",
+		"query"
+	].includes(key)) return;
+	const query = GLOB_QUERIES.get(options.query);
+	const exhaustive = GLOB_FLAGS.get(options.exhaustive);
+	if (query === void 0 || exhaustive === void 0) return void 0;
+	if (!GLOB_FLAGS.has(options.eager)) return void 0;
+	return {
+		query,
+		exhaustive
+	};
+}
+/**
+* The glob a variable `import()` of a template literal becomes under
+* Vite's dynamic-import-vars (`dynamicImportToGlob`): each substitution one
+* `*` within a segment. It must start `./` or `../` and name a file
+* extension in its last static text; Vite leaves any other one, and a
+* concatenation, a runtime import, which it does not expand.
+*/
+function importVarsGlob(quasis) {
+	if (quasis.length < 2) return void 0;
+	const head = quasis[0];
+	if (!head.startsWith("./") && !head.startsWith("../")) return void 0;
+	if (quasis.slice(1, -1).some((quasi) => quasi === "")) return void 0;
+	if (quasis.some((quasi) => /[*?{}[\]]/.test(quasi))) return void 0;
+	const last = quasis[quasis.length - 1];
+	if (!/\.[a-z0-9]+$/i.test(last) || last.includes("?")) return void 0;
+	return quasis.join("*");
+}
+/**
+* How a bundled Vite environment (Vite 8, rolldown's native glob and
+* dynamic-import-vars plugins) expands computed loads (spec §6.3):
+* `import.meta.glob` and a variable `import()`. `importVars` is false where
+* the project's `build.dynamicImportVarsOptions` differ from Vite's
+* default, which transforms every importer outside `node_modules`.
+* Anything this does not reproduce exactly lists no expansion.
+*/
+function viteLoadExpander(viteRoot, importVars) {
+	return { expand(load, rootDir) {
+		const importer = resolve(rootDir, load.importer);
+		const importerDir = dirname(importer);
+		let patterns;
+		let query = "";
+		let exhaustive = false;
+		if (load.kind === "glob" && load.args && "patterns" in load.args) {
+			const read = globOptions(load.args.options);
+			if (read === void 0) return void 0;
+			({query, exhaustive} = read);
+			patterns = load.args.patterns;
+		} else if (load.kind === "import" && load.args && "quasis" in load.args) {
+			if (!importVars || importer.split(sep).includes("node_modules") || !load.args.template || load.args.options !== null || load.args.comments.some((comment) => comment.includes("@vite-ignore"))) return;
+			const glob = importVarsGlob(load.args.quasis);
+			if (glob === void 0) return void 0;
+			patterns = [glob];
+		} else return;
+		const globs = [];
+		for (const pattern of patterns) {
+			const glob = resolveGlob(pattern, importerDir, viteRoot);
+			if (glob === void 0) return void 0;
+			globs.push(glob);
+		}
+		if (!globs.some((glob) => !glob.negated)) return void 0;
+		let files;
+		let realRoot;
+		try {
+			files = expandGlobs(globs, importer, exhaustive);
+			realRoot = realpathSync(rootDir);
+		} catch {
+			return;
+		}
+		return files.map((file) => ({
+			path: relative(realRoot, file).split(sep).join(posix.sep),
+			query
+		}));
+	} };
+}
+/** Whether `build.dynamicImportVarsOptions` are Vite's default, which
+*  transforms every importer outside `node_modules`. */
+function defaultImportVars(options) {
+	const exclude = options?.exclude;
+	return options?.include === void 0 && Array.isArray(exclude) && exclude.length === 1 && exclude[0] instanceof RegExp && exclude[0].source === "node_modules" && exclude[0].flags === "";
+}
+/** The aliases Vite adds to every configuration (`clientAlias`), which
+*  name only its own `@vite/` modules. */
+const VITE_CLIENT_ALIASES = /* @__PURE__ */ new Set(["^\\/?@vite\\/env", "^\\/?@vite\\/client"]);
+/** Whether an alias could rewrite a relative or root specifier, which the
+*  expander reads without the resolver: a string from `.` or `/`, or a
+*  RegExp other than Vite's own client aliases. */
+function aliasesRelative(aliases) {
+	return (aliases ?? []).some(({ find }) => find instanceof RegExp ? !(find.flags === "" && VITE_CLIENT_ALIASES.has(find.source)) : find.startsWith(".") || find.startsWith("/"));
+}
+/**
+* The expander for a resolved Vite configuration: only where every
+* environment is bundled (Vite 8, rolldown's native plugins; an earlier
+* Vite marks none), and no alias could rewrite a relative or root
+* specifier. A variable `import()` is expanded only where every environment
+* keeps Vite's default dynamic-import-vars options.
+*/
+function viteHostExpander(config) {
+	const environments = Object.values(config.environments ?? {});
+	if (environments.length === 0 || !environments.every((environment) => environment.isBundled === true) || aliasesRelative(config.resolve?.alias)) return;
+	return viteLoadExpander(config.root, environments.every((environment) => defaultImportVars(environment.build?.dynamicImportVarsOptions)));
+}
+//#endregion
+//#region pipeline/webpack-expansions.ts
+/** Webpack's `quoteMeta`. */
+function quoteMeta(text) {
+	return text.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+}
+/** A literal as a RegExp, where webpack tests it statelessly: a global or
+*  sticky one carries state between tests, which is not reproduced. */
+function regex(literal) {
+	if (literal === null) return void 0;
+	if (/[gy]/.test(literal.flags)) return null;
+	try {
+		return new RegExp(literal.source, literal.flags);
+	} catch {
+		return null;
+	}
+}
+/** Webpack's `splitContextFromPrefix`. */
+function splitContextFromPrefix(prefix) {
+	const at = prefix.lastIndexOf("/");
+	return at >= 0 ? {
+		context: prefix.slice(0, at),
+		prefix: `.${prefix.slice(at)}`
+	} : {
+		context: ".",
+		prefix
+	};
+}
+/** A context directory webpack resolves relative to the importer; another
+*  form goes through the resolver (aliases, modules), not reproduced. */
+function contextDir(importerDir, context) {
+	return context === "." || context.startsWith("./") || context.startsWith("../") ? resolve(importerDir, context) : void 0;
+}
+/** The comments that change which files a webpack context holds. */
+const SELECTING_COMMENT = /webpack(?:Include|Exclude|Ignore)\b/;
+/**
+* The context webpack builds for a template literal or a concatenation
+* (`ContextDependencyHelpers.create`), with the default wrapped-context
+* options (`/.*\/`, recursive): a template's inner text joins the
+* expression pattern; a concatenation keeps its prefix and postfix only.
+*/
+function specifierContext(load, importerDir) {
+	const { args } = load;
+	if (args === null || !("quasis" in args)) return void 0;
+	if (args.options !== null) return void 0;
+	if (args.comments.some((comment) => SELECTING_COMMENT.test(comment))) return;
+	const { quasis, template } = args;
+	if (quasis.length < 2 || !template && quasis.length > 2) return void 0;
+	const { context, prefix } = splitContextFromPrefix(quasis[0]);
+	const postfixRaw = quasis[quasis.length - 1];
+	if (postfixRaw.includes("#")) return void 0;
+	const at = postfixRaw.indexOf("?");
+	const postfix = at === -1 ? postfixRaw : postfixRaw.slice(0, at);
+	const query = at === -1 ? "" : postfixRaw.slice(at);
+	const inner = template ? quasis.slice(1, -1).map((quasi) => `${quoteMeta(quasi)}.*`).join("") : "";
+	const dir = contextDir(importerDir, context);
+	if (dir === void 0) return void 0;
+	return {
+		dir,
+		recursive: true,
+		regExp: new RegExp(`^${quoteMeta(prefix)}.*${inner}${quoteMeta(postfix)}$`),
+		include: void 0,
+		exclude: void 0,
+		query,
+		category: load.kind === "require" ? "commonjs" : "esm"
+	};
+}
+/** `require.context(dir, recursive, regExp, mode)` and
+*  `import.meta.webpackContext(dir, { … })`, with webpack's defaults. */
+function directContext(load, importerDir) {
+	const { args } = load;
+	if (args === null || !("dir" in args)) return void 0;
+	const regExp = regex(args.regExp);
+	const include = regex(args.include);
+	const exclude = regex(args.exclude);
+	if (regExp === null || include === null || exclude === null) return;
+	const dir = contextDir(importerDir, args.dir);
+	if (dir === void 0) return void 0;
+	return {
+		dir,
+		recursive: args.recursive ?? true,
+		regExp: regExp ?? /^\.\/.*$/,
+		include,
+		exclude,
+		query: "",
+		category: load.kind === "context" ? "commonjs" : "esm"
+	};
+}
+/** A group of module directory names, rather than one absolute module
+*  directory. */
+function isModuleGroup(modules) {
+	return Array.isArray(modules);
+}
+/** The requests webpack tests a context file's regExp against
+*  (`RequireContextPlugin`'s `alternativeRequests`). */
+function alternatives(context, request, reading) {
+	let items = [request];
+	if (!reading.fullySpecified) {
+		const extended = [];
+		for (const item of items) {
+			for (const extension of reading.extensions) if (item.endsWith(extension)) extended.push(item.slice(0, -extension.length));
+			if (!reading.enforceExtension) extended.push(item);
+		}
+		items = [];
+		for (const item of extended) {
+			for (const mainFile of reading.mainFiles) if (item.endsWith(`/${mainFile}`)) {
+				items.push(item.slice(0, -mainFile.length));
+				items.push(item.slice(0, -mainFile.length - 1));
+			}
+			items.push(item);
+		}
+	}
+	const requests = [];
+	for (const item of items) {
+		let hidden = false;
+		for (const modules of reading.modules) if (isModuleGroup(modules)) {
+			for (const name of modules) if (item.startsWith(`./${name}/`)) {
+				requests.push(item.slice(name.length + 3));
+				hidden = true;
+			}
+		} else {
+			const dir = modules.replace(/\\/g, "/");
+			const full = context.replace(/\\/g, "/") + item.slice(1);
+			if (full.startsWith(dir)) requests.push(full.slice(dir.length + 1));
+		}
+		if (!hidden) requests.push(item);
+	}
+	return requests;
+}
+/** The files a context holds (`resolveDependencies`): below its directory,
+*  dot-led names skipped, `exclude` and `include` tested on each absolute
+*  path, a file kept when any of its alternative requests matches. */
+function contextFiles(context, reading) {
+	const files = [];
+	const visit = (dir, visited) => {
+		const real = realpathSync(dir);
+		const names = readdirSync(dir).map((name) => name.normalize("NFC"));
+		if (visited.has(real)) return;
+		const inside = new Set(visited).add(real);
+		for (const name of names) {
+			if (name.startsWith(".")) continue;
+			const path = `${dir}${sep}${name}`;
+			if (context.exclude?.test(path)) continue;
+			const stat = statSync(path);
+			if (stat.isDirectory()) {
+				if (context.recursive) visit(path, inside);
+			} else if (stat.isFile() && (!context.include || context.include.test(path))) {
+				const request = `.${path.slice(context.dir.length).replace(/\\/g, "/")}`;
+				if (alternatives(context.dir, request, reading).some((alternative) => context.regExp.test(alternative))) files.push(realpathSync(path));
+			}
+		}
+	};
+	visit(context.dir, /* @__PURE__ */ new Set());
+	return files.sort();
+}
+/**
+* How a webpack 5 build expands computed loads (spec §6.3): a template or
+* concatenated `import()` or `require()`, `require.context` and
+* `import.meta.webpackContext`, each a context module whose files
+* `ContextModuleFactory` lists. `resolveReading` is the resolver's options
+* for a dependency category; `wrappedDefaults` is false where the project
+* changes `wrappedContextRegExp` or `wrappedContextRecursive`. Anything not
+* reproduced exactly lists no expansion.
+*/
+function webpackLoadExpander(resolveReading, wrappedDefaults) {
+	return { expand(load, rootDir) {
+		const importerDir = dirname(resolve(rootDir, load.importer));
+		let context;
+		if (load.kind === "import" || load.kind === "require") context = wrappedDefaults ? specifierContext(load, importerDir) : void 0;
+		else if (load.kind === "context" || load.kind === "webpackContext") context = directContext(load, importerDir);
+		if (context === void 0) return void 0;
+		const reading = resolveReading(context.category);
+		if (reading === void 0 || reading.aliasNames.length > 0) return;
+		let files;
+		let realRoot;
+		try {
+			files = contextFiles(context, reading);
+			realRoot = realpathSync(rootDir);
+		} catch {
+			return;
+		}
+		return files.map((file) => ({
+			path: relative(realRoot, file).split(sep).join(posix.sep),
+			query: context.query
+		}));
+	} };
+}
+/** A rule entry, rather than `'...'` or a falsy placeholder. */
+function isRule(rule) {
+	return rule instanceof Object;
+}
+/** Every rule, nested `rules` and `oneOf` included. */
+function everyRule(rules) {
+	return rules.filter(isRule).flatMap((rule) => [
+		rule,
+		...everyRule(rule.rules ?? []),
+		...everyRule(rule.oneOf ?? [])
+	]);
+}
+/**
+* The expander for a webpack 5 compiler. Each expansion reads the
+* compiler's options again and lists nothing where a rule carries its own
+* resolve options or context parser options, `module.defaultRules` is not
+* webpack's own, or the options cannot be read.
+*/
+function webpackHostExpander(reading) {
+	return { expand(load, rootDir) {
+		let options;
+		try {
+			options = reading.options();
+		} catch {
+			return;
+		}
+		if (everyRule(options.rules).some((rule) => rule.resolve !== void 0 || Object.keys(rule.parser ?? {}).some((key) => key.includes("Context"))) || !options.defaultRulesAreWebpacks) return void 0;
+		return webpackLoadExpander(reading.resolveReading, options.wrappedDefaults).expand(load, rootDir);
+	} };
+}
+//#endregion
+//#region pipeline/served-files.ts
+function servedFiles(manifest) {
+	const dropped = /* @__PURE__ */ new Map();
+	for (const input of manifest.missing_inputs ?? []) {
+		if (input.outcome === "failed-parent") continue;
+		if (!dropped.has(input.file)) dropped.set(input.file, input);
+	}
+	return {
+		listed: new Set(Object.entries(manifest.files ?? {}).filter(([, ids]) => ids.length > 0).map(([file]) => file)),
+		dropped
+	};
+}
+/** Why a file dropped over its extension parent is not served: its builder
+*  code would render with empty classes. */
+function droppedExtensionMessage(drop) {
+	const from = drop.specifier === null ? "" : ` from '${drop.specifier}'`;
+	return `[animus-extract] cannot serve ${drop.file}: '${drop.component}' extends '${drop.parent}'${from}, which the analysis could not resolve (${drop.outcome}); serving it untransformed would render it without its styles. Make the parent an analysed Animus component, or remove the extension.`;
+}
+//#endregion
+export { excludeCollectedPackages as $, createSourceIdentity as $t, postProcessCss as A, substituteAssetPlaceholders as An, webpackExtensionPolicy as At, noOutputTargets as B, __require as Bn, CORE_OPTION_KEYS as Bt, serializeStaticCss as C, systemLoadDiagnostics as Cn, tsconfigChainPaths as Ct, clearEngineCache as D, findSheetAssetSpecifiers as Dn, rollupExtensionPolicy as Dt, buildAnalysisInputs as E, findAssetSpecifiers as En, extensionPolicyJson as Et, resolveThroughPathAliases as F, buildAnalyzeProjectArgs as Fn, pruneStaleAssets as Ft, discoveryResolver as G, assertKnownOptionKeys as Gt, rollupOutputTargets as H, DRIVER_NAMESPACES as Ht, createSourceCorpus as I, ANIMUS_LAYERS as In, writeAssetCopy as It, packageInstanceFinding as J, outputSourceGuard as Jt, AliasAgreementCache as K, createExcludeMatcher as Kt, analysedOutputs as L, assembleStylesheet as Ln, RETIRED_ENGINE_MESSAGE as Lt, buildPathAliasesJson as M, caseMismatchReason as Mn, discoverFiles as Mt, enforceExternalTokenContracts as N, contentHash as Nn, DEFAULT_RUNTIME_IMPORT as Nt, runProjectAnalysis as O, generatedModuleCode as On, turbopackExtensionPolicy as Ot, resolveAssetFile as P, parseInternalWire as Pn, assertRuntimeImportSuppliesTerminals as Pt, engineModuleParser as Q, unmatchedExcludeLines as Qt, esbuildOutputTargets as R, stripLeadingLayerDeclaration as Rn, assertSupportedEngine as Rt, applyPrefix as S, surfaceManifestDiagnostics as Sn, readTsconfigAliasPairs as St, stableStringify as T, vocabularyWitnessDiagnostics as Tn, esbuildExtensionPolicy as Tt, viteOutputTargets as U, REPLACEABLE_DEFAULT_EXCLUDE as Ut, outputExclusions as V, DEFAULT_EXCLUDE as Vt, webpackOutputTargets as W, STRUCTURAL_EXCLUDE as Wt, bareSpecifierPackageName as X, resolveMode as Xt, packageReadRecord as Y, outputSourceMessage as Yt, collectExternalPackageSources as Z, resolveVerbosity as Zt, buildSystemPropsModule as _, VOCABULARY_COLLISION as _n, declaredWorkspacePackages as _t, viteHostExpander as a, parseFilesJson as an, isExcludedPackageRelativePath as at, loadSystemConfig as b, noKitFilesDiagnostics as bn, kitDescriptorDiagnostics as bt, esbuildAssetClassification as c, adaptedOriginals as cn, kitSourceModuleSideEffects as ct, toWatchKeys as d, isEngineTransformExtension as dn, probeAbsolutePathSpecifier as dt, isPathWithinRoot as en, extractSystemFilePackages as et, diffFilePlans as f, preprocessMdx as fn, sourceKitDependencies as ft, assertNoErrorDiagnostics as g, SYSTEM_INSTANCE_MISMATCH as gn, walkPackageSources as gt, kitPublicationFailures as h, INVALID_PROPERTY_REGISTRATION as hn, unresolvableIncludesMessage as ht, webpackLoadExpander as i, isAdvisorySourceDiagnostic as in, importedKitDiagnostics as it, resolveLightningTargets as j, substituteSheetAssets as jn, compareDiscoveryOrder as jt, applyUnitFallback as k, reportSurvivingAssetPlaceholders as kn, viteExtensionPolicy as kt, nextImageAssetClassification as l, DEFAULT_EXTENSIONS as ln, nativeKitSourceRoot as lt, snapshotFilePlans as m, DiagnosticFailure as mn, systemKitDependencies as mt, servedFiles as n, createV2EngineApi as nn, findPackageRoot as nt, viteLoadExpander as o, projectExternalFileOwners as on, isPackageSpecifier as ot, hashReplacementPlans as p, DIAGNOSTIC_LEVELS as pn, staleDistIncludesMessage as pt, compareAliases as q, outputExclusion as qt, webpackHostExpander as r, ingestSourceEntries as rn, firstOwners as rt, builtInAssetClassification as s, adaptSvelteSource as sn, keepsKitSourceEffects as st, droppedExtensionMessage as t, sharesVolumeRoot as tn, fileSideEffects as tt, viteAssetClassification as u, ENGINE_TRANSFORM_EXTENSIONS as un, nativePackageLocator as ut, buildDynamicPropConfig as v, VOCABULARY_LEGACY_VERB as vn, KIT_DESCRIPTOR_FILE as vt, camelToKebab as w, unreadableSourceDiagnostic as wn, BUILT_IN_EXTENSION_POLICY as wt, systemLoadReads as x, severityFor as xn, readKitDescriptor as xt, runStructuralSelfCheck as y, isDeletedSource as yn, buildKitDescriptor as yt, mergeOutputTargets as z, validateLayerOrder as zn, AnimusConfigError as zt };