@animus-ui/extract 0.1.9 → 0.1.11

package/dist/pipeline-lkbOoyAr.mjs

@@ -0,0 +1,3228 @@
+import { createRequire } from "node:module";
+import { createHash } from "crypto";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "fs";
+import { dirname, extname, isAbsolute, join, relative, resolve } from "path";
+import { realpathSync as realpathSync$1 } from "node:fs";
+import path, { basename as basename$1, dirname as dirname$1, join as join$1, normalize, posix } from "node:path";
+import { createRequire as createRequire$1 } from "module";
+import browserslist from "browserslist";
+import { browserslistToTargets, transform } from "lightningcss";
+import { isUnitlessProperty } from "@animus-ui/properties";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region pipeline/assemble-stylesheet.ts
+/**
+* The 7 Animus cascade layers. Always prefixed with `anm-` to avoid
+* collision with other frameworks' layer names (e.g., Tailwind's `base`).
+*/
+const ANIMUS_LAYERS = [
+	"anm-global",
+	"anm-base",
+	"anm-variants",
+	"anm-compounds",
+	"anm-states",
+	"anm-system",
+	"anm-custom"
+];
+/**
+* Build the `@layer` declaration line.
+*
+* When `isCustom` is false (default layers), uses ANIMUS_LAYERS directly.
+* When `isCustom` is true, passes names through as-is — the consumer already
+* wrote the final names including the `anm-` prefixed entries.
+*/
+function buildLayerDeclaration(layers, isCustom) {
+	return `@layer ${(isCustom ? layers : [...ANIMUS_LAYERS]).join(", ")};\n`;
+}
+/**
+* Validate that a consumer `layers` array contains all 7 Animus layers
+* in the correct relative order. Consumer layers may be interleaved.
+*
+* @throws Error with descriptive message on violation
+*/
+function validateLayerOrder(layers) {
+	const expected = [...ANIMUS_LAYERS];
+	let cursor = 0;
+	for (const layer of layers) if (cursor < expected.length && layer === expected[cursor]) cursor++;
+	if (cursor < expected.length) {
+		const missing = expected.slice(cursor);
+		const found = expected.slice(0, cursor);
+		if (!expected.every((l) => layers.includes(l))) {
+			const absent = expected.filter((l) => !layers.includes(l));
+			throw new Error(`[animus-extract] Custom layers missing required layers: ${absent.join(", ")}. All 7 Animus layers must be present: ${expected.join(", ")}`);
+		}
+		throw new Error(`[animus-extract] Custom layers have wrong order. Found ${found.join(", ")} but then expected ${missing[0]}. Required order: (${expected.join(" < ")}). You may interleave custom layers but must preserve this subsequence.`);
+	}
+}
+/**
+* Strip a leading `@layer ...;` declaration line from CSS if present.
+* The Rust crate embeds this in prod-mode output; we strip it so the
+* shared assembler controls placement.
+*/
+function stripLeadingLayerDeclaration(css) {
+	return css.replace(/^@layer\s+[^;{]+;\s*\n?/, "");
+}
+function assembleStylesheet(options) {
+	const hasCustomLayers = !!options.layers;
+	const layers = options.layers ?? ANIMUS_LAYERS;
+	if (options.layers) validateLayerOrder(options.layers);
+	const declaration = buildLayerDeclaration(layers, hasCustomLayers);
+	const variables = options.variableCss || "";
+	const componentCss = options.componentCss ? stripLeadingLayerDeclaration(options.componentCss) : "";
+	const body = [options.globalCss || "", componentCss].filter(Boolean).join("\n");
+	if (options.split) return {
+		declaration,
+		variables,
+		body
+	};
+	return [
+		declaration,
+		variables,
+		body
+	].filter(Boolean).join("\n");
+}
+//#endregion
+//#region pipeline/analyze-project-args.ts
+/** @internal */
+function buildAnalyzeProjectArgs(inputs) {
+	return [
+		inputs.filesJson,
+		inputs.scalesJson,
+		inputs.variableMapJson,
+		inputs.contextualVarsJson,
+		inputs.propConfigJson,
+		inputs.groupRegistryJson,
+		inputs.packageResolutionJson,
+		inputs.devMode,
+		inputs.emitterConfigJson,
+		inputs.selectorAliasesJson,
+		null,
+		inputs.globalStyleBlocksJson,
+		inputs.pathAliasesJson,
+		inputs.keyframesJson,
+		inputs.staticCssJson,
+		inputs.conditionAliasesJson,
+		inputs.externalDirsJson,
+		inputs.transformSourcesJson
+	];
+}
+//#endregion
+//#region pipeline/engine-adapter.ts
+/**
+* Build the engine-agnostic `engineApi()` both plugins call. Returns a function
+* (invoked per call site) so `isV2()` and `loadNativeEngine()` re-evaluate each
+* time — next reads its engine choice and native module dynamically from
+* globalThis.
+*/
+function createV2EngineApi(deps) {
+	const { label, isV2, loadNativeEngine, store } = deps;
+	return () => {
+		if (!isV2()) return loadNativeEngine();
+		const native = loadNativeEngine();
+		return {
+			loadSystemModule: (...args) => native.loadSystemModule(...args),
+			scanKeyframesExports: (entryPath, rootDir) => native.scanKeyframesExports(entryPath, rootDir) ?? null,
+			extractFacts: (filesJson) => native.extractFacts(filesJson),
+			analyzeProject: (filesJsonRaw, scalesJson, variableMapJson, contextualVarsJson, propConfigJson, groupRegistryJson, packageResolutionJson, devMode, emitterConfigJson, selectorAliasesJson, _selectorOrderJson, globalStyleBlocksJson, pathAliasesJson, keyframesJson, staticCssJson, conditionAliasesJson, externalDirsJson, transformSourcesJson) => {
+				const filesJson = deps.rehydrateFilesJson ? deps.rehydrateFilesJson(filesJsonRaw) : filesJsonRaw;
+				const sent = /* @__PURE__ */ new Map();
+				for (const entry of JSON.parse(filesJson)) sent.set(entry.path, entry.source);
+				store.setSentSources(sent);
+				const emitterConfig = emitterConfigJson ? JSON.parse(emitterConfigJson) : {};
+				store.setEngine(null);
+				const config = {
+					runtimeImport: emitterConfig.runtime_import ?? void 0,
+					cssModuleId: emitterConfig.css_module_id ?? void 0,
+					systemPropsModuleId: emitterConfig.system_props_module_id ?? void 0,
+					themeJson: scalesJson,
+					variableMapJson,
+					contextualVarsJson: contextualVarsJson ?? void 0,
+					configJson: propConfigJson,
+					groupRegistryJson,
+					selectorAliasesJson: selectorAliasesJson ?? void 0,
+					conditionAliasesJson: conditionAliasesJson ?? void 0,
+					globalStyleBlocksJson: globalStyleBlocksJson ?? void 0,
+					keyframesJson: keyframesJson ?? void 0,
+					packageResolutionJson: packageResolutionJson ?? void 0,
+					pathAliasesJson: pathAliasesJson ?? void 0,
+					staticCssJson: staticCssJson ?? void 0,
+					externalDirsJson: externalDirsJson ?? void 0,
+					transformSourcesJson: transformSourcesJson ?? void 0,
+					devMode
+				};
+				const engine = new native.ExtractEngine(config);
+				store.setEngine(engine);
+				return engine.analyze(filesJson);
+			},
+			transformFile: (source, path, _manifest) => {
+				const engine = store.getEngine();
+				if (!engine) throw new Error(`[${label}] v2 transform before analyze — engine instance not initialized`);
+				const sentMap = store.getSentSources();
+				if (deps.passThroughUnknownPaths && sentMap && !sentMap.has(path)) return {
+					code: source,
+					hasComponents: false
+				};
+				const sent = sentMap?.get(path);
+				if (sent !== void 0 && sent !== source && !store.getDriftWarned()) {
+					store.setDriftWarned(true);
+					console.warn(`[${label}] v2: transform-time source for ${path} differs from analyze-time source — an upstream transform may be reverted`);
+				}
+				return JSON.parse(engine.transformFile(path));
+			},
+			clearAnalysisCache: () => {
+				const engine = store.getEngine();
+				if (engine) engine.clearCache();
+				store.setEngine(null);
+			}
+		};
+	};
+}
+//#endregion
+//#region pipeline/engine-retirement.ts
+/**
+* Loud rejection of the retired v1 extraction engine (openspec:
+* retire-extract-v1).
+*
+* v2 is the only engine. Selecting v1 — via a plugin `engine: 'v1'` option or
+* the `ANIMUS_ENGINE=v1` fixture env override — is a build-stopping error, never
+* a silent upgrade to v2 (design D1: a silent flip would let a pinned consumer's
+* build change engines without notice). Both extraction plugins call this before
+* any engine selection so the rejection is uniform and the message is defined
+* once.
+*/
+/** The one canonical retirement message, shared verbatim by both plugins and
+*  the env path (tasks.md cross-cutting: define once, reuse). */
+const RETIRED_ENGINE_MESSAGE = "animus: extraction engine 'v1' was retired (openspec: retire-extract-v1) — v2 is the only engine; remove the engine option / ANIMUS_ENGINE override";
+/**
+* Throw the canonical retirement error when v1 is selected through either
+* surface. Accepts the raw engine option as a string because the option type no
+* longer admits `'v1'` — callers cast it so a stale `'v1'` config still fails
+* loud at runtime instead of being silently coerced.
+*/
+function assertNoRetiredEngineSelection(engineOption) {
+	if (engineOption === "v1" || process.env.ANIMUS_ENGINE === "v1") throw new Error(RETIRED_ENGINE_MESSAGE);
+}
+//#endregion
+//#region pipeline/content-hash.ts
+/**
+* MD5 content hash used for file-change detection (HMR diffing) by both
+* extraction plugins, and for content-addressing copied asset bytes. The
+* algorithm/encoding is a cross-plugin contract: cache keys written by one
+* build path must compare equal in the next. Accepts a Buffer directly so
+* binary sources hash without an intermediate string copy.
+*/
+function contentHash(source) {
+	return createHash("md5").update(source).digest("hex");
+}
+//#endregion
+//#region pipeline/external-keyframes.ts
+/** Stable codes for external keyframes discovery. */
+const KEYFRAMES_EXTERNAL_ENTRY_FAILED = "animus.keyframes.external-entry-failed";
+const KEYFRAMES_EXPORT_COLLISION = "animus.keyframes.export-collision";
+/**
+* Merge `Keyframes` collections discovered from external package entries into
+* the consumer system's collections. Keyframes are the sole carve-out from
+* the consumer-config singular-authority rule: nothing but branded
+* collections is read from an entry, an entry that fails to evaluate
+* degrades to a coded diagnostic naming it, and a collection whose export
+* name collides keeps the earlier (consumer-first) collection with a coded
+* diagnostic instead of silently reordering names.
+*/
+function mergeExternalKeyframes(scan, consumerKeyframesJson, externalEntries, rootDir) {
+	const merged = {};
+	if (consumerKeyframesJson) try {
+		Object.assign(merged, JSON.parse(consumerKeyframesJson));
+	} catch {
+		return {
+			keyframesJson: consumerKeyframesJson,
+			diagnostics: []
+		};
+	}
+	const diagnostics = [];
+	const seenEntries = /* @__PURE__ */ new Set();
+	for (const entryPath of externalEntries) {
+		if (seenEntries.has(entryPath)) continue;
+		seenEntries.add(entryPath);
+		let scanned;
+		try {
+			scanned = scan(entryPath, rootDir);
+		} catch (error) {
+			diagnostics.push({
+				file: entryPath,
+				component: "keyframes",
+				kind: "warn",
+				message: `external package entry failed the keyframes scan — its collections are invisible to extraction: ${String(error)}. Keyframe collections must be reachable from the package's definition entry without evaluating framework re-exports: export them (directly or as a named re-export) from the definition entry, and avoid \`export *\` of framework packages there (${KEYFRAMES_EXTERNAL_ENTRY_FAILED})`,
+				code: KEYFRAMES_EXTERNAL_ENTRY_FAILED,
+				severity: "warn"
+			});
+			continue;
+		}
+		if (!scanned) continue;
+		let collections;
+		try {
+			collections = JSON.parse(scanned);
+		} catch {
+			continue;
+		}
+		for (const [exportName, collection] of Object.entries(collections)) {
+			const existing = merged[exportName];
+			if (existing !== void 0) {
+				if (JSON.stringify(existing) !== JSON.stringify(collection)) diagnostics.push({
+					file: entryPath,
+					component: exportName,
+					kind: "warn",
+					message: `keyframes collection export '${exportName}' collides with an earlier collection of the same name — the earlier one wins (${KEYFRAMES_EXPORT_COLLISION})`,
+					code: KEYFRAMES_EXPORT_COLLISION,
+					severity: "warn"
+				});
+				continue;
+			}
+			merged[exportName] = collection;
+		}
+	}
+	return {
+		keyframesJson: Object.keys(merged).length > 0 ? JSON.stringify(merged) : null,
+		diagnostics
+	};
+}
+//#endregion
+//#region pipeline/core-options.ts
+/** Closed set of driver namespaces a shared config file may carry. */
+const DRIVER_NAMESPACES = [
+	"vite",
+	"next",
+	"cli"
+];
+/**
+* Structural exclusions applied unconditionally, whether or not the user
+* supplies an `exclude` list. `node_modules` is owned by the external-package
+* collection path (never the source walk), and `.next`/`.animus` are artifact
+* output directories inside the scanned root that must never be re-ingested
+* as source.
+*/
+const STRUCTURAL_EXCLUDE = [
+	"node_modules",
+	".next",
+	".animus"
+];
+/**
+* Convenience defaults applied only when the user supplies no `exclude`
+* list — a user list replaces these (but never the structural set).
+*/
+const REPLACEABLE_DEFAULT_EXCLUDE = [
+	"dist",
+	".test.",
+	".spec."
+];
+/**
+* Default path patterns excluded from source discovery — the single
+* authoritative set for every driver when no user `exclude` is given.
+* Composed, never hand-listed: a structural addition must not silently
+* miss this union.
+*/
+const DEFAULT_EXCLUDE = [...STRUCTURAL_EXCLUDE, ...REPLACEABLE_DEFAULT_EXCLUDE];
+/** Core keys accepted at the top level of any driver's options. */
+const CORE_OPTION_KEYS = new Set([
+	"system",
+	"exclude",
+	"extensions",
+	"strict",
+	"verbose",
+	"prefix",
+	"targets",
+	"minify",
+	"staticCss",
+	"layers",
+	"engine",
+	"mode",
+	"root"
+]);
+/** Configuration errors carry a stable name so drivers can map them to
+*  their config-error surface (the CLI's exit code 2). */
+var AnimusConfigError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AnimusConfigError";
+	}
+};
+/**
+* Reject unknown top-level option keys and invalid core values. `ownKeys`
+* is the calling driver's legacy/driver-specific top-level surface (e.g.
+* Vite's `verify`, Next's `cssImportTarget`); driver namespaces are always
+* legal and inert for non-owning drivers. `rejectKeys` names core keys the
+* calling driver does NOT honor — accepting-and-ignoring a key the
+* validator vouches for is the exact silent failure this seam exists to
+* kill, so the driver must reject it with its reason (or, in `'warn'`
+* mode, name it loudly while the key stays inert as it always was).
+*/
+function assertKnownOptionKeys(raw, ownKeys = [], rejectKeys = [], opts = {}) {
+	const surface = (message) => {
+		if (opts.onUnknownKey === "warn") {
+			opts.warn(message);
+			return;
+		}
+		throw new AnimusConfigError(message);
+	};
+	const own = new Set(ownKeys);
+	for (const key of Object.keys(raw)) {
+		if (raw[key] === void 0) continue;
+		const rejected = rejectKeys.find((entry) => entry.key === key);
+		if (rejected) {
+			surface(`Option "${key}" is not supported by this driver: ${rejected.reason}`);
+			continue;
+		}
+		if (CORE_OPTION_KEYS.has(key) || DRIVER_NAMESPACES.includes(key) || own.has(key)) continue;
+		const nearest = suggestNearest(key);
+		surface(`Unknown option "${key}".${nearest ? ` Did you mean "${nearest}"?` : ""} Core keys: ${[...CORE_OPTION_KEYS].join(", ")}. Driver namespaces: ${DRIVER_NAMESPACES.join(", ")}.`);
+	}
+	const mode = raw["mode"];
+	if (mode !== void 0 && mode !== "development" && mode !== "production") throw new AnimusConfigError(`Invalid mode "${String(mode)}" — expected "development" or "production".`);
+	for (const { key, ok, expected } of CORE_VALUE_GATES) {
+		const value = raw[key];
+		if (value === void 0 || ok(value)) continue;
+		throw new AnimusConfigError(`Invalid value for "${key}" — expected ${expected}, got ${JSON.stringify(value)}.`);
+	}
+}
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+const CORE_VALUE_GATES = [
+	{
+		key: "system",
+		ok: (v) => typeof v === "string",
+		expected: "a string path"
+	},
+	{
+		key: "exclude",
+		ok: isStringArray,
+		expected: "an array of string patterns"
+	},
+	{
+		key: "extensions",
+		ok: isStringArray,
+		expected: "an array of string extensions"
+	},
+	{
+		key: "strict",
+		ok: (v) => typeof v === "boolean",
+		expected: "a boolean"
+	},
+	{
+		key: "verbose",
+		ok: (v) => typeof v === "boolean",
+		expected: "a boolean"
+	},
+	{
+		key: "minify",
+		ok: (v) => typeof v === "boolean",
+		expected: "a boolean"
+	},
+	{
+		key: "prefix",
+		ok: (v) => typeof v === "string",
+		expected: "a string"
+	},
+	{
+		key: "targets",
+		ok: (v) => typeof v === "string" || isStringArray(v),
+		expected: "a string or an array of strings"
+	},
+	{
+		key: "layers",
+		ok: isStringArray,
+		expected: "an array of layer names"
+	}
+];
+function suggestNearest(key) {
+	const lower = key.toLowerCase();
+	let best = null;
+	let bestScore = 3;
+	for (const candidate of CORE_OPTION_KEYS) {
+		const score = editDistance(lower, candidate.toLowerCase());
+		if (score < bestScore) {
+			bestScore = score;
+			best = candidate;
+		}
+	}
+	return best;
+}
+function editDistance(a, b) {
+	const dp = Array.from({ length: a.length + 1 }, (_, i) => [i]);
+	for (let j = 1; j <= b.length; j++) dp[0][j] = j;
+	for (let i = 1; i <= a.length; i++) for (let j = 1; j <= b.length; j++) dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+	return dp[a.length][b.length];
+}
+const GLOB_META = /[*?]/;
+/**
+* Compile one exclusion pattern. Glob patterns (containing `*` or `?`)
+* compile to a RegExp over the slash-normalized root-relative path — a
+* match on the path itself OR any ancestor directory excludes it, so a
+* directory-shaped glob (double-star slash "generated") excludes files
+* inside that directory identically for tree discovery (which prunes at
+* the directory) and per-file watch classification (which only ever sees
+* file paths).
+* Plain patterns keep the historical substring semantics over both path
+* forms.
+* A leading `./` is stripped first: relative paths are computed without
+* one, so `./fixtures/**` must mean exactly `fixtures/**` rather than
+* compiling to a regex that can never match.
+*/
+function compilePattern(raw) {
+	let pattern = raw.split("\\").join("/");
+	while (pattern.startsWith("./")) pattern = pattern.slice(2);
+	if (pattern === "") return () => false;
+	if (!GLOB_META.test(pattern)) return (full, rel) => full.includes(pattern) || rel.includes(pattern);
+	const regex = globToRegExp(pattern);
+	return (_full, rel) => {
+		const normalized = rel.split("\\").join("/");
+		if (regex.test(normalized)) return true;
+		for (let slash = normalized.indexOf("/"); slash !== -1; slash = normalized.indexOf("/", slash + 1)) if (regex.test(normalized.slice(0, slash))) return true;
+		return false;
+	};
+}
+/** Minimal glob → RegExp: `**` spans segments, `*`/`?` stay within one. */
+function globToRegExp(glob) {
+	let out = "";
+	let i = 0;
+	const normalized = glob.split("\\").join("/");
+	while (i < normalized.length) {
+		const ch = normalized[i];
+		if (ch === "*") if (normalized[i + 1] === "*") if (normalized[i + 2] === "/") {
+			out += "(?:[^/]+/)*";
+			i += 3;
+		} else {
+			out += ".*";
+			i += 2;
+		}
+		else {
+			out += "[^/]*";
+			i += 1;
+		}
+		else if (ch === "?") {
+			out += "[^/]";
+			i += 1;
+		} else {
+			out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+			i += 1;
+		}
+	}
+	return new RegExp(`^${out}$`);
+}
+/**
+* Build the effective exclusion matcher. A user list REPLACES the
+* replaceable defaults (`dist`, `.test.`, `.spec.`) — the HEAD driver
+* contract (`options.exclude ?? DEFAULT_EXCLUDE`) — while the structural
+* exclusions (`node_modules`, `.next`, `.animus`) always apply: those
+* protect pipeline invariants, not preferences, so no user list can
+* re-admit them. `extraStructural` joins that never-replaceable set — the
+* channel for driver-owned invariants (a CLI outDir inside the root),
+* which must NOT ride the user list: appending there would flip the
+* replace semantics and silently drop the replaceable defaults.
+*/
+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]));
+	const explain = (full, rel) => {
+		for (const [pattern, test] of compiled) if (test(full, rel)) {
+			hits.set(pattern, (hits.get(pattern) ?? 0) + 1);
+			return pattern;
+		}
+		return null;
+	};
+	return {
+		patterns: merged,
+		matches: (full, rel) => explain(full, rel) !== null,
+		explain,
+		stats: () => hits
+	};
+}
+/**
+* Resolve the effective mode: the explicit `mode` key wins over every
+* environment-derived signal; otherwise the driver's documented default
+* applies.
+*/
+function resolveMode(explicit, driverDefault) {
+	if (explicit === "development" || explicit === "production") return {
+		mode: explicit,
+		provenance: "explicit"
+	};
+	return {
+		mode: driverDefault(),
+		provenance: "driver-default"
+	};
+}
+//#endregion
+//#region pipeline/discover-files.ts
+/**
+* Recursively discover source files under `dir`, skipping excluded paths
+* (an `ExcludeMatcher` — see core-options, the one pattern authority — or
+* undefined for NO exclusion at all: the dist-package walks deliberately
+* run under node_modules, which `createExcludeMatcher`'s structural set
+* would prune) and keeping files whose extension is in `extensionsSet`.
+*
+* Single authoritative copy for both extraction plugins.
+*/
+function discoverFiles(dir, rootDir, exclude, extensionsSet) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir, { encoding: "utf8" });
+	} catch {
+		return results;
+	}
+	entries.sort();
+	const isExcluded = exclude ? (full, rel) => exclude.matches(full, rel) : () => false;
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		if (isExcluded(fullPath, relative(rootDir, fullPath))) continue;
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, exclude, extensionsSet));
+		else if (extensionsSet.has(extname(entry))) results.push(fullPath);
+	}
+	return results;
+}
+//#endregion
+//#region pipeline/source-identity.ts
+/**
+* SourceId derivation authority + allowlist membership (openspec:
+* external-source-watch-ingestion, design D1/D2/D5).
+*
+* One shared derivation produces the canonical source identity consumed by
+* discovery, watch ingestion, ownership, deletion pruning, and diagnostics
+* — raw event paths are lookup INPUTS only, so event spelling (symlink
+* alias vs canonical, lexical vs realpath) can never fork identity.
+*
+* The containment and volume helpers are pure and path-API-injectable so
+* Windows semantics are unit-testable via `path.win32` on any host; runtime
+* callers use the ambient platform implementation.
+*/
+/**
+* Structural containment: `target` is the root itself or a descendant of it,
+* decided by `relative()` shape — never by string prefixing, so `/ui` can
+* never claim `/ui-old`, and a cross-drive win32 target (whose relative()
+* result is absolute) is never contained.
+*/
+function isPathWithinRoot(root, target, pathApi = path) {
+	const rel = pathApi.relative(root, target);
+	return rel === "" || !pathApi.isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + pathApi.sep);
+}
+/**
+* Cross-volume gate (design D5): two paths share a platform path root
+* (win32 drive letter or UNC share; always true on posix). Compared
+* case-insensitively — win32 drive letters are case-insensitive.
+*/
+function sharesVolumeRoot(a, b, pathApi = path) {
+	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
+	return volumeOf(a) === volumeOf(b);
+}
+function canonicalize(p) {
+	try {
+		return realpathSync$1(p);
+	} catch {
+		return null;
+	}
+}
+function createSourceIdentity(rootDir) {
+	const normalizedRootDir = path.normalize(rootDir);
+	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
+	const roots = [];
+	const aliases = /* @__PURE__ */ new Map();
+	const owningRecord = (canonicalPath) => {
+		let owner = null;
+		for (const record of roots) {
+			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
+			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+		}
+		return owner;
+	};
+	return {
+		rootDir: normalizedRootDir,
+		canonicalRootDir,
+		registerExternalRoot(root) {
+			const asRegistered = path.normalize(root);
+			const canonical = canonicalize(asRegistered) ?? asRegistered;
+			const existing = roots.find((record) => record.canonical === canonical);
+			if (existing) return existing.canonical;
+			roots.push({
+				asRegistered,
+				canonical
+			});
+			return canonical;
+		},
+		externalRoots() {
+			return roots.map((record) => record.canonical);
+		},
+		resolveSourceId(inputPath) {
+			const lexical = path.normalize(inputPath);
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			const owner = owningRecord(canonical);
+			const ownedBy = (record) => {
+				const pathInRoot = path.relative(record.canonical, canonical);
+				return {
+					sourceKey: path.relative(normalizedRootDir, path.join(record.asRegistered, pathInRoot)),
+					owningRoot: record.canonical,
+					pathInRoot
+				};
+			};
+			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
+			let resolved;
+			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
+				const key = path.relative(canonicalRootDir, canonical);
+				resolved = {
+					sourceKey: key,
+					owningRoot: null,
+					pathInRoot: key
+				};
+			} else if (owner) resolved = ownedBy(owner);
+			else return null;
+			aliases.set(lexical, resolved);
+			aliases.set(canonical, resolved);
+			return resolved;
+		},
+		resolveDeletedSourceId(inputPath) {
+			return aliases.get(path.normalize(inputPath)) ?? null;
+		},
+		containingExternalRoot(inputPath) {
+			const lexical = path.normalize(inputPath);
+			let owner = null;
+			for (const record of roots) {
+				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			if (owner) return owner.canonical;
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			for (const record of roots) {
+				if (!isPathWithinRoot(record.canonical, canonical)) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			return owner?.canonical ?? null;
+		}
+	};
+}
+//#endregion
+//#region pipeline/discover-packages.ts
+/**
+* Walk up from a resolved package entry file to the nearest directory
+* containing a package.json (the package root). Stops at the filesystem
+* root and returns it if no package.json is found on the way up.
+*/
+function findPackageRoot(absEntryPath) {
+	let pkgRoot = dirname(absEntryPath);
+	while (pkgRoot !== dirname(pkgRoot) && !existsSync(join(pkgRoot, "package.json"))) pkgRoot = dirname(pkgRoot);
+	return pkgRoot;
+}
+/**
+* Exclusion fragments for discovery inside an external package's src/,
+* matched against paths RELATIVE TO the src dir. Per spec
+* external-package-file-discovery, the filters apply "within the package" —
+* an npm-installed package whose own location is under node_modules (or a
+* repo path containing 'dist') must still have its sources discovered.
+*/
+const PACKAGE_SRC_EXCLUDES = [
+	"dist",
+	"node_modules",
+	".test.",
+	".spec."
+];
+/** True when a PACKAGE-RELATIVE path matches a package-source exclusion
+*  fragment (the "within the package" filter — see PACKAGE_SRC_EXCLUDES). */
+function isExcludedPackageRelativePath(rel) {
+	return PACKAGE_SRC_EXCLUDES.some((pattern) => rel.includes(pattern));
+}
+/**
+* THE package-source walk (guardrail G1 — one policy): shared discovery with
+* no consumer patterns, then exclusion by package-relative path so fragments
+* in the package's own location can't blank out its sources. Used by the
+* collector, hosts' dirty-root rewalks, and watch-path classification alike.
+*/
+function walkPackageSources(packageDir, extensionsSet) {
+	return discoverFiles(packageDir, packageDir, void 0, extensionsSet).filter((absPath) => !isExcludedPackageRelativePath(relative(packageDir, absPath)));
+}
+/** Exclusions for the compiled-output fallback when a package does not ship src/. */
+const PACKAGE_OUTPUT_EXCLUDES = [
+	"node_modules",
+	".test.",
+	".spec.",
+	".d.ts",
+	".map"
+];
+const isFile = (path) => {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+};
+/**
+* Resolve an absolute-path specifier (a relative `includes` entry already
+* resolved against the system file) without a bundler: the path itself when it
+* is a file, otherwise the extension and directory-index candidates built from
+* the caller's extension set. Used only as a fallback — a bundler resolver that
+* answers first still wins, since it also knows aliases and `.js`→`.ts` mapping.
+*/
+function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
+	return [
+		absSpecifier,
+		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
+		...Array.from(extensionsSet, (ext) => join(absSpecifier, `index${ext}`))
+	].find(isFile) ?? null;
+}
+/** The package-name half of a bare specifier (`@scope/name/sub` → `@scope/name`). */
+function bareSpecifierPackageName(specifier) {
+	const segments = specifier.split("/");
+	return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+}
+function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
+	if (isAbsolute(specifier)) {
+		const resolved = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		if (!resolved) return null;
+		return isPathWithinRoot(srcDir, resolved) ? resolved : null;
+	}
+	const packageName = bareSpecifierPackageName(specifier);
+	return resolveAbsolutePathSpecifier(join(srcDir, specifier.slice(packageName.length + 1) || "index"), extensionsSet);
+}
+/**
+* The D13 dist-freshness check: applicable only when a specifier has BOTH a
+* walked src/ tree and a resolved dist entry that exists on disk outside that
+* tree; stale when the dist entry's mtime is older than the newest walked
+* source file's. Not applicable (never stale) when the entry resolves inside
+* src/ (no dist to skew), when the entry file is missing, or when no source
+* file's mtime is readable. Detection only — reporting is the caller's policy.
+*/
+function distEntryIsStale(absEntry, srcDir, srcFiles) {
+	if (isPathWithinRoot(srcDir, absEntry)) return false;
+	let distMtime;
+	try {
+		distMtime = statSync(absEntry).mtimeMs;
+	} catch {
+		return false;
+	}
+	let newestSrcMtime = -Infinity;
+	for (const srcFile of srcFiles) try {
+		newestSrcMtime = Math.max(newestSrcMtime, statSync(srcFile).mtimeMs);
+	} catch {}
+	return distMtime < newestSrcMtime;
+}
+/**
+* Shared external-package source collection (spec:
+* external-package-file-discovery), consumed by both extraction plugins.
+* For each specifier: resolve to an absolute entry (null/throw → silently
+* skip; an absolute-path specifier falls back to a filesystem probe), walk up
+* to the package root, then either discover sources under src/ (redirecting
+* module resolution to src/index.ts when present) or fall back to ingesting
+* the resolved entry file itself.
+*
+* The only bundler-specific seams are callbacks: specifier resolution,
+* dedup against already-ingested files, per-file preprocessing (MDX), and
+* the unreadable-file warning. Hashing and caching stay in the plugins —
+* their cache policies legitimately differ.
+*
+* Alongside the aggregates, one `ExternalPackageOutcome` per declared
+* specifier records what that specifier produced. Collection never reports on
+* them — any warning or gate is the caller's policy.
+*/
+async function collectExternalPackageSources(opts) {
+	const { specifiers, resolveSpecifier, rootDir, extensionsSet, hasEntry, onSourceRead, onUnreadable, onPackageResolved } = opts;
+	const entries = [];
+	const pushed = /* @__PURE__ */ new Set();
+	const packageMap = {};
+	const sourceEntries = /* @__PURE__ */ new Map();
+	const keyframesScanEntries = /* @__PURE__ */ new Map();
+	const packageDirs = [];
+	const dirOwnerSets = {};
+	const dirExtensions = {};
+	const fileOwners = {};
+	const outcomes = [];
+	const claimDir = (dir, specifier) => {
+		(dirOwnerSets[dir] ??= []).push(specifier);
+	};
+	const alreadyIngested = (relPath) => hasEntry(relPath) || pushed.has(relPath);
+	for (const specifier of specifiers) {
+		let absEntry;
+		try {
+			absEntry = await resolveSpecifier(specifier);
+		} catch {
+			absEntry = null;
+		}
+		if (!absEntry && isAbsolute(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		if (!absEntry) {
+			outcomes.push({
+				specifier,
+				outcome: "unresolvable",
+				fileCount: 0
+			});
+			continue;
+		}
+		const srcDir = join(findPackageRoot(absEntry), "src");
+		let fileCount = 0;
+		let staleDist = false;
+		if (existsSync(srcDir)) {
+			packageDirs.push(srcDir);
+			claimDir(srcDir, specifier);
+			dirExtensions[srcDir] = [...extensionsSet];
+			onPackageResolved?.(specifier, srcDir);
+			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
+			if (srcEntry) {
+				packageMap[specifier] = relative(rootDir, srcEntry);
+				sourceEntries.set(specifier, srcEntry);
+			} else packageMap[specifier] = relative(rootDir, absEntry);
+			keyframesScanEntries.set(specifier, srcEntry ?? absEntry);
+			if (!isAbsolute(specifier)) {
+				const packageName = bareSpecifierPackageName(specifier);
+				if (packageName !== specifier && !(packageName in packageMap)) {
+					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
+					if (rootEntry) {
+						packageMap[packageName] = relative(rootDir, rootEntry);
+						sourceEntries.set(packageName, rootEntry);
+						keyframesScanEntries.set(packageName, rootEntry);
+					}
+				}
+			}
+			const pkgFiles = walkPackageSources(srcDir, extensionsSet);
+			staleDist = distEntryIsStale(absEntry, srcDir, pkgFiles);
+			for (const pkgFile of pkgFiles) {
+				const relPath = relative(rootDir, pkgFile);
+				if (alreadyIngested(relPath)) {
+					fileCount++;
+					continue;
+				}
+				let source;
+				try {
+					source = readFileSync(pkgFile, "utf-8");
+				} catch (err) {
+					onUnreadable(relPath, err);
+					continue;
+				}
+				onSourceRead?.(source, relPath, pkgFile);
+				entries.push({
+					path: relPath,
+					source
+				});
+				pushed.add(relPath);
+				fileOwners[relPath] ??= specifier;
+				fileCount++;
+			}
+		} else {
+			const outputDir = dirname(absEntry);
+			packageDirs.push(outputDir);
+			claimDir(outputDir, specifier);
+			onPackageResolved?.(specifier, outputDir);
+			packageMap[specifier] = relative(rootDir, absEntry);
+			keyframesScanEntries.set(specifier, absEntry);
+			const outputExtensions = new Set(extensionsSet);
+			outputExtensions.add(extname(absEntry));
+			dirExtensions[outputDir] = [...outputExtensions];
+			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
+				const relToOutput = relative(outputDir, file);
+				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
+			});
+			if (!outputFiles.includes(absEntry)) outputFiles.unshift(absEntry);
+			for (const outputFile of outputFiles) {
+				const outputRelPath = relative(rootDir, outputFile);
+				if (alreadyIngested(outputRelPath)) {
+					fileCount++;
+					continue;
+				}
+				let source;
+				try {
+					source = readFileSync(outputFile, "utf-8");
+				} catch (err) {
+					onUnreadable(outputRelPath, err);
+					continue;
+				}
+				onSourceRead?.(source, outputRelPath, outputFile);
+				entries.push({
+					path: outputRelPath,
+					source
+				});
+				pushed.add(outputRelPath);
+				fileOwners[outputRelPath] ??= specifier;
+				fileCount++;
+			}
+		}
+		outcomes.push({
+			specifier,
+			outcome: staleDist ? "stale-dist" : fileCount > 0 ? "resolved" : "empty",
+			fileCount
+		});
+	}
+	return {
+		entries,
+		packageMap,
+		sourceEntries,
+		keyframesScanEntries,
+		packageDirs,
+		dirOwnerSets,
+		dirExtensions,
+		fileOwners,
+		outcomes
+	};
+}
+/** First-declared specifier per package dir — the single-value ownership
+*  view correlation consumers key on, derived from `dirOwnerSets`. */
+function firstOwners(dirOwnerSets) {
+	const owners = {};
+	for (const [dir, specifiers] of Object.entries(dirOwnerSets)) if (specifiers.length > 0) owners[dir] = specifiers[0];
+	return owners;
+}
+/**
+* Excise a set of rejected specifiers from a collection result ATOMICALLY
+* (openspec: external-source-watch-ingestion, design D5): the returned copy
+* carries no entries, package-map targets, source entries, package dirs, or
+* ownership for the rejected packages — a package dir is removed only when
+* EVERY specifier that claimed it is rejected (a dir-level rejection, such
+* as the cross-volume gate, always rejects them together). Outcome records
+* are reporting inputs, not membership, and pass through untouched.
+*/
+function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
+	if (rejectedSpecifiers.size === 0) return collected;
+	const rejectedDirs = Object.entries(collected.dirOwnerSets).filter(([, specs]) => specs.every((s) => rejectedSpecifiers.has(s))).map(([dir]) => dir);
+	const underRejectedDir = (absPath) => rejectedDirs.some((dir) => isPathWithinRoot(dir, absPath));
+	const targetRejected = (specifier, absTarget) => rejectedSpecifiers.has(specifier) || underRejectedDir(absTarget);
+	const packageMap = {};
+	for (const [specifier, relTarget] of Object.entries(collected.packageMap)) {
+		if (targetRejected(specifier, resolve(rootDir, relTarget))) continue;
+		packageMap[specifier] = relTarget;
+	}
+	const sourceEntries = /* @__PURE__ */ new Map();
+	for (const [specifier, absEntry] of collected.sourceEntries) {
+		if (targetRejected(specifier, absEntry)) continue;
+		sourceEntries.set(specifier, absEntry);
+	}
+	const keyframesScanEntries = /* @__PURE__ */ new Map();
+	for (const [specifier, absEntry] of collected.keyframesScanEntries) {
+		if (targetRejected(specifier, absEntry)) continue;
+		keyframesScanEntries.set(specifier, absEntry);
+	}
+	const dirOwnerSets = {};
+	for (const [dir, specs] of Object.entries(collected.dirOwnerSets)) {
+		const kept = specs.filter((s) => !rejectedSpecifiers.has(s));
+		if (kept.length === 0) continue;
+		dirOwnerSets[dir] = kept;
+	}
+	const dirExtensions = {};
+	for (const [dir, exts] of Object.entries(collected.dirExtensions)) {
+		if (rejectedDirs.includes(dir)) continue;
+		dirExtensions[dir] = exts;
+	}
+	const fileOwners = {};
+	for (const [relPath, owner] of Object.entries(collected.fileOwners)) {
+		if (rejectedSpecifiers.has(owner)) continue;
+		fileOwners[relPath] = owner;
+	}
+	return {
+		entries: collected.entries.filter((entry) => !rejectedSpecifiers.has(collected.fileOwners[entry.path])),
+		packageMap,
+		sourceEntries,
+		keyframesScanEntries,
+		packageDirs: collected.packageDirs.filter((dir) => !rejectedDirs.includes(dir)),
+		dirOwnerSets,
+		dirExtensions,
+		fileOwners,
+		outcomes: collected.outcomes
+	};
+}
+/**
+* Extract external DS package names from inheritance declarations in the
+* system file.
+*
+* Supports four forms:
+*   - Primary:            `createSystem(...).extend(identifier)` chain calls
+*                         (repeatable, mixable with `.from()` links; each call
+*                         contributes one source; a library-bundle identifier
+*                         traces its base import)
+*   - Deprecated chain:   `createSystem(...).from(identifier)` chain calls
+*   - Deprecated alias:   `createSystem({ includes: [identifier, ...] })`
+*   - Legacy:             `.includes([identifier, ...])` chain method (RC
+*                         migration fallback)
+*
+* For each identifier found, traces back to its import declaration and returns
+* the import specifier: a bare specifier normalized to its package name, a
+* relative specifier resolved against the system file's directory into an
+* absolute path (so a sibling package referenced by path contributes discovery
+* too). Only packages explicitly declared through one of these forms are
+* treated as external DS dependencies.
+*
+* Falls back to empty array if no declaration is found.
+*/
+/**
+* The message for the strict/warn gate over unresolvable includes, or null
+* when every declared specifier resolved (external-package-file-discovery:
+* silence is never an outcome — non-strict consumers warn with this line,
+* strict consumers throw it).
+*/
+function unresolvableIncludesMessage(outcomes) {
+	const unresolvable = outcomes.filter((record) => record.outcome === "unresolvable").map((record) => record.specifier);
+	if (unresolvable.length === 0) return null;
+	return `[animus-extract] unresolvable include specifier(s): ${unresolvable.join(", ")}`;
+}
+/**
+* The message for the strict/warn gate over stale dist entries
+* (first-class-extension D13), or null when no declared specifier is stale.
+* A stale dist silently skews merged registry content while discovery
+* compiles the fresh sources, so it surfaces like an unresolvable specifier:
+* non-strict consumers warn with this line, strict consumers throw it.
+*/
+function staleDistIncludesMessage(outcomes) {
+	const stale = outcomes.filter((record) => record.outcome === "stale-dist").map((record) => record.specifier);
+	if (stale.length === 0) return null;
+	return `[animus-extract] stale dist for include specifier(s): ${stale.join(", ")} — dist entry is older than the newest src/ file; rebuild the package(s) before extracting`;
+}
+function extractSystemFilePackages(systemFilePath) {
+	let source;
+	try {
+		source = readFileSync(systemFilePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const identifiers = /* @__PURE__ */ new Set();
+	const constructorRegex = /createSystem\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);
+			}
+		}
+	};
+	collectIdentifiers(constructorRegex);
+	collectIdentifiers(chainRegex);
+	const IDENT_START_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*/;
+	/** Position after any run of whitespace, line comments, block comments. */
+	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;
+		}
+	};
+	/**
+	* Consume consecutive extend/from links starting at `from`, collecting
+	* each link's base identifier; tolerates trivia between tokens and a
+	* trailing comma in the argument list. Returns the position after the
+	* last consumed link (`from` itself when none matched).
+	*/
+	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] !== "(") 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;
+		}
+	};
+	/** Identifier assigned directly before `index` (`const x = <here>`), if any. */
+	const boundIdentifierBefore = (index) => {
+		const match = /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*$/.exec(source.slice(0, index));
+		return match ? match[1] : null;
+	};
+	const chainRootIdentifiers = /* @__PURE__ */ new Set();
+	const createSystemAnchor = /createSystem\s*\(/g;
+	let anchorMatch;
+	while ((anchorMatch = createSystemAnchor.exec(source)) !== 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);
+			}
+		}
+	}
+	if (identifiers.size === 0) return [];
+	const importMap = /* @__PURE__ */ new Map();
+	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;
+	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 systemFileDir = dirname(systemFilePath);
+	const packages = /* @__PURE__ */ new Set();
+	for (const id of identifiers) {
+		const specifier = importMap.get(id);
+		if (!specifier) continue;
+		if (specifier.startsWith(".")) packages.add(resolve(systemFileDir, specifier));
+		else packages.add(specifier);
+	}
+	return Array.from(packages);
+}
+//#endregion
+//#region pipeline/svelte-source-adapter.ts
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+function childNode(value) {
+	return isNode(value) ? value : null;
+}
+function nodeName(node) {
+	return node?.type === "Identifier" && typeof node.name === "string" ? node.name : null;
+}
+/** Adaptation touches one source at a time, so a last-value memo makes the
+*  all-ASCII check O(n) once per file instead of per span endpoint. */
+let asciiMemoSource = null;
+let asciiMemoValue = false;
+function isAsciiOnly(source) {
+	if (asciiMemoSource !== source) {
+		asciiMemoSource = source;
+		asciiMemoValue = Buffer.byteLength(source) === source.length;
+	}
+	return asciiMemoValue;
+}
+function byteOffset(source, characterOffset) {
+	if (isAsciiOnly(source)) return characterOffset;
+	return Buffer.byteLength(source.slice(0, characterOffset));
+}
+function byteSpan(source, node) {
+	return {
+		start: byteOffset(source, node.start),
+		end: byteOffset(source, node.end)
+	};
+}
+function sourcePosition(source, characterOffset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let index = 0; index < characterOffset; index += 1) {
+		const code = source.charCodeAt(index);
+		if (code === 13) {
+			if (index + 1 < characterOffset && source.charCodeAt(index + 1) === 10) index += 1;
+			line += 1;
+			lineStart = index + 1;
+		} else if (code === 10 || code === 8232 || code === 8233) {
+			line += 1;
+			lineStart = index + 1;
+		}
+	}
+	return {
+		line,
+		column: characterOffset - lineStart
+	};
+}
+function sourceLocation(source, node) {
+	return {
+		start: sourcePosition(source, node.start),
+		end: sourcePosition(source, node.end)
+	};
+}
+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) {
+	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);
+	}
+}
+/**
+* Fragment traversal: Svelte `Fragment` containers (the template root and
+* every block body) carry no `start`/`end`, so the script walker's isNode
+* gate would stop at each one. Descend through every plain object/array,
+* visit only span-carrying nodes, and guard against metadata back-references.
+*/
+function walkFragment(value, visit) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const descend = (current) => {
+		if (Array.isArray(current)) {
+			for (const item of current) descend(item);
+			return;
+		}
+		if (typeof current !== "object" || current === null) return;
+		if (seen.has(current)) return;
+		seen.add(current);
+		if (isNode(current)) visit(current);
+		for (const [key, child] of Object.entries(current)) {
+			if (key === "loc" || key === "start" || key === "end" || key === "metadata" || key === "parent") continue;
+			descend(child);
+		}
+	};
+	descend(value);
+}
+function importBindings(program) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const declaration of program.body) {
+		if (declaration.type !== "ImportDeclaration" || declaration.importKind === "type" || !Array.isArray(declaration.specifiers)) continue;
+		for (const value of declaration.specifiers) {
+			if (!isNode(value) || value.importKind === "type") continue;
+			const local = childNode(value.local);
+			const localName = nodeName(local);
+			if (!local || !localName) continue;
+			const sourceNode = childNode(declaration.source);
+			const importSource = sourceNode && typeof sourceNode.value === "string" ? sourceNode.value : null;
+			if (!importSource) continue;
+			const namedImported = importedName(value);
+			if (value.type === "ImportSpecifier" && namedImported === null) continue;
+			const importedNode = childNode(value.imported);
+			const kind = value.type === "ImportSpecifier" ? importedNode?.type === "Literal" ? "string-named" : namedImported === "default" ? "named-default" : "named" : value.type === "ImportDefaultSpecifier" ? "default" : value.type === "ImportNamespaceSpecifier" ? "namespace" : null;
+			if (kind) bindings.set(localName, {
+				kind,
+				source: importSource,
+				imported: kind === "default" || kind === "named-default" ? "default" : kind === "namespace" ? "*" : namedImported,
+				declaration,
+				specifier: value,
+				local
+			});
+		}
+	}
+	return bindings;
+}
+function diagnostic(code, message, originalPath, source, node, location) {
+	return {
+		code,
+		message,
+		originalPath,
+		...node ? {
+			span: byteSpan(source, node),
+			location: location ?? sourceLocation(source, node)
+		} : {}
+	};
+}
+function compilerParseErrorRange(error, source) {
+	if (typeof error !== "object" || error === null) return null;
+	const candidate = error;
+	const positions = Array.isArray(candidate.position) ? candidate.position : [];
+	const startCharacter = typeof candidate.start?.character === "number" ? candidate.start.character : typeof positions[0] === "number" ? positions[0] : null;
+	const endCharacter = typeof candidate.end?.character === "number" ? candidate.end.character : typeof positions[1] === "number" ? positions[1] : startCharacter;
+	if (startCharacter === null || endCharacter === null || startCharacter < 0 || endCharacter < startCharacter || endCharacter > source.length) return null;
+	const node = {
+		type: "SvelteParseError",
+		start: startCharacter,
+		end: endCharacter
+	};
+	const fallback = sourceLocation(source, node);
+	const point = (value, fallbackPoint) => ({
+		line: typeof value?.line === "number" ? value.line : fallbackPoint.line,
+		column: typeof value?.column === "number" ? value.column : fallbackPoint.column
+	});
+	return {
+		node,
+		location: {
+			start: point(candidate.start, fallback.start),
+			end: point(candidate.end, fallback.end)
+		}
+	};
+}
+function calleeParts(node) {
+	if (node.type !== "CallExpression") return null;
+	const callee = childNode(node.callee);
+	if (!callee || callee.type !== "MemberExpression") return null;
+	const object = childNode(callee.object);
+	const property = childNode(callee.property);
+	if (!object || !property) return null;
+	if ((nodeName(property) ?? (property.type === "Literal" && property.value === "attrs" ? "attrs" : null)) !== "attrs") return null;
+	return {
+		object,
+		property,
+		computed: callee.computed === true,
+		optional: callee.optional === true || node.optional === true
+	};
+}
+function resolverImportAccess(receiver, bindings) {
+	const directName = nodeName(receiver);
+	if (directName) {
+		const binding = bindings.get(directName);
+		if (!binding) return null;
+		return {
+			binding,
+			resolver: receiver,
+			displayName: directName,
+			request: {
+				source: binding.source,
+				imported: binding.imported,
+				local: directName,
+				access: {
+					kind: "direct",
+					importKind: binding.kind
+				}
+			}
+		};
+	}
+	if (receiver.type !== "MemberExpression" || receiver.computed === true || receiver.optional === true) return null;
+	const namespaceNode = childNode(receiver.object);
+	const memberNode = childNode(receiver.property);
+	const namespaceName = nodeName(namespaceNode);
+	const memberName = nodeName(memberNode) ?? (memberNode?.type === "Literal" && typeof memberNode.value === "string" ? memberNode.value : null);
+	if (!namespaceNode || !namespaceName || !memberName) return null;
+	const binding = bindings.get(namespaceName);
+	if (!binding || binding.kind !== "namespace") return null;
+	return {
+		binding,
+		resolver: receiver,
+		displayName: `${namespaceName}.${memberName}`,
+		request: {
+			source: binding.source,
+			imported: memberName,
+			local: namespaceName,
+			access: {
+				kind: "namespace-member",
+				importKind: "namespace"
+			}
+		}
+	};
+}
+function isSupportedResolverAccess(access) {
+	return access.binding.kind === "named" && access.request.access.kind === "direct";
+}
+function resolverCallSite(node, bindings) {
+	if (node.type !== "CallExpression") return null;
+	const parts = calleeParts(node);
+	if (parts) {
+		const access = resolverImportAccess(parts.object, bindings);
+		if (!access) return null;
+		return {
+			access,
+			form: "attrs",
+			computed: parts.computed,
+			optional: parts.optional
+		};
+	}
+	const callee = childNode(node.callee);
+	if (!callee) return null;
+	const access = resolverImportAccess(callee, bindings);
+	if (!access) return null;
+	return {
+		access,
+		form: "callable",
+		computed: callee.type === "MemberExpression" && callee.computed === true,
+		optional: node.optional === true || callee.type === "MemberExpression" && callee.optional === true
+	};
+}
+function argumentSpan(argumentsList, fallback) {
+	if (argumentsList.length === 0) return fallback;
+	return {
+		type: "ArgumentRange",
+		start: argumentsList[0].start,
+		end: argumentsList[argumentsList.length - 1].end
+	};
+}
+function propertyName(node) {
+	const key = childNode(node.key);
+	if (!key) return null;
+	if (key.type === "Identifier" && typeof key.name === "string") return key.name;
+	if (key.type === "Literal" && typeof key.value === "string") return key.value;
+	return null;
+}
+function isJsxAttributeName(name) {
+	return /^[A-Za-z_$][A-Za-z0-9_$-]*$/.test(name);
+}
+function tsxIncompatibleValue(value) {
+	let incompatible = null;
+	walk(value, (node) => {
+		if (incompatible) return;
+		if (node.type === "TSTypeAssertion" || node.type === "ArrowFunctionExpression" && childNode(node.typeParameters) !== null) incompatible = node;
+	});
+	return incompatible;
+}
+function readProperties(argument, source, originalPath) {
+	if (!Array.isArray(argument.properties)) return diagnostic("SVELTE_ATTRS_ARGUMENT_UNRESOLVED", "Resolver .attrs() requires an object literal with statically named properties.", originalPath, source, argument);
+	const properties = [];
+	for (const value of argument.properties) {
+		if (!isNode(value)) continue;
+		if (value.type === "SpreadElement") return diagnostic("SVELTE_ATTRS_SPREAD_UNRESOLVED", "Resolver .attrs() object spreads are unresolved; enumerate properties explicitly.", originalPath, source, value);
+		if (value.type !== "Property") return diagnostic("SVELTE_ATTRS_PROPERTY_UNSUPPORTED", "Resolver .attrs() accepts ordinary object properties only.", originalPath, source, value);
+		if (value.computed === true) return diagnostic("SVELTE_ATTRS_COMPUTED_KEY", "Resolver .attrs() computed property names cannot be attributed safely.", originalPath, source, value);
+		if (value.method === true || value.kind !== "init") return diagnostic("SVELTE_ATTRS_PROPERTY_UNSUPPORTED", "Resolver .attrs() methods and accessors cannot be projected as attributes.", originalPath, source, value);
+		const key = childNode(value.key);
+		const propertyValue = childNode(value.value);
+		const name = propertyName(value);
+		if (!key || !propertyValue || !name || !isJsxAttributeName(name)) return diagnostic("SVELTE_ATTRS_PROPERTY_UNSUPPORTED", "Resolver .attrs() property names must be JSX-compatible identifier or string names.", originalPath, source, value);
+		const incompatibleValue = tsxIncompatibleValue(propertyValue);
+		if (incompatibleValue) return diagnostic("SVELTE_ATTRS_VALUE_UNSUPPORTED", "Resolver .attrs() values using angle-bracket type assertions or generic arrow parameters cannot be projected into TSX safely.", originalPath, source, incompatibleValue);
+		properties.push({
+			name,
+			property: value,
+			key,
+			value: propertyValue
+		});
+	}
+	return properties;
+}
+var VirtualSourceBuilder = class {
+	chunks = [];
+	bytes = 0;
+	mappings = [];
+	constructor(originalSource) {
+		this.originalSource = originalSource;
+	}
+	append(text) {
+		this.chunks.push(text);
+		this.bytes += Buffer.byteLength(text);
+	}
+	appendMapped(text, kind, original) {
+		const start = this.bytes;
+		this.append(text);
+		this.mappings.push({
+			kind,
+			generated: {
+				start,
+				end: this.bytes
+			},
+			original: byteSpan(this.originalSource, original)
+		});
+	}
+	toString() {
+		return this.chunks.join("");
+	}
+};
+function importedName(specifier) {
+	const imported = childNode(specifier.imported);
+	if (!imported) return null;
+	if (imported.type === "Identifier" && typeof imported.name === "string") return imported.name;
+	if (imported.type === "Literal" && typeof imported.value === "string") return imported.value;
+	return null;
+}
+function renderImport(declaration, witnessedBindings, source) {
+	if (!Array.isArray(declaration.specifiers)) return null;
+	const names = [];
+	const locals = [];
+	for (const value of declaration.specifiers) {
+		if (!isNode(value) || value.type !== "ImportSpecifier") continue;
+		const localName = nodeName(childNode(value.local));
+		if (!localName || !witnessedBindings.has(localName)) continue;
+		names.push(source.slice(value.start, value.end));
+		locals.push(localName);
+	}
+	if (names.length === 0) return null;
+	const sourceNode = childNode(declaration.source);
+	const sourceText = sourceNode && typeof sourceNode.raw === "string" ? sourceNode.raw : sourceNode && typeof sourceNode.value === "string" ? JSON.stringify(sourceNode.value) : null;
+	return sourceText ? {
+		text: `import { ${names.join(", ")} } from ${sourceText};\n`,
+		locals
+	} : null;
+}
+/** Memoizes success only: a missing optional peer retries per file, so
+*  installing `svelte` mid-session recovers without a process restart. */
+let compilerMemo = null;
+async function loadCompiler() {
+	if (compilerMemo) return compilerMemo;
+	compilerMemo = await import("svelte/compiler").catch(() => null);
+	return compilerMemo;
+}
+function projectScope(script, scope, source, originalPath, options, inherited, precomputedOwnBindings) {
+	const ownBindings = precomputedOwnBindings ?? importBindings(script.content);
+	const bindings = inherited ? new Map([...inherited.bindings, ...ownBindings]) : ownBindings;
+	const witnesses = [];
+	const diagnostics = [];
+	if (bindings.size > 0) walk(script.content, (node, nestedScopeDepth) => {
+		const site = resolverCallSite(node, bindings);
+		if (!site) return;
+		const { access, form } = site;
+		const attribution = options.attributeResolver(access.request);
+		if (attribution === "other") return;
+		const resolverName = access.displayName;
+		const callDisplay = form === "attrs" ? `${resolverName}.attrs()` : `${resolverName}()`;
+		if (attribution === "unsupported-resolver-form" || !isSupportedResolverAccess(access)) {
+			diagnostics.push(diagnostic("SVELTE_ATTRS_IMPORT_UNSUPPORTED", `Resolver '${resolverName}' uses an import/access form that the extraction engine cannot attribute to its exported .asClass() binding.`, originalPath, source, access.resolver));
+			return;
+		}
+		if (nestedScopeDepth > 0) {
+			diagnostics.push(diagnostic("SVELTE_ATTRS_SCOPE_UNSUPPORTED", `Resolver '${callDisplay}' is inside a nested binding scope; move the call to the top-level script scope so its import identity is unambiguous.`, originalPath, source, access.resolver));
+			return;
+		}
+		if (site.computed || site.optional) {
+			diagnostics.push(diagnostic("SVELTE_ATTRS_CALLEE_UNSUPPORTED", `Resolver '${resolverName}' must be called directly as ${resolverName}(...) or ${resolverName}.attrs(...).`, originalPath, source, node));
+			return;
+		}
+		const argumentsList = Array.isArray(node.arguments) ? node.arguments.filter(isNode) : [];
+		if (argumentsList.length === 0) {
+			witnesses.push({
+				binding: access.binding,
+				resolver: access.resolver,
+				properties: []
+			});
+			return;
+		}
+		if (argumentsList.length !== 1 || argumentsList[0].type !== "ObjectExpression") {
+			diagnostics.push(diagnostic("SVELTE_ATTRS_ARGUMENT_UNRESOLVED", `Resolver '${callDisplay}' accepts no argument or one object literal in Svelte projection.`, originalPath, source, argumentSpan(argumentsList, node)));
+			return;
+		}
+		const properties = readProperties(argumentsList[0], source, originalPath);
+		if (!Array.isArray(properties)) {
+			diagnostics.push(properties);
+			return;
+		}
+		witnesses.push({
+			binding: access.binding,
+			resolver: access.resolver,
+			properties
+		});
+	});
+	if (diagnostics.length > 0 || witnesses.length === 0) return { diagnostics };
+	const witnessedBindings = new Set(witnesses.map((witness) => nodeName(witness.binding.local)));
+	const builder = new VirtualSourceBuilder(source);
+	const pendingNames = new Set(witnessedBindings);
+	const renderDeclarations = (declarations) => {
+		for (const declaration of declarations) {
+			if (declaration.type !== "ImportDeclaration") continue;
+			const rendered = renderImport(declaration, pendingNames, source);
+			if (!rendered) continue;
+			builder.append(rendered.text);
+			for (const local of rendered.locals) pendingNames.delete(local);
+		}
+	};
+	renderDeclarations(script.content.body);
+	if (inherited) renderDeclarations(inherited.importDeclarations);
+	for (const witness of witnesses) {
+		const resolverName = nodeName(witness.resolver);
+		builder.append("<");
+		builder.appendMapped(resolverName, "resolver", witness.resolver);
+		for (const property of witness.properties) {
+			builder.append(" ");
+			builder.appendMapped(property.name, "attribute", property.key);
+			builder.append("={");
+			builder.appendMapped(source.slice(property.value.start, property.value.end), "value", property.value);
+			builder.append("}");
+		}
+		builder.append(" />;\n");
+	}
+	return {
+		diagnostics: [],
+		entry: {
+			scope,
+			path: `${originalPath}.${scope}.tsx`,
+			source: builder.toString(),
+			mappings: builder.mappings
+		}
+	};
+}
+/**
+* Project native Svelte script scopes into parser-only TSX witnesses.
+*
+* This adapter parses source, never compiler-generated runtime JavaScript.
+* Module and instance scripts project separately (module bindings are in
+* scope for the instance script, per Svelte semantics) and contribute only
+* witnessed named imports plus synthetic JSX attributes for direct resolver
+* `.attrs()` and callable-string calls. Caller-owned metadata attributes
+* candidate imports; unsupported call shapes — including resolver calls
+* written in the template fragment — fail the whole source closed.
+*/
+async function adaptSvelteSource(source, originalPath, options) {
+	const original = {
+		path: originalPath,
+		hash: contentHash(source)
+	};
+	const compiler = await loadCompiler();
+	if (!compiler) return {
+		kind: "missing-dep",
+		original,
+		dependency: "svelte/compiler"
+	};
+	let ast;
+	try {
+		ast = compiler.parse(source, {
+			filename: originalPath,
+			modern: true
+		});
+	} catch (error) {
+		const range = compilerParseErrorRange(error, source);
+		return {
+			kind: "error",
+			original,
+			diagnostics: [diagnostic("SVELTE_PARSE_ERROR", error instanceof Error ? error.message : String(error), originalPath, source, range?.node, range?.location)]
+		};
+	}
+	const projections = [];
+	const moduleBindings = ast.module ? importBindings(ast.module.content) : void 0;
+	const instanceBindings = ast.instance ? importBindings(ast.instance.content) : void 0;
+	const moduleScope = ast.module && moduleBindings ? {
+		bindings: moduleBindings,
+		importDeclarations: ast.module.content.body.filter((declaration) => declaration.type === "ImportDeclaration")
+	} : void 0;
+	if (ast.module) projections.push(projectScope(ast.module, "module", source, originalPath, options, void 0, moduleBindings));
+	if (ast.instance) projections.push(projectScope(ast.instance, "instance", source, originalPath, options, moduleScope, instanceBindings));
+	const diagnostics = projections.flatMap((projection) => projection.diagnostics);
+	if (ast.fragment) {
+		const scriptBindings = instanceBindings ?? /* @__PURE__ */ new Map();
+		const fragmentBindings = moduleScope ? new Map([...moduleScope.bindings, ...scriptBindings]) : scriptBindings;
+		if (fragmentBindings.size > 0) walkFragment(ast.fragment, (node) => {
+			const site = resolverCallSite(node, fragmentBindings);
+			if (!site) return;
+			if (options.attributeResolver(site.access.request) === "other") return;
+			diagnostics.push(diagnostic("SVELTE_ATTRS_TEMPLATE_UNSUPPORTED", `Resolver '${site.access.displayName}' is called inside the template; assign the result to a const in the instance script and spread that instead.`, originalPath, source, node));
+		});
+	}
+	if (diagnostics.length > 0) return {
+		kind: "error",
+		original,
+		diagnostics
+	};
+	return {
+		kind: "ok",
+		original,
+		entries: projections.flatMap((projection) => projection.entry ? [projection.entry] : [])
+	};
+}
+//#endregion
+//#region pipeline/mdx-preprocessor.ts
+/**
+* MDX source preprocessor for the extraction pipeline.
+*
+* MDX files are first-class consumers of ds-built components but are not
+* directly parseable by OXC (which the scanner uses for .tsx/.jsx). This
+* module compiles MDX sources to scanner-consumable JSX using @mdx-js/mdx.
+*
+* @mdx-js/mdx is declared as `peerDependenciesMeta.optional` on the
+* plugin packages that import this module. The dynamic import with
+* .catch() ensures non-MDX consumers (who configure `extensions` to
+* exclude .mdx) never trigger the resolution — zero install-footprint
+* cost for them.
+*
+* The `DEFAULT_EXTENSIONS` constant is the shared source of truth for
+* both `@animus-ui/vite-plugin` and `@animus-ui/next-plugin`. Each plugin
+* imports it directly; independent redeclaration of default extensions
+* is considered a regression.
+*/
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mdx"
+];
+/**
+* Extensions the ENGINE TRANSFORM may rewrite (distinct from
+* `DEFAULT_EXTENSIONS`, the discovery set: `.mjs` is here so dist-entry
+* kits reach the engine, `.mdx` is not — MDX is preprocessed to `.tsx`
+* before the engine sees it). The single source for the Turbopack rule
+* glob and the unplugin transform gate; independent redeclaration of this
+* set is considered a regression — a missed copy silently skips a whole
+* file class on one bundler family.
+*/
+const ENGINE_TRANSFORM_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"jsx",
+	"mjs"
+];
+/**
+* Preprocess an MDX source string into scanner-consumable JSX.
+*
+* - Returns `{ kind: 'ok', source }` with JSX-compiled output on success.
+* - Returns `{ kind: 'missing-dep' }` if @mdx-js/mdx is not resolvable
+*   (consumer needs to install it).
+* - Returns `{ kind: 'error', error }` on compile failure (e.g. malformed
+*   MDX syntax). Plugins SHALL warn + skip affected files; the build
+*   continues with remaining files.
+*/
+async function preprocessMdx(source, filename) {
+	const mdxMod = await import("@mdx-js/mdx").catch(() => null);
+	if (mdxMod === null) return { kind: "missing-dep" };
+	try {
+		const vfile = await mdxMod.compile(source, {
+			outputFormat: "program",
+			development: false,
+			jsx: true
+		});
+		return {
+			kind: "ok",
+			source: `/* @mdx-source: ${filename} */\n${String(vfile)}`
+		};
+	} catch (err) {
+		return {
+			kind: "error",
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+//#endregion
+//#region pipeline/source-ingestion.ts
+/**
+* Advisory diagnostics surface as warnings in EVERY mode and never
+* quarantine their file. OXC reports recovered parse diagnostics for
+* sources the consumer's own toolchain may accept (`.js` now parses
+* JSX-enabled, so genuinely malformed code is the remaining producer),
+* and the engine still analyzes whatever the recovered AST carries —
+* failing the build for that would make extraction stricter than the
+* host bundler, which surfaces its own error for the same file. Everything
+* else stays fatal: strict throws, non-strict warns and quarantines.
+*/
+function isAdvisorySourceDiagnostic(diagnostic) {
+	return diagnostic.code === "SOURCE_NATIVE_PARSE_ERROR";
+}
+const RELATIVE_PROBE_SUFFIXES = [
+	"",
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	"/index.ts",
+	"/index.tsx",
+	"/index.js",
+	"/index.jsx"
+];
+function extension(path) {
+	const basename = posix.basename(path);
+	const dot = basename.lastIndexOf(".");
+	return dot === -1 ? "" : basename.slice(dot).toLowerCase();
+}
+function canonicalResolverPath(path) {
+	return posix.normalize(path.replaceAll("\\", "/"));
+}
+/** NodeNext-style relative specifiers carry the EMITTED extension
+*  (`./definition.js` for `definition.ts`); map each back to its source
+*  forms. The exact spelling is probed first by the suffix loop's empty
+*  suffix, so a literal `.js` neighbor still wins. */
+const NODE_NEXT_EXTENSION_MAP = {
+	".js": [
+		".ts",
+		".tsx",
+		".jsx"
+	],
+	".mjs": [".mts"],
+	".cjs": [".cts"]
+};
+function resolveRelativeSource(importerPath, specifier, files) {
+	if (!specifier.startsWith(".")) return null;
+	const base = posix.normalize(posix.join(posix.dirname(canonicalResolverPath(importerPath)), specifier));
+	for (const suffix of RELATIVE_PROBE_SUFFIXES) {
+		const candidate = `${base}${suffix}`;
+		const actualPath = files.get(candidate);
+		if (actualPath !== void 0) return actualPath;
+	}
+	const explicitExtension = extension(base);
+	for (const sourceExtension of NODE_NEXT_EXTENSION_MAP[explicitExtension] ?? []) {
+		const candidate = `${base.slice(0, -explicitExtension.length)}${sourceExtension}`;
+		const actualPath = files.get(candidate);
+		if (actualPath !== void 0) return actualPath;
+	}
+	return null;
+}
+var ResolverExportIndex = class {
+	collisions;
+	files;
+	resolverBindings = /* @__PURE__ */ new Map();
+	/** The same (importer, request) pair repeats for every call site of one
+	*  resolver in one file; the index is rebuilt per ingest, so neither memo
+	*  needs invalidation. */
+	attributionMemo = /* @__PURE__ */ new Map();
+	resolveMemo = /* @__PURE__ */ new Map();
+	constructor(facts, analysisPaths) {
+		this.facts = facts;
+		const pathsByCanonical = /* @__PURE__ */ new Map();
+		for (const path of analysisPaths) {
+			const canonicalPath = canonicalResolverPath(path);
+			const paths = pathsByCanonical.get(canonicalPath) ?? [];
+			paths.push(path);
+			pathsByCanonical.set(canonicalPath, paths);
+		}
+		this.collisions = [...pathsByCanonical].filter(([, paths]) => paths.length > 1).map(([canonicalPath, paths]) => ({
+			canonicalPath,
+			paths
+		}));
+		const factPathsByCanonical = /* @__PURE__ */ new Map();
+		for (const path of Object.keys(facts.files)) {
+			const canonicalPath = canonicalResolverPath(path);
+			const paths = factPathsByCanonical.get(canonicalPath) ?? [];
+			paths.push(path);
+			factPathsByCanonical.set(canonicalPath, paths);
+		}
+		const files = /* @__PURE__ */ new Map();
+		for (const [canonicalPath, paths] of pathsByCanonical) {
+			const factPaths = factPathsByCanonical.get(canonicalPath) ?? [];
+			if (paths.length === 1 && factPaths.length === 1) files.set(canonicalPath, factPaths[0]);
+		}
+		this.files = files;
+		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) {
+		const memoKey = `${importerPath}\0${request.source}\0${request.imported}\0${request.access.kind}\0${request.access.importKind}`;
+		const memoized = this.attributionMemo.get(memoKey);
+		if (memoized !== void 0) return memoized;
+		const attribution = this.attributeUncached(importerPath, request);
+		this.attributionMemo.set(memoKey, attribution);
+		return attribution;
+	}
+	attributeUncached(importerPath, request) {
+		const importedFile = this.resolveSource(importerPath, request.source);
+		if (!importedFile) return "other";
+		if (this.resolveClassExport(importedFile, request.imported, /* @__PURE__ */ new Set()) === null) return "other";
+		return request.access.kind === "direct" && request.access.importKind === "named" ? "resolver" : "unsupported-resolver-form";
+	}
+	resolveSource(importerPath, specifier) {
+		const key = `${importerPath}\0${specifier}`;
+		let resolved = this.resolveMemo.get(key);
+		if (resolved === void 0) {
+			resolved = resolveRelativeSource(importerPath, specifier, this.files);
+			this.resolveMemo.set(key, resolved);
+		}
+		return resolved;
+	}
+	resolveClassExport(path, exportedName, seen) {
+		const identity = `${path}\0${exportedName}`;
+		if (seen.has(identity)) return null;
+		seen.add(identity);
+		const file = this.facts.files[path];
+		const exported = file?.exports.find((candidate) => candidate.exported === exportedName);
+		if (!file || !exported) return null;
+		if (exported.source === null) {
+			if (exported.local === null) return null;
+			if (this.resolverBindings.get(path)?.has(exported.local)) return exported.local;
+			const imported = file.imports.find((candidate) => candidate.local === exported.local);
+			if (!imported) return null;
+			const importedFile = this.resolveSource(path, imported.source);
+			return importedFile ? this.resolveClassExport(importedFile, imported.imported, seen) : null;
+		}
+		if (exported.original === null) return null;
+		const nextFile = this.resolveSource(path, exported.source);
+		return nextFile ? this.resolveClassExport(nextFile, exported.original, seen) : null;
+	}
+};
+/**
+* Convert raw source identities into parser-ready analysis entries once.
+*
+* Native and MDX entries establish the resolver-export index through the
+* native fact collector before any Svelte projection. Svelte calls are then
+* attributed by exact relative import/export identity and parsed once. Bare
+* package and configured-alias sources deliberately remain `other`; callers
+* must not guess those identities.
+*/
+async function ingestSourceEntries(rawEntries, options) {
+	const mdxAdapter = options.preprocessMdx ?? preprocessMdx;
+	const svelteAdapter = options.adaptSvelte ?? adaptSvelteSource;
+	const originalEntries = rawEntries.map((entry) => ({
+		...entry,
+		hash: entry.hash ?? contentHash(entry.source)
+	}));
+	const rawOriginalPaths = new Set(originalEntries.map((entry) => entry.path));
+	const analysisEntries = [];
+	const ownership = {};
+	const analysisOwner = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	const svelteEntries = [];
+	const addAnalysisEntry = (originalPath, path, source, hash) => {
+		analysisEntries.push({
+			path,
+			source,
+			hash: hash ?? contentHash(source)
+		});
+		ownership[originalPath].analysisPaths.push(path);
+		analysisOwner.set(path, originalPath);
+	};
+	const addAdaptedEntries = (originalPath, entries) => {
+		const pendingPaths = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			const conflictingOriginalPath = rawOriginalPaths.has(entry.path) ? entry.path : analysisOwner.get(entry.path) ?? (pendingPaths.has(entry.path) ? originalPath : null);
+			if (conflictingOriginalPath !== null) {
+				diagnostics.push({
+					code: "SOURCE_ANALYSIS_PATH_COLLISION",
+					message: `Generated analysis path '${entry.path}' collides with '${conflictingOriginalPath}'. Rename one of the source files so adapted analysis paths remain unique.`,
+					originalPath,
+					analysisPath: entry.path,
+					conflictingOriginalPath
+				});
+				return;
+			}
+			pendingPaths.add(entry.path);
+		}
+		for (const entry of entries) addAnalysisEntry(originalPath, entry.path, entry.source);
+	};
+	for (const original of originalEntries) {
+		ownership[original.path] = {
+			originalPath: original.path,
+			originalHash: original.hash,
+			analysisPaths: []
+		};
+		const kind = extension(original.path);
+		if (kind === ".svelte") {
+			svelteEntries.push(original);
+			continue;
+		}
+		if (kind !== ".mdx") {
+			addAnalysisEntry(original.path, original.path, original.source, original.hash);
+			continue;
+		}
+		const result = await mdxAdapter(original.source, original.path);
+		if (result.kind === "missing-dep") {
+			diagnostics.push({
+				code: "SOURCE_MDX_DEPENDENCY_MISSING",
+				message: "Install optional peer dependency '@mdx-js/mdx' to analyze opted-in MDX source.",
+				originalPath: original.path
+			});
+			continue;
+		}
+		if (result.kind === "error" || result.source === void 0) {
+			diagnostics.push({
+				code: "SOURCE_MDX_PARSE_ERROR",
+				message: result.error ?? "MDX preprocessing produced no source.",
+				originalPath: original.path
+			});
+			continue;
+		}
+		addAdaptedEntries(original.path, [{
+			path: `${original.path}.tsx`,
+			source: result.source
+		}]);
+	}
+	const facts = collectFileFacts(analysisEntries, options);
+	for (const [analysisPath, file] of Object.entries(facts.files)) {
+		const originalPath = analysisOwner.get(analysisPath) ?? analysisPath;
+		for (const message of file.parseDiagnostics) diagnostics.push({
+			code: "SOURCE_NATIVE_PARSE_ERROR",
+			message,
+			originalPath,
+			analysisPath
+		});
+	}
+	const resolvers = new ResolverExportIndex(facts, analysisEntries.map((entry) => entry.path));
+	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];
+		diagnostics.push({
+			code: "SOURCE_RESOLVER_IDENTITY_COLLISION",
+			message: `Resolver lookup paths '${path}' and '${conflictingPath}' normalize to the same private identity '${canonicalPath}'. Rename one of the source files so resolver identities remain unique.`,
+			originalPath: analysisOwner.get(path) ?? path,
+			canonicalPath,
+			conflictingOriginalPath: analysisOwner.get(conflictingPath) ?? conflictingPath
+		});
+	}
+	for (const original of svelteEntries) {
+		const result = await svelteAdapter(original.source, original.path, { attributeResolver: (request) => resolvers.attribute(original.path, request) });
+		if (result.kind === "missing-dep") {
+			diagnostics.push({
+				code: "SOURCE_SVELTE_DEPENDENCY_MISSING",
+				message: "Install optional peer dependency 'svelte' to analyze opted-in Svelte source.",
+				originalPath: original.path
+			});
+			continue;
+		}
+		if (result.kind === "error") {
+			diagnostics.push(...result.diagnostics);
+			continue;
+		}
+		addAdaptedEntries(original.path, result.entries);
+	}
+	return {
+		originalEntries,
+		analysisEntries,
+		ownership,
+		diagnostics
+	};
+}
+/**
+* Run the native fact collector, re-extracting only changed entries when the
+* caller supplies a `factsCache`. `parseCount` keeps its meaning — parses
+* performed by THIS call — so a fully-memoized pass reports zero.
+*/
+function collectFileFacts(analysisEntries, options) {
+	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);
+	let parseCount = 0;
+	if (pending.length > 0) {
+		const fresh = JSON.parse(options.extractFacts(JSON.stringify(pending)));
+		parseCount = fresh.parseCount;
+		for (const entry of pending) {
+			const facts = fresh.files[entry.path];
+			if (facts) cache.set(entry.path, {
+				hash: entry.hash,
+				facts
+			});
+			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);
+	const files = {};
+	for (const entry of analysisEntries) {
+		const cached = cache.get(entry.path);
+		if (cached) files[entry.path] = cached.facts;
+	}
+	return {
+		files,
+		parseCount
+	};
+}
+/**
+* The per-file quarantine: drop every original a diagnostic named — and the
+* analysis children it owns — so one invalid source never aborts the rest
+* of the corpus. Shared by buildStart AND every incremental path in both
+* hosts; asymmetry here is how a permanently-diagnosable file (an `.mdx`
+* with the optional peer absent, an unsupported `.svelte` shape) froze all
+* re-analysis for the life of the dev server.
+*/
+function withoutInvalidOriginals(result, invalidOriginals) {
+	if (invalidOriginals.size === 0) return result;
+	const ownership = Object.fromEntries(Object.entries(result.ownership).filter(([originalPath]) => !invalidOriginals.has(originalPath)));
+	const analysisPaths = new Set(Object.values(ownership).flatMap((owner) => owner.analysisPaths));
+	return {
+		...result,
+		originalEntries: result.originalEntries.filter((entry) => !invalidOriginals.has(entry.path)),
+		analysisEntries: result.analysisEntries.filter((entry) => analysisPaths.has(entry.path)),
+		ownership
+	};
+}
+/**
+* The one source-ingestion policy point shared by every host (vite-plugin,
+* next-plugin, cli, unplugin). Hosts hold exactly their prefix, strict flag,
+* and warn sink; the capability guard, facts memo, and warn-dedupe lifecycle
+* live here so the plugins cannot fork (precedent: pkg-collection
+* divergences; see also `enforceExternalTokenContracts`).
+*/
+function createSourceIngestor(host) {
+	const factsCache = /* @__PURE__ */ new Map();
+	/** Non-strict warn dedupe: a quarantined-but-retained original re-ingests
+	*  on every later corpus pass, and re-warning each save is noise. Keyed by
+	*  original path; cleared when that original publishes clean again. */
+	const warnedByOriginal = /* @__PURE__ */ new Map();
+	return {
+		async ingest(entries) {
+			const extractFacts = host.engineApi().extractFacts;
+			if (typeof extractFacts !== "function") throw new Error(`${host.prefix} native engine does not expose extractFacts required for source adaptation`);
+			return ingestSourceEntries(entries, {
+				extractFacts,
+				factsCache
+			});
+		},
+		surfaceDiagnostics(diagnostics) {
+			const fatal = diagnostics.filter((diagnostic) => !isAdvisorySourceDiagnostic(diagnostic));
+			const invalidOriginals = new Set(fatal.map((diagnostic) => diagnostic.originalPath));
+			if (diagnostics.length === 0) return invalidOriginals;
+			if (host.strict() && fatal.length > 0) {
+				const lines = fatal.map((diagnostic) => `${diagnostic.code} ${diagnostic.originalPath}: ${diagnostic.message}`);
+				throw new Error(`${host.prefix} ${lines.join(`\n${host.prefix} `)}`);
+			}
+			for (const diagnostic of diagnostics) {
+				const line = `${diagnostic.code} ${diagnostic.originalPath}: ${diagnostic.message}`;
+				let warned = warnedByOriginal.get(diagnostic.originalPath);
+				if (!warned) {
+					warned = /* @__PURE__ */ new Set();
+					warnedByOriginal.set(diagnostic.originalPath, warned);
+				}
+				if (warned.has(line)) continue;
+				warned.add(line);
+				host.warn(`${host.prefix} ${line}`);
+			}
+			return invalidOriginals;
+		},
+		markPublished(result) {
+			for (const originalPath of Object.keys(result.ownership)) warnedByOriginal.delete(originalPath);
+		}
+	};
+}
+//#endregion
+//#region pipeline/asset-placeholders.ts
+/**
+* Host-side handling of `asset()` placeholders (global-styles-system):
+* `animus-asset:<specifier>` markers ride through the sandbox and the
+* emitter byte-exact; each HOST plugin substitutes them with its bundler's
+* resolved asset URL after extraction. This module owns the shared scanning
+* and replacement mechanics — resolution and strict gating stay at the
+* plugin call sites.
+*/
+/** Mirrors the producer-side constant in `@animus-ui/system`'s `asset.ts`
+*  (extract must not take a runtime dependency on system); the pairing is
+*  pinned by a contract test in `tests/asset-placeholders.test.ts`. */
+const ASSET_PLACEHOLDER_PREFIX = "animus-asset:";
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const PREFIX_RE = escapeRegExp(ASSET_PLACEHOLDER_PREFIX);
+/**
+* Quoted `url('animus-asset:<specifier>')` form — the emitter always quotes
+* `url()` values, so a quoted match carries the FULL specifier, including
+* whitespace and parentheses (D5 pins the placeholder as specifier-verbatim,
+* so scanning fidelity is the only place such characters can be honored).
+*/
+const QUOTED_PLACEHOLDER_RE = new RegExp(`(['"])${PREFIX_RE}([^'"]*?)\\1`, "g");
+/** Bare-form fallback: a placeholder up to CSS url()/quote/whitespace. */
+const BARE_PLACEHOLDER_RE = new RegExp(`${PREFIX_RE}([^'")\\s]+)`, "g");
+/** Unique asset specifiers referenced by placeholders, in appearance order. */
+function findAssetSpecifiers(css) {
+	if (!css.includes("animus-asset:")) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const remainder = css.replace(QUOTED_PLACEHOLDER_RE, (_match, _quote, specifier) => {
+		seen.add(specifier);
+		return "";
+	});
+	for (const match of remainder.matchAll(BARE_PLACEHOLDER_RE)) seen.add(match[1]);
+	return [...seen];
+}
+/**
+* Replace each specifier's placeholder with its substitution. Specifiers
+* absent from the map keep their placeholder — the caller decides whether
+* that is a strict failure or a warn-and-emit-literally. A substitution may
+* itself be a bundler marker (e.g. Vite's `__VITE_ASSET__<ref>__`) that the
+* host's own asset pipeline resolves to a hashed file name later.
+*
+* Each replacement is anchored to a following delimiter (quote, `)`,
+* whitespace, or end of input) so a specifier that textually prefixes a
+* longer one can never clobber the longer placeholder; longest-first
+* ordering additionally lets the longer of two mapped specifiers claim its
+* occurrences before the shorter runs.
+*/
+function substituteAssetPlaceholders(css, urlBySpecifier) {
+	if (urlBySpecifier.size === 0) return css;
+	if (!css.includes("animus-asset:")) return css;
+	const specifiers = [...urlBySpecifier.keys()].sort((a, b) => b.length - a.length);
+	let out = css;
+	for (const specifier of specifiers) {
+		const placeholder = new RegExp(escapeRegExp(ASSET_PLACEHOLDER_PREFIX + specifier) + String.raw`(?=['")\s]|$)`, "g");
+		out = out.replace(placeholder, () => urlBySpecifier.get(specifier));
+	}
+	return out;
+}
+//#endregion
+//#region pipeline/resolve-asset.ts
+/**
+* Node-side asset specifier resolution shared by the host plugins (the
+* asset() contract, global-styles-system): host path aliases apply FIRST —
+* an alias such as `@fonts` works in application modules, so
+* `asset('@fonts/inter.woff2')` must resolve identically — then direct Node
+* resolution, then the package-root fallback (exports maps rarely list
+* asset subpaths). Bundler-native resolution (Vite's `this.resolve`) is
+* still preferred where available; this resolver covers the paths that have
+* no bundler hook (Next's session, Vite's dev re-analysis).
+*/
+const requireByRoot = /* @__PURE__ */ new Map();
+function requireAnchoredAt(rootDir) {
+	let req = requireByRoot.get(rootDir);
+	if (!req) {
+		req = createRequire$1(join(rootDir, "package.json"));
+		requireByRoot.set(rootDir, req);
+	}
+	return req;
+}
+function packageRootFromEntry(entry) {
+	let current = dirname(entry);
+	while (true) {
+		if (existsSync(join(current, "package.json"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+const aliasTableCache = /* @__PURE__ */ new Map();
+function parseAliasTable(pathAliasesJson) {
+	const cached = aliasTableCache.get(pathAliasesJson);
+	if (cached) return cached;
+	let aliases;
+	try {
+		aliases = JSON.parse(pathAliasesJson).aliases ?? [];
+	} catch {
+		aliases = [];
+	}
+	aliasTableCache.set(pathAliasesJson, aliases);
+	return aliases;
+}
+/**
+* Map a specifier through the harvested host alias table (the same
+* `pathAliasesJson` wire the engine consumes — entries pre-sorted longest
+* pattern first by `buildPathAliasesJson`). Returns an absolute path to an
+* EXISTING file, or null when no alias claims the specifier.
+*/
+function resolveThroughPathAliases(specifier, rootDir, pathAliasesJson) {
+	if (!pathAliasesJson) return null;
+	const aliases = parseAliasTable(pathAliasesJson);
+	for (const alias of aliases) {
+		let mapped = null;
+		if (alias.type === "exact") {
+			if (alias.pattern === specifier) mapped = alias.replacement;
+		} else if (specifier.startsWith(alias.pattern)) mapped = alias.replacement + specifier.slice(alias.pattern.length);
+		if (mapped === null) continue;
+		const absolute = isAbsolute(mapped) ? mapped : join(rootDir, mapped);
+		if (existsSync(absolute)) return absolute;
+	}
+	return null;
+}
+/**
+* Resolve an asset specifier to an absolute file: host aliases, then direct
+* Node resolution anchored at `rootDir`, then the package-root fallback.
+* Returns null when nothing matches — strict gating stays at the caller.
+*/
+function resolveAssetFile(specifier, rootDir, pathAliasesJson) {
+	const aliased = resolveThroughPathAliases(specifier, rootDir, pathAliasesJson);
+	if (aliased) return aliased;
+	const requireFromRoot = requireAnchoredAt(rootDir);
+	try {
+		return requireFromRoot.resolve(specifier);
+	} catch {}
+	const segments = specifier.split("/");
+	const packageName = specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+	const subpath = specifier.slice(packageName.length + 1);
+	if (!subpath) return null;
+	for (const modulesDir of requireFromRoot.resolve.paths(packageName) ?? []) {
+		const packageRoot = join(modulesDir, packageName);
+		if (!existsSync(join(packageRoot, "package.json"))) continue;
+		const candidate = join(packageRoot, subpath);
+		if (existsSync(candidate)) return candidate;
+	}
+	try {
+		const packageRoot = packageRootFromEntry(requireFromRoot.resolve(packageName));
+		if (!packageRoot) return null;
+		const candidate = join(packageRoot, subpath);
+		return existsSync(candidate) ? candidate : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region pipeline/correlate-external-tokens.ts
+/**
+* Index the loader-captured theme manifests by owning specifier. Module paths
+* are canonical absolute paths (symlinks resolved), so each package dir is
+* realpath'd before prefix-matching; a module outside every known package dir
+* (typically the consumer's own theme) contributes nothing.
+*/
+function buildSourceTokenIndex(opts) {
+	const index = /* @__PURE__ */ new Map();
+	if (!opts.sourceThemeManifestsJson) return index;
+	let manifests;
+	try {
+		manifests = JSON.parse(opts.sourceThemeManifestsJson);
+	} catch {
+		return index;
+	}
+	const realDirOwners = [];
+	const addOwnerDir = (dir, specifier) => {
+		if (!realDirOwners.some((entry) => entry.dir === dir)) realDirOwners.push({
+			dir,
+			specifier
+		});
+	};
+	for (const [dir, specifier] of Object.entries(opts.dirOwners)) {
+		let real = dir;
+		try {
+			real = realpathSync(dir);
+		} catch {}
+		addOwnerDir(real, specifier);
+		let packageRoot = real;
+		while (packageRoot !== dirname(packageRoot) && !existsSync(join(packageRoot, "package.json"))) packageRoot = dirname(packageRoot);
+		if (existsSync(join(packageRoot, "package.json"))) addOwnerDir(packageRoot, specifier);
+	}
+	for (const [modulePath, exports] of Object.entries(manifests)) {
+		const owner = realDirOwners.find(({ dir }) => isPathWithinRoot(dir, modulePath));
+		if (!owner) continue;
+		let tokens = index.get(owner.specifier);
+		if (!tokens) {
+			tokens = /* @__PURE__ */ new Set();
+			index.set(owner.specifier, tokens);
+		}
+		for (const paths of Object.values(exports)) for (const token of paths) tokens.add(token);
+	}
+	return index;
+}
+/**
+* The correlation join. Returns one teaching-error message per distinct
+* (component, token, specifier) whose file belongs to a discovered source AND
+* whose token that source's manifest defines. The messages follow the
+* standard severity routing at the CALLER (throw under `strict`, warn
+* otherwise) — this join never reports on its own.
+*/
+function correlateExternalTokenDiagnostics(opts) {
+	const messages = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const diagnostic of opts.diagnostics ?? []) {
+		if (diagnostic.kind !== "external-token-candidate" || !diagnostic.token) continue;
+		const specifier = opts.fileOwners[diagnostic.file];
+		if (!specifier) continue;
+		if (!opts.sourceTokens.get(specifier)?.has(diagnostic.token)) continue;
+		const key = `${diagnostic.component}\u0000${diagnostic.token}\u0000${specifier}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		messages.push(`${diagnostic.component} (from '${specifier}') references token '${diagnostic.token}', which the consumer theme does not define — inherit the source's tokens with createTheme().extend(...) using the tokens (or bundle) export of '${specifier}'`);
+	}
+	return messages;
+}
+const indexCache = /* @__PURE__ */ new WeakMap();
+/**
+* The complete cross-source token-contract gate both plugins share
+* (extraction-diagnostics): index the loader-captured source manifests,
+* join them against the engine's candidates, and route the resulting
+* teaching errors — throw under `strict`, warn otherwise. One entry point
+* so the two hosts cannot drift on wiring or severity semantics.
+*/
+function enforceExternalTokenContracts(opts) {
+	const manifestsJson = opts.sourceThemeManifestsJson ?? "";
+	const cached = indexCache.get(opts.dirOwners);
+	let sourceTokens;
+	if (cached && cached.manifestsJson === manifestsJson) sourceTokens = cached.index;
+	else {
+		sourceTokens = buildSourceTokenIndex({
+			sourceThemeManifestsJson: opts.sourceThemeManifestsJson,
+			dirOwners: opts.dirOwners
+		});
+		indexCache.set(opts.dirOwners, {
+			manifestsJson,
+			index: sourceTokens
+		});
+	}
+	const messages = correlateExternalTokenDiagnostics({
+		diagnostics: opts.diagnostics,
+		fileOwners: opts.fileOwners,
+		sourceTokens
+	});
+	if (messages.length === 0) return;
+	if (opts.strict) throw new Error(`${opts.prefix} ${messages.join("\n")}`);
+	for (const message of messages) opts.warn(message);
+}
+//#endregion
+//#region pipeline/path-aliases.ts
+/**
+* Normalize alias pairs: strip a `rootDir` prefix from targets, classify
+* exact (file) vs prefix (directory) matches, force trailing slashes on
+* prefix entries, and sort longest pattern first for correct matching
+* priority. Returns null when no entries survive.
+*/
+function buildPathAliasesJson(pairs, rootDir) {
+	const entries = [];
+	for (const { pattern, target, kind } of pairs) {
+		const replacement = target.startsWith(rootDir) ? target.slice(rootDir.length + 1) : target;
+		if (kind ? kind === "exact" : /\.\w+$/.test(replacement)) entries.push({
+			pattern,
+			replacement,
+			type: "exact"
+		});
+		else entries.push({
+			pattern: pattern.endsWith("/") ? pattern : pattern + "/",
+			replacement: replacement.endsWith("/") ? replacement : replacement + "/",
+			type: "prefix"
+		});
+	}
+	entries.sort((a, b) => b.pattern.length - a.pattern.length);
+	if (entries.length === 0) return null;
+	return {
+		json: JSON.stringify({ aliases: entries }),
+		count: entries.length
+	};
+}
+//#endregion
+//#region pipeline/post-process-css.ts
+/**
+* CSS post-processing (spec: css-post-processing) — Lightning CSS
+* autoprefixing, syntax lowering, and optional minification against
+* browserslist targets. The single implementation consumed by both the
+* Vite plugin (virtual-module serve time) and the Next.js plugin
+* (ExtractionSession artifact emission).
+*/
+/**
+* Resolve browser targets for Lightning CSS.
+* Priority: explicit config → project browserslist → 'defaults' fallback.
+*/
+function resolveLightningTargets(explicitTargets, rootDir) {
+	let queries;
+	if (explicitTargets) queries = Array.isArray(explicitTargets) ? explicitTargets : [explicitTargets];
+	else {
+		const detected = browserslist(void 0, { path: rootDir });
+		queries = detected.length > 0 ? detected : browserslist("defaults");
+	}
+	return browserslistToTargets(Array.isArray(queries) && typeof queries[0] === "string" && queries[0].includes(" ") ? browserslist(queries) : queries);
+}
+/**
+* Post-process CSS with Lightning CSS: autoprefixing + optional minification.
+* On failure, returns the original CSS and logs a warning.
+*/
+function postProcessCss(css, opts) {
+	if (!css) return css;
+	try {
+		return transform({
+			filename: "animus-extracted.css",
+			code: Buffer.from(css),
+			minify: opts.minify,
+			targets: opts.targets
+		}).code.toString();
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		(opts.warnFn ?? console.warn)(`[animus] Lightning CSS post-processing failed: ${msg}`);
+		return css;
+	}
+}
+//#endregion
+//#region pipeline/manifest-diagnostics.ts
+/** Stable code for selector forms with no substitutable subject.
+*  Mirrors the Rust constant in `extract-v2/src/eval.rs`. */
+const SELECTOR_UNSUPPORTED_SUBJECT = "animus.selector.unsupported-subject";
+/** Unresolved-parent chain-drop message (mirrors the Rust diagnostic in
+*  `extract-v2` — the ONE encoding of this message shape; consumers match
+*  through the helpers below, never their own regex copies). */
+const UNRESOLVED_PARENT_RE = /chain dropped: could not resolve parent component '([^']+)'/;
+/** True when the diagnostic reports a chain dropped for an unresolved
+*  parent component. */
+function isUnresolvedParentDrop(diagnostic) {
+	return typeof diagnostic?.message === "string" && UNRESOLVED_PARENT_RE.test(diagnostic.message);
+}
+/** The parent binding named by an unresolved-parent drop, or null when the
+*  diagnostic is not one. */
+function unresolvedParentName(diagnostic) {
+	if (typeof diagnostic?.message !== "string") return null;
+	return UNRESOLVED_PARENT_RE.exec(diagnostic.message)?.[1] ?? null;
+}
+/** True when the selector string carries at least one substitutable `&`
+*  subject outside quoted text (mirrors the Rust `selector_subject` walk —
+*  ancestor, leading, and repeated subjects all count; a `&` inside a
+*  quoted attribute value does not). */
+function hasSelectorSubject(value) {
+	let quote = null;
+	let escaped = false;
+	for (const c of value) {
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (c === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote !== null) {
+			if (c === quote) quote = null;
+		} else if (c === "\"" || c === "'") quote = c;
+		else if (c === "&") return true;
+	}
+	return false;
+}
+/**
+* Synthesize coded diagnostics for registered selector-alias values that
+* look selector-shaped (`&` present) but carry no substitutable subject —
+* every `&` sits inside quoted text, so there is nothing to anchor the
+* class to. Ancestor-prefixed and repeated subjects are supported and pass
+* validation. The system-config boundary is where these must fail loud
+* (alias values never reach the evaluator's key guard).
+*/
+function collectSelectorAliasDiagnostics(selectorAliasesJson) {
+	if (!selectorAliasesJson) return [];
+	let aliases;
+	try {
+		aliases = JSON.parse(selectorAliasesJson);
+	} catch {
+		return [];
+	}
+	const diagnostics = [];
+	for (const [name, value] of Object.entries(aliases)) {
+		if (typeof value !== "string") continue;
+		if (value.includes("&") && !hasSelectorSubject(value)) diagnostics.push({
+			file: "system",
+			component: name,
+			kind: "warn",
+			message: `selector alias '${name}' value '${value}' has no substitutable '&' subject outside quoted text (${SELECTOR_UNSUPPORTED_SUBJECT})`,
+			code: SELECTOR_UNSUPPORTED_SUBJECT,
+			severity: "error"
+		});
+	}
+	return diagnostics;
+}
+/**
+* Surface extraction-manifest diagnostics through a plugin's warn channel.
+*
+* Single authoritative copy for both extraction plugins — and the single
+* strict-escalation policy point: error-severity diagnostics throw one
+* Error naming every offender when `policy.strict`, and print as warnings
+* otherwise. Surfaces `bail` (component not extracted), `skip` (component
+* skipped), and `warn` kinds; unknown kinds stay silent. Printed lines
+* include the diagnostic code when the message doesn't already carry it.
+*/
+function surfaceManifestDiagnostics(manifest, warn, policy = {}) {
+	const errors = [];
+	const diagnostics = policy.prepend?.length ? [...policy.prepend, ...manifest.diagnostics ?? []] : manifest.diagnostics ?? [];
+	for (const diagnostic of diagnostics) {
+		let line = null;
+		if (diagnostic.kind === "bail") line = `⚠ ${diagnostic.component} not extracted: ${diagnostic.message}`;
+		else if (diagnostic.kind === "skip") line = `⚠ ${diagnostic.component}: skipped ${diagnostic.message}`;
+		else if (diagnostic.kind === "warn") line = `⚠ ${diagnostic.file}: ${diagnostic.component}: ${diagnostic.message}`;
+		if (line === null) continue;
+		if (diagnostic.code && !diagnostic.message.includes(diagnostic.code)) line += ` [${diagnostic.code}]`;
+		if (policy.strict && diagnostic.severity === "error") {
+			errors.push(`${diagnostic.code ?? "error"} — ${diagnostic.component}: ${diagnostic.message}`);
+			continue;
+		}
+		warn(line);
+	}
+	if (errors.length > 0) throw new Error(`[animus] strict: ${errors.length} error diagnostic(s):\n${errors.join("\n")}`);
+}
+//#endregion
+//#region pipeline/unit-fallback.ts
+/**
+* Append `px` to bare numeric values in CSS declarations for properties
+* that expect length units. Unitless properties are preserved as-is.
+* Numbers inside CSS function calls (cubic-bezier, rgb, calc, etc.) are skipped.
+*/
+function applyUnitFallback(css) {
+	return css.replace(/([a-z-]+)\s*:\s*([^;{}]+);/g, (match, prop, value) => {
+		if (isUnitlessProperty(prop)) return match;
+		let depth = 0;
+		let fixed = "";
+		let i = 0;
+		while (i < value.length) if (value[i] === "(") {
+			depth++;
+			fixed += value[i];
+			i++;
+		} else if (value[i] === ")") {
+			depth--;
+			fixed += value[i];
+			i++;
+		} else if (depth > 0) {
+			fixed += value[i];
+			i++;
+		} else {
+			const numMatch = value.slice(i).match(/^(-?\d+\.?\d*)/);
+			if (numMatch) {
+				const num = numMatch[1];
+				const after = value[i + num.length];
+				if (after && /[a-z%]/i.test(after)) fixed += num;
+				else fixed += num + "px";
+				i += num.length;
+			} else {
+				fixed += value[i];
+				i++;
+			}
+		}
+		return fixed !== value ? `${prop}:${fixed};` : match;
+	});
+}
+//#endregion
+//#region pipeline/run-analysis.ts
+/**
+* Build the named `analyzeProject` input set from analysis options. Also
+* the persistence shape for `.animus/analysis-inputs.json` — an isolated
+* process can replay the analysis from exactly this object
+* (spec: next-turbopack-integration).
+*/
+function buildAnalysisInputs(opts) {
+	return {
+		filesJson: JSON.stringify(opts.fileEntries),
+		scalesJson: opts.system.scalesJson,
+		variableMapJson: opts.system.variableMapJson,
+		contextualVarsJson: opts.system.contextualVarsJson,
+		propConfigJson: opts.system.propConfigJson,
+		groupRegistryJson: opts.system.groupRegistryJson,
+		packageResolutionJson: JSON.stringify(opts.packageMap),
+		devMode: opts.devMode,
+		emitterConfigJson: JSON.stringify({
+			runtime_import: opts.emitter.runtimeImport,
+			css_module_id: opts.emitter.cssModuleId,
+			...opts.emitter.systemPropsModuleId ? { system_props_module_id: opts.emitter.systemPropsModuleId } : {}
+		}),
+		selectorAliasesJson: opts.system.selectorAliasesJson,
+		globalStyleBlocksJson: opts.system.globalStyleBlocksJson,
+		pathAliasesJson: opts.pathAliasesJson,
+		keyframesJson: opts.system.keyframesJson,
+		staticCssJson: opts.staticCssJson ?? null,
+		conditionAliasesJson: opts.system.conditionAliasesJson ?? null,
+		transformSourcesJson: opts.system.transformSourcesJson ?? null,
+		externalDirsJson: opts.externalDirs?.length && hasSourceThemeManifests(opts.system) ? JSON.stringify(opts.externalDirs) : null
+	};
+}
+/** Whether the loader captured at least one source built-theme manifest. */
+function hasSourceThemeManifests(system) {
+	const json = system.sourceThemeManifestsJson;
+	return typeof json === "string" && json.length > 0 && json !== "{}";
+}
+/**
+* The one analysis invocation both plugins share: build the emitter
+* config, serialize inputs, call the NAPI `analyzeProject`, parse the
+* manifest, surface its diagnostics, and resolve the CSS outputs.
+*
+* Error handling stays at the call site (strict-mode throw vs warn).
+*/
+function runProjectAnalysis(engineApi, opts) {
+	const { analyzeProject } = engineApi();
+	let t = performance.now();
+	const inputs = buildAnalysisInputs(opts);
+	const serializeMs = Math.round(performance.now() - t);
+	t = performance.now();
+	const manifestJson = analyzeProject(...buildAnalyzeProjectArgs(inputs));
+	const extractMs = Math.round(performance.now() - t);
+	t = performance.now();
+	const manifest = JSON.parse(manifestJson);
+	surfaceManifestDiagnostics(manifest, opts.warn, {
+		strict: opts.strict,
+		prepend: [...collectSelectorAliasDiagnostics(opts.system.selectorAliasesJson), ...opts.extraDiagnostics ?? []]
+	});
+	const parseMs = Math.round(performance.now() - t);
+	return {
+		manifest,
+		manifestJson,
+		globalCss: manifest?.sheets?.global || "",
+		componentCss: applyUnitFallback(manifest?.css || ""),
+		inputs,
+		timings: {
+			serializeMs,
+			extractMs,
+			parseMs
+		}
+	};
+}
+/**
+* Clear the engine's per-file analysis cache so stale results from a prior
+* build never bleed into a fresh run. Tolerates engines without the
+* capability (older builds) — the probe is benign.
+*/
+function clearEngineCache(engineApi) {
+	try {
+		const { clearAnalysisCache } = engineApi();
+		clearAnalysisCache();
+	} catch {}
+}
+//#endregion
+//#region pipeline/static-css.ts
+/** Key-sorted stringify so semantically identical configs serialize
+*  identically (stable analysis-inputs hashing). */
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+/** Serialize a staticCss option for the engine; null when absent/empty. */
+function serializeStaticCss(config) {
+	if (!config) return null;
+	const json = stableStringify(config);
+	return json === "{}" ? null : json;
+}
+//#endregion
+//#region pipeline/prefix.ts
+/**
+* Apply namespace prefix to a variable map, CSS variable declarations, and theme JSON.
+*
+* Variable map: `{ "colors.ember": "--color-ember" }` -> `{ "colors.ember": "--prefix-color-ember" }`
+* Variable CSS: `--color-ember: #FF2800` -> `--prefix-color-ember: #FF2800`
+*               `var(--color-ember)` -> `var(--prefix-color-ember)`
+* Theme JSON:   `{ "colors.ember": "var(--color-ember)" }` -> `{ "colors.ember": "var(--prefix-color-ember)" }`
+*/
+function applyPrefix(prefix, variableMapJson, variableCss, themeJson, contextualVarsJson) {
+	if (!prefix) return {
+		variableMapJson,
+		variableCss,
+		themeJson,
+		contextualVarsJson
+	};
+	const varRefRe = /var\(--([a-zA-Z][\w-]*)\)/g;
+	const map = JSON.parse(variableMapJson);
+	const prefixed = {};
+	for (const [key, varName] of Object.entries(map)) prefixed[key] = varName.startsWith("--") ? `--${prefix}-${varName.slice(2)}` : varName;
+	let css = variableCss;
+	css = css.replace(/--([a-zA-Z][\w-]*)\s*:/g, `--${prefix}-$1:`);
+	css = css.replace(varRefRe, `var(--${prefix}-$1)`);
+	const result = {
+		variableMapJson: JSON.stringify(prefixed),
+		variableCss: css
+	};
+	if (themeJson) result.themeJson = themeJson.replace(varRefRe, `var(--${prefix}-$1)`);
+	if (contextualVarsJson) {
+		const ctxVars = JSON.parse(contextualVarsJson);
+		const prefixedCtx = {};
+		for (const [scale, names] of Object.entries(ctxVars)) prefixedCtx[scale] = names.map((name) => `${prefix}-${name}`);
+		result.contextualVarsJson = JSON.stringify(prefixedCtx);
+	}
+	return result;
+}
+//#endregion
+//#region pipeline/system-config.ts
+/**
+* Load a SystemInstance via the engine's `loadSystemModule` and normalize
+* it into a SystemConfig. When `prefix` is set, CSS variable names in the
+* variable map/css (and theme + contextual vars when affected) are
+* namespaced via the shared `applyPrefix`.
+*
+* Error handling stays at the call site — the Vite plugin warns (or throws
+* in strict mode) and keeps its previous config, the Next plugin lets the
+* failure propagate.
+*/
+function loadSystemConfig(engineApi, opts) {
+	const { loadSystemModule } = engineApi();
+	const config = loadSystemModule(opts.systemPath, opts.rootDir);
+	let scalesJson = config.scalesJson;
+	let variableMapJson = config.variableMapJson;
+	let variableCss = config.variableCss;
+	let contextualVarsJson = config.contextualVarsJson || null;
+	if (opts.prefix) {
+		const prefixed = applyPrefix(opts.prefix, variableMapJson, variableCss, scalesJson, contextualVarsJson || void 0);
+		variableMapJson = prefixed.variableMapJson;
+		variableCss = prefixed.variableCss;
+		if (prefixed.themeJson) scalesJson = prefixed.themeJson;
+		if (prefixed.contextualVarsJson) contextualVarsJson = prefixed.contextualVarsJson;
+	}
+	return {
+		propConfigJson: config.propConfig,
+		groupRegistryJson: config.groupRegistry,
+		scalesJson,
+		variableMapJson,
+		variableCss,
+		contextualVarsJson,
+		selectorAliasesJson: config.selectorAliases || null,
+		conditionAliasesJson: config.conditionAliases || null,
+		transformSourcesJson: config.transformSources || null,
+		globalStyleBlocksJson: config.globalStyleBlocks || null,
+		keyframesJson: config.keyframesBlocks || null,
+		dependencies: config.dependencies ?? [],
+		sourceThemeManifestsJson: config.sourceThemeManifests || null
+	};
+}
+//#endregion
+//#region pipeline/structural-self-check.ts
+/**
+* Structural self-check over an emitted extraction result — the affirmative
+* post-condition against silent-empty output (openspec:
+* standalone-extraction-cli, "Silent-empty success is impossible").
+*
+* One shared implementation for every driver: the Vite plugin's `verify`
+* option and the standalone CLI (default-on) both call this; the caller
+* owns the failure POLICY (warn vs throw vs exit code), never the checks.
+*/
+/** Run every structural check; returns human-readable failure lines
+*  (empty = pass). */
+function runStructuralSelfCheck(input) {
+	const failures = [];
+	if (input.componentCount === 0) failures.push("No component CSS produced — check the system file and its includes list");
+	else if (input.assembledCss !== void 0 ? !/@layer\s+anm-base\s*\{/.test(input.assembledCss) : input.componentCss.trim().length === 0) failures.push(`${input.componentCount} component(s) discovered but the emitted component CSS is empty`);
+	for (const { specifier, outcome } of input.externalOutcomes ?? []) if (outcome === "empty") failures.push(`include '${specifier}' resolved but discovered no component sources`);
+	else if (outcome === "unresolvable") failures.push(`include '${specifier}' could not be resolved`);
+	if (!input.variableCss.includes(":root")) failures.push("No :root variable block found in variable CSS");
+	if ((input.assembledCss ?? `${input.variableCss}\n${input.globalCss}\n${input.componentCss}`).includes("__TRANSFORM__")) failures.push("Unresolved __TRANSFORM__ placeholders found in CSS output");
+	if (input.componentCount > 0 && (input.componentCss.length > 0 || input.assembledCss !== void 0)) {
+		const assembled = input.assembledCss ?? assembleStylesheet({
+			layers: input.layers,
+			variableCss: input.variableCss,
+			globalCss: input.globalCss,
+			componentCss: input.componentCss
+		});
+		const baseIdx = assembled.search(/@layer\s+anm-base\s*\{/);
+		const variantsIdx = assembled.search(/@layer\s+anm-variants\s*\{/);
+		if (baseIdx !== -1 && variantsIdx !== -1 && baseIdx >= variantsIdx) failures.push(`CSS layer ordering violated — @layer anm-base (offset ${baseIdx}) must precede @layer anm-variants (offset ${variantsIdx})`);
+	}
+	return failures;
+}
+//#endregion
+//#region pipeline/dynamic-prop-config.ts
+function buildDynamicPropConfig(dynamicProps) {
+	const configEntries = {};
+	for (const [propName, meta] of Object.entries(dynamicProps)) {
+		if (!meta.varName || !meta.slotClass) throw new Error(`buildDynamicPropConfig: dynamic prop '${propName}' carries no slot metadata — expected varName and slotClass, got keys [${Object.keys(meta).join(", ")}].`);
+		const entry = {
+			varName: meta.varName,
+			slotClass: meta.slotClass
+		};
+		if (meta.property) entry.property = meta.property;
+		if (meta.properties && meta.properties.length > 0) entry.properties = meta.properties;
+		if (meta.transformName) entry.transformName = meta.transformName;
+		if (meta.scaleValues && Object.keys(meta.scaleValues).length > 0) entry.scaleValues = meta.scaleValues;
+		configEntries[propName] = entry;
+	}
+	return configEntries;
+}
+//#endregion
+//#region pipeline/system-props-module.ts
+/**
+* Build the source of the runtime system-props module — served as
+* `virtual:animus/system-props` by the Vite plugin and written as the
+* session-scoped `system-props.js` artifact by the extraction session
+* (`@animus-ui/extract/session`). One generator so the runtimes can never
+* drift.
+*
+* Runtime transform functions for dynamic props are not yet supported
+* (transforms are resolved at extraction time via boa_engine in Rust), so
+* `transforms` defaults to an empty object literal.
+*
+* `dynamicPropConfig` entries carry the CSS property the slot class declares
+* — the runtime's unit-fallback decision. Their field order and omission
+* rules belong to buildDynamicPropConfig.
+*/
+function buildSystemPropsModule(opts) {
+	const dynamicPropConfig = buildDynamicPropConfig(opts.dynamicProps);
+	return `export const systemPropMap = ${opts.systemPropMapJson};\nexport const systemPropGroups = ${opts.groupRegistryJson};\nexport const dynamicPropConfig = ${JSON.stringify(dynamicPropConfig)};\nexport const transforms = ${opts.transformsSource ?? "{}"};\n`;
+}
+//#endregion
+//#region pipeline/timing-waterfall.ts
+/**
+* Rust-side timing phases as reported in `manifest.timing`, in waterfall
+* order, with their display labels. Mirrors the timing struct in the
+* extract-v2 crate — a renamed or added Rust phase is updated here once,
+* not per plugin.
+*/
+const RUST_TIMING_PHASES = [
+	["parseAndWalk", "parse+walk"],
+	["importResolution", "imports"],
+	["extensionProvenance", "provenance"],
+	["topologicalSort", "topo-sort"],
+	["chainEvaluation", "chains"],
+	["jsxScanning", "jsx-scan"],
+	["systemPropAggregation", "sys-props"],
+	["usageLedger", "usage"],
+	["reconciliation", "reconcile"],
+	["cssGeneration", "css-gen"],
+	["manifestSerialization", "serialize"]
+];
+/**
+* Format the Rust timing waterfall as log lines. `indent` and `labelWidth`
+* let each plugin keep its established column layout; the phase table and
+* the `(N files, M cached)` suffix are shared.
+*/
+function formatRustTimingWaterfall(timing, opts) {
+	const lines = [];
+	for (const [key, label] of RUST_TIMING_PHASES) {
+		const ms = timing[key] ?? 0;
+		const pad = " ".repeat(Math.max(0, opts.labelWidth - label.length));
+		const extra = key === "parseAndWalk" ? `  (${timing.fileCount ?? 0} files, ${timing.cacheHits ?? 0} cached)` : "";
+		lines.push(`${opts.indent}${label}${pad}${String(ms).padStart(5)}ms${extra}`);
+	}
+	return lines;
+}
+//#endregion
+//#region pipeline/tsconfig-paths.ts
+/**
+* tsconfig `paths` → alias pairs for the Rust `pathAliasesJson` contract
+* (via `buildPathAliasesJson`). Used by drivers that cannot harvest aliases
+* from a live bundler config — Turbopack exposes none.
+*
+* Semantics (deliberately the TypeScript subset that matters for import
+* provenance): JSONC tolerated (comments + trailing commas); `extends`
+* chains followed (string or array; missing parents and cycles skipped);
+* the NEAREST config declaring `paths` wins wholesale (TS replaces the
+* object, never merges); targets resolve against the nearest `baseUrl`
+* (resolved from its declaring config's directory) or, absent one, the
+* directory of the config declaring `paths`; first target per pattern.
+* `x/*` patterns become prefix pairs, non-wildcard patterns exact pairs,
+* bare `*` catch-alls and mid-pattern wildcards are skipped.
+*/
+/** String-aware JSONC → JSON: strips // and block comments + trailing commas. */
+function stripJsonc(text) {
+	let out = "";
+	let inString = false;
+	let inLine = false;
+	let inBlock = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		const next = text[i + 1];
+		if (inLine) {
+			if (ch === "\n") {
+				inLine = false;
+				out += ch;
+			}
+			continue;
+		}
+		if (inBlock) {
+			if (ch === "*" && next === "/") {
+				inBlock = false;
+				i++;
+			}
+			continue;
+		}
+		if (inString) {
+			out += ch;
+			if (ch === "\\") {
+				out += next ?? "";
+				i++;
+			} else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			out += ch;
+			continue;
+		}
+		if (ch === "/" && next === "/") {
+			inLine = true;
+			i++;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			inBlock = true;
+			i++;
+			continue;
+		}
+		out += ch;
+	}
+	return out.replace(/,(\s*[}\]])/g, "$1");
+}
+function readConfig(path) {
+	let raw;
+	try {
+		raw = readFileSync(path, "utf-8");
+	} catch {
+		return null;
+	}
+	try {
+		const json = JSON.parse(stripJsonc(raw));
+		return {
+			dir: dirname(path),
+			compilerOptions: json.compilerOptions ?? {},
+			extends: json.extends
+		};
+	} catch {
+		return null;
+	}
+}
+function resolveExtendsTarget(specifier, fromDir) {
+	if (specifier.startsWith(".") || isAbsolute(specifier)) {
+		const base = resolve(fromDir, specifier);
+		for (const candidate of [
+			base,
+			`${base}.json`,
+			join(base, "tsconfig.json")
+		]) if (existsSync(candidate)) return candidate;
+		return null;
+	}
+	try {
+		return __require.resolve(specifier.endsWith(".json") ? specifier : `${specifier}/tsconfig.json`, { paths: [fromDir] });
+	} catch {
+		try {
+			return __require.resolve(specifier, { paths: [fromDir] });
+		} catch {
+			return null;
+		}
+	}
+}
+/** Child-first flattened extends chain starting at `entryPath`. */
+function loadChain(entryPath) {
+	const chain = [];
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [entryPath];
+	while (queue.length > 0) {
+		const key = resolve(queue.shift());
+		if (visited.has(key)) continue;
+		visited.add(key);
+		const node = readConfig(key);
+		if (!node) continue;
+		chain.push(node);
+		const parents = Array.isArray(node.extends) ? node.extends : node.extends !== void 0 ? [node.extends] : [];
+		for (const parent of parents) {
+			if (typeof parent !== "string") continue;
+			const resolved = resolveExtendsTarget(parent, node.dir);
+			if (resolved) queue.push(resolved);
+		}
+	}
+	return chain;
+}
+/**
+* Read the project's tsconfig path aliases as pairs consumable by
+* `buildPathAliasesJson`. Returns an empty array when no readable tsconfig
+* (or no usable `paths`) exists.
+*/
+function readTsconfigAliasPairs(rootDir) {
+	const chain = loadChain(join(rootDir, "tsconfig.json"));
+	if (chain.length === 0) return [];
+	const pathsOwner = chain.find((node) => node.compilerOptions.paths && typeof node.compilerOptions.paths === "object");
+	if (!pathsOwner) return [];
+	const paths = pathsOwner.compilerOptions.paths;
+	const baseOwner = chain.find((node) => typeof node.compilerOptions.baseUrl === "string");
+	const base = baseOwner ? resolve(baseOwner.dir, baseOwner.compilerOptions.baseUrl) : pathsOwner.dir;
+	const pairs = [];
+	for (const [pattern, targets] of Object.entries(paths)) {
+		const target = Array.isArray(targets) ? targets[0] : void 0;
+		if (typeof target !== "string") continue;
+		const patternStars = pattern.split("*").length - 1;
+		const targetStars = target.split("*").length - 1;
+		if (pattern === "*" || patternStars > 1 || targetStars > 1) continue;
+		if (pattern.endsWith("/*")) {
+			if (!target.endsWith("/*")) continue;
+			pairs.push({
+				pattern: pattern.slice(0, -2),
+				target: resolve(base, target.slice(0, -2)),
+				kind: "prefix"
+			});
+			continue;
+		}
+		if (patternStars > 0 || targetStars > 0) continue;
+		pairs.push({
+			pattern,
+			target: resolve(base, target),
+			kind: "exact"
+		});
+	}
+	return pairs;
+}
+//#endregion
+//#region pipeline/error-diagnostics.ts
+/**
+* Throw when the diagnostics carry any `kind: "error"` entry — one
+* aggregated `Error` naming EVERY offender (component, file, message — one
+* line per entry, each prefixed `[animus]`). Warning-only diagnostics
+* (`bail`/`skip`/`warn`, any severity) never trip this gate; their routing
+* stays with `surfaceManifestDiagnostics`. Callers accept the manifest only
+* past this point, so no stylesheet from a failing analysis is published.
+*/
+function assertNoErrorDiagnostics(diagnostics) {
+	const errors = (diagnostics ?? []).filter((diagnostic) => diagnostic.kind === "error");
+	if (errors.length === 0) return;
+	const lines = [...new Set(errors.map((diagnostic) => `[animus] ${diagnostic.component || "<unknown component>"} (${diagnostic.file || "<unknown file>"}): ${diagnostic.message || "<no message>"}`))];
+	throw new Error(lines.join("\n"));
+}
+//#endregion
+//#region pipeline/replacement-plans.ts
+const snapshotByManifest = /* @__PURE__ */ new WeakMap();
+function snapshotFilePlans(manifest) {
+	const memoKey = manifest !== null && typeof manifest === "object" ? manifest : null;
+	if (memoKey) {
+		const cached = snapshotByManifest.get(memoKey);
+		if (cached) return cached;
+	}
+	const entriesByFile = /* @__PURE__ */ new Map();
+	for (const [id, desc] of Object.entries(manifest?.components ?? {})) {
+		const file = desc.file;
+		if (!file) continue;
+		const list = entriesByFile.get(file) ?? [];
+		list.push([id, desc.replacement ?? ""]);
+		entriesByFile.set(file, list);
+	}
+	const snapshot = /* @__PURE__ */ new Map();
+	for (const [file, entries] of entriesByFile) {
+		entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+		snapshot.set(file, JSON.stringify(entries));
+	}
+	if (memoKey) snapshotByManifest.set(memoKey, snapshot);
+	return snapshot;
+}
+/**
+* Rel paths whose plan changed between two snapshots: absent→present,
+* present→absent, and any change to membership or replacement content.
+* `exclude` drops one path (the changed file itself on the edit path — its
+* own modules are already in the update set).
+*/
+function diffFilePlans(prev, next, opts) {
+	const changed = /* @__PURE__ */ new Set();
+	for (const [file, plan] of next) if (prev.get(file) !== plan) changed.add(file);
+	for (const file of prev.keys()) if (!next.has(file)) changed.add(file);
+	if (opts?.exclude) changed.delete(opts.exclude);
+	return [...changed].sort();
+}
+/** Domain prefix keeping the epoch hash disjoint from every other
+*  contentHash use in the pipeline (design D5). */
+const REPLACEMENT_PLANS_DOMAIN = "animus-replacement-plans-v1\0";
+/** Section marker for the served-dependency witness. Leads with NUL: every
+*  plan entry ends `…\0` and neither file paths nor plan JSON contain NUL,
+*  so `\0\0` is unreachable from entry serialization alone — a snapshot can
+*  never forge the witness section. */
+const SERVED_DEPENDENCY_DOMAIN = "\0animus-served-dependency-v1\0";
+/**
+* Canonical replacement epoch: contentHash over the domain-prefixed, sorted
+* canonical serialization of a file-plan snapshot — each entry contributes
+* `file + '\0' + plan + '\0'` (unambiguous: neither file paths nor the
+* JSON plan strings contain NUL). Byte-identical plans → identical epoch;
+* any membership/replacement/absent↔present change moves it.
+*
+* `servedDependencyWitness` extends the epoch to content the plans cannot
+* see but restored modules depend on: transformed modules import the
+* session's served system-props artifact, so a consumer passes that
+* artifact's content here and an offline change to it moves the epoch —
+* invalidating persistent-cache snapshots that reference the old epoch
+* artifact. Absence and empty-string are distinct values.
+*
+* This is THE epoch definition — integrations consume this hash (or the
+* snapshot diff) and never define their own. Epoch values compare only for
+* equality (a moved value invalidates), so the serialization is free to
+* evolve with a domain bump: sessions running different serializations
+* simply disagree once and rebuild.
+*/
+function hashReplacementPlans(snapshot, servedDependencyWitness) {
+	const entries = [...snapshot.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	let serialized = REPLACEMENT_PLANS_DOMAIN;
+	for (const [file, plan] of entries) serialized += file + "\0" + plan + "\0";
+	if (servedDependencyWitness !== void 0) serialized += SERVED_DEPENDENCY_DOMAIN + servedDependencyWitness;
+	return contentHash(serialized);
+}
+//#endregion
+//#region pipeline/utils.ts
+/** Convert camelCase CSS property names to kebab-case. */
+function camelToKebab(str) {
+	return str.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+//#endregion
+//#region pipeline/watch-keys.ts
+/**
+* Membership keys for a filesystem path in the system-dependency watch set.
+*
+* The loader reports symlink-resolved canonical paths; watcher events carry
+* lexical absolute paths that may traverse symlinks (bun workspace links) and
+* — for deletions — may no longer exist, so `realpathSync` on the event path
+* alone cannot produce the canonical form. Both insertion and lookup go
+* through this one normalizer: the lexical form plus a canonical form
+* reconstructed through the nearest existing ancestor.
+*/
+function toWatchKeys(input) {
+	const lexical = normalize(input);
+	const canonical = realpathThroughNearestExistingAncestor(lexical);
+	return canonical === lexical ? [lexical] : [lexical, canonical];
+}
+/**
+* Canonicalize a path that may not exist: walk up to the nearest existing
+* ancestor, realpath it, and re-append the missing suffix. Handles deleted
+* files under still-existing (possibly symlinked) directories and atomic
+* unlink/rename saves. Falls back to the input when no ancestor resolves.
+*
+* Known limit: a symlink retargeted AFTER the system load canonicalizes to
+* the new target, which cannot match the recorded (old-target) dependency —
+* the membership test then fails open (no reset), identical to not having
+* this reconstruction at all. Retarget sensitivity is a resolution-input
+* concern, deliberately out of scope for the watch set.
+*/
+function realpathThroughNearestExistingAncestor(path) {
+	try {
+		return realpathSync$1(path);
+	} catch {}
+	const suffix = [];
+	let current = path;
+	for (;;) {
+		const parent = dirname$1(current);
+		if (parent === current) return path;
+		suffix.unshift(basename$1(current));
+		current = parent;
+		try {
+			return join$1(realpathSync$1(current), ...suffix);
+		} catch {}
+	}
+}
+//#endregion
+export { CORE_OPTION_KEYS as $, createSourceIngestor as A, extractSystemFilePackages as B, resolveLightningTargets as C, resolveThroughPathAliases as D, resolveAssetFile as E, ENGINE_TRANSFORM_EXTENSIONS as F, staleDistIncludesMessage as G, firstOwners as H, preprocessMdx as I, createSourceIdentity as J, unresolvableIncludesMessage as K, adaptSvelteSource as L, isAdvisorySourceDiagnostic as M, withoutInvalidOriginals as N, findAssetSpecifiers as O, DEFAULT_EXTENSIONS as P, AnimusConfigError as Q, collectExternalPackageSources as R, postProcessCss as S, enforceExternalTokenContracts as T, isExcludedPackageRelativePath as U, findPackageRoot as V, resolveAbsolutePathSpecifier as W, sharesVolumeRoot as X, isPathWithinRoot as Y, discoverFiles as Z, runProjectAnalysis as _, stripLeadingLayerDeclaration as _t, snapshotFilePlans as a, createExcludeMatcher as at, surfaceManifestDiagnostics as b, formatRustTimingWaterfall as c, KEYFRAMES_EXTERNAL_ENTRY_FAILED as ct, runStructuralSelfCheck as d, RETIRED_ENGINE_MESSAGE as dt, DEFAULT_EXCLUDE as et, loadSystemConfig as f, assertNoRetiredEngineSelection as ft, clearEngineCache as g, assembleStylesheet as gt, buildAnalysisInputs as h, ANIMUS_LAYERS as ht, hashReplacementPlans as i, assertKnownOptionKeys as it, ingestSourceEntries as j, substituteAssetPlaceholders as k, buildSystemPropsModule as l, mergeExternalKeyframes as lt, serializeStaticCss as m, buildAnalyzeProjectArgs as mt, camelToKebab as n, REPLACEABLE_DEFAULT_EXCLUDE as nt, assertNoErrorDiagnostics as o, resolveMode as ot, applyPrefix as p, createV2EngineApi as pt, walkPackageSources as q, diffFilePlans as r, STRUCTURAL_EXCLUDE as rt, readTsconfigAliasPairs as s, KEYFRAMES_EXPORT_COLLISION as st, toWatchKeys as t, DRIVER_NAMESPACES as tt, buildDynamicPropConfig as u, contentHash as ut, applyUnitFallback as v, validateLayerOrder as vt, buildPathAliasesJson as w, unresolvedParentName as x, isUnresolvedParentDrop as y, __require as yt, excludeCollectedPackages as z };