@animus-ui/extract 0.1.11 → 0.1.12

package/dist/{pipeline-lkbOoyAr.mjs → pipeline-DeEENy5C.mjs}

@@ -1,21 +1,17 @@
 import { createRequire } from "node:module";
+import path, { basename, dirname, join, normalize, posix } from "node:path";
 import { createHash } from "crypto";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "fs";
-import { dirname, extname, isAbsolute, join, relative, resolve } from "path";
+import { dirname as dirname$1, extname, isAbsolute, join as join$1, relative, resolve } from "path";
 import { realpathSync as realpathSync$1 } from "node:fs";
-import path, { basename as basename$1, dirname as dirname$1, join as join$1, normalize, posix } from "node:path";
 import { createRequire as createRequire$1 } from "module";
 import browserslist from "browserslist";
 import { browserslistToTargets, transform } from "lightningcss";
 import { isUnitlessProperty } from "@animus-ui/properties";
 //#region \0rolldown/runtime.js
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
 //#region pipeline/assemble-stylesheet.ts
-/**
-* The 7 Animus cascade layers. Always prefixed with `anm-` to avoid
-* collision with other frameworks' layer names (e.g., Tailwind's `base`).
-*/
 const ANIMUS_LAYERS = [
 	"anm-global",
 	"anm-base",
@@ -25,22 +21,9 @@ const ANIMUS_LAYERS = [
 	"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;
@@ -55,11 +38,6 @@ function validateLayerOrder(layers) {
 		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?/, "");
 }
@@ -108,2091 +86,1891 @@ function buildAnalyzeProjectArgs(inputs) {
 	];
 }
 //#endregion
-//#region pipeline/engine-adapter.ts
-/**
-* Build the engine-agnostic `engineApi()` both plugins call. Returns a function
-* (invoked per call site) so `isV2()` and `loadNativeEngine()` re-evaluate each
-* time — next reads its engine choice and native module dynamically from
-* globalThis.
-*/
-function createV2EngineApi(deps) {
-	const { label, isV2, loadNativeEngine, store } = deps;
-	return () => {
-		if (!isV2()) return loadNativeEngine();
-		const native = loadNativeEngine();
-		return {
-			loadSystemModule: (...args) => native.loadSystemModule(...args),
-			scanKeyframesExports: (entryPath, rootDir) => native.scanKeyframesExports(entryPath, rootDir) ?? null,
-			extractFacts: (filesJson) => native.extractFacts(filesJson),
-			analyzeProject: (filesJsonRaw, scalesJson, variableMapJson, contextualVarsJson, propConfigJson, groupRegistryJson, packageResolutionJson, devMode, emitterConfigJson, selectorAliasesJson, _selectorOrderJson, globalStyleBlocksJson, pathAliasesJson, keyframesJson, staticCssJson, conditionAliasesJson, externalDirsJson, transformSourcesJson) => {
-				const filesJson = deps.rehydrateFilesJson ? deps.rehydrateFilesJson(filesJsonRaw) : filesJsonRaw;
-				const sent = /* @__PURE__ */ new Map();
-				for (const entry of JSON.parse(filesJson)) sent.set(entry.path, entry.source);
-				store.setSentSources(sent);
-				const emitterConfig = emitterConfigJson ? JSON.parse(emitterConfigJson) : {};
-				store.setEngine(null);
-				const config = {
-					runtimeImport: emitterConfig.runtime_import ?? void 0,
-					cssModuleId: emitterConfig.css_module_id ?? void 0,
-					systemPropsModuleId: emitterConfig.system_props_module_id ?? void 0,
-					themeJson: scalesJson,
-					variableMapJson,
-					contextualVarsJson: contextualVarsJson ?? void 0,
-					configJson: propConfigJson,
-					groupRegistryJson,
-					selectorAliasesJson: selectorAliasesJson ?? void 0,
-					conditionAliasesJson: conditionAliasesJson ?? void 0,
-					globalStyleBlocksJson: globalStyleBlocksJson ?? void 0,
-					keyframesJson: keyframesJson ?? void 0,
-					packageResolutionJson: packageResolutionJson ?? void 0,
-					pathAliasesJson: pathAliasesJson ?? void 0,
-					staticCssJson: staticCssJson ?? void 0,
-					externalDirsJson: externalDirsJson ?? void 0,
-					transformSourcesJson: transformSourcesJson ?? void 0,
-					devMode
-				};
-				const engine = new native.ExtractEngine(config);
-				store.setEngine(engine);
-				return engine.analyze(filesJson);
-			},
-			transformFile: (source, path, _manifest) => {
-				const engine = store.getEngine();
-				if (!engine) throw new Error(`[${label}] v2 transform before analyze — engine instance not initialized`);
-				const sentMap = store.getSentSources();
-				if (deps.passThroughUnknownPaths && sentMap && !sentMap.has(path)) return {
-					code: source,
-					hasComponents: false
-				};
-				const sent = sentMap?.get(path);
-				if (sent !== void 0 && sent !== source && !store.getDriftWarned()) {
-					store.setDriftWarned(true);
-					console.warn(`[${label}] v2: transform-time source for ${path} differs from analyze-time source — an upstream transform may be reverted`);
-				}
-				return JSON.parse(engine.transformFile(path));
-			},
-			clearAnalysisCache: () => {
-				const engine = store.getEngine();
-				if (engine) engine.clearCache();
-				store.setEngine(null);
-			}
-		};
-	};
-}
-//#endregion
-//#region pipeline/engine-retirement.ts
-/**
-* Loud rejection of the retired v1 extraction engine (openspec:
-* retire-extract-v1).
-*
-* v2 is the only engine. Selecting v1 — via a plugin `engine: 'v1'` option or
-* the `ANIMUS_ENGINE=v1` fixture env override — is a build-stopping error, never
-* a silent upgrade to v2 (design D1: a silent flip would let a pinned consumer's
-* build change engines without notice). Both extraction plugins call this before
-* any engine selection so the rejection is uniform and the message is defined
-* once.
-*/
-/** The one canonical retirement message, shared verbatim by both plugins and
-*  the env path (tasks.md cross-cutting: define once, reuse). */
-const RETIRED_ENGINE_MESSAGE = "animus: extraction engine 'v1' was retired (openspec: retire-extract-v1) — v2 is the only engine; remove the engine option / ANIMUS_ENGINE override";
-/**
-* Throw the canonical retirement error when v1 is selected through either
-* surface. Accepts the raw engine option as a string because the option type no
-* longer admits `'v1'` — callers cast it so a stale `'v1'` config still fails
-* loud at runtime instead of being silently coerced.
-*/
-function assertNoRetiredEngineSelection(engineOption) {
-	if (engineOption === "v1" || process.env.ANIMUS_ENGINE === "v1") throw new Error(RETIRED_ENGINE_MESSAGE);
-}
-//#endregion
 //#region pipeline/content-hash.ts
-/**
-* MD5 content hash used for file-change detection (HMR diffing) by both
-* extraction plugins, and for content-addressing copied asset bytes. The
-* algorithm/encoding is a cross-plugin contract: cache keys written by one
-* build path must compare equal in the next. Accepts a Buffer directly so
-* binary sources hash without an intermediate string copy.
-*/
 function contentHash(source) {
 	return createHash("md5").update(source).digest("hex");
 }
 //#endregion
-//#region pipeline/external-keyframes.ts
-/** Stable codes for external keyframes discovery. */
-const KEYFRAMES_EXTERNAL_ENTRY_FAILED = "animus.keyframes.external-entry-failed";
-const KEYFRAMES_EXPORT_COLLISION = "animus.keyframes.export-collision";
-/**
-* Merge `Keyframes` collections discovered from external package entries into
-* the consumer system's collections. Keyframes are the sole carve-out from
-* the consumer-config singular-authority rule: nothing but branded
-* collections is read from an entry, an entry that fails to evaluate
-* degrades to a coded diagnostic naming it, and a collection whose export
-* name collides keeps the earlier (consumer-first) collection with a coded
-* diagnostic instead of silently reordering names.
-*/
-function mergeExternalKeyframes(scan, consumerKeyframesJson, externalEntries, rootDir) {
-	const merged = {};
-	if (consumerKeyframesJson) try {
-		Object.assign(merged, JSON.parse(consumerKeyframesJson));
-	} catch {
-		return {
-			keyframesJson: consumerKeyframesJson,
-			diagnostics: []
-		};
-	}
-	const diagnostics = [];
-	const seenEntries = /* @__PURE__ */ new Set();
-	for (const entryPath of externalEntries) {
-		if (seenEntries.has(entryPath)) continue;
-		seenEntries.add(entryPath);
-		let scanned;
-		try {
-			scanned = scan(entryPath, rootDir);
-		} catch (error) {
-			diagnostics.push({
-				file: entryPath,
-				component: "keyframes",
-				kind: "warn",
-				message: `external package entry failed the keyframes scan — its collections are invisible to extraction: ${String(error)}. Keyframe collections must be reachable from the package's definition entry without evaluating framework re-exports: export them (directly or as a named re-export) from the definition entry, and avoid \`export *\` of framework packages there (${KEYFRAMES_EXTERNAL_ENTRY_FAILED})`,
-				code: KEYFRAMES_EXTERNAL_ENTRY_FAILED,
-				severity: "warn"
-			});
-			continue;
-		}
-		if (!scanned) continue;
-		let collections;
-		try {
-			collections = JSON.parse(scanned);
-		} catch {
-			continue;
-		}
-		for (const [exportName, collection] of Object.entries(collections)) {
-			const existing = merged[exportName];
-			if (existing !== void 0) {
-				if (JSON.stringify(existing) !== JSON.stringify(collection)) diagnostics.push({
-					file: entryPath,
-					component: exportName,
-					kind: "warn",
-					message: `keyframes collection export '${exportName}' collides with an earlier collection of the same name — the earlier one wins (${KEYFRAMES_EXPORT_COLLISION})`,
-					code: KEYFRAMES_EXPORT_COLLISION,
-					severity: "warn"
-				});
-				continue;
-			}
-			merged[exportName] = collection;
-		}
+//#region pipeline/internal-wire.ts
+function parseInternalWire(json, wire) {
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch (error) {
+		throw new TypeError(`[animus] ${wire} is not valid JSON. animus produces this wire, so this is an engine bug rather than a configuration error: ${String(error)}`, { cause: error });
 	}
-	return {
-		keyframesJson: Object.keys(merged).length > 0 ? JSON.stringify(merged) : null,
-		diagnostics
-	};
+	return parsed;
 }
 //#endregion
-//#region pipeline/core-options.ts
-/** Closed set of driver namespaces a shared config file may carry. */
-const DRIVER_NAMESPACES = [
-	"vite",
-	"next",
-	"cli"
-];
+//#region pipeline/mdx-preprocessor.ts
 /**
-* 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.
+* MDX compiled to scanner-consumable JSX, plus the extension sets every
+* driver imports. `@mdx-js/mdx` is an optional peer, so its import is lazy.
 */
-const STRUCTURAL_EXCLUDE = [
-	"node_modules",
-	".next",
-	".animus"
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mdx"
 ];
 /**
-* Convenience defaults applied only when the user supplies no `exclude`
-* list — a user list replaces these (but never the structural set).
+* The one engine-transform file gate every driver imports — the suffixes the
+* engine's parser accepts. `.mdx` is preprocessed to `.tsx` before it.
 */
-const REPLACEABLE_DEFAULT_EXCLUDE = [
-	"dist",
-	".test.",
-	".spec."
+const ENGINE_TRANSFORM_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"jsx",
+	"mjs"
 ];
+const ENGINE_TRANSFORM_RE = new RegExp(`\\.(?:${ENGINE_TRANSFORM_EXTENSIONS.join("|")})$`);
+function isEngineTransformExtension(path) {
+	return ENGINE_TRANSFORM_RE.test(path);
+}
 /**
-* 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.
+* Compile MDX to scanner-consumable JSX. `missing-dep` means the consumer
+* must install `@mdx-js/mdx`; hosts warn and skip the file on `error`.
 */
-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";
+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/svelte-source-adapter.ts
+const isCompilerReference = (value) => Object(value) === value;
+const isCompilerCallable = (value) => {
+	if (!isCompilerReference(value)) return false;
+	try {
+		Function.prototype.toString.call(value);
+		return true;
+	} catch {
+		return false;
 	}
 };
-/**
-* 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 isCompilerRecord = (value) => isCompilerReference(value) && !isCompilerCallable(value);
+const acceptsCompilerPrimitive = (value, read) => {
+	if (isCompilerReference(value)) return false;
+	try {
+		read();
+		return true;
+	} catch {
+		return false;
 	}
-	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 isCompilerString = (value) => acceptsCompilerPrimitive(value, () => String.prototype.valueOf.call(value));
+const isCompilerNumber = (value) => acceptsCompilerPrimitive(value, () => Number.prototype.valueOf.call(value));
+function isNode(value) {
+	return isCompilerRecord(value) && isCompilerString(value.type) && isCompilerNumber(value.start) && isCompilerNumber(value.end);
+}
+function childNode(value) {
+	return isNode(value) ? value : null;
+}
+function isProgramNode(value) {
+	return isNode(value) && Array.isArray(value.body) && value.body.every((child) => isNode(child));
+}
+function isScriptNode(value) {
+	return isNode(value) && isProgramNode(value.content);
+}
+function parseSvelteAst(value) {
+	if (value.module !== void 0 && value.module !== null && !isScriptNode(value.module)) throw new TypeError("svelte/compiler returned an invalid module script");
+	if (value.instance !== void 0 && value.instance !== null && !isScriptNode(value.instance)) throw new TypeError("svelte/compiler returned an invalid instance script");
+	if (!isCompilerRecord(value.fragment)) throw new TypeError("svelte/compiler returned an invalid fragment");
+	return {
+		module: value.module,
+		instance: value.instance,
+		fragment: value.fragment
+	};
+}
+function nodeName(node) {
+	return node?.type === "Identifier" && isCompilerString(node.name) ? node.name : null;
+}
+/** Adaptation touches one source at a time, so a last-value memo runs the
+*  all-ASCII check once per file rather than 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;
 }
-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];
+function byteOffset(source, characterOffset) {
+	if (isAsciiOnly(source)) return characterOffset;
+	return Buffer.byteLength(source.slice(0, characterOffset));
 }
-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;
+function byteSpan(source, node) {
+	return {
+		start: byteOffset(source, node.start),
+		end: byteOffset(source, node.end)
 	};
 }
-/** 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;
+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 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
+		line,
+		column: characterOffset - lineStart
 	};
 }
-/**
-* 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"
-	};
+function sourceLocation(source, node) {
 	return {
-		mode: driverDefault(),
-		provenance: "driver-default"
+		start: sourcePosition(source, node.start),
+		end: sourcePosition(source, node.end)
 	};
 }
-//#endregion
-//#region pipeline/discover-files.ts
-/**
-* Recursively discover source files under `dir`, skipping excluded paths
-* (an `ExcludeMatcher` — see core-options, the one pattern authority — or
-* undefined for NO exclusion at all: the dist-package walks deliberately
-* run under node_modules, which `createExcludeMatcher`'s structural set
-* would prune) and keeping files whose extension is in `extensionsSet`.
-*
-* Single authoritative copy for both extraction plugins.
-*/
-function discoverFiles(dir, rootDir, exclude, extensionsSet) {
-	const results = [];
-	let entries;
-	try {
-		entries = readdirSync(dir, { encoding: "utf8" });
-	} catch {
-		return results;
-	}
-	entries.sort();
-	const isExcluded = exclude ? (full, rel) => exclude.matches(full, rel) : () => false;
-	for (const entry of entries) {
-		const fullPath = join(dir, entry);
-		if (isExcluded(fullPath, relative(rootDir, fullPath))) continue;
-		let stat;
-		try {
-			stat = statSync(fullPath);
-		} catch {
-			continue;
-		}
-		if (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, exclude, extensionsSet));
-		else if (extensionsSet.has(extname(entry))) results.push(fullPath);
+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);
 	}
-	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.
+* Svelte `Fragment` containers carry no `start`/`end`, so the `isNode` gate
+* would stop at each one: descend plain objects, visit span-carrying nodes.
 */
-function isPathWithinRoot(root, target, pathApi = path) {
-	const rel = pathApi.relative(root, target);
-	return rel === "" || !pathApi.isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + pathApi.sep);
+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 (!isCompilerRecord(current)) 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);
 }
-/**
-* Cross-volume gate (design D5): two paths share a platform path root
-* (win32 drive letter or UNC share; always true on posix). Compared
-* case-insensitively — win32 drive letters are case-insensitive.
-*/
-function sharesVolumeRoot(a, b, pathApi = path) {
-	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
-	return volumeOf(a) === volumeOf(b);
+function 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 && isCompilerString(sourceNode.value) ? 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 canonicalize(p) {
-	try {
-		return realpathSync$1(p);
-	} catch {
-		return null;
+function diagnostic(code, message, originalPath, source, node, location) {
+	const result = {
+		code,
+		message,
+		originalPath
+	};
+	if (node) {
+		result.span = byteSpan(source, node);
+		result.location = location ?? sourceLocation(source, node);
 	}
+	return result;
 }
-function createSourceIdentity(rootDir) {
-	const normalizedRootDir = path.normalize(rootDir);
-	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
-	const roots = [];
-	const aliases = /* @__PURE__ */ new Map();
-	const owningRecord = (canonicalPath) => {
-		let owner = null;
-		for (const record of roots) {
-			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
-			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+function parseCompilerError(value) {
+	if (!isCompilerRecord(value)) return null;
+	const parsed = { positions: Array.isArray(value.position) ? value.position : [] };
+	if (isCompilerRecord(value.start)) parsed.start = value.start;
+	if (isCompilerRecord(value.end)) parsed.end = value.end;
+	return parsed;
+}
+function compilerParseErrorRange(error, source) {
+	const candidate = parseCompilerError(error);
+	if (candidate === null) return null;
+	const positions = candidate.positions;
+	const startCharacter = isCompilerNumber(candidate.start?.character) ? candidate.start.character : isCompilerNumber(positions[0]) ? positions[0] : null;
+	const endCharacter = isCompilerNumber(candidate.end?.character) ? candidate.end.character : isCompilerNumber(positions[1]) ? 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: isCompilerNumber(value?.line) ? value.line : fallbackPoint.line,
+		column: isCompilerNumber(value?.column) ? value.column : fallbackPoint.column
+	});
+	return {
+		node,
+		location: {
+			start: point(candidate.start, fallback.start),
+			end: point(candidate.end, fallback.end)
 		}
-		return owner;
 	};
+}
+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 {
-		rootDir: normalizedRootDir,
-		canonicalRootDir,
-		registerExternalRoot(root) {
-			const asRegistered = path.normalize(root);
-			const canonical = canonicalize(asRegistered) ?? asRegistered;
-			const existing = roots.find((record) => record.canonical === canonical);
-			if (existing) return existing.canonical;
-			roots.push({
-				asRegistered,
-				canonical
-			});
-			return canonical;
-		},
-		externalRoots() {
-			return roots.map((record) => record.canonical);
-		},
-		resolveSourceId(inputPath) {
-			const lexical = path.normalize(inputPath);
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			const owner = owningRecord(canonical);
-			const ownedBy = (record) => {
-				const pathInRoot = path.relative(record.canonical, canonical);
-				return {
-					sourceKey: path.relative(normalizedRootDir, path.join(record.asRegistered, pathInRoot)),
-					owningRoot: record.canonical,
-					pathInRoot
-				};
-			};
-			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
-			let resolved;
-			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
-				const key = path.relative(canonicalRootDir, canonical);
-				resolved = {
-					sourceKey: key,
-					owningRoot: null,
-					pathInRoot: key
-				};
-			} else if (owner) resolved = ownedBy(owner);
-			else return null;
-			aliases.set(lexical, resolved);
-			aliases.set(canonical, resolved);
-			return resolved;
-		},
-		resolveDeletedSourceId(inputPath) {
-			return aliases.get(path.normalize(inputPath)) ?? null;
-		},
-		containingExternalRoot(inputPath) {
-			const lexical = path.normalize(inputPath);
-			let owner = null;
-			for (const record of roots) {
-				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
-				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+		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 (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;
+		};
+	}
+	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" && isCompilerString(memberNode.value) ? 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"
 			}
-			return owner?.canonical ?? null;
 		}
 	};
 }
-//#endregion
-//#region pipeline/discover-packages.ts
-/**
-* Walk up from a resolved package entry file to the nearest directory
-* containing a package.json (the package root). Stops at the filesystem
-* root and returns it if no package.json is found on the way up.
-*/
-function findPackageRoot(absEntryPath) {
-	let pkgRoot = dirname(absEntryPath);
-	while (pkgRoot !== dirname(pkgRoot) && !existsSync(join(pkgRoot, "package.json"))) pkgRoot = dirname(pkgRoot);
-	return pkgRoot;
+function isSupportedResolverAccess(access) {
+	return access.binding.kind === "named" && access.request.access.kind === "direct";
 }
-/**
-* 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));
+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
+	};
 }
-/**
-* THE package-source walk (guardrail G1 — one policy): shared discovery with
-* no consumer patterns, then exclusion by package-relative path so fragments
-* in the package's own location can't blank out its sources. Used by the
-* collector, hosts' dirty-root rewalks, and watch-path classification alike.
-*/
-function walkPackageSources(packageDir, extensionsSet) {
-	return discoverFiles(packageDir, packageDir, void 0, extensionsSet).filter((absPath) => !isExcludedPackageRelativePath(relative(packageDir, absPath)));
+function argumentSpan(argumentsList, fallback) {
+	if (argumentsList.length === 0) return fallback;
+	return {
+		type: "ArgumentRange",
+		start: argumentsList[0].start,
+		end: argumentsList[argumentsList.length - 1].end
+	};
 }
-/** Exclusions for the compiled-output fallback when a package does not ship src/. */
-const PACKAGE_OUTPUT_EXCLUDES = [
-	"node_modules",
-	".test.",
-	".spec.",
-	".d.ts",
-	".map"
-];
-const isFile = (path) => {
-	try {
-		return statSync(path).isFile();
-	} catch {
-		return false;
-	}
-};
-/**
-* Resolve an absolute-path specifier (a relative `includes` entry already
-* resolved against the system file) without a bundler: the path itself when it
-* is a file, otherwise the extension and directory-index candidates built from
-* the caller's extension set. Used only as a fallback — a bundler resolver that
-* answers first still wins, since it also knows aliases and `.js`→`.ts` mapping.
-*/
-function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
-	return [
-		absSpecifier,
-		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
-		...Array.from(extensionsSet, (ext) => join(absSpecifier, `index${ext}`))
-	].find(isFile) ?? null;
+function propertyName(node) {
+	const key = childNode(node.key);
+	if (!key) return null;
+	if (key.type === "Identifier" && isCompilerString(key.name)) return key.name;
+	if (key.type === "Literal" && isCompilerString(key.value)) return key.value;
+	return 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 isJsxAttributeName(name) {
+	return /^[A-Za-z_$][A-Za-z0-9_$-]*$/.test(name);
 }
-function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
-	if (isAbsolute(specifier)) {
-		const resolved = resolveAbsolutePathSpecifier(specifier, extensionsSet);
-		if (!resolved) return null;
-		return isPathWithinRoot(srcDir, resolved) ? resolved : null;
-	}
-	const packageName = bareSpecifierPackageName(specifier);
-	return resolveAbsolutePathSpecifier(join(srcDir, specifier.slice(packageName.length + 1) || "index"), extensionsSet);
+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;
 }
-/**
-* The D13 dist-freshness check: applicable only when a specifier has BOTH a
-* walked src/ tree and a resolved dist entry that exists on disk outside that
-* tree; stale when the dist entry's mtime is older than the newest walked
-* source file's. Not applicable (never stale) when the entry resolves inside
-* src/ (no dist to skew), when the entry file is missing, or when no source
-* file's mtime is readable. Detection only — reporting is the caller's policy.
-*/
-function distEntryIsStale(absEntry, srcDir, srcFiles) {
-	if (isPathWithinRoot(srcDir, absEntry)) return false;
-	let distMtime;
-	try {
-		distMtime = statSync(absEntry).mtimeMs;
-	} catch {
-		return false;
+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
+		});
 	}
-	let newestSrcMtime = -Infinity;
-	for (const srcFile of srcFiles) try {
-		newestSrcMtime = Math.max(newestSrcMtime, statSync(srcFile).mtimeMs);
-	} catch {}
-	return distMtime < newestSrcMtime;
+	return properties;
 }
-/**
-* Shared external-package source collection (spec:
-* external-package-file-discovery), consumed by both extraction plugins.
-* For each specifier: resolve to an absolute entry (null/throw → silently
-* skip; an absolute-path specifier falls back to a filesystem probe), walk up
-* to the package root, then either discover sources under src/ (redirecting
-* module resolution to src/index.ts when present) or fall back to ingesting
-* the resolved entry file itself.
-*
-* The only bundler-specific seams are callbacks: specifier resolution,
-* dedup against already-ingested files, per-file preprocessing (MDX), and
-* the unreadable-file warning. Hashing and caching stay in the plugins —
-* their cache policies legitimately differ.
-*
-* Alongside the aggregates, one `ExternalPackageOutcome` per declared
-* specifier records what that specifier produced. Collection never reports on
-* them — any warning or gate is the caller's policy.
-*/
-async function collectExternalPackageSources(opts) {
-	const { specifiers, resolveSpecifier, rootDir, extensionsSet, hasEntry, onSourceRead, onUnreadable, onPackageResolved } = opts;
-	const entries = [];
-	const pushed = /* @__PURE__ */ new Set();
-	const packageMap = {};
-	const sourceEntries = /* @__PURE__ */ new Map();
-	const keyframesScanEntries = /* @__PURE__ */ new Map();
-	const packageDirs = [];
-	const dirOwnerSets = {};
-	const dirExtensions = {};
-	const fileOwners = {};
-	const outcomes = [];
-	const claimDir = (dir, specifier) => {
-		(dirOwnerSets[dir] ??= []).push(specifier);
-	};
-	const alreadyIngested = (relPath) => hasEntry(relPath) || pushed.has(relPath);
-	for (const specifier of specifiers) {
-		let absEntry;
-		try {
-			absEntry = await resolveSpecifier(specifier);
-		} catch {
-			absEntry = null;
-		}
-		if (!absEntry && isAbsolute(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
-		if (!absEntry) {
-			outcomes.push({
-				specifier,
-				outcome: "unresolvable",
-				fileCount: 0
-			});
-			continue;
+var VirtualSourceBuilder = class {
+	originalSource;
+	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" && isCompilerString(imported.name)) return imported.name;
+	if (imported.type === "Literal" && isCompilerString(imported.value)) 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 && isCompilerString(sourceNode.raw) ? sourceNode.raw : sourceNode && isCompilerString(sourceNode.value) ? 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 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;
 		}
-		const srcDir = join(findPackageRoot(absEntry), "src");
-		let fileCount = 0;
-		let staleDist = false;
-		if (existsSync(srcDir)) {
-			packageDirs.push(srcDir);
-			claimDir(srcDir, specifier);
-			dirExtensions[srcDir] = [...extensionsSet];
-			onPackageResolved?.(specifier, srcDir);
-			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
-			if (srcEntry) {
-				packageMap[specifier] = relative(rootDir, srcEntry);
-				sourceEntries.set(specifier, srcEntry);
-			} else packageMap[specifier] = relative(rootDir, absEntry);
-			keyframesScanEntries.set(specifier, srcEntry ?? absEntry);
-			if (!isAbsolute(specifier)) {
-				const packageName = bareSpecifierPackageName(specifier);
-				if (packageName !== specifier && !(packageName in packageMap)) {
-					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
-					if (rootEntry) {
-						packageMap[packageName] = relative(rootDir, rootEntry);
-						sourceEntries.set(packageName, rootEntry);
-						keyframesScanEntries.set(packageName, rootEntry);
-					}
-				}
-			}
-			const pkgFiles = walkPackageSources(srcDir, extensionsSet);
-			staleDist = distEntryIsStale(absEntry, srcDir, pkgFiles);
-			for (const pkgFile of pkgFiles) {
-				const relPath = relative(rootDir, pkgFile);
-				if (alreadyIngested(relPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = readFileSync(pkgFile, "utf-8");
-				} catch (err) {
-					onUnreadable(relPath, err);
-					continue;
-				}
-				onSourceRead?.(source, relPath, pkgFile);
-				entries.push({
-					path: relPath,
-					source
-				});
-				pushed.add(relPath);
-				fileOwners[relPath] ??= specifier;
-				fileCount++;
-			}
-		} else {
-			const outputDir = dirname(absEntry);
-			packageDirs.push(outputDir);
-			claimDir(outputDir, specifier);
-			onPackageResolved?.(specifier, outputDir);
-			packageMap[specifier] = relative(rootDir, absEntry);
-			keyframesScanEntries.set(specifier, absEntry);
-			const outputExtensions = new Set(extensionsSet);
-			outputExtensions.add(extname(absEntry));
-			dirExtensions[outputDir] = [...outputExtensions];
-			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
-				const relToOutput = relative(outputDir, file);
-				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
+		if (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: []
 			});
-			if (!outputFiles.includes(absEntry)) outputFiles.unshift(absEntry);
-			for (const outputFile of outputFiles) {
-				const outputRelPath = relative(rootDir, outputFile);
-				if (alreadyIngested(outputRelPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = readFileSync(outputFile, "utf-8");
-				} catch (err) {
-					onUnreadable(outputRelPath, err);
-					continue;
-				}
-				onSourceRead?.(source, outputRelPath, outputFile);
-				entries.push({
-					path: outputRelPath,
-					source
-				});
-				pushed.add(outputRelPath);
-				fileOwners[outputRelPath] ??= specifier;
-				fileCount++;
-			}
+			return;
 		}
-		outcomes.push({
-			specifier,
-			outcome: staleDist ? "stale-dist" : fileCount > 0 ? "resolved" : "empty",
-			fileCount
+		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 {
-		entries,
-		packageMap,
-		sourceEntries,
-		keyframesScanEntries,
-		packageDirs,
-		dirOwnerSets,
-		dirExtensions,
-		fileOwners,
-		outcomes
+		diagnostics: [],
+		entry: {
+			scope,
+			path: `${originalPath}.${scope}.tsx`,
+			source: builder.toString(),
+			mappings: builder.mappings
+		}
 	};
 }
-/** 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.
+* Project Svelte script scopes into parser-only TSX witnesses from SOURCE,
+* never compiler output. Unsupported call shapes fail the whole source closed.
 */
-function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
-	if (rejectedSpecifiers.size === 0) return collected;
-	const rejectedDirs = Object.entries(collected.dirOwnerSets).filter(([, specs]) => specs.every((s) => rejectedSpecifiers.has(s))).map(([dir]) => dir);
-	const underRejectedDir = (absPath) => rejectedDirs.some((dir) => isPathWithinRoot(dir, absPath));
-	const targetRejected = (specifier, absTarget) => rejectedSpecifiers.has(specifier) || underRejectedDir(absTarget);
-	const packageMap = {};
-	for (const [specifier, relTarget] of Object.entries(collected.packageMap)) {
-		if (targetRejected(specifier, resolve(rootDir, relTarget))) continue;
-		packageMap[specifier] = relTarget;
-	}
-	const sourceEntries = /* @__PURE__ */ new Map();
-	for (const [specifier, absEntry] of collected.sourceEntries) {
-		if (targetRejected(specifier, absEntry)) continue;
-		sourceEntries.set(specifier, absEntry);
-	}
-	const keyframesScanEntries = /* @__PURE__ */ new Map();
-	for (const [specifier, absEntry] of collected.keyframesScanEntries) {
-		if (targetRejected(specifier, absEntry)) continue;
-		keyframesScanEntries.set(specifier, absEntry);
-	}
-	const dirOwnerSets = {};
-	for (const [dir, specs] of Object.entries(collected.dirOwnerSets)) {
-		const kept = specs.filter((s) => !rejectedSpecifiers.has(s));
-		if (kept.length === 0) continue;
-		dirOwnerSets[dir] = kept;
-	}
-	const dirExtensions = {};
-	for (const [dir, exts] of Object.entries(collected.dirExtensions)) {
-		if (rejectedDirs.includes(dir)) continue;
-		dirExtensions[dir] = exts;
+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 compilerAst;
+	try {
+		compilerAst = 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 fileOwners = {};
-	for (const [relPath, owner] of Object.entries(collected.fileOwners)) {
-		if (rejectedSpecifiers.has(owner)) continue;
-		fileOwners[relPath] = owner;
+	const ast = parseSvelteAst(compilerAst);
+	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 {
-		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
+		kind: "ok",
+		original,
+		entries: projections.flatMap((projection) => projection.entry ? [projection.entry] : [])
 	};
 }
+//#endregion
+//#region pipeline/source-ingestion.ts
+function isSerializedSourceEntry(value) {
+	if (!(value instanceof Object) || Array.isArray(value)) return false;
+	return String(value.path) === value.path && String(value.source) === value.source && (value.hash === void 0 || String(value.hash) === value.hash);
+}
 /**
-* 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).
+* Throws on a payload that is not a corpus: an empty corpus is
+* indistinguishable from "no files" and would publish an empty stylesheet.
 */
-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(", ")}`;
+function parseFilesJson(filesJson, context) {
+	const candidate = parseInternalWire(filesJson, `${context} filesJson`);
+	if (!Array.isArray(candidate) || !candidate.every(isSerializedSourceEntry)) throw new TypeError(`[${context}] analysis files JSON must be an array of {path, source} entries`);
+	return candidate;
 }
 /**
-* 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.
+* Advisory diagnostics warn in every mode and never quarantine their file:
+* OXC recovers parse errors the host bundler itself accepts. All else is fatal.
 */
-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 isAdvisorySourceDiagnostic(diagnostic) {
+	return diagnostic.code === "SOURCE_NATIVE_PARSE_ERROR";
 }
-function extractSystemFilePackages(systemFilePath) {
-	let source;
-	try {
-		source = readFileSync(systemFilePath, "utf-8");
-	} catch {
-		return [];
+const RELATIVE_PROBE_SUFFIXES = [
+	"",
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	"/index.ts",
+	"/index.tsx",
+	"/index.js",
+	"/index.jsx"
+];
+function extension(path) {
+	const basename = posix.basename(path);
+	const dot = basename.lastIndexOf(".");
+	return dot === -1 ? "" : basename.slice(dot).toLowerCase();
+}
+function canonicalResolverPath(path) {
+	return posix.normalize(path.replaceAll("\\", "/"));
+}
+const NODE_NEXT_EXTENSION_MAP = {
+	".js": [
+		".ts",
+		".tsx",
+		".jsx"
+	],
+	".mjs": [".mts"],
+	".cjs": [".cts"]
+};
+function resolveRelativeSource(importerPath, specifier, files) {
+	if (!specifier.startsWith(".")) return null;
+	const base = posix.normalize(posix.join(posix.dirname(canonicalResolverPath(importerPath)), specifier));
+	for (const suffix of RELATIVE_PROBE_SUFFIXES) {
+		const candidate = `${base}${suffix}`;
+		const actualPath = files.get(candidate);
+		if (actualPath !== void 0) return actualPath;
 	}
-	const 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;
+	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 {
+	facts;
+	collisions;
+	files;
+	resolverBindings = /* @__PURE__ */ new Map();
+	/** Both memos live for one ingest only — the index is rebuilt per call,
+	*  so neither needs invalidation. */
+	attributionMemo = /* @__PURE__ */ new Map();
+	resolveMemo = /* @__PURE__ */ new Map();
+	constructor(facts, analysisPaths) {
+		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);
 		}
-	};
-	/**
-	* 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;
+		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);
 		}
-	};
-	/** 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++;
+		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]);
 		}
-		consumeChainLinks(pos);
-		const bound = boundIdentifierBefore(anchorMatch.index);
-		if (bound) chainRootIdentifiers.add(bound);
+		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)));
 	}
-	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);
-			}
+	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;
 	}
-	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);
+	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;
 	}
-	const systemFileDir = dirname(systemFilePath);
-	const packages = /* @__PURE__ */ new Set();
-	for (const id of identifiers) {
-		const specifier = importMap.get(id);
-		if (!specifier) continue;
-		if (specifier.startsWith(".")) packages.add(resolve(systemFileDir, specifier));
-		else packages.add(specifier);
+};
+/**
+* Native and MDX entries must establish the resolver index before any Svelte
+* projection; bare-package and aliased sources stay unattributed by design.
+*/
+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
+		}]);
 	}
-	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;
+	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 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)
+		originalEntries,
+		analysisEntries,
+		ownership,
+		diagnostics
 	};
 }
-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;
+/**
+* `parseCount` counts the 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 {
-		line,
-		column: characterOffset - lineStart
+		files,
+		parseCount
 	};
 }
-function sourceLocation(source, node) {
+/**
+* Drops each named original and the analysis children it owns. Every corpus
+* path applies it — skipping it on incremental passes freezes re-analysis.
+*/
+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 {
-		start: sourcePosition(source, node.start),
-		end: sourcePosition(source, node.end)
+		...result,
+		originalEntries: result.originalEntries.filter((entry) => !invalidOriginals.has(entry.path)),
+		analysisEntries: result.analysisEntries.filter((entry) => analysisPaths.has(entry.path)),
+		ownership
 	};
 }
-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.
+* Diagnostics name ANALYSIS paths while ownership is recorded for originals,
+* so projection is required; the result REPLACES the caller's owner map.
 */
-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
-			});
-		}
+function projectExternalFileOwners(result, rawOwners) {
+	const projected = {};
+	for (const owner of Object.values(result.ownership)) {
+		const packageOwner = rawOwners[owner.originalPath];
+		if (!packageOwner) continue;
+		projected[owner.originalPath] = packageOwner;
+		for (const analysisPath of owner.analysisPaths) projected[analysisPath] = packageOwner;
 	}
-	return bindings;
-}
-function diagnostic(code, message, originalPath, source, node, location) {
-	return {
-		code,
-		message,
-		originalPath,
-		...node ? {
-			span: byteSpan(source, node),
-			location: location ?? sourceLocation(source, node)
-		} : {}
-	};
+	return projected;
 }
-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
-	});
+/**
+* One ingestion policy point for every host: a host supplies only a prefix, a
+* strict flag, and a warn sink; policy and per-host memos stay here.
+*/
+function createSourceIngestor(host) {
+	const factsCache = /* @__PURE__ */ new Map();
+	/** Non-strict dedupe: a quarantined original re-ingests on every later
+	*  corpus pass, so re-warning it on each save is noise. */
+	const warnedByOriginal = /* @__PURE__ */ new Map();
 	return {
-		node,
-		location: {
-			start: point(candidate.start, fallback.start),
-			end: point(candidate.end, fallback.end)
+		async ingest(entries) {
+			const extractFacts = host.engineApi().extractFacts;
+			if (extractFacts === void 0) throw new Error(`${host.prefix} native engine does not expose extractFacts required for source adaptation`);
+			return ingestSourceEntries(entries, {
+				extractFacts,
+				factsCache
+			});
+		},
+		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);
 		}
 	};
 }
-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;
+//#endregion
+//#region pipeline/engine-adapter.ts
+/**
+* One engine API for both plugins. Imports neither the native binding nor any
+* plugin or bundler — every such dependency arrives injected.
+*/
+/**
+* Returns a function, invoked per call site, so `isV2()` and
+* `loadNativeEngine()` re-evaluate each time instead of being captured.
+*/
+function createV2EngineApi(deps) {
+	const { label, isV2, loadNativeEngine, store } = deps;
+	return () => {
+		if (!isV2()) return loadNativeEngine();
+		const native = loadNativeEngine();
 		return {
-			binding,
-			resolver: receiver,
-			displayName: directName,
-			request: {
-				source: binding.source,
-				imported: binding.imported,
-				local: directName,
-				access: {
-					kind: "direct",
-					importKind: binding.kind
+			loadSystemModule: (...args) => native.loadSystemModule(...args),
+			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 parseFilesJson(filesJson, label)) 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);
 			}
 		};
-	}
-	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
-	};
+//#endregion
+//#region pipeline/engine-retirement.ts
+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";
+function assertNoRetiredEngineSelection(engineOption) {
+	if (engineOption === "v1" || process.env.ANIMUS_ENGINE === "v1") throw new Error(RETIRED_ENGINE_MESSAGE);
 }
-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("");
+//#endregion
+//#region pipeline/core-options.ts
+const DRIVER_NAMESPACES = [
+	"vite",
+	"next",
+	"cli"
+];
+const DRIVER_NAMESPACE_KEYS = new Set(DRIVER_NAMESPACES);
+/**
+* Applied unconditionally: `node_modules` belongs to external-package
+* collection, and `.next`/`.animus` hold output, never source.
+*/
+const STRUCTURAL_EXCLUDE = [
+	"node_modules",
+	".next",
+	".animus"
+];
+/** Defaults a user `exclude` list replaces; the structural set it cannot. */
+const REPLACEABLE_DEFAULT_EXCLUDE = [
+	"dist",
+	".test.",
+	".spec."
+];
+const DEFAULT_EXCLUDE = [...STRUCTURAL_EXCLUDE, ...REPLACEABLE_DEFAULT_EXCLUDE];
+const CORE_OPTION_KEYS = /* @__PURE__ */ new Set([
+	"system",
+	"exclude",
+	"extensions",
+	"strict",
+	"verbose",
+	"prefix",
+	"targets",
+	"minify",
+	"staticCss",
+	"layers",
+	"engine",
+	"mode",
+	"root"
+]);
+/** Carries a stable `name` so drivers can map it to their own config-error
+*  surface (the CLI's exit code 2). */
+var AnimusConfigError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AnimusConfigError";
 	}
 };
-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);
+/**
+* `ownKeys` is the caller's own top-level surface; `rejectKeys` names core
+* keys it does not honor, which must fail rather than be silently ignored.
+*/
+function assertKnownOptionKeys(raw, ownKeys = [], rejectKeys = [], opts = {}) {
+	const surface = (message) => {
+		if (opts.onUnknownKey === "warn") {
+			opts.warn(message);
 			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);
-		}
+		throw new AnimusConfigError(message);
 	};
-	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("}");
+	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_NAMESPACE_KEYS.has(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)}.`);
+	}
+}
+/**
+* Options are foreign JS, so a boxed `String`/`Boolean` must not pass: a
+* boxed value never behaves as the primitive its consumers expect.
+*/
+const isString = (value) => Object(value) !== value && Object.prototype.toString.call(value) === "[object String]";
+const isBoolean = (value) => Object(value) !== value && Object.prototype.toString.call(value) === "[object Boolean]";
+const isStringArray = (value) => Array.isArray(value) && value.every(isString);
+const isStringOrStringArray = (value) => isString(value) || isStringArray(value);
+const CORE_VALUE_GATES = [
+	{
+		key: "system",
+		ok: isString,
+		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: isBoolean,
+		expected: "a boolean"
+	},
+	{
+		key: "verbose",
+		ok: isBoolean,
+		expected: "a boolean"
+	},
+	{
+		key: "minify",
+		ok: isBoolean,
+		expected: "a boolean"
+	},
+	{
+		key: "prefix",
+		ok: isString,
+		expected: "a string"
+	},
+	{
+		key: "targets",
+		ok: isStringOrStringArray,
+		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;
 		}
-		builder.append(" />;\n");
 	}
-	return {
-		diagnostics: [],
-		entry: {
-			scope,
-			path: `${originalPath}.${scope}.tsx`,
-			source: builder.toString(),
-			mappings: builder.mappings
-		}
+	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 = /[*?]/;
+/**
+* Globs compile to a RegExp over the root-relative path, matching the path or
+* any ancestor directory; plain patterns are substrings. `./` is stripped.
+*/
+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}$`);
+}
 /**
-* 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.
+* A user list replaces only the replaceable defaults. Driver-owned
+* invariants belong in `extraStructural`; a user list would replace those.
 */
-async function adaptSvelteSource(source, originalPath, options) {
-	const original = {
-		path: originalPath,
-		hash: contentHash(source)
+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;
 	};
-	const compiler = await loadCompiler();
-	if (!compiler) return {
-		kind: "missing-dep",
-		original,
-		dependency: "svelte/compiler"
+	return {
+		patterns: merged,
+		matches: (full, rel) => explain(full, rel) !== null,
+		explain,
+		stats: () => hits
 	};
-	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
+}
+function resolveMode(explicit, driverDefault) {
+	if (explicit === "development" || explicit === "production") return {
+		mode: explicit,
+		provenance: "explicit"
 	};
 	return {
-		kind: "ok",
-		original,
-		entries: projections.flatMap((projection) => projection.entry ? [projection.entry] : [])
+		mode: driverDefault(),
+		provenance: "driver-default"
 	};
 }
 //#endregion
-//#region pipeline/mdx-preprocessor.ts
+//#region pipeline/discover-files.ts
+function pathCharRank(code) {
+	return code === 47 || code === 92 ? -1 : code;
+}
+function compareDiscoveryOrder(a, b) {
+	const shared = Math.min(a.length, b.length);
+	for (let i = 0; i < shared; i++) {
+		const left = pathCharRank(a.charCodeAt(i));
+		const right = pathCharRank(b.charCodeAt(i));
+		if (left !== right) return left - right;
+	}
+	return a.length - b.length;
+}
+function discoverFiles(dir, rootDir, exclude, extensionsSet) {
+	return walkFiles(dir, rootDir, exclude, extensionsSet).sort(compareDiscoveryOrder);
+}
+function walkFiles(dir, rootDir, exclude, extensionsSet) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir, { encoding: "utf8" });
+	} catch {
+		return results;
+	}
+	const isExcluded = exclude ? (full, rel) => exclude.matches(full, rel) : () => false;
+	for (const entry of entries) {
+		const fullPath = join$1(dir, entry);
+		if (isExcluded(fullPath, relative(rootDir, fullPath))) continue;
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) results.push(...walkFiles(fullPath, rootDir, exclude, extensionsSet));
+		else if (extensionsSet.has(extname(entry))) results.push(fullPath);
+	}
+	return results;
+}
+//#endregion
+//#region pipeline/source-identity.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.
+* One derivation of source identity for discovery, watch ingestion, ownership
+* and deletion: event paths are lookup INPUTS only and never fork identity.
 */
-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.
+* True when `target` is `root` or a descendant, decided by `relative()`
+* shape: string prefixing would let `/ui` claim `/ui-old`.
 */
-const ENGINE_TRANSFORM_EXTENSIONS = [
-	"ts",
-	"tsx",
-	"js",
-	"jsx",
-	"mjs"
-];
+function isPathWithinRoot(root, target, pathApi = path) {
+	const rel = pathApi.relative(root, target);
+	return rel === "" || !pathApi.isAbsolute(rel) && rel !== ".." && !rel.startsWith(".." + pathApi.sep);
+}
 /**
-* 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.
+* True when two paths share a platform root (win32 drive letter or UNC
+* share; always true on posix). Drive letters compare case-insensitively.
 */
-async function preprocessMdx(source, filename) {
-	const mdxMod = await import("@mdx-js/mdx").catch(() => null);
-	if (mdxMod === null) return { kind: "missing-dep" };
+function sharesVolumeRoot(a, b, pathApi = path) {
+	const volumeOf = (p) => pathApi.parse(pathApi.resolve(p)).root.toLowerCase();
+	return volumeOf(a) === volumeOf(b);
+}
+function canonicalize(p) {
 	try {
-		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)
-		};
+		return realpathSync$1(p);
+	} catch {
+		return null;
 	}
 }
+function createSourceIdentity(rootDir) {
+	const normalizedRootDir = path.normalize(rootDir);
+	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
+	const roots = [];
+	const aliases = /* @__PURE__ */ new Map();
+	const owningRecord = (canonicalPath) => {
+		let owner = null;
+		for (const record of roots) {
+			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
+			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+		}
+		return owner;
+	};
+	return {
+		rootDir: normalizedRootDir,
+		canonicalRootDir,
+		registerExternalRoot(root) {
+			const asRegistered = path.normalize(root);
+			const canonical = canonicalize(asRegistered) ?? asRegistered;
+			const existing = roots.find((record) => record.canonical === canonical);
+			if (existing) return existing.canonical;
+			roots.push({
+				asRegistered,
+				canonical
+			});
+			return canonical;
+		},
+		externalRoots() {
+			return roots.map((record) => record.canonical);
+		},
+		resolveSourceId(inputPath) {
+			const lexical = path.normalize(inputPath);
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			const owner = owningRecord(canonical);
+			const ownedBy = (record) => {
+				const pathInRoot = path.relative(record.canonical, canonical);
+				return {
+					sourceKey: path.relative(normalizedRootDir, path.join(record.asRegistered, pathInRoot)),
+					owningRoot: record.canonical,
+					pathInRoot
+				};
+			};
+			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
+			let resolved;
+			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
+				const key = path.relative(canonicalRootDir, canonical);
+				resolved = {
+					sourceKey: key,
+					owningRoot: null,
+					pathInRoot: key
+				};
+			} else if (owner) resolved = ownedBy(owner);
+			else return null;
+			aliases.set(lexical, resolved);
+			aliases.set(canonical, resolved);
+			return resolved;
+		},
+		resolveDeletedSourceId(inputPath) {
+			return aliases.get(path.normalize(inputPath)) ?? null;
+		},
+		containingExternalRoot(inputPath) {
+			const lexical = path.normalize(inputPath);
+			let owner = null;
+			for (const record of roots) {
+				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			if (owner) return owner.canonical;
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			for (const record of roots) {
+				if (!isPathWithinRoot(record.canonical, canonical)) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			return owner?.canonical ?? null;
+		}
+	};
+}
 //#endregion
-//#region pipeline/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";
+//#region pipeline/discover-packages.ts
+function findPackageRoot(absEntryPath) {
+	let pkgRoot = dirname$1(absEntryPath);
+	while (pkgRoot !== dirname$1(pkgRoot) && !existsSync(join$1(pkgRoot, "package.json"))) pkgRoot = dirname$1(pkgRoot);
+	return pkgRoot;
 }
-const RELATIVE_PROBE_SUFFIXES = [
-	"",
-	".ts",
-	".tsx",
-	".js",
-	".jsx",
-	"/index.ts",
-	"/index.tsx",
-	"/index.js",
-	"/index.jsx"
+const PACKAGE_SRC_EXCLUDES = [
+	"dist",
+	"node_modules",
+	".test.",
+	".spec."
 ];
-function extension(path) {
-	const basename = posix.basename(path);
-	const dot = basename.lastIndexOf(".");
-	return dot === -1 ? "" : basename.slice(dot).toLowerCase();
+function isExcludedPackageRelativePath(rel) {
+	return PACKAGE_SRC_EXCLUDES.some((pattern) => rel.includes(pattern));
 }
-function canonicalResolverPath(path) {
-	return posix.normalize(path.replaceAll("\\", "/"));
+function walkPackageSources(packageDir, extensionsSet) {
+	return discoverFiles(packageDir, packageDir, void 0, extensionsSet).filter((absPath) => !isExcludedPackageRelativePath(relative(packageDir, absPath)));
 }
-/** 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"]
+const PACKAGE_OUTPUT_EXCLUDES = [
+	"node_modules",
+	".test.",
+	".spec.",
+	".d.ts",
+	".map"
+];
+const isFile = (path) => {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
 };
-function resolveRelativeSource(importerPath, specifier, files) {
-	if (!specifier.startsWith(".")) return null;
-	const base = posix.normalize(posix.join(posix.dirname(canonicalResolverPath(importerPath)), specifier));
-	for (const suffix of RELATIVE_PROBE_SUFFIXES) {
-		const candidate = `${base}${suffix}`;
-		const actualPath = files.get(candidate);
-		if (actualPath !== void 0) return actualPath;
+function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
+	return [
+		absSpecifier,
+		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
+		...Array.from(extensionsSet, (ext) => join$1(absSpecifier, `index${ext}`))
+	].find(isFile) ?? null;
+}
+function bareSpecifierPackageName(specifier) {
+	const segments = specifier.split("/");
+	return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+}
+function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
+	if (isAbsolute(specifier)) {
+		const resolved = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		if (!resolved) return null;
+		return isPathWithinRoot(srcDir, resolved) ? resolved : null;
 	}
-	const 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;
+	const packageName = bareSpecifierPackageName(specifier);
+	const subpath = specifier.slice(packageName.length + 1);
+	return resolveAbsolutePathSpecifier(join$1(srcDir, subpath || "index"), extensionsSet);
+}
+function distEntryIsStale(absEntry, srcDir, srcFiles) {
+	if (isPathWithinRoot(srcDir, absEntry)) return false;
+	let distMtime;
+	try {
+		distMtime = statSync(absEntry).mtimeMs;
+	} catch {
+		return false;
 	}
-	return null;
+	let newestSrcMtime = -Infinity;
+	for (const srcFile of srcFiles) try {
+		newestSrcMtime = Math.max(newestSrcMtime, statSync(srcFile).mtimeMs);
+	} catch {}
+	return distMtime < newestSrcMtime;
 }
-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);
+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 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;
 		}
-		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);
+		if (!absEntry && isAbsolute(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		if (!absEntry) {
+			outcomes.push({
+				specifier,
+				outcome: "unresolvable",
+				fileCount: 0
+			});
+			continue;
 		}
-		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]);
+		const pkgRoot = findPackageRoot(absEntry);
+		const srcDir = join$1(pkgRoot, "src");
+		let fileCount = 0;
+		let staleDist = false;
+		if (existsSync(srcDir)) {
+			packageDirs.push(srcDir);
+			claimDir(srcDir, specifier);
+			dirExtensions[srcDir] = [...extensionsSet];
+			onPackageResolved?.(specifier, srcDir);
+			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
+			if (srcEntry) {
+				packageMap[specifier] = relative(rootDir, srcEntry);
+				sourceEntries.set(specifier, srcEntry);
+			} else packageMap[specifier] = relative(rootDir, absEntry);
+			if (!isAbsolute(specifier)) {
+				const packageName = bareSpecifierPackageName(specifier);
+				if (packageName !== specifier && !(packageName in packageMap)) {
+					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
+					if (rootEntry) {
+						packageMap[packageName] = relative(rootDir, rootEntry);
+						sourceEntries.set(packageName, rootEntry);
+					}
+				}
+			}
+			const pkgFiles = walkPackageSources(srcDir, extensionsSet);
+			staleDist = distEntryIsStale(absEntry, srcDir, pkgFiles);
+			for (const pkgFile of pkgFiles) {
+				const relPath = relative(rootDir, pkgFile);
+				if (alreadyIngested(relPath)) {
+					fileCount++;
+					continue;
+				}
+				let source;
+				try {
+					source = readFileSync(pkgFile, "utf-8");
+				} catch (err) {
+					onUnreadable(relPath, err);
+					continue;
+				}
+				onSourceRead?.(source, relPath, pkgFile);
+				entries.push({
+					path: relPath,
+					source
+				});
+				pushed.add(relPath);
+				fileOwners[relPath] ??= specifier;
+				fileCount++;
+			}
+		} else {
+			const outputDir = dirname$1(absEntry);
+			packageDirs.push(outputDir);
+			claimDir(outputDir, specifier);
+			onPackageResolved?.(specifier, outputDir);
+			packageMap[specifier] = relative(rootDir, absEntry);
+			const outputExtensions = new Set(extensionsSet);
+			outputExtensions.add(extname(absEntry));
+			dirExtensions[outputDir] = [...outputExtensions];
+			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
+				const relToOutput = relative(outputDir, file);
+				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
+			});
+			if (!outputFiles.includes(absEntry)) outputFiles.unshift(absEntry);
+			for (const outputFile of outputFiles) {
+				const outputRelPath = relative(rootDir, outputFile);
+				if (alreadyIngested(outputRelPath)) {
+					fileCount++;
+					continue;
+				}
+				let source;
+				try {
+					source = readFileSync(outputFile, "utf-8");
+				} catch (err) {
+					onUnreadable(outputRelPath, err);
+					continue;
+				}
+				onSourceRead?.(source, outputRelPath, outputFile);
+				entries.push({
+					path: outputRelPath,
+					source
+				});
+				pushed.add(outputRelPath);
+				fileOwners[outputRelPath] ??= specifier;
+				fileCount++;
+			}
 		}
-		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)));
+		outcomes.push({
+			specifier,
+			outcome: staleDist ? "stale-dist" : fileCount > 0 ? "resolved" : "empty",
+			fileCount
+		});
 	}
-	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;
+	return {
+		entries,
+		packageMap,
+		sourceEntries,
+		packageDirs,
+		dirOwnerSets,
+		dirExtensions,
+		fileOwners,
+		outcomes
+	};
+}
+function firstOwners(dirOwnerSets) {
+	const owners = {};
+	for (const [dir, specifiers] of Object.entries(dirOwnerSets)) if (specifiers.length > 0) owners[dir] = specifiers[0];
+	return owners;
+}
+function excludeCollectedPackages(collected, rejectedSpecifiers, rootDir) {
+	if (rejectedSpecifiers.size === 0) return collected;
+	const rejectedDirs = Object.entries(collected.dirOwnerSets).filter(([, specs]) => specs.every((s) => rejectedSpecifiers.has(s))).map(([dir]) => dir);
+	const underRejectedDir = (absPath) => rejectedDirs.some((dir) => isPathWithinRoot(dir, absPath));
+	const targetRejected = (specifier, absTarget) => rejectedSpecifiers.has(specifier) || underRejectedDir(absTarget);
+	const packageMap = {};
+	for (const [specifier, relTarget] of Object.entries(collected.packageMap)) {
+		if (targetRejected(specifier, resolve(rootDir, relTarget))) continue;
+		packageMap[specifier] = relTarget;
 	}
-	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";
+	const sourceEntries = /* @__PURE__ */ new Map();
+	for (const [specifier, absEntry] of collected.sourceEntries) {
+		if (targetRejected(specifier, absEntry)) continue;
+		sourceEntries.set(specifier, absEntry);
 	}
-	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;
+	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;
 	}
-	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;
+	const dirExtensions = {};
+	for (const [dir, exts] of Object.entries(collected.dirExtensions)) {
+		if (rejectedDirs.includes(dir)) continue;
+		dirExtensions[dir] = exts;
 	}
-};
-/**
-* 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 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,
+		packageDirs: collected.packageDirs.filter((dir) => !rejectedDirs.includes(dir)),
+		dirOwnerSets,
+		dirExtensions,
+		fileOwners,
+		outcomes: collected.outcomes
 	};
-	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;
+}
+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(", ")}`;
+}
+/** A stale dist silently skews merged registry content while discovery
+*  compiles the fresh sources; null when no specifier is stale. */
+function staleDistIncludesMessage(outcomes) {
+	const stale = outcomes.filter((record) => record.outcome === "stale-dist").map((record) => record.specifier);
+	if (stale.length === 0) return null;
+	return `[animus-extract] stale dist for include specifier(s): ${stale.join(", ")} — dist entry is older than the newest src/ file; rebuild the package(s) before extracting`;
+}
+function extractSystemFilePackages(systemFilePath) {
+	let source;
+	try {
+		source = readFileSync(systemFilePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const identifiers = /* @__PURE__ */ new Set();
+	const constructorRegex = /createSystem\s*\(\s*\{[^}]*?\bincludes\s*:\s*\[([^\]]*)\]/gs;
+	const chainRegex = /\.includes\s*\(\s*\[([^\]]*)\]\s*\)/gs;
+	const collectIdentifiers = (regex) => {
+		let match;
+		while ((match = regex.exec(source)) !== null) {
+			const inner = match[1];
+			for (const token of inner.split(",")) {
+				const id = token.trim();
+				if (id && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(id)) identifiers.add(id);
 			}
-			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;
+	collectIdentifiers(constructorRegex);
+	collectIdentifiers(chainRegex);
+	const IDENT_START_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*/;
+	const skipTrivia = (from) => {
+		let pos = from;
+		for (;;) {
+			while (pos < source.length && /\s/.test(source[pos])) pos++;
+			if (source.startsWith("//", pos)) {
+				const newline = source.indexOf("\n", pos);
+				pos = newline === -1 ? source.length : newline + 1;
+				continue;
+			}
+			if (source.startsWith("/*", pos)) {
+				const close = source.indexOf("*/", pos + 2);
+				pos = close === -1 ? source.length : close + 2;
+				continue;
+			}
+			return pos;
 		}
-		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;
+	};
+	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;
 		}
-		if (result.kind === "error") {
-			diagnostics.push(...result.diagnostics);
-			continue;
+	};
+	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++;
 		}
-		addAdaptedEntries(original.path, result.entries);
+		consumeChainLinks(pos);
+		const bound = boundIdentifierBefore(anchorMatch.index);
+		if (bound) chainRootIdentifiers.add(bound);
 	}
-	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 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);
+			}
 		}
 	}
-	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;
+	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);
+		}
 	}
-	return {
-		files,
-		parseCount
-	};
+	const systemFileDir = dirname$1(systemFilePath);
+	const packages = /* @__PURE__ */ new Set();
+	for (const id of identifiers) {
+		const specifier = importMap.get(id);
+		if (!specifier) continue;
+		if (specifier.startsWith(".")) packages.add(resolve(systemFileDir, specifier));
+		else packages.add(specifier);
+	}
+	return Array.from(packages);
 }
-/**
-* 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
-	};
+//#endregion
+//#region pipeline/source-corpus.ts
+function assembleRawEntries({ fileCache, externalFileOwners }) {
+	const project = [];
+	const external = [];
+	for (const [path, { hash, source }] of fileCache) (externalFileOwners[path] === void 0 ? project : external).push({
+		path,
+		source,
+		hash
+	});
+	project.sort((a, b) => compareDiscoveryOrder(a.path, b.path));
+	return [...project, ...external];
 }
-/**
-* 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();
+function createSourceCorpus(host, ingestor = createSourceIngestor(host)) {
+	let published = {
+		analysisEntries: /* @__PURE__ */ new Map(),
+		ownership: {}
+	};
 	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
-			});
+		async prepare(input) {
+			const rawEntries = "fileCache" in input ? assembleRawEntries(input) : input;
+			const ingested = await ingestor.ingest(rawEntries);
+			return withoutInvalidOriginals(ingested, ingestor.surfaceDiagnostics(ingested.diagnostics));
 		},
-		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;
+		publish(accepted) {
+			ingestor.markPublished(accepted);
+			published = {
+				analysisEntries: new Map(accepted.analysisEntries.map((entry) => [entry.path, {
+					hash: entry.hash,
+					source: entry.source
+				}])),
+				ownership: accepted.ownership
+			};
 		},
-		markPublished(result) {
-			for (const originalPath of Object.keys(result.ownership)) warnedByOriginal.delete(originalPath);
+		get published() {
+			return published;
 		}
 	};
 }
 //#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();
@@ -2203,19 +1981,6 @@ function findAssetSpecifiers(css) {
 	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;
@@ -2230,51 +1995,42 @@ function substituteAssetPlaceholders(css, urlBySpecifier) {
 //#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).
+* Asset resolution for hosts with no bundler hook. Host path aliases apply
+* FIRST, so `asset('@fonts/x')` resolves as the alias does in app modules.
 */
 const requireByRoot = /* @__PURE__ */ new Map();
 function requireAnchoredAt(rootDir) {
 	let req = requireByRoot.get(rootDir);
 	if (!req) {
-		req = createRequire$1(join(rootDir, "package.json"));
+		req = createRequire$1(join$1(rootDir, "package.json"));
 		requireByRoot.set(rootDir, req);
 	}
 	return req;
 }
 function packageRootFromEntry(entry) {
-	let current = dirname(entry);
+	let current = dirname$1(entry);
 	while (true) {
-		if (existsSync(join(current, "package.json"))) return current;
-		const parent = dirname(current);
+		if (existsSync(join$1(current, "package.json"))) return current;
+		const parent = dirname$1(current);
 		if (parent === current) return null;
 		current = parent;
 	}
 }
 const aliasTableCache = /* @__PURE__ */ new Map();
+/**
+* A parse failure throws: an empty table would disable every alias-based
+* `asset()` and ship dangling `url()`s as a successful build.
+*/
 function parseAliasTable(pathAliasesJson) {
 	const cached = aliasTableCache.get(pathAliasesJson);
 	if (cached) return cached;
-	let aliases;
-	try {
-		aliases = JSON.parse(pathAliasesJson).aliases ?? [];
-	} catch {
-		aliases = [];
-	}
+	const aliases = parseInternalWire(pathAliasesJson, "pathAliasesJson (the host alias table from buildPathAliasesJson)").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.
+* Map a specifier through the host alias table, whose entries arrive sorted
+* longest-pattern-first. Returns an absolute path to an EXISTING file.
 */
 function resolveThroughPathAliases(specifier, rootDir, pathAliasesJson) {
 	if (!pathAliasesJson) return null;
@@ -2285,15 +2041,14 @@ function resolveThroughPathAliases(specifier, rootDir, pathAliasesJson) {
 			if (alias.pattern === specifier) mapped = alias.replacement;
 		} else if (specifier.startsWith(alias.pattern)) mapped = alias.replacement + specifier.slice(alias.pattern.length);
 		if (mapped === null) continue;
-		const absolute = isAbsolute(mapped) ? mapped : join(rootDir, mapped);
+		const absolute = isAbsolute(mapped) ? mapped : join$1(rootDir, mapped);
 		if (existsSync(absolute)) return absolute;
 	}
 	return null;
 }
 /**
-* Resolve an asset specifier to an absolute file: host aliases, then direct
-* Node resolution anchored at `rootDir`, then the package-root fallback.
-* Returns null when nothing matches — strict gating stays at the caller.
+* Resolve an asset specifier: host aliases, then Node resolution anchored at
+* `rootDir`, then the package root. Strict gating stays at the caller.
 */
 function resolveAssetFile(specifier, rootDir, pathAliasesJson) {
 	const aliased = resolveThroughPathAliases(specifier, rootDir, pathAliasesJson);
@@ -2307,15 +2062,15 @@ function resolveAssetFile(specifier, rootDir, pathAliasesJson) {
 	const subpath = specifier.slice(packageName.length + 1);
 	if (!subpath) return null;
 	for (const modulesDir of requireFromRoot.resolve.paths(packageName) ?? []) {
-		const packageRoot = join(modulesDir, packageName);
-		if (!existsSync(join(packageRoot, "package.json"))) continue;
-		const candidate = join(packageRoot, subpath);
+		const packageRoot = join$1(modulesDir, packageName);
+		if (!existsSync(join$1(packageRoot, "package.json"))) continue;
+		const candidate = join$1(packageRoot, subpath);
 		if (existsSync(candidate)) return candidate;
 	}
 	try {
 		const packageRoot = packageRootFromEntry(requireFromRoot.resolve(packageName));
 		if (!packageRoot) return null;
-		const candidate = join(packageRoot, subpath);
+		const candidate = join$1(packageRoot, subpath);
 		return existsSync(candidate) ? candidate : null;
 	} catch {
 		return null;
@@ -2324,20 +2079,13 @@ function resolveAssetFile(specifier, rootDir, pathAliasesJson) {
 //#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.
+* Index the loader-captured theme manifests by owning specifier. An
+* unparseable capture throws: an empty index reads as "no source defines it".
 */
 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 manifests = parseInternalWire(opts.sourceThemeManifestsJson, "sourceThemeManifestsJson (the system loader's built-theme capture)");
 	const realDirOwners = [];
 	const addOwnerDir = (dir, specifier) => {
 		if (!realDirOwners.some((entry) => entry.dir === dir)) realDirOwners.push({
@@ -2352,8 +2100,8 @@ function buildSourceTokenIndex(opts) {
 		} catch {}
 		addOwnerDir(real, specifier);
 		let packageRoot = real;
-		while (packageRoot !== dirname(packageRoot) && !existsSync(join(packageRoot, "package.json"))) packageRoot = dirname(packageRoot);
-		if (existsSync(join(packageRoot, "package.json"))) addOwnerDir(packageRoot, specifier);
+		while (packageRoot !== dirname$1(packageRoot) && !existsSync(join$1(packageRoot, "package.json"))) packageRoot = dirname$1(packageRoot);
+		if (existsSync(join$1(packageRoot, "package.json"))) addOwnerDir(packageRoot, specifier);
 	}
 	for (const [modulePath, exports] of Object.entries(manifests)) {
 		const owner = realDirOwners.find(({ dir }) => isPathWithinRoot(dir, modulePath));
@@ -2368,11 +2116,8 @@ function buildSourceTokenIndex(opts) {
 	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.
+* One message per distinct (component, token, specifier) whose source
+* defines the token. Severity routing stays at the caller.
 */
 function correlateExternalTokenDiagnostics(opts) {
 	const messages = [];
@@ -2391,11 +2136,8 @@ function correlateExternalTokenDiagnostics(opts) {
 }
 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.
+* The one cross-source token-contract gate both plugins share, so the hosts
+* cannot drift on wiring or severity.
 */
 function enforceExternalTokenContracts(opts) {
 	const manifestsJson = opts.sourceThemeManifestsJson ?? "";
@@ -2423,12 +2165,6 @@ function enforceExternalTokenContracts(opts) {
 }
 //#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) {
@@ -2453,17 +2189,6 @@ function buildPathAliasesJson(pairs, rootDir) {
 }
 //#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];
@@ -2471,12 +2196,9 @@ function resolveLightningTargets(explicitTargets, rootDir) {
 		const detected = browserslist(void 0, { path: rootDir });
 		queries = detected.length > 0 ? detected : browserslist("defaults");
 	}
-	return browserslistToTargets(Array.isArray(queries) && typeof queries[0] === "string" && queries[0].includes(" ") ? browserslist(queries) : queries);
+	const [firstQuery] = queries;
+	return browserslistToTargets(firstQuery !== void 0 && firstQuery.includes(" ") ? browserslist(queries) : queries);
 }
-/**
-* Post-process CSS with Lightning CSS: autoprefixing + optional minification.
-* On failure, returns the original CSS and logs a warning.
-*/
 function postProcessCss(css, opts) {
 	if (!css) return css;
 	try {
@@ -2494,28 +2216,20 @@ function postProcessCss(css, opts) {
 }
 //#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`. */
+/** Stable code for selector forms with no substitutable subject; the
+*  extraction engine mints the same string. */
 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). */
+/** The one matcher for the engine's unresolved-parent chain-drop message;
+*  consumers match through the exported helpers, never their own copy. */
 const UNRESOLVED_PARENT_RE = /chain dropped: could not resolve parent component '([^']+)'/;
-/** 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);
+	return 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). */
+/** True when the selector carries at least one substitutable `&` subject
+*  outside quoted text. */
 function hasSelectorSubject(value) {
 	let quote = null;
 	let escaped = false;
@@ -2536,44 +2250,91 @@ function hasSelectorSubject(value) {
 	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).
+* Coded diagnostics for selector-shaped alias values with no substitutable
+* subject; alias values never reach the evaluator's own key guard.
 */
 function collectSelectorAliasDiagnostics(selectorAliasesJson) {
 	if (!selectorAliasesJson) return [];
-	let aliases;
-	try {
-		aliases = JSON.parse(selectorAliasesJson);
-	} catch {
-		return [];
-	}
+	const aliases = parseInternalWire(selectorAliasesJson, "selectorAliasesJson (the system loader's selector-alias registry)");
 	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"
-		});
-	}
+	for (const [name, value] of Object.entries(aliases)) 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: severityFor(SELECTOR_UNSUPPORTED_SUBJECT)
+	});
+	return diagnostics;
+}
+const UNREADABLE_SOURCE_FILE = "animus.ingestion.unreadable-source-file";
+/**
+* A configured source file that could not be read is a LOST INPUT: the
+* emitted artifacts silently lack whatever that file declared.
+*/
+function unreadableSourceDiagnostic(relPath, error) {
+	return {
+		file: relPath,
+		component: "source",
+		kind: "warn",
+		message: `configured source file ${relPath} could not be read and was skipped: ${String(error)}`,
+		code: UNREADABLE_SOURCE_FILE,
+		severity: severityFor(UNREADABLE_SOURCE_FILE)
+	};
+}
+/** The collision entry code minted by the system package's merge. */
+const VOCABULARY_COLLISION = "animus.vocabulary.collision";
+/** Minted when a sealed kit with registered vocabulary is consumed through
+*  the deprecated `from()`/`includes:` verbs. */
+const VOCABULARY_LEGACY_VERB = "animus.vocabulary.legacy-verb";
+const DIAGNOSTIC_SEVERITY = /* @__PURE__ */ new Map([
+	[SELECTOR_UNSUPPORTED_SUBJECT, "error"],
+	[UNREADABLE_SOURCE_FILE, "error"],
+	[VOCABULARY_COLLISION, "warn"],
+	[VOCABULARY_LEGACY_VERB, "warn"]
+]);
+/** An unlisted code is `warn`: a witness kind from a newer system package
+*  must not fail the strict build of a host that predates its writer. */
+function severityFor(code) {
+	return (code === void 0 ? void 0 : DIAGNOSTIC_SEVERITY.get(code)) ?? "warn";
+}
+/**
+* The one mapper of a sealed system's witness entries for every host: the
+* loader's evaluation host shims `console`, so the record is the channel.
+*/
+function vocabularyWitnessDiagnostics(vocabularyWitnessesJson) {
+	if (!vocabularyWitnessesJson) return [];
+	const entries = parseInternalWire(vocabularyWitnessesJson, "vocabularyWitnessesJson (the sealed system's vocabulary witness record)");
+	const diagnostics = [];
+	for (const entry of entries) if (entry.code === "animus.vocabulary.collision") diagnostics.push({
+		file: "system",
+		component: entry.name ?? "keyframes",
+		kind: "warn",
+		message: `keyframes vocabulary "${entry.name}" is registered by both ${entry.loser} and ${entry.winner} — ${entry.winner} wins; rename one collection (${entry.code})`,
+		code: entry.code,
+		severity: severityFor(entry.code)
+	});
+	else if (entry.code === "animus.vocabulary.legacy-verb") diagnostics.push({
+		file: "system",
+		component: "keyframes",
+		kind: "warn",
+		message: `a sealed system (${entry.source ?? `'${entry.verb}' source`}) with registered vocabulary [${(entry.names ?? []).join(", ")}] was consumed through the deprecated '${entry.verb}' verb, which cannot carry it — those collections do NOT reach this consumer; use createSystem().extend(source) (${entry.code})`,
+		code: entry.code,
+		severity: severityFor(entry.code)
+	});
+	else diagnostics.push({
+		file: "system",
+		component: "vocabulary",
+		kind: "warn",
+		message: `unrecognized vocabulary witness entry ${JSON.stringify(entry)} — a newer @animus-ui/system may have recorded a witness kind this host predates${entry.code ? ` (${entry.code})` : ""}`,
+		code: entry.code,
+		severity: severityFor(entry.code)
+	});
 	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.
+* The single strict-escalation policy point for both extraction plugins:
+* error-severity diagnostics throw together under `strict`, else warn.
 */
 function surfaceManifestDiagnostics(manifest, warn, policy = {}) {
 	const errors = [];
@@ -2595,11 +2356,6 @@ function surfaceManifestDiagnostics(manifest, warn, policy = {}) {
 }
 //#endregion
 //#region pipeline/unit-fallback.ts
-/**
-* Append `px` to bare numeric values in CSS declarations for properties
-* that expect length units. Unitless properties are preserved as-is.
-* Numbers inside CSS function calls (cubic-bezier, rgb, calc, etc.) are skipped.
-*/
 function applyUnitFallback(css) {
 	return css.replace(/([a-z-]+)\s*:\s*([^;{}]+);/g, (match, prop, value) => {
 		if (isUnitlessProperty(prop)) return match;
@@ -2635,13 +2391,14 @@ function applyUnitFallback(css) {
 }
 //#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).
-*/
+/** The named `analyzeProject` input set, and the persistence shape an
+*  isolated process replays the analysis from. */
 function buildAnalysisInputs(opts) {
+	const emitterConfig = {
+		runtime_import: opts.emitter.runtimeImport,
+		css_module_id: opts.emitter.cssModuleId
+	};
+	if (opts.emitter.systemPropsModuleId) emitterConfig.system_props_module_id = opts.emitter.systemPropsModuleId;
 	return {
 		filesJson: JSON.stringify(opts.fileEntries),
 		scalesJson: opts.system.scalesJson,
@@ -2651,11 +2408,7 @@ function buildAnalysisInputs(opts) {
 		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 } : {}
-		}),
+		emitterConfigJson: JSON.stringify(emitterConfig),
 		selectorAliasesJson: opts.system.selectorAliasesJson,
 		globalStyleBlocksJson: opts.system.globalStyleBlocksJson,
 		pathAliasesJson: opts.pathAliasesJson,
@@ -2666,17 +2419,13 @@ function buildAnalysisInputs(opts) {
 		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 !== "{}";
+	const json = system.sourceThemeManifestsJson ?? "";
+	return 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).
+* The one analysis invocation both plugins share. Error handling stays at
+* the call site (strict-mode throw vs warn).
 */
 function runProjectAnalysis(engineApi, opts) {
 	const { analyzeProject } = engineApi();
@@ -2696,8 +2445,8 @@ function runProjectAnalysis(engineApi, opts) {
 	return {
 		manifest,
 		manifestJson,
-		globalCss: manifest?.sheets?.global || "",
-		componentCss: applyUnitFallback(manifest?.css || ""),
+		globalCss: manifest.sheets.global,
+		componentCss: applyUnitFallback(manifest.css),
 		inputs,
 		timings: {
 			serializeMs,
@@ -2707,9 +2456,8 @@ function runProjectAnalysis(engineApi, opts) {
 	};
 }
 /**
-* 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.
+* Clear the engine's per-file analysis cache so stale results never bleed
+* into a fresh run. Engines without the capability are tolerated.
 */
 function clearEngineCache(engineApi) {
 	try {
@@ -2718,15 +2466,32 @@ function clearEngineCache(engineApi) {
 	} catch {}
 }
 //#endregion
-//#region pipeline/static-css.ts
-/** Key-sorted stringify so semantically identical configs serialize
-*  identically (stable analysis-inputs hashing). */
+//#region pipeline/utils.ts
+function camelToKebab(str) {
+	return str.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
 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(",")}}`;
+	if (isKeyedReference(value)) 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. */
+/** Decided by an intrinsic only functions accept, so a spoofed
+*  `Symbol.toStringTag` cannot pass a plain object off as a function. */
+function isCallable(value) {
+	try {
+		Function.prototype.toString.call(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isKeyedReference(value) {
+	return Object(value) === value && !isCallable(value);
+}
+//#endregion
+//#region pipeline/static-css.ts
+/** The `staticCss` option declares emission the JSX scanner cannot observe
+*  (config-driven variants, spread props); the engine applies it as usage. */
 function serializeStaticCss(config) {
 	if (!config) return null;
 	const json = stableStringify(config);
@@ -2734,14 +2499,6 @@ function serializeStaticCss(config) {
 }
 //#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,
@@ -2772,14 +2529,8 @@ function applyPrefix(prefix, variableMapJson, variableCss, themeJson, contextual
 //#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.
+* Load and normalize a SystemInstance; `prefix` namespaces every CSS
+* variable name. Error handling stays at the call site.
 */
 function loadSystemConfig(engineApi, opts) {
 	const { loadSystemModule } = engineApi();
@@ -2807,23 +2558,13 @@ function loadSystemConfig(engineApi, opts) {
 		transformSourcesJson: config.transformSources || null,
 		globalStyleBlocksJson: config.globalStyleBlocks || null,
 		keyframesJson: config.keyframesBlocks || null,
+		vocabularyWitnessesJson: config.vocabularyWitnesses || 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");
@@ -2865,33 +2606,12 @@ function buildDynamicPropConfig(dynamicProps) {
 }
 //#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"],
@@ -2905,11 +2625,6 @@ const RUST_TIMING_PHASES = [
 	["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) {
@@ -2923,21 +2638,9 @@ function formatRustTimingWaterfall(timing, opts) {
 //#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.
+* tsconfig `paths` → alias pairs, for drivers with no live bundler config.
+* The nearest config declaring `paths` wins wholesale — TS never merges.
 */
-/** String-aware JSONC → JSON: strips // and block comments + trailing commas. */
 function stripJsonc(text) {
 	let out = "";
 	let inString = false;
@@ -2987,6 +2690,35 @@ function stripJsonc(text) {
 	}
 	return out.replace(/,(\s*[}\]])/g, "$1");
 }
+/** `Object(value) === value` holds for exactly the blocks and lists
+*  `JSON.parse` produces; the `[object Object]` tag separates the two. */
+function isJsonBlock(value) {
+	return Object(value) === value && Object.prototype.toString.call(value) === "[object Object]";
+}
+/** A block or a list. A declared `paths` OWNS the setting and blocks its
+*  parents' even when it contributes nothing usable. */
+function isJsonKeyed(value) {
+	return Object(value) === value;
+}
+/** A JSON string, excluding the boxed `String` object, which no path join
+*  accepts. */
+function isJsonString(value) {
+	return Object(value) !== value && Object.prototype.toString.call(value) === "[object String]";
+}
+function decodePaths(value) {
+	if (!isJsonKeyed(value)) return null;
+	const decoded = /* @__PURE__ */ new Map();
+	for (const [pattern, targets] of Object.entries(value)) {
+		const [first] = Array.isArray(targets) ? targets : [];
+		if (isJsonString(first)) decoded.set(pattern, first);
+	}
+	return decoded;
+}
+/** TypeScript accepts one specifier or an array; a non-string member names
+*  no config and is dropped here. */
+function decodeExtends(value) {
+	return (Array.isArray(value) ? value : [value]).filter(isJsonString);
+}
 function readConfig(path) {
 	let raw;
 	try {
@@ -2994,16 +2726,20 @@ function readConfig(path) {
 	} catch {
 		return null;
 	}
+	let parsed;
 	try {
-		const json = JSON.parse(stripJsonc(raw));
-		return {
-			dir: dirname(path),
-			compilerOptions: json.compilerOptions ?? {},
-			extends: json.extends
-		};
+		parsed = JSON.parse(stripJsonc(raw));
 	} catch {
 		return null;
 	}
+	const root = isJsonBlock(parsed) ? parsed : {};
+	const compilerOptions = isJsonBlock(root.compilerOptions) ? root.compilerOptions : {};
+	return {
+		dir: dirname$1(path),
+		baseUrl: isJsonString(compilerOptions.baseUrl) ? compilerOptions.baseUrl : null,
+		paths: decodePaths(compilerOptions.paths),
+		extends: decodeExtends(root.extends)
+	};
 }
 function resolveExtendsTarget(specifier, fromDir) {
 	if (specifier.startsWith(".") || isAbsolute(specifier)) {
@@ -3011,7 +2747,7 @@ function resolveExtendsTarget(specifier, fromDir) {
 		for (const candidate of [
 			base,
 			`${base}.json`,
-			join(base, "tsconfig.json")
+			join$1(base, "tsconfig.json")
 		]) if (existsSync(candidate)) return candidate;
 		return null;
 	}
@@ -3031,15 +2767,14 @@ function loadChain(entryPath) {
 	const visited = /* @__PURE__ */ new Set();
 	const queue = [entryPath];
 	while (queue.length > 0) {
-		const key = resolve(queue.shift());
+		const path = queue.shift();
+		const key = resolve(path);
 		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;
+		for (const parent of node.extends) {
 			const resolved = resolveExtendsTarget(parent, node.dir);
 			if (resolved) queue.push(resolved);
 		}
@@ -3047,22 +2782,20 @@ function loadChain(entryPath) {
 	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.
+* The project's tsconfig path aliases as `buildPathAliasesJson` pairs; empty
+* when no readable tsconfig, or no usable `paths`, exists.
 */
 function readTsconfigAliasPairs(rootDir) {
-	const chain = loadChain(join(rootDir, "tsconfig.json"));
+	const chain = loadChain(join$1(rootDir, "tsconfig.json"));
 	if (chain.length === 0) return [];
-	const pathsOwner = chain.find((node) => node.compilerOptions.paths && typeof node.compilerOptions.paths === "object");
-	if (!pathsOwner) return [];
-	const paths = pathsOwner.compilerOptions.paths;
-	const baseOwner = chain.find((node) => typeof node.compilerOptions.baseUrl === "string");
-	const base = baseOwner ? resolve(baseOwner.dir, baseOwner.compilerOptions.baseUrl) : pathsOwner.dir;
+	const pathsOwner = chain.find((node) => node.paths !== null);
+	const paths = pathsOwner?.paths ?? null;
+	if (pathsOwner === void 0 || paths === null) return [];
+	const baseOwner = chain.find((node) => node.baseUrl !== null);
+	const baseUrl = baseOwner?.baseUrl ?? null;
+	const base = baseOwner !== void 0 && baseUrl !== null ? resolve(baseOwner.dir, 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;
+	for (const [pattern, target] of paths) {
 		const patternStars = pattern.split("*").length - 1;
 		const targetStars = target.split("*").length - 1;
 		if (pattern === "*" || patternStars > 1 || targetStars > 1) continue;
@@ -3086,14 +2819,6 @@ function readTsconfigAliasPairs(rootDir) {
 }
 //#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;
@@ -3103,33 +2828,29 @@ function assertNoErrorDiagnostics(diagnostics) {
 //#endregion
 //#region pipeline/replacement-plans.ts
 const snapshotByManifest = /* @__PURE__ */ new WeakMap();
+/** `null` (a context before its first analysis) snapshots to the empty plan
+*  set — the same state as an empty universe. */
 function snapshotFilePlans(manifest) {
-	const memoKey = manifest !== null && typeof manifest === "object" ? manifest : null;
-	if (memoKey) {
-		const cached = snapshotByManifest.get(memoKey);
-		if (cached) return cached;
-	}
+	if (manifest === null) return /* @__PURE__ */ new Map();
+	const cached = snapshotByManifest.get(manifest);
+	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);
+	for (const [id, desc] of Object.entries(manifest.components)) {
+		const list = entriesByFile.get(desc.file) ?? [];
+		list.push([id, desc.replacement]);
+		entriesByFile.set(desc.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);
+	snapshotByManifest.set(manifest, 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).
+* Paths whose plan changed: absent↔present, membership, or content.
+* `exclude` drops one path whose own modules are already being updated.
 */
 function diffFilePlans(prev, next, opts) {
 	const changed = /* @__PURE__ */ new Set();
@@ -3138,33 +2859,15 @@ function diffFilePlans(prev, next, opts) {
 	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). */
+/** Domain prefix keeping this hash disjoint from every other `contentHash`
+*  use in the pipeline. */
 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. */
+/** Leads with NUL: entries end with `\0` and contain none, so `\0\0` is
+*  unreachable from entries alone and the section cannot be forged. */
 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.
+* THE replacement epoch: integrations consume this hash, never their own.
+* `servedDependencyWitness` folds in content the plans cannot see.
 */
 function hashReplacementPlans(snapshot, servedDependencyWitness) {
 	const entries = [...snapshot.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
@@ -3174,40 +2877,14 @@ function hashReplacementPlans(snapshot, servedDependencyWitness) {
 	return contentHash(serialized);
 }
 //#endregion
-//#region pipeline/utils.ts
-/** Convert camelCase CSS property names to kebab-case. */
-function camelToKebab(str) {
-	return str.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-}
-//#endregion
 //#region pipeline/watch-keys.ts
-/**
-* Membership keys for a filesystem path in the system-dependency watch set.
-*
-* The loader reports symlink-resolved canonical paths; watcher events carry
-* lexical absolute paths that may traverse symlinks (bun workspace links) and
-* — for deletions — may no longer exist, so `realpathSync` on the event path
-* alone cannot produce the canonical form. Both insertion and lookup go
-* through this one normalizer: the lexical form plus a canonical form
-* reconstructed through the nearest existing ancestor.
-*/
 function toWatchKeys(input) {
 	const lexical = normalize(input);
 	const canonical = realpathThroughNearestExistingAncestor(lexical);
 	return canonical === lexical ? [lexical] : [lexical, canonical];
 }
-/**
-* Canonicalize a path that may not exist: walk up to the nearest existing
-* ancestor, realpath it, and re-append the missing suffix. Handles deleted
-* files under still-existing (possibly symlinked) directories and atomic
-* unlink/rename saves. Falls back to the input when no ancestor resolves.
-*
-* Known limit: a symlink retargeted AFTER the system load canonicalizes to
-* the new target, which cannot match the recorded (old-target) dependency —
-* the membership test then fails open (no reset), identical to not having
-* this reconstruction at all. Retarget sensitivity is a resolution-input
-* concern, deliberately out of scope for the watch set.
-*/
+/** Canonicalizes a path that may not exist, through its nearest existing
+*  ancestor. A symlink retargeted after load fails open: no match. */
 function realpathThroughNearestExistingAncestor(path) {
 	try {
 		return realpathSync$1(path);
@@ -3215,14 +2892,14 @@ function realpathThroughNearestExistingAncestor(path) {
 	const suffix = [];
 	let current = path;
 	for (;;) {
-		const parent = dirname$1(current);
+		const parent = dirname(current);
 		if (parent === current) return path;
-		suffix.unshift(basename$1(current));
+		suffix.unshift(basename(current));
 		current = parent;
 		try {
-			return join$1(realpathSync$1(current), ...suffix);
+			return join(realpathSync$1(current), ...suffix);
 		} catch {}
 	}
 }
 //#endregion
-export { CORE_OPTION_KEYS as $, createSourceIngestor as A, extractSystemFilePackages as B, resolveLightningTargets as C, resolveThroughPathAliases as D, resolveAssetFile as E, ENGINE_TRANSFORM_EXTENSIONS as F, staleDistIncludesMessage as G, firstOwners as H, preprocessMdx as I, createSourceIdentity as J, unresolvableIncludesMessage as K, adaptSvelteSource as L, isAdvisorySourceDiagnostic as M, withoutInvalidOriginals as N, findAssetSpecifiers as O, DEFAULT_EXTENSIONS as P, AnimusConfigError as Q, collectExternalPackageSources as R, postProcessCss as S, enforceExternalTokenContracts as T, isExcludedPackageRelativePath as U, findPackageRoot as V, resolveAbsolutePathSpecifier as W, sharesVolumeRoot as X, isPathWithinRoot as Y, discoverFiles as Z, runProjectAnalysis as _, stripLeadingLayerDeclaration as _t, snapshotFilePlans as a, createExcludeMatcher as at, surfaceManifestDiagnostics as b, formatRustTimingWaterfall as c, KEYFRAMES_EXTERNAL_ENTRY_FAILED as ct, runStructuralSelfCheck as d, RETIRED_ENGINE_MESSAGE as dt, DEFAULT_EXCLUDE as et, loadSystemConfig as f, assertNoRetiredEngineSelection as ft, clearEngineCache as g, assembleStylesheet as gt, buildAnalysisInputs as h, ANIMUS_LAYERS as ht, hashReplacementPlans as i, assertKnownOptionKeys as it, ingestSourceEntries as j, substituteAssetPlaceholders as k, buildSystemPropsModule as l, mergeExternalKeyframes as lt, serializeStaticCss as m, buildAnalyzeProjectArgs as mt, camelToKebab as n, REPLACEABLE_DEFAULT_EXCLUDE as nt, assertNoErrorDiagnostics as o, resolveMode as ot, applyPrefix as p, createV2EngineApi as pt, walkPackageSources as q, diffFilePlans as r, STRUCTURAL_EXCLUDE as rt, readTsconfigAliasPairs as s, KEYFRAMES_EXPORT_COLLISION as st, toWatchKeys as t, DRIVER_NAMESPACES as tt, buildDynamicPropConfig as u, contentHash as ut, applyUnitFallback as v, validateLayerOrder as vt, buildPathAliasesJson as w, unresolvedParentName as x, isUnresolvedParentDrop as y, __require as yt, excludeCollectedPackages as z };
+export { DEFAULT_EXCLUDE as $, enforceExternalTokenContracts as A, firstOwners as B, surfaceManifestDiagnostics as C, validateLayerOrder as Ct, postProcessCss as D, vocabularyWitnessDiagnostics as E, createSourceCorpus as F, walkPackageSources as G, resolveAbsolutePathSpecifier as H, collectExternalPackageSources as I, sharesVolumeRoot as J, createSourceIdentity as K, excludeCollectedPackages as L, resolveThroughPathAliases as M, findAssetSpecifiers as N, resolveLightningTargets as O, substituteAssetPlaceholders as P, CORE_OPTION_KEYS as Q, extractSystemFilePackages as R, isUnresolvedParentDrop as S, stripLeadingLayerDeclaration as St, unresolvedParentName as T, staleDistIncludesMessage as U, isExcludedPackageRelativePath as V, unresolvableIncludesMessage as W, discoverFiles as X, compareDiscoveryOrder as Y, AnimusConfigError as Z, clearEngineCache as _, preprocessMdx as _t, assertNoErrorDiagnostics as a, resolveMode as at, VOCABULARY_COLLISION as b, ANIMUS_LAYERS as bt, buildSystemPropsModule as c, createV2EngineApi as ct, loadSystemConfig as d, parseFilesJson as dt, DRIVER_NAMESPACES as et, applyPrefix as f, projectExternalFileOwners as ft, buildAnalysisInputs as g, isEngineTransformExtension as gt, stableStringify as h, ENGINE_TRANSFORM_EXTENSIONS as ht, snapshotFilePlans as i, createExcludeMatcher as it, resolveAssetFile as j, buildPathAliasesJson as k, buildDynamicPropConfig as l, ingestSourceEntries as lt, camelToKebab as m, DEFAULT_EXTENSIONS as mt, diffFilePlans as n, STRUCTURAL_EXCLUDE as nt, readTsconfigAliasPairs as o, RETIRED_ENGINE_MESSAGE as ot, serializeStaticCss as p, adaptSvelteSource as pt, isPathWithinRoot as q, hashReplacementPlans as r, assertKnownOptionKeys as rt, formatRustTimingWaterfall as s, assertNoRetiredEngineSelection as st, toWatchKeys as t, REPLACEABLE_DEFAULT_EXCLUDE as tt, runStructuralSelfCheck as u, isAdvisorySourceDiagnostic as ut, runProjectAnalysis as v, contentHash as vt, unreadableSourceDiagnostic as w, __require as wt, VOCABULARY_LEGACY_VERB as x, assembleStylesheet as xt, applyUnitFallback as y, buildAnalyzeProjectArgs as yt, findPackageRoot as z };