@animus-ui/extract 0.1.24 → 0.1.26

package/dist/{pipeline-CAH9mxnK.cjs → pipeline-DyUf-eKZ.cjs}

@@ -23,9 +23,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let node_path = require("node:path");
 node_path = __toESM(node_path);
 let crypto = require("crypto");
+let node_fs = require("node:fs");
 let fs = require("fs");
 let path = require("path");
-let node_fs = require("node:fs");
 let module$1 = require("module");
 let browserslist = require("browserslist");
 browserslist = __toESM(browserslist);
@@ -90,7 +90,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,
@@ -115,18 +115,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 (0, crypto.createHash)("md5").update(source).digest("hex");
-}
-//#endregion
 //#region pipeline/internal-wire.ts
 function parseInternalWire(json, wire) {
 	let parsed;
@@ -138,6 +135,160 @@ function parseInternalWire(json, wire) {
 	return parsed;
 }
 //#endregion
+//#region pipeline/content-hash.ts
+function contentHash(source) {
+	return (0, crypto.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 (0, node_fs.statSync)(path).isFile();
+	} catch {
+		return false;
+	}
+};
+/** Whether `directory` lists an entry spelled exactly `name`. */
+function lists(directory, name) {
+	try {
+		return (0, node_fs.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 node_fs.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 = (0, node_path.normalize)(candidate);
+	if (!isFile(path)) return { kind: "missing" };
+	const { root } = (0, node_path.parse)(path);
+	const names = path.slice(root.length).split(node_path.sep).filter(Boolean);
+	const baseNames = within === void 0 ? [] : (0, node_path.normalize)(within).slice(root.length).split(node_path.sep).filter(Boolean);
+	let shared = 0;
+	while (shared < baseNames.length && names[shared] === baseNames[shared] && names[shared] !== "..") shared++;
+	let directory = (0, node_path.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 = (0, node_path.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;
@@ -315,15 +466,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",
@@ -441,11 +583,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. */
@@ -453,10 +595,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";
@@ -542,6 +708,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"],
@@ -743,6 +915,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?.((0, node_path.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 node_fs.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?.((0, node_path.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((0, node_path.join)(rootDir, file), rootDir);
+		if (seen.kind === "missing") continue;
+		if (seen.kind === "case-only") return {
+			candidate,
+			actual: (0, node_path.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) => {
@@ -840,14 +1141,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);
 	}
 }
 /**
@@ -1049,7 +1350,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;
 	});
@@ -1146,7 +1447,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;
@@ -1311,17 +1612,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 = node_path.posix.basename(path);
 	const dot = basename.lastIndexOf(".");
@@ -1330,27 +1620,40 @@ function extension(path) {
 function canonicalResolverPath(path) {
 	return node_path.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 = node_path.posix.normalize(node_path.posix.join(node_path.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(node_path.posix.normalize(node_path.posix.join(node_path.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, node_path.posix.normalize(node_path.posix.join(node_path.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;
 	}
@@ -1358,15 +1661,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);
@@ -1391,6 +1701,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) {
@@ -1411,7 +1722,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;
@@ -1533,7 +1848,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];
@@ -1568,13 +1886,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);
@@ -1591,8 +1910,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);
@@ -1642,15 +1963,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));
@@ -1698,9 +2030,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);
@@ -1729,11 +2068,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();
@@ -1759,10 +2104,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 = node_path.default) {
+	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 = node_path.default) {
+	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
+	return volumeOf(a) === volumeOf(b);
+}
+function canonicalize(p) {
+	try {
+		return (0, node_fs.realpathSync)(p);
+	} catch {
+		return null;
+	}
+}
+function createSourceIdentity(rootDir) {
+	const normalizedRootDir = node_path.default.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 = node_path.default.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 = node_path.default.normalize(inputPath);
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			const owner = owningRecord(canonical);
+			const ownedBy = (record) => {
+				const pathInRoot = node_path.default.relative(record.canonical, canonical);
+				return {
+					sourceKey: node_path.default.relative(normalizedRootDir, node_path.default.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 = node_path.default.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(node_path.default.normalize(inputPath)) ?? null;
+		},
+		containingExternalRoot(inputPath) {
+			const lexical = node_path.default.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
@@ -1871,6 +2318,11 @@ const CORE_VALUE_GATES = [
 		ok: isString,
 		expected: "a string path"
 	},
+	{
+		key: "root",
+		ok: isString,
+		expected: "a string path"
+	},
 	{
 		key: "exclude",
 		ok: isStringArray,
@@ -1989,30 +2441,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 = (0, path.relative)(root, outDir);
+	return rel === "" ? null : rel.split(path.sep).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((0, path.resolve)(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$8) {
+	try {
+		return (0, fs.realpathSync)(path$8);
+	} catch {
+		return path$8;
+	}
+}
 function resolveMode(explicit, driverDefault) {
 	if (explicit === "development" || explicit === "production") return {
 		mode: explicit,
@@ -2024,18 +2547,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 = (0, fs.readFileSync)(sourcePath);
+	const digest = contentHash(bytes);
+	const ext = (0, path.extname)(sourcePath);
+	const fileName = `${(0, path.basename)(sourcePath, ext)}.${digest.slice(0, 8)}${ext}`;
+	if (!(0, fs.existsSync)(assetsDir)) (0, fs.mkdirSync)(assetsDir, { recursive: true });
+	const copyPath = (0, path.join)(assetsDir, fileName);
+	if (!(0, fs.existsSync)(copyPath)) (0, fs.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 (!(0, fs.existsSync)(assetsDir)) return;
+	let entries;
+	try {
+		entries = (0, fs.readdirSync)(assetsDir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (expected.has(entry)) continue;
+		try {
+			(0, fs.unlinkSync)((0, path.join)(assetsDir, entry));
+		} catch {}
+	}
+}
+//#endregion
+//#region 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);
@@ -2064,6 +2661,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.
@@ -2147,10 +2899,10 @@ function decodePaths(value) {
 function decodeExtends(value) {
 	return (Array.isArray(value) ? value : [value]).filter(isJsonString);
 }
-function readConfig(path$8) {
+function readConfig(path$6) {
 	let raw;
 	try {
-		raw = (0, fs.readFileSync)(path$8, "utf-8");
+		raw = (0, fs.readFileSync)(path$6, "utf-8");
 	} catch {
 		return null;
 	}
@@ -2163,22 +2915,33 @@ function readConfig(path$8) {
 	const root = isJsonBlock(parsed) ? parsed : {};
 	const compilerOptions = isJsonBlock(root.compilerOptions) ? root.compilerOptions : {};
 	return {
-		dir: (0, path.dirname)(path$8),
+		dir: (0, path.dirname)(path$6),
 		baseUrl: isJsonString(compilerOptions.baseUrl) ? compilerOptions.baseUrl : null,
 		paths: decodePaths(compilerOptions.paths),
 		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(".") || (0, path.isAbsolute)(specifier)) {
 		const base = (0, path.resolve)(fromDir, specifier);
-		for (const candidate of [
+		return [
 			base,
 			`${base}.json`,
 			(0, path.join)(base, "tsconfig.json")
-		]) if ((0, fs.existsSync)(candidate)) return candidate;
-		return null;
+		];
+	}
+	const target = specifier.endsWith(".json") ? specifier : `${specifier}/tsconfig.json`;
+	const candidates = [];
+	for (let dir = (0, path.resolve)(fromDir);; dir = (0, path.dirname)(dir)) {
+		candidates.push((0, path.join)(dir, "node_modules", target));
+		if ((0, path.dirname)(dir) === dir) return candidates;
 	}
+}
+function resolveExtendsTarget(specifier, fromDir) {
+	if (specifier.startsWith(".") || (0, path.isAbsolute)(specifier)) return extendsCandidates(specifier, fromDir).find((candidate) => (0, fs.existsSync)(candidate)) ?? null;
 	try {
 		return require.resolve(specifier.endsWith(".json") ? specifier : `${specifier}/tsconfig.json`, { paths: [fromDir] });
 	} catch {
@@ -2190,13 +2953,12 @@ 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$9 = queue.shift();
-		const key = (0, path.resolve)(path$9);
+		const path$7 = queue.shift();
+		const key = (0, path.resolve)(path$7);
 		if (visited.has(key)) continue;
 		visited.add(key);
 		const node = readConfig(key);
@@ -2205,10 +2967,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((0, path.join)(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.
@@ -2348,112 +3120,42 @@ 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 = node_path.default) {
-	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 = node_path.default) {
-	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 (0, node_fs.realpathSync)(p);
+		return JSON.parse((0, fs.readFileSync)((0, path.join)(dir, "package.json"), "utf-8"));
 	} catch {
 		return null;
 	}
 }
-function createSourceIdentity(rootDir) {
-	const normalizedRootDir = node_path.default.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 = node_path.default.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 = node_path.default.normalize(inputPath);
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			const owner = owningRecord(canonical);
-			const ownedBy = (record) => {
-				const pathInRoot = node_path.default.relative(record.canonical, canonical);
-				return {
-					sourceKey: node_path.default.relative(normalizedRootDir, node_path.default.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 = node_path.default.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(node_path.default.normalize(inputPath)) ?? null;
-		},
-		containingExternalRoot(inputPath) {
-			const lexical = node_path.default.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 = (0, fs.realpathSync)((0, path.resolve)(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
@@ -2481,34 +3183,31 @@ const PACKAGE_OUTPUT_EXCLUDES = [
 	".d.ts",
 	".map"
 ];
-const isFile$1 = (path$2) => {
-	try {
-		return (0, fs.statSync)(path$2).isFile();
-	} catch {
-		return false;
-	}
-};
-function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
-	return [
-		absSpecifier,
-		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
-		...Array.from(extensionsSet, (ext) => (0, path.join)(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((0, path.normalize)(absSpecifier), {
+		sources: extensionsSet,
+		index: path.join,
+		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 ((0, path.isAbsolute)(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((0, path.join)(srcDir, subpath || "index"), extensionsSet);
+	const probed = probeAbsolutePathSpecifier((0, path.join)(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) {
@@ -2533,51 +3232,50 @@ 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 = (0, path.resolve)(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 ? (0, path.dirname)(file) : commonDirectory(root, (0, path.dirname)(file)), null);
-	return condition;
-}
-function commonDirectory(a, b) {
-	let dir = a;
-	while (!isPathWithinRoot(dir, b)) dir = (0, path.dirname)(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$3) {
+function realPath(path$2) {
 	try {
-		return (0, fs.realpathSync)(path$3);
+		return (0, fs.realpathSync)(path$2);
 	} catch {
-		return path$3;
-	}
-}
-/** 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 = (0, path.dirname)(dir)) {
-		const candidate = (0, path.join)(dir, "node_modules", name);
-		if ((0, fs.existsSync)((0, path.join)(candidate, "package.json"))) return realPath(candidate);
-		if (dir === (0, path.dirname)(dir)) return null;
+		return path$2;
 	}
 }
 /**
@@ -2723,14 +3421,21 @@ function distEntryIsStale(absEntry, srcDir, srcFiles) {
 	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. */
@@ -2741,6 +3446,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);
@@ -2785,8 +3492,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;
@@ -2795,23 +3512,78 @@ async function collectExternalPackageSources(opts) {
 		} catch {
 			absEntry = null;
 		}
-		if (!absEntry && (0, path.isAbsolute)(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		let caseMismatch;
+		if ((0, path.isAbsolute)(specifier)) {
+			const own = probeAbsolutePathSpecifier(specifier, extensionsSet, rootDir, extensions);
+			const hosted = absEntry === null ? null : (0, path.normalize)(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 = (0, path.isAbsolute)(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 !== (0, path.dirname)(resolvedRoot)) resolvedRoot = (0, path.dirname)(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(path.sep).includes("node_modules")) diagnostics.push(packageMismatchDiagnostic(specifier, (0, path.relative)(rootDir, absEntry), (0, path.relative)(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, (0, path.join)(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);
@@ -2821,10 +3593,24 @@ async function collectExternalPackageSources(opts) {
 		const srcDir = (0, path.join)(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 = (0, path.dirname)(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((0, path.extname)(entryFile));
+			dirExtensions[outputDir] = [...outputExtensions];
+			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
+				const relToOutput = (0, path.relative)(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);
@@ -2832,6 +3618,7 @@ async function collectExternalPackageSources(opts) {
 				await redirect(entrySpecifier, target, pkgRoot, () => shippedEntry(entrySpecifier, pkgRoot, entry));
 			}
 			packageMap[specifier] ??= (0, path.relative)(rootDir, absEntry);
+			if (!condition.entries.some(([entry]) => entry === entryKey)) ingestOutput(absEntry);
 			if (condition.root) {
 				packageDirs.push(condition.root);
 				if (linked) linkedDirs.push(condition.root);
@@ -2840,13 +3627,13 @@ async function collectExternalPackageSources(opts) {
 				onPackageResolved?.(specifier, condition.root);
 				for (const file of walkPackageSources(condition.root, extensionsSet)) if (ingest(file, specifier)) fileCount++;
 			}
-		} else if ((0, fs.existsSync)(srcDir)) {
+		} else if (selection === null ? (0, fs.existsSync)(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] = (0, path.relative)(rootDir, srcEntry);
 				const replaced = absEntry;
@@ -2854,7 +3641,7 @@ async function collectExternalPackageSources(opts) {
 			} else packageMap[specifier] = (0, path.relative)(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] = (0, path.relative)(rootDir, rootEntry);
 						await redirect(packageName, rootEntry, pkgRoot, () => shippedEntry(packageName, pkgRoot, "."));
@@ -2865,22 +3652,8 @@ async function collectExternalPackageSources(opts) {
 			staleDist = linked && distEntryIsStale(absEntry, srcDir, pkgFiles);
 			for (const pkgFile of pkgFiles) if (ingest(pkgFile, specifier)) fileCount++;
 		} else {
-			const outputDir = (0, path.dirname)(absEntry);
-			packageDirs.push(outputDir);
-			if (linked) linkedDirs.push(outputDir);
-			outputDirs.push(outputDir);
-			claimDir(outputDir, specifier);
-			onPackageResolved?.(specifier, outputDir);
 			packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
-			const outputExtensions = new Set(extensionsSet);
-			outputExtensions.add((0, path.extname)(absEntry));
-			dirExtensions[outputDir] = [...outputExtensions];
-			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
-				const relToOutput = (0, path.relative)(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);
@@ -2888,6 +3661,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",
@@ -2907,7 +3690,8 @@ async function collectExternalPackageSources(opts) {
 		fileOwners,
 		outcomes,
 		diagnostics: [...diagnostics, ...noKitFilesDiagnostics(outcomes)],
-		kitDescriptors
+		kitDescriptors,
+		packageInstances
 	};
 }
 /** The dependency names a manifest lists in `fields`. */
@@ -2920,14 +3704,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),
@@ -2935,6 +3727,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 : (0, path.dirname)(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) {
@@ -2950,22 +3770,19 @@ 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;
-	const parsed = files.filter(({ path: path$4 }) => isEngineTransformExtension(path$4));
-	if (!extractFacts || parsed.length === 0) return [];
+function importedKitDiagnostics(files, engine, rootDir, systemKits, factsOf) {
+	const parsed = files.filter(({ path: path$3 }) => isEngineTransformExtension(path$3));
+	if (parsed.length === 0) return [];
+	const locatePackage = nativePackageLocator(engine, declaredWorkspacePackages(rootDir));
 	let facts;
 	try {
-		facts = parseInternalWire(extractFacts(JSON.stringify(parsed.map(({ path: path$5, source }) => ({
-			path: path$5,
-			source
-		})))), "extractFacts");
+		facts = factsOf(parsed);
 	} catch {
 		return [];
 	}
 	const seen = new Set(systemKits.filter((specifier) => !(0, path.isAbsolute)(specifier)).map(bareSpecifierPackageName));
 	const diagnostics = [];
-	for (const [path$6, file] of Object.entries(facts.files)) {
+	for (const [path$4, file] of Object.entries(facts.files)) {
 		if (file.parsePanicked) continue;
 		const specifiers = [...file.imports.map((fact) => fact.source), ...file.exports.flatMap((fact) => fact.source === null ? [] : [fact.source])];
 		for (const specifier of specifiers) {
@@ -2973,9 +3790,9 @@ function importedKitDiagnostics(files, engine, rootDir, systemKits) {
 			const name = bareSpecifierPackageName(specifier);
 			if (seen.has(name)) continue;
 			seen.add(name);
-			const pkgRoot = locatePackageRoot(name, (0, path.dirname)((0, path.resolve)(rootDir, path$6)));
-			if (pkgRoot && readKitSourceCondition(pkgRoot)) diagnostics.push({
-				file: path$6,
+			const pkgRoot = locatePackage(name, (0, path.dirname)((0, path.resolve)(rootDir, path$4)));
+			if (pkgRoot && declaresKitSource(engine, pkgRoot)) diagnostics.push({
+				file: path$4,
 				component: name,
 				kind: "warn",
 				message: `the application imports this kit, but its system is not included in the application's system, so its components are not extracted — include the kit's system in the application's system: createSystem().extend(<the kit's system>)`,
@@ -2987,7 +3804,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,
@@ -2997,11 +3826,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)
 	}));
@@ -3058,13 +3887,16 @@ function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
 		fileOwners,
 		outcomes: collected.outcomes,
 		diagnostics: collected.diagnostics,
-		kitDescriptors: collected.kitDescriptors.filter((record) => !rejectedDirs.some((dir) => isPathWithinRoot((0, path.resolve)(rootDir, record.packageRoot), dir)))
+		kitDescriptors: collected.kitDescriptors.filter((record) => !rejectedDirs.some((dir) => isPathWithinRoot((0, path.resolve)(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. */
@@ -3079,12 +3911,12 @@ function staleDistIncludesMessage(outcomes) {
 function engineModuleParser(engine) {
 	const { extractFacts } = engine;
 	if (!extractFacts) return void 0;
-	return (source, path$7) => {
+	return (source, path$5) => {
 		try {
 			const facts = parseInternalWire(extractFacts(JSON.stringify([{
-				path: path$7,
+				path: path$5,
 				source
-			}])), "extractFacts").files[path$7];
+			}])), "extractFacts").files[path$5];
 			return facts && !facts.parsePanicked ? {
 				imports: facts.imports,
 				exports: facts.exports,
@@ -3095,178 +3927,24 @@ function engineModuleParser(engine) {
 		}
 	};
 }
-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;
+/** 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), (0, path.dirname)(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;
 	}
-}
-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 = (0, fs.readFileSync)(file, "utf-8");
+		const file = await resolvePackage?.(specifier, importer);
+		return file ? { file: file.split("?")[0] } : unresolved;
 	} 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;
-		}
-		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()
-			};
-		}
+		return unresolved;
 	}
 }
 /** The warning for a `createSystem` call that the parser's scopes leave
@@ -3286,229 +3964,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 = (0, fs.readFileSync)(systemFilePath, "utf-8");
+		files[systemFilePath] = (0, fs.readFileSync)(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] = (0, fs.readFileSync)(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(".") ? (0, path.resolve)((0, path.dirname)(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 node_fs.realpathSync.native(file);
+	} catch {
+		return (0, node_path.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") || !(0, node_path.isAbsolute)(file)) return { virtual: id };
+	return (0, node_fs.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((0, node_path.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) => (0, node_path.relative)(record.rootDir, path).split(node_path.sep).join(node_path.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 = `${node_path.posix.dirname(importer)}\0${specifier}`;
+		let answer = packageAnswers.get(key);
+		if (answer === void 0) {
+			answer = input.resolve(specifier, (0, node_path.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, (0, node_path.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((0, node_path.join)(input.rootDir, analysis)) === physical(host.file)) return null;
+		const shown = host === null ? "no file" : "virtual" in host ? host.virtual : (0, node_path.relative)(input.rootDir, host.file).split(node_path.sep).join(node_path.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 = (0, path.join)(context.rootDir, "__animus_discovery__.js");
+	return {
+		hostFirst: true,
+		async resolveSpecifier(specifier) {
+			let hosted;
+			try {
+				hosted = await hostResolve(specifier, rootImporter);
+			} catch {
+				hosted = null;
 			}
-		}
-	}
-	const systemFileDir = (0, path.dirname)(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((0, path.resolve)(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((0, path.resolve)(base, output.dir));
+	else if (output.file !== void 0) targets.files.push((0, path.resolve)(base, output.file));
+	else if (fallbackDir !== void 0) targets.dirs.push((0, path.resolve)(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(path.sep);
+	const placeholder = segments.findIndex((segment) => segment.includes("["));
+	const fixed = placeholder === -1 ? outputPath : segments.slice(0, placeholder).join(path.sep);
+	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) => (0, path.relative)(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
@@ -3529,6 +4405,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);
@@ -4346,15 +5223,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 ?? "";
@@ -4388,7 +5278,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);
@@ -4624,12 +5518,20 @@ 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 {
@@ -4648,7 +5550,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);
@@ -4698,6 +5600,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;
@@ -4817,13 +5720,6 @@ const CODE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".mjs",
 	".cjs"
 ]);
-const isFile = (path) => {
-	try {
-		return (0, node_fs.statSync)(path).isFile();
-	} catch {
-		return false;
-	}
-};
 const posixPath = (path) => path.split(node_path.sep).join("/");
 /**
 * The package-relative files `npm pack` publishes, read with npm's own rules
@@ -4952,8 +5848,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((0, node_path.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((0, node_path.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) {
@@ -4966,8 +5868,13 @@ function kitPublicationFailures(pkgRoot, engine, artifactDir) {
 		}])), "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), (0, node_path.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((0, node_path.extname)(target))) queue.push(target);
@@ -5066,18 +5973,665 @@ function realpathThroughNearestExistingAncestor(path) {
 	}
 }
 //#endregion
+//#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$1 = (0, node_module.createRequire)(`${rootDir}/package.json`);
+		const { version } = require$1("next/package.json");
+		const { nextImageLoaderRegex } = require$1("next/dist/build/webpack-config");
+		const { regexLikeCss } = require$1("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] === ".." ? (0, node_path.dirname)(base) : (0, node_path.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 = (0, node_fs.realpathSync)(dir);
+	if (visited.has(real)) return [];
+	const inside = new Set(visited).add(real);
+	const files = [];
+	for (const name of (0, node_fs.readdirSync)(dir)) {
+		const path = `${dir}${node_path.sep}${name}`;
+		const names = [...prefix, name];
+		const stat = (0, node_fs.statSync)(path);
+		if (stat.isDirectory()) files.push(...walk(path, names, inside));
+		else if (stat.isFile()) files.push({
+			names,
+			path,
+			real: (0, node_fs.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 = (0, node_path.relative)(glob.base, file);
+		if ((0, node_path.isAbsolute)(rel) || rel.split(node_path.sep)[0] === "..") return false;
+		return matches(glob.segments, rel.split(node_path.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 = (0, node_path.resolve)(rootDir, load.importer);
+		const importerDir = (0, node_path.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(node_path.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 = (0, node_fs.realpathSync)(rootDir);
+		} catch {
+			return;
+		}
+		return files.map((file) => ({
+			path: (0, node_path.relative)(realRoot, file).split(node_path.sep).join(node_path.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("../") ? (0, node_path.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 = (0, node_fs.realpathSync)(dir);
+		const names = (0, node_fs.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}${node_path.sep}${name}`;
+			if (context.exclude?.test(path)) continue;
+			const stat = (0, node_fs.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((0, node_fs.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 = (0, node_path.dirname)((0, node_path.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 = (0, node_fs.realpathSync)(rootDir);
+		} catch {
+			return;
+		}
+		return files.map((file) => ({
+			path: (0, node_path.relative)(realRoot, file).split(node_path.sep).join(node_path.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
 Object.defineProperty(exports, "ANIMUS_LAYERS", {
 	enumerable: true,
 	get: function() {
 		return ANIMUS_LAYERS;
 	}
 });
+Object.defineProperty(exports, "AliasAgreementCache", {
+	enumerable: true,
+	get: function() {
+		return AliasAgreementCache;
+	}
+});
 Object.defineProperty(exports, "AnimusConfigError", {
 	enumerable: true,
 	get: function() {
 		return AnimusConfigError;
 	}
 });
+Object.defineProperty(exports, "BUILT_IN_EXTENSION_POLICY", {
+	enumerable: true,
+	get: function() {
+		return BUILT_IN_EXTENSION_POLICY;
+	}
+});
 Object.defineProperty(exports, "CORE_OPTION_KEYS", {
 	enumerable: true,
 	get: function() {
@@ -5096,6 +6650,12 @@ Object.defineProperty(exports, "DEFAULT_EXTENSIONS", {
 		return DEFAULT_EXTENSIONS;
 	}
 });
+Object.defineProperty(exports, "DEFAULT_RUNTIME_IMPORT", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_RUNTIME_IMPORT;
+	}
+});
 Object.defineProperty(exports, "DIAGNOSTIC_LEVELS", {
 	enumerable: true,
 	get: function() {
@@ -5150,6 +6710,12 @@ Object.defineProperty(exports, "STRUCTURAL_EXCLUDE", {
 		return STRUCTURAL_EXCLUDE;
 	}
 });
+Object.defineProperty(exports, "SYSTEM_INSTANCE_MISMATCH", {
+	enumerable: true,
+	get: function() {
+		return SYSTEM_INSTANCE_MISMATCH;
+	}
+});
 Object.defineProperty(exports, "VOCABULARY_COLLISION", {
 	enumerable: true,
 	get: function() {
@@ -5168,6 +6734,18 @@ Object.defineProperty(exports, "adaptSvelteSource", {
 		return adaptSvelteSource;
 	}
 });
+Object.defineProperty(exports, "adaptedOriginals", {
+	enumerable: true,
+	get: function() {
+		return adaptedOriginals;
+	}
+});
+Object.defineProperty(exports, "analysedOutputs", {
+	enumerable: true,
+	get: function() {
+		return analysedOutputs;
+	}
+});
 Object.defineProperty(exports, "applyPrefix", {
 	enumerable: true,
 	get: function() {
@@ -5198,10 +6776,22 @@ Object.defineProperty(exports, "assertNoErrorDiagnostics", {
 		return assertNoErrorDiagnostics;
 	}
 });
-Object.defineProperty(exports, "assertNoRetiredEngineSelection", {
+Object.defineProperty(exports, "assertRuntimeImportSuppliesTerminals", {
+	enumerable: true,
+	get: function() {
+		return assertRuntimeImportSuppliesTerminals;
+	}
+});
+Object.defineProperty(exports, "assertSupportedEngine", {
 	enumerable: true,
 	get: function() {
-		return assertNoRetiredEngineSelection;
+		return assertSupportedEngine;
+	}
+});
+Object.defineProperty(exports, "bareSpecifierPackageName", {
+	enumerable: true,
+	get: function() {
+		return bareSpecifierPackageName;
 	}
 });
 Object.defineProperty(exports, "buildAnalysisInputs", {
@@ -5240,12 +6830,24 @@ Object.defineProperty(exports, "buildSystemPropsModule", {
 		return buildSystemPropsModule;
 	}
 });
+Object.defineProperty(exports, "builtInAssetClassification", {
+	enumerable: true,
+	get: function() {
+		return builtInAssetClassification;
+	}
+});
 Object.defineProperty(exports, "camelToKebab", {
 	enumerable: true,
 	get: function() {
 		return camelToKebab;
 	}
 });
+Object.defineProperty(exports, "caseMismatchReason", {
+	enumerable: true,
+	get: function() {
+		return caseMismatchReason;
+	}
+});
 Object.defineProperty(exports, "clearEngineCache", {
 	enumerable: true,
 	get: function() {
@@ -5258,6 +6860,12 @@ Object.defineProperty(exports, "collectExternalPackageSources", {
 		return collectExternalPackageSources;
 	}
 });
+Object.defineProperty(exports, "compareAliases", {
+	enumerable: true,
+	get: function() {
+		return compareAliases;
+	}
+});
 Object.defineProperty(exports, "compareDiscoveryOrder", {
 	enumerable: true,
 	get: function() {
@@ -5294,6 +6902,12 @@ Object.defineProperty(exports, "createV2EngineApi", {
 		return createV2EngineApi;
 	}
 });
+Object.defineProperty(exports, "declaredWorkspacePackages", {
+	enumerable: true,
+	get: function() {
+		return declaredWorkspacePackages;
+	}
+});
 Object.defineProperty(exports, "diffFilePlans", {
 	enumerable: true,
 	get: function() {
@@ -5306,6 +6920,18 @@ Object.defineProperty(exports, "discoverFiles", {
 		return discoverFiles;
 	}
 });
+Object.defineProperty(exports, "discoveryResolver", {
+	enumerable: true,
+	get: function() {
+		return discoveryResolver;
+	}
+});
+Object.defineProperty(exports, "droppedExtensionMessage", {
+	enumerable: true,
+	get: function() {
+		return droppedExtensionMessage;
+	}
+});
 Object.defineProperty(exports, "enforceExternalTokenContracts", {
 	enumerable: true,
 	get: function() {
@@ -5318,12 +6944,36 @@ Object.defineProperty(exports, "engineModuleParser", {
 		return engineModuleParser;
 	}
 });
+Object.defineProperty(exports, "esbuildAssetClassification", {
+	enumerable: true,
+	get: function() {
+		return esbuildAssetClassification;
+	}
+});
+Object.defineProperty(exports, "esbuildExtensionPolicy", {
+	enumerable: true,
+	get: function() {
+		return esbuildExtensionPolicy;
+	}
+});
+Object.defineProperty(exports, "esbuildOutputTargets", {
+	enumerable: true,
+	get: function() {
+		return esbuildOutputTargets;
+	}
+});
 Object.defineProperty(exports, "excludeCollectedPackages", {
 	enumerable: true,
 	get: function() {
 		return excludeCollectedPackages;
 	}
 });
+Object.defineProperty(exports, "extensionPolicyJson", {
+	enumerable: true,
+	get: function() {
+		return extensionPolicyJson;
+	}
+});
 Object.defineProperty(exports, "extractSystemFilePackages", {
 	enumerable: true,
 	get: function() {
@@ -5408,16 +7058,10 @@ Object.defineProperty(exports, "isExcludedPackageRelativePath", {
 		return isExcludedPackageRelativePath;
 	}
 });
-Object.defineProperty(exports, "isJsonBlock", {
-	enumerable: true,
-	get: function() {
-		return isJsonBlock;
-	}
-});
-Object.defineProperty(exports, "isJsonString", {
+Object.defineProperty(exports, "isPackageSpecifier", {
 	enumerable: true,
 	get: function() {
-		return isJsonString;
+		return isPackageSpecifier;
 	}
 });
 Object.defineProperty(exports, "isPathWithinRoot", {
@@ -5426,12 +7070,6 @@ Object.defineProperty(exports, "isPathWithinRoot", {
 		return isPathWithinRoot;
 	}
 });
-Object.defineProperty(exports, "isUnresolvedParentDrop", {
-	enumerable: true,
-	get: function() {
-		return isUnresolvedParentDrop;
-	}
-});
 Object.defineProperty(exports, "keepsKitSourceEffects", {
 	enumerable: true,
 	get: function() {
@@ -5462,12 +7100,78 @@ Object.defineProperty(exports, "loadSystemConfig", {
 		return loadSystemConfig;
 	}
 });
+Object.defineProperty(exports, "mergeOutputTargets", {
+	enumerable: true,
+	get: function() {
+		return mergeOutputTargets;
+	}
+});
+Object.defineProperty(exports, "nativeKitSourceRoot", {
+	enumerable: true,
+	get: function() {
+		return nativeKitSourceRoot;
+	}
+});
+Object.defineProperty(exports, "nativePackageLocator", {
+	enumerable: true,
+	get: function() {
+		return nativePackageLocator;
+	}
+});
+Object.defineProperty(exports, "nextImageAssetClassification", {
+	enumerable: true,
+	get: function() {
+		return nextImageAssetClassification;
+	}
+});
 Object.defineProperty(exports, "noKitFilesDiagnostics", {
 	enumerable: true,
 	get: function() {
 		return noKitFilesDiagnostics;
 	}
 });
+Object.defineProperty(exports, "noOutputTargets", {
+	enumerable: true,
+	get: function() {
+		return noOutputTargets;
+	}
+});
+Object.defineProperty(exports, "outputExclusion", {
+	enumerable: true,
+	get: function() {
+		return outputExclusion;
+	}
+});
+Object.defineProperty(exports, "outputExclusions", {
+	enumerable: true,
+	get: function() {
+		return outputExclusions;
+	}
+});
+Object.defineProperty(exports, "outputSourceGuard", {
+	enumerable: true,
+	get: function() {
+		return outputSourceGuard;
+	}
+});
+Object.defineProperty(exports, "outputSourceMessage", {
+	enumerable: true,
+	get: function() {
+		return outputSourceMessage;
+	}
+});
+Object.defineProperty(exports, "packageInstanceFinding", {
+	enumerable: true,
+	get: function() {
+		return packageInstanceFinding;
+	}
+});
+Object.defineProperty(exports, "packageReadRecord", {
+	enumerable: true,
+	get: function() {
+		return packageReadRecord;
+	}
+});
 Object.defineProperty(exports, "parseFilesJson", {
 	enumerable: true,
 	get: function() {
@@ -5492,12 +7196,24 @@ Object.defineProperty(exports, "preprocessMdx", {
 		return preprocessMdx;
 	}
 });
+Object.defineProperty(exports, "probeAbsolutePathSpecifier", {
+	enumerable: true,
+	get: function() {
+		return probeAbsolutePathSpecifier;
+	}
+});
 Object.defineProperty(exports, "projectExternalFileOwners", {
 	enumerable: true,
 	get: function() {
 		return projectExternalFileOwners;
 	}
 });
+Object.defineProperty(exports, "pruneStaleAssets", {
+	enumerable: true,
+	get: function() {
+		return pruneStaleAssets;
+	}
+});
 Object.defineProperty(exports, "readKitDescriptor", {
 	enumerable: true,
 	get: function() {
@@ -5516,12 +7232,6 @@ Object.defineProperty(exports, "reportSurvivingAssetPlaceholders", {
 		return reportSurvivingAssetPlaceholders;
 	}
 });
-Object.defineProperty(exports, "resolveAbsolutePathSpecifier", {
-	enumerable: true,
-	get: function() {
-		return resolveAbsolutePathSpecifier;
-	}
-});
 Object.defineProperty(exports, "resolveAssetFile", {
 	enumerable: true,
 	get: function() {
@@ -5552,6 +7262,18 @@ Object.defineProperty(exports, "resolveVerbosity", {
 		return resolveVerbosity;
 	}
 });
+Object.defineProperty(exports, "rollupExtensionPolicy", {
+	enumerable: true,
+	get: function() {
+		return rollupExtensionPolicy;
+	}
+});
+Object.defineProperty(exports, "rollupOutputTargets", {
+	enumerable: true,
+	get: function() {
+		return rollupOutputTargets;
+	}
+});
 Object.defineProperty(exports, "runProjectAnalysis", {
 	enumerable: true,
 	get: function() {
@@ -5570,6 +7292,18 @@ Object.defineProperty(exports, "serializeStaticCss", {
 		return serializeStaticCss;
 	}
 });
+Object.defineProperty(exports, "servedFiles", {
+	enumerable: true,
+	get: function() {
+		return servedFiles;
+	}
+});
+Object.defineProperty(exports, "severityFor", {
+	enumerable: true,
+	get: function() {
+		return severityFor;
+	}
+});
 Object.defineProperty(exports, "sharesVolumeRoot", {
 	enumerable: true,
 	get: function() {
@@ -5624,18 +7358,48 @@ Object.defineProperty(exports, "surfaceManifestDiagnostics", {
 		return surfaceManifestDiagnostics;
 	}
 });
+Object.defineProperty(exports, "systemKitDependencies", {
+	enumerable: true,
+	get: function() {
+		return systemKitDependencies;
+	}
+});
 Object.defineProperty(exports, "systemLoadDiagnostics", {
 	enumerable: true,
 	get: function() {
 		return systemLoadDiagnostics;
 	}
 });
+Object.defineProperty(exports, "systemLoadReads", {
+	enumerable: true,
+	get: function() {
+		return systemLoadReads;
+	}
+});
 Object.defineProperty(exports, "toWatchKeys", {
 	enumerable: true,
 	get: function() {
 		return toWatchKeys;
 	}
 });
+Object.defineProperty(exports, "tsconfigChainPaths", {
+	enumerable: true,
+	get: function() {
+		return tsconfigChainPaths;
+	}
+});
+Object.defineProperty(exports, "turbopackExtensionPolicy", {
+	enumerable: true,
+	get: function() {
+		return turbopackExtensionPolicy;
+	}
+});
+Object.defineProperty(exports, "unmatchedExcludeLines", {
+	enumerable: true,
+	get: function() {
+		return unmatchedExcludeLines;
+	}
+});
 Object.defineProperty(exports, "unreadableSourceDiagnostic", {
 	enumerable: true,
 	get: function() {
@@ -5648,16 +7412,40 @@ Object.defineProperty(exports, "unresolvableIncludesMessage", {
 		return unresolvableIncludesMessage;
 	}
 });
-Object.defineProperty(exports, "unresolvedParentName", {
+Object.defineProperty(exports, "validateLayerOrder", {
 	enumerable: true,
 	get: function() {
-		return unresolvedParentName;
+		return validateLayerOrder;
 	}
 });
-Object.defineProperty(exports, "validateLayerOrder", {
+Object.defineProperty(exports, "viteAssetClassification", {
 	enumerable: true,
 	get: function() {
-		return validateLayerOrder;
+		return viteAssetClassification;
+	}
+});
+Object.defineProperty(exports, "viteExtensionPolicy", {
+	enumerable: true,
+	get: function() {
+		return viteExtensionPolicy;
+	}
+});
+Object.defineProperty(exports, "viteHostExpander", {
+	enumerable: true,
+	get: function() {
+		return viteHostExpander;
+	}
+});
+Object.defineProperty(exports, "viteLoadExpander", {
+	enumerable: true,
+	get: function() {
+		return viteLoadExpander;
+	}
+});
+Object.defineProperty(exports, "viteOutputTargets", {
+	enumerable: true,
+	get: function() {
+		return viteOutputTargets;
 	}
 });
 Object.defineProperty(exports, "vocabularyWitnessDiagnostics", {
@@ -5672,3 +7460,33 @@ Object.defineProperty(exports, "walkPackageSources", {
 		return walkPackageSources;
 	}
 });
+Object.defineProperty(exports, "webpackExtensionPolicy", {
+	enumerable: true,
+	get: function() {
+		return webpackExtensionPolicy;
+	}
+});
+Object.defineProperty(exports, "webpackHostExpander", {
+	enumerable: true,
+	get: function() {
+		return webpackHostExpander;
+	}
+});
+Object.defineProperty(exports, "webpackLoadExpander", {
+	enumerable: true,
+	get: function() {
+		return webpackLoadExpander;
+	}
+});
+Object.defineProperty(exports, "webpackOutputTargets", {
+	enumerable: true,
+	get: function() {
+		return webpackOutputTargets;
+	}
+});
+Object.defineProperty(exports, "writeAssetCopy", {
+	enumerable: true,
+	get: function() {
+		return writeAssetCopy;
+	}
+});