@animus-ui/extract 0.1.9 → 0.1.11

package/dist/index.cjs

@@ -1,2102 +1,74 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#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,
-			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/discover-files.ts
-/**
-* Recursively discover source files under `dir`, skipping any path that
-* contains one of `excludePatterns` (matched as substrings of both the full
-* and root-relative path) and keeping files whose extension is in
-* `extensionsSet`.
-*
-* Single authoritative copy for both extraction plugins.
-*/
-function discoverFiles(dir, rootDir, excludePatterns, extensionsSet) {
-	const results = [];
-	let entries;
-	try {
-		entries = (0, fs.readdirSync)(dir, { encoding: "utf8" });
-	} catch {
-		return results;
-	}
-	for (const entry of entries) {
-		const fullPath = (0, path.join)(dir, entry);
-		const relativePath = (0, path.relative)(rootDir, fullPath);
-		if (excludePatterns.some((pattern) => fullPath.includes(pattern) || relativePath.includes(pattern))) continue;
-		let stat;
-		try {
-			stat = (0, fs.statSync)(fullPath);
-		} catch {
-			continue;
-		}
-		if (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, excludePatterns, 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, [], 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, preprocessFile, 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;
-				}
-				const processed = await preprocessFile(source, relPath, pkgFile);
-				if (!processed) continue;
-				entries.push({
-					path: processed.relPath,
-					source: processed.source
-				});
-				pushed.add(processed.relPath);
-				fileOwners[processed.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, [], 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;
-				}
-				const processed = await preprocessFile(source, outputRelPath, outputFile);
-				if (!processed) continue;
-				entries.push({
-					path: processed.relPath,
-					source: processed.source
-				});
-				pushed.add(processed.relPath);
-				fileOwners[processed.relPath] ??= 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/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/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 to
-* `.animus/system-props.js` by the Next plugin. One generator so the two
-* 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/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"
-];
-/**
-* 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/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
-exports.ANIMUS_LAYERS = ANIMUS_LAYERS;
-exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
-exports.KEYFRAMES_EXPORT_COLLISION = KEYFRAMES_EXPORT_COLLISION;
-exports.KEYFRAMES_EXTERNAL_ENTRY_FAILED = KEYFRAMES_EXTERNAL_ENTRY_FAILED;
-exports.RETIRED_ENGINE_MESSAGE = RETIRED_ENGINE_MESSAGE;
-exports.applyPrefix = applyPrefix;
-exports.applyUnitFallback = applyUnitFallback;
-exports.assembleStylesheet = assembleStylesheet;
-exports.assertNoErrorDiagnostics = assertNoErrorDiagnostics;
-exports.assertNoRetiredEngineSelection = assertNoRetiredEngineSelection;
-exports.buildAnalysisInputs = buildAnalysisInputs;
-exports.buildAnalyzeProjectArgs = buildAnalyzeProjectArgs;
-exports.buildDynamicPropConfig = buildDynamicPropConfig;
-exports.buildPathAliasesJson = buildPathAliasesJson;
-exports.buildSystemPropsModule = buildSystemPropsModule;
-exports.camelToKebab = camelToKebab;
-exports.clearEngineCache = clearEngineCache;
-exports.collectExternalPackageSources = collectExternalPackageSources;
-exports.contentHash = contentHash;
-exports.createSourceIdentity = createSourceIdentity;
-exports.createV2EngineApi = createV2EngineApi;
-exports.diffFilePlans = diffFilePlans;
-exports.discoverFiles = discoverFiles;
-exports.enforceExternalTokenContracts = enforceExternalTokenContracts;
-exports.excludeCollectedPackages = excludeCollectedPackages;
-exports.extractSystemFilePackages = extractSystemFilePackages;
-exports.findAssetSpecifiers = findAssetSpecifiers;
-exports.findPackageRoot = findPackageRoot;
-exports.firstOwners = firstOwners;
-exports.formatRustTimingWaterfall = formatRustTimingWaterfall;
-exports.hashReplacementPlans = hashReplacementPlans;
-exports.isExcludedPackageRelativePath = isExcludedPackageRelativePath;
-exports.isPathWithinRoot = isPathWithinRoot;
-exports.isUnresolvedParentDrop = isUnresolvedParentDrop;
-exports.loadSystemConfig = loadSystemConfig;
-exports.mergeExternalKeyframes = mergeExternalKeyframes;
-exports.postProcessCss = postProcessCss;
-exports.preprocessMdx = preprocessMdx;
-exports.readTsconfigAliasPairs = readTsconfigAliasPairs;
-exports.resolveAbsolutePathSpecifier = resolveAbsolutePathSpecifier;
-exports.resolveAssetFile = resolveAssetFile;
-exports.resolveLightningTargets = resolveLightningTargets;
-exports.resolveThroughPathAliases = resolveThroughPathAliases;
-exports.runProjectAnalysis = runProjectAnalysis;
-exports.serializeStaticCss = serializeStaticCss;
-exports.sharesVolumeRoot = sharesVolumeRoot;
-exports.snapshotFilePlans = snapshotFilePlans;
-exports.staleDistIncludesMessage = staleDistIncludesMessage;
-exports.stripLeadingLayerDeclaration = stripLeadingLayerDeclaration;
-exports.substituteAssetPlaceholders = substituteAssetPlaceholders;
-exports.surfaceManifestDiagnostics = surfaceManifestDiagnostics;
-exports.toWatchKeys = toWatchKeys;
-exports.unresolvableIncludesMessage = unresolvableIncludesMessage;
-exports.unresolvedParentName = unresolvedParentName;
-exports.validateLayerOrder = validateLayerOrder;
-exports.walkPackageSources = walkPackageSources;
+const require_pipeline = require("./pipeline-ojNeABi0.cjs");
+exports.ANIMUS_LAYERS = require_pipeline.ANIMUS_LAYERS;
+exports.AnimusConfigError = require_pipeline.AnimusConfigError;
+exports.CORE_OPTION_KEYS = require_pipeline.CORE_OPTION_KEYS;
+exports.DEFAULT_EXCLUDE = require_pipeline.DEFAULT_EXCLUDE;
+exports.DEFAULT_EXTENSIONS = require_pipeline.DEFAULT_EXTENSIONS;
+exports.DRIVER_NAMESPACES = require_pipeline.DRIVER_NAMESPACES;
+exports.ENGINE_TRANSFORM_EXTENSIONS = require_pipeline.ENGINE_TRANSFORM_EXTENSIONS;
+exports.KEYFRAMES_EXPORT_COLLISION = require_pipeline.KEYFRAMES_EXPORT_COLLISION;
+exports.KEYFRAMES_EXTERNAL_ENTRY_FAILED = require_pipeline.KEYFRAMES_EXTERNAL_ENTRY_FAILED;
+exports.REPLACEABLE_DEFAULT_EXCLUDE = require_pipeline.REPLACEABLE_DEFAULT_EXCLUDE;
+exports.RETIRED_ENGINE_MESSAGE = require_pipeline.RETIRED_ENGINE_MESSAGE;
+exports.STRUCTURAL_EXCLUDE = require_pipeline.STRUCTURAL_EXCLUDE;
+exports.adaptSvelteSource = require_pipeline.adaptSvelteSource;
+exports.applyPrefix = require_pipeline.applyPrefix;
+exports.applyUnitFallback = require_pipeline.applyUnitFallback;
+exports.assembleStylesheet = require_pipeline.assembleStylesheet;
+exports.assertKnownOptionKeys = require_pipeline.assertKnownOptionKeys;
+exports.assertNoErrorDiagnostics = require_pipeline.assertNoErrorDiagnostics;
+exports.assertNoRetiredEngineSelection = require_pipeline.assertNoRetiredEngineSelection;
+exports.buildAnalysisInputs = require_pipeline.buildAnalysisInputs;
+exports.buildAnalyzeProjectArgs = require_pipeline.buildAnalyzeProjectArgs;
+exports.buildDynamicPropConfig = require_pipeline.buildDynamicPropConfig;
+exports.buildPathAliasesJson = require_pipeline.buildPathAliasesJson;
+exports.buildSystemPropsModule = require_pipeline.buildSystemPropsModule;
+exports.camelToKebab = require_pipeline.camelToKebab;
+exports.clearEngineCache = require_pipeline.clearEngineCache;
+exports.collectExternalPackageSources = require_pipeline.collectExternalPackageSources;
+exports.contentHash = require_pipeline.contentHash;
+exports.createExcludeMatcher = require_pipeline.createExcludeMatcher;
+exports.createSourceIdentity = require_pipeline.createSourceIdentity;
+exports.createSourceIngestor = require_pipeline.createSourceIngestor;
+exports.createV2EngineApi = require_pipeline.createV2EngineApi;
+exports.diffFilePlans = require_pipeline.diffFilePlans;
+exports.discoverFiles = require_pipeline.discoverFiles;
+exports.enforceExternalTokenContracts = require_pipeline.enforceExternalTokenContracts;
+exports.excludeCollectedPackages = require_pipeline.excludeCollectedPackages;
+exports.extractSystemFilePackages = require_pipeline.extractSystemFilePackages;
+exports.findAssetSpecifiers = require_pipeline.findAssetSpecifiers;
+exports.findPackageRoot = require_pipeline.findPackageRoot;
+exports.firstOwners = require_pipeline.firstOwners;
+exports.formatRustTimingWaterfall = require_pipeline.formatRustTimingWaterfall;
+exports.hashReplacementPlans = require_pipeline.hashReplacementPlans;
+exports.ingestSourceEntries = require_pipeline.ingestSourceEntries;
+exports.isAdvisorySourceDiagnostic = require_pipeline.isAdvisorySourceDiagnostic;
+exports.isExcludedPackageRelativePath = require_pipeline.isExcludedPackageRelativePath;
+exports.isPathWithinRoot = require_pipeline.isPathWithinRoot;
+exports.isUnresolvedParentDrop = require_pipeline.isUnresolvedParentDrop;
+exports.loadSystemConfig = require_pipeline.loadSystemConfig;
+exports.mergeExternalKeyframes = require_pipeline.mergeExternalKeyframes;
+exports.postProcessCss = require_pipeline.postProcessCss;
+exports.preprocessMdx = require_pipeline.preprocessMdx;
+exports.readTsconfigAliasPairs = require_pipeline.readTsconfigAliasPairs;
+exports.resolveAbsolutePathSpecifier = require_pipeline.resolveAbsolutePathSpecifier;
+exports.resolveAssetFile = require_pipeline.resolveAssetFile;
+exports.resolveLightningTargets = require_pipeline.resolveLightningTargets;
+exports.resolveMode = require_pipeline.resolveMode;
+exports.resolveThroughPathAliases = require_pipeline.resolveThroughPathAliases;
+exports.runProjectAnalysis = require_pipeline.runProjectAnalysis;
+exports.runStructuralSelfCheck = require_pipeline.runStructuralSelfCheck;
+exports.serializeStaticCss = require_pipeline.serializeStaticCss;
+exports.sharesVolumeRoot = require_pipeline.sharesVolumeRoot;
+exports.snapshotFilePlans = require_pipeline.snapshotFilePlans;
+exports.staleDistIncludesMessage = require_pipeline.staleDistIncludesMessage;
+exports.stripLeadingLayerDeclaration = require_pipeline.stripLeadingLayerDeclaration;
+exports.substituteAssetPlaceholders = require_pipeline.substituteAssetPlaceholders;
+exports.surfaceManifestDiagnostics = require_pipeline.surfaceManifestDiagnostics;
+exports.toWatchKeys = require_pipeline.toWatchKeys;
+exports.unresolvableIncludesMessage = require_pipeline.unresolvableIncludesMessage;
+exports.unresolvedParentName = require_pipeline.unresolvedParentName;
+exports.validateLayerOrder = require_pipeline.validateLayerOrder;
+exports.walkPackageSources = require_pipeline.walkPackageSources;
+exports.withoutInvalidOriginals = require_pipeline.withoutInvalidOriginals;