@animus-ui/extract 0.1.9 → 0.1.11

package/dist/pipeline-ojNeABi0.cjs

@@ -0,0 +1,3685 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let crypto = require("crypto");
+let fs = require("fs");
+let path = require("path");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let module$1 = require("module");
+let browserslist = require("browserslist");
+browserslist = __toESM(browserslist);
+let lightningcss = require("lightningcss");
+let _animus_ui_properties = require("@animus-ui/properties");
+//#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 (0, crypto.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 = (0, fs.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 = (0, path.join)(dir, entry);
+		if (isExcluded(fullPath, (0, path.relative)(rootDir, fullPath))) continue;
+		let stat;
+		try {
+			stat = (0, fs.statSync)(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, exclude, extensionsSet));
+		else if (extensionsSet.has((0, path.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 = node_path.default) {
+	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 = node_path.default) {
+	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
+	return volumeOf(a) === volumeOf(b);
+}
+function canonicalize(p) {
+	try {
+		return (0, node_fs.realpathSync)(p);
+	} catch {
+		return null;
+	}
+}
+function createSourceIdentity(rootDir) {
+	const normalizedRootDir = node_path.default.normalize(rootDir);
+	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
+	const roots = [];
+	const aliases = /* @__PURE__ */ new Map();
+	const owningRecord = (canonicalPath) => {
+		let owner = null;
+		for (const record of roots) {
+			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
+			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+		}
+		return owner;
+	};
+	return {
+		rootDir: normalizedRootDir,
+		canonicalRootDir,
+		registerExternalRoot(root) {
+			const asRegistered = node_path.default.normalize(root);
+			const canonical = canonicalize(asRegistered) ?? asRegistered;
+			const existing = roots.find((record) => record.canonical === canonical);
+			if (existing) return existing.canonical;
+			roots.push({
+				asRegistered,
+				canonical
+			});
+			return canonical;
+		},
+		externalRoots() {
+			return roots.map((record) => record.canonical);
+		},
+		resolveSourceId(inputPath) {
+			const lexical = node_path.default.normalize(inputPath);
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			const owner = owningRecord(canonical);
+			const ownedBy = (record) => {
+				const pathInRoot = node_path.default.relative(record.canonical, canonical);
+				return {
+					sourceKey: node_path.default.relative(normalizedRootDir, node_path.default.join(record.asRegistered, pathInRoot)),
+					owningRoot: record.canonical,
+					pathInRoot
+				};
+			};
+			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
+			let resolved;
+			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
+				const key = node_path.default.relative(canonicalRootDir, canonical);
+				resolved = {
+					sourceKey: key,
+					owningRoot: null,
+					pathInRoot: key
+				};
+			} else if (owner) resolved = ownedBy(owner);
+			else return null;
+			aliases.set(lexical, resolved);
+			aliases.set(canonical, resolved);
+			return resolved;
+		},
+		resolveDeletedSourceId(inputPath) {
+			return aliases.get(node_path.default.normalize(inputPath)) ?? null;
+		},
+		containingExternalRoot(inputPath) {
+			const lexical = node_path.default.normalize(inputPath);
+			let owner = null;
+			for (const record of roots) {
+				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			if (owner) return owner.canonical;
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			for (const record of roots) {
+				if (!isPathWithinRoot(record.canonical, canonical)) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			return owner?.canonical ?? null;
+		}
+	};
+}
+//#endregion
+//#region pipeline/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 = (0, path.dirname)(absEntryPath);
+	while (pkgRoot !== (0, path.dirname)(pkgRoot) && !(0, fs.existsSync)((0, path.join)(pkgRoot, "package.json"))) pkgRoot = (0, path.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((0, path.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$3) => {
+	try {
+		return (0, fs.statSync)(path$3).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) => (0, path.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 ((0, path.isAbsolute)(specifier)) {
+		const resolved = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		if (!resolved) return null;
+		return isPathWithinRoot(srcDir, resolved) ? resolved : null;
+	}
+	const packageName = bareSpecifierPackageName(specifier);
+	return resolveAbsolutePathSpecifier((0, path.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 = (0, fs.statSync)(absEntry).mtimeMs;
+	} catch {
+		return false;
+	}
+	let newestSrcMtime = -Infinity;
+	for (const srcFile of srcFiles) try {
+		newestSrcMtime = Math.max(newestSrcMtime, (0, fs.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 && (0, path.isAbsolute)(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		if (!absEntry) {
+			outcomes.push({
+				specifier,
+				outcome: "unresolvable",
+				fileCount: 0
+			});
+			continue;
+		}
+		const srcDir = (0, path.join)(findPackageRoot(absEntry), "src");
+		let fileCount = 0;
+		let staleDist = false;
+		if ((0, fs.existsSync)(srcDir)) {
+			packageDirs.push(srcDir);
+			claimDir(srcDir, specifier);
+			dirExtensions[srcDir] = [...extensionsSet];
+			onPackageResolved?.(specifier, srcDir);
+			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
+			if (srcEntry) {
+				packageMap[specifier] = (0, path.relative)(rootDir, srcEntry);
+				sourceEntries.set(specifier, srcEntry);
+			} else packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
+			keyframesScanEntries.set(specifier, srcEntry ?? absEntry);
+			if (!(0, path.isAbsolute)(specifier)) {
+				const packageName = bareSpecifierPackageName(specifier);
+				if (packageName !== specifier && !(packageName in packageMap)) {
+					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
+					if (rootEntry) {
+						packageMap[packageName] = (0, path.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 = (0, path.relative)(rootDir, pkgFile);
+				if (alreadyIngested(relPath)) {
+					fileCount++;
+					continue;
+				}
+				let source;
+				try {
+					source = (0, fs.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 = (0, path.dirname)(absEntry);
+			packageDirs.push(outputDir);
+			claimDir(outputDir, specifier);
+			onPackageResolved?.(specifier, outputDir);
+			packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
+			keyframesScanEntries.set(specifier, absEntry);
+			const outputExtensions = new Set(extensionsSet);
+			outputExtensions.add((0, path.extname)(absEntry));
+			dirExtensions[outputDir] = [...outputExtensions];
+			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
+				const relToOutput = (0, path.relative)(outputDir, file);
+				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
+			});
+			if (!outputFiles.includes(absEntry)) outputFiles.unshift(absEntry);
+			for (const outputFile of outputFiles) {
+				const outputRelPath = (0, path.relative)(rootDir, outputFile);
+				if (alreadyIngested(outputRelPath)) {
+					fileCount++;
+					continue;
+				}
+				let source;
+				try {
+					source = (0, fs.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, (0, path.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 = (0, fs.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 = (0, path.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((0, path.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 = node_path.posix.basename(path);
+	const dot = basename.lastIndexOf(".");
+	return dot === -1 ? "" : basename.slice(dot).toLowerCase();
+}
+function canonicalResolverPath(path) {
+	return node_path.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 = node_path.posix.normalize(node_path.posix.join(node_path.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 = (0, module$1.createRequire)((0, path.join)(rootDir, "package.json"));
+		requireByRoot.set(rootDir, req);
+	}
+	return req;
+}
+function packageRootFromEntry(entry) {
+	let current = (0, path.dirname)(entry);
+	while (true) {
+		if ((0, fs.existsSync)((0, path.join)(current, "package.json"))) return current;
+		const parent = (0, path.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 = (0, path.isAbsolute)(mapped) ? mapped : (0, path.join)(rootDir, mapped);
+		if ((0, fs.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 = (0, path.join)(modulesDir, packageName);
+		if (!(0, fs.existsSync)((0, path.join)(packageRoot, "package.json"))) continue;
+		const candidate = (0, path.join)(packageRoot, subpath);
+		if ((0, fs.existsSync)(candidate)) return candidate;
+	}
+	try {
+		const packageRoot = packageRootFromEntry(requireFromRoot.resolve(packageName));
+		if (!packageRoot) return null;
+		const candidate = (0, path.join)(packageRoot, subpath);
+		return (0, fs.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 = (0, fs.realpathSync)(dir);
+		} catch {}
+		addOwnerDir(real, specifier);
+		let packageRoot = real;
+		while (packageRoot !== (0, path.dirname)(packageRoot) && !(0, fs.existsSync)((0, path.join)(packageRoot, "package.json"))) packageRoot = (0, path.dirname)(packageRoot);
+		if ((0, fs.existsSync)((0, path.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 = (0, browserslist.default)(void 0, { path: rootDir });
+		queries = detected.length > 0 ? detected : (0, browserslist.default)("defaults");
+	}
+	return (0, lightningcss.browserslistToTargets)(Array.isArray(queries) && typeof queries[0] === "string" && queries[0].includes(" ") ? (0, browserslist.default)(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 (0, lightningcss.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 ((0, _animus_ui_properties.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$2) {
+	let raw;
+	try {
+		raw = (0, fs.readFileSync)(path$2, "utf-8");
+	} catch {
+		return null;
+	}
+	try {
+		const json = JSON.parse(stripJsonc(raw));
+		return {
+			dir: (0, path.dirname)(path$2),
+			compilerOptions: json.compilerOptions ?? {},
+			extends: json.extends
+		};
+	} catch {
+		return null;
+	}
+}
+function resolveExtendsTarget(specifier, fromDir) {
+	if (specifier.startsWith(".") || (0, path.isAbsolute)(specifier)) {
+		const base = (0, path.resolve)(fromDir, specifier);
+		for (const candidate of [
+			base,
+			`${base}.json`,
+			(0, path.join)(base, "tsconfig.json")
+		]) if ((0, fs.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 = (0, path.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((0, path.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 ? (0, path.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: (0, path.resolve)(base, target.slice(0, -2)),
+				kind: "prefix"
+			});
+			continue;
+		}
+		if (patternStars > 0 || targetStars > 0) continue;
+		pairs.push({
+			pattern,
+			target: (0, path.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 = (0, node_path.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 (0, node_fs.realpathSync)(path);
+	} catch {}
+	const suffix = [];
+	let current = path;
+	for (;;) {
+		const parent = (0, node_path.dirname)(current);
+		if (parent === current) return path;
+		suffix.unshift((0, node_path.basename)(current));
+		current = parent;
+		try {
+			return (0, node_path.join)((0, node_fs.realpathSync)(current), ...suffix);
+		} catch {}
+	}
+}
+//#endregion
+Object.defineProperty(exports, "ANIMUS_LAYERS", {
+	enumerable: true,
+	get: function() {
+		return ANIMUS_LAYERS;
+	}
+});
+Object.defineProperty(exports, "AnimusConfigError", {
+	enumerable: true,
+	get: function() {
+		return AnimusConfigError;
+	}
+});
+Object.defineProperty(exports, "CORE_OPTION_KEYS", {
+	enumerable: true,
+	get: function() {
+		return CORE_OPTION_KEYS;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_EXCLUDE", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_EXCLUDE;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_EXTENSIONS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_EXTENSIONS;
+	}
+});
+Object.defineProperty(exports, "DRIVER_NAMESPACES", {
+	enumerable: true,
+	get: function() {
+		return DRIVER_NAMESPACES;
+	}
+});
+Object.defineProperty(exports, "ENGINE_TRANSFORM_EXTENSIONS", {
+	enumerable: true,
+	get: function() {
+		return ENGINE_TRANSFORM_EXTENSIONS;
+	}
+});
+Object.defineProperty(exports, "KEYFRAMES_EXPORT_COLLISION", {
+	enumerable: true,
+	get: function() {
+		return KEYFRAMES_EXPORT_COLLISION;
+	}
+});
+Object.defineProperty(exports, "KEYFRAMES_EXTERNAL_ENTRY_FAILED", {
+	enumerable: true,
+	get: function() {
+		return KEYFRAMES_EXTERNAL_ENTRY_FAILED;
+	}
+});
+Object.defineProperty(exports, "REPLACEABLE_DEFAULT_EXCLUDE", {
+	enumerable: true,
+	get: function() {
+		return REPLACEABLE_DEFAULT_EXCLUDE;
+	}
+});
+Object.defineProperty(exports, "RETIRED_ENGINE_MESSAGE", {
+	enumerable: true,
+	get: function() {
+		return RETIRED_ENGINE_MESSAGE;
+	}
+});
+Object.defineProperty(exports, "STRUCTURAL_EXCLUDE", {
+	enumerable: true,
+	get: function() {
+		return STRUCTURAL_EXCLUDE;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "adaptSvelteSource", {
+	enumerable: true,
+	get: function() {
+		return adaptSvelteSource;
+	}
+});
+Object.defineProperty(exports, "applyPrefix", {
+	enumerable: true,
+	get: function() {
+		return applyPrefix;
+	}
+});
+Object.defineProperty(exports, "applyUnitFallback", {
+	enumerable: true,
+	get: function() {
+		return applyUnitFallback;
+	}
+});
+Object.defineProperty(exports, "assembleStylesheet", {
+	enumerable: true,
+	get: function() {
+		return assembleStylesheet;
+	}
+});
+Object.defineProperty(exports, "assertKnownOptionKeys", {
+	enumerable: true,
+	get: function() {
+		return assertKnownOptionKeys;
+	}
+});
+Object.defineProperty(exports, "assertNoErrorDiagnostics", {
+	enumerable: true,
+	get: function() {
+		return assertNoErrorDiagnostics;
+	}
+});
+Object.defineProperty(exports, "assertNoRetiredEngineSelection", {
+	enumerable: true,
+	get: function() {
+		return assertNoRetiredEngineSelection;
+	}
+});
+Object.defineProperty(exports, "buildAnalysisInputs", {
+	enumerable: true,
+	get: function() {
+		return buildAnalysisInputs;
+	}
+});
+Object.defineProperty(exports, "buildAnalyzeProjectArgs", {
+	enumerable: true,
+	get: function() {
+		return buildAnalyzeProjectArgs;
+	}
+});
+Object.defineProperty(exports, "buildDynamicPropConfig", {
+	enumerable: true,
+	get: function() {
+		return buildDynamicPropConfig;
+	}
+});
+Object.defineProperty(exports, "buildPathAliasesJson", {
+	enumerable: true,
+	get: function() {
+		return buildPathAliasesJson;
+	}
+});
+Object.defineProperty(exports, "buildSystemPropsModule", {
+	enumerable: true,
+	get: function() {
+		return buildSystemPropsModule;
+	}
+});
+Object.defineProperty(exports, "camelToKebab", {
+	enumerable: true,
+	get: function() {
+		return camelToKebab;
+	}
+});
+Object.defineProperty(exports, "clearEngineCache", {
+	enumerable: true,
+	get: function() {
+		return clearEngineCache;
+	}
+});
+Object.defineProperty(exports, "collectExternalPackageSources", {
+	enumerable: true,
+	get: function() {
+		return collectExternalPackageSources;
+	}
+});
+Object.defineProperty(exports, "contentHash", {
+	enumerable: true,
+	get: function() {
+		return contentHash;
+	}
+});
+Object.defineProperty(exports, "createExcludeMatcher", {
+	enumerable: true,
+	get: function() {
+		return createExcludeMatcher;
+	}
+});
+Object.defineProperty(exports, "createSourceIdentity", {
+	enumerable: true,
+	get: function() {
+		return createSourceIdentity;
+	}
+});
+Object.defineProperty(exports, "createSourceIngestor", {
+	enumerable: true,
+	get: function() {
+		return createSourceIngestor;
+	}
+});
+Object.defineProperty(exports, "createV2EngineApi", {
+	enumerable: true,
+	get: function() {
+		return createV2EngineApi;
+	}
+});
+Object.defineProperty(exports, "diffFilePlans", {
+	enumerable: true,
+	get: function() {
+		return diffFilePlans;
+	}
+});
+Object.defineProperty(exports, "discoverFiles", {
+	enumerable: true,
+	get: function() {
+		return discoverFiles;
+	}
+});
+Object.defineProperty(exports, "enforceExternalTokenContracts", {
+	enumerable: true,
+	get: function() {
+		return enforceExternalTokenContracts;
+	}
+});
+Object.defineProperty(exports, "excludeCollectedPackages", {
+	enumerable: true,
+	get: function() {
+		return excludeCollectedPackages;
+	}
+});
+Object.defineProperty(exports, "extractSystemFilePackages", {
+	enumerable: true,
+	get: function() {
+		return extractSystemFilePackages;
+	}
+});
+Object.defineProperty(exports, "findAssetSpecifiers", {
+	enumerable: true,
+	get: function() {
+		return findAssetSpecifiers;
+	}
+});
+Object.defineProperty(exports, "findPackageRoot", {
+	enumerable: true,
+	get: function() {
+		return findPackageRoot;
+	}
+});
+Object.defineProperty(exports, "firstOwners", {
+	enumerable: true,
+	get: function() {
+		return firstOwners;
+	}
+});
+Object.defineProperty(exports, "formatRustTimingWaterfall", {
+	enumerable: true,
+	get: function() {
+		return formatRustTimingWaterfall;
+	}
+});
+Object.defineProperty(exports, "hashReplacementPlans", {
+	enumerable: true,
+	get: function() {
+		return hashReplacementPlans;
+	}
+});
+Object.defineProperty(exports, "ingestSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return ingestSourceEntries;
+	}
+});
+Object.defineProperty(exports, "isAdvisorySourceDiagnostic", {
+	enumerable: true,
+	get: function() {
+		return isAdvisorySourceDiagnostic;
+	}
+});
+Object.defineProperty(exports, "isExcludedPackageRelativePath", {
+	enumerable: true,
+	get: function() {
+		return isExcludedPackageRelativePath;
+	}
+});
+Object.defineProperty(exports, "isPathWithinRoot", {
+	enumerable: true,
+	get: function() {
+		return isPathWithinRoot;
+	}
+});
+Object.defineProperty(exports, "isUnresolvedParentDrop", {
+	enumerable: true,
+	get: function() {
+		return isUnresolvedParentDrop;
+	}
+});
+Object.defineProperty(exports, "loadSystemConfig", {
+	enumerable: true,
+	get: function() {
+		return loadSystemConfig;
+	}
+});
+Object.defineProperty(exports, "mergeExternalKeyframes", {
+	enumerable: true,
+	get: function() {
+		return mergeExternalKeyframes;
+	}
+});
+Object.defineProperty(exports, "postProcessCss", {
+	enumerable: true,
+	get: function() {
+		return postProcessCss;
+	}
+});
+Object.defineProperty(exports, "preprocessMdx", {
+	enumerable: true,
+	get: function() {
+		return preprocessMdx;
+	}
+});
+Object.defineProperty(exports, "readTsconfigAliasPairs", {
+	enumerable: true,
+	get: function() {
+		return readTsconfigAliasPairs;
+	}
+});
+Object.defineProperty(exports, "resolveAbsolutePathSpecifier", {
+	enumerable: true,
+	get: function() {
+		return resolveAbsolutePathSpecifier;
+	}
+});
+Object.defineProperty(exports, "resolveAssetFile", {
+	enumerable: true,
+	get: function() {
+		return resolveAssetFile;
+	}
+});
+Object.defineProperty(exports, "resolveLightningTargets", {
+	enumerable: true,
+	get: function() {
+		return resolveLightningTargets;
+	}
+});
+Object.defineProperty(exports, "resolveMode", {
+	enumerable: true,
+	get: function() {
+		return resolveMode;
+	}
+});
+Object.defineProperty(exports, "resolveThroughPathAliases", {
+	enumerable: true,
+	get: function() {
+		return resolveThroughPathAliases;
+	}
+});
+Object.defineProperty(exports, "runProjectAnalysis", {
+	enumerable: true,
+	get: function() {
+		return runProjectAnalysis;
+	}
+});
+Object.defineProperty(exports, "runStructuralSelfCheck", {
+	enumerable: true,
+	get: function() {
+		return runStructuralSelfCheck;
+	}
+});
+Object.defineProperty(exports, "serializeStaticCss", {
+	enumerable: true,
+	get: function() {
+		return serializeStaticCss;
+	}
+});
+Object.defineProperty(exports, "sharesVolumeRoot", {
+	enumerable: true,
+	get: function() {
+		return sharesVolumeRoot;
+	}
+});
+Object.defineProperty(exports, "snapshotFilePlans", {
+	enumerable: true,
+	get: function() {
+		return snapshotFilePlans;
+	}
+});
+Object.defineProperty(exports, "staleDistIncludesMessage", {
+	enumerable: true,
+	get: function() {
+		return staleDistIncludesMessage;
+	}
+});
+Object.defineProperty(exports, "stripLeadingLayerDeclaration", {
+	enumerable: true,
+	get: function() {
+		return stripLeadingLayerDeclaration;
+	}
+});
+Object.defineProperty(exports, "substituteAssetPlaceholders", {
+	enumerable: true,
+	get: function() {
+		return substituteAssetPlaceholders;
+	}
+});
+Object.defineProperty(exports, "surfaceManifestDiagnostics", {
+	enumerable: true,
+	get: function() {
+		return surfaceManifestDiagnostics;
+	}
+});
+Object.defineProperty(exports, "toWatchKeys", {
+	enumerable: true,
+	get: function() {
+		return toWatchKeys;
+	}
+});
+Object.defineProperty(exports, "unresolvableIncludesMessage", {
+	enumerable: true,
+	get: function() {
+		return unresolvableIncludesMessage;
+	}
+});
+Object.defineProperty(exports, "unresolvedParentName", {
+	enumerable: true,
+	get: function() {
+		return unresolvedParentName;
+	}
+});
+Object.defineProperty(exports, "validateLayerOrder", {
+	enumerable: true,
+	get: function() {
+		return validateLayerOrder;
+	}
+});
+Object.defineProperty(exports, "walkPackageSources", {
+	enumerable: true,
+	get: function() {
+		return walkPackageSources;
+	}
+});
+Object.defineProperty(exports, "withoutInvalidOriginals", {
+	enumerable: true,
+	get: function() {
+		return withoutInvalidOriginals;
+	}
+});