@animus-ui/extract 0.1.11 → 0.1.12

package/dist/{pipeline-ojNeABi0.cjs → pipeline-x1yBZ2UP.cjs}

@@ -15,27 +15,23 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
 //#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path);
 let crypto = require("crypto");
 let fs = require("fs");
 let path = require("path");
 let node_fs = require("node:fs");
-let node_path = require("node:path");
-node_path = __toESM(node_path);
 let module$1 = require("module");
 let browserslist = require("browserslist");
 browserslist = __toESM(browserslist);
 let lightningcss = require("lightningcss");
 let _animus_ui_properties = require("@animus-ui/properties");
 //#region pipeline/assemble-stylesheet.ts
-/**
-* The 7 Animus cascade layers. Always prefixed with `anm-` to avoid
-* collision with other frameworks' layer names (e.g., Tailwind's `base`).
-*/
 const ANIMUS_LAYERS = [
 	"anm-global",
 	"anm-base",
@@ -45,22 +41,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;
@@ -75,11 +58,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?/, "");
 }
@@ -128,2091 +106,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 (0, crypto.createHash)("md5").update(source).digest("hex");
 }
 //#endregion
-//#region pipeline/external-keyframes.ts
-/** Stable codes for external keyframes discovery. */
-const KEYFRAMES_EXTERNAL_ENTRY_FAILED = "animus.keyframes.external-entry-failed";
-const KEYFRAMES_EXPORT_COLLISION = "animus.keyframes.export-collision";
-/**
-* Merge `Keyframes` collections discovered from external package entries into
-* the consumer system's collections. Keyframes are the sole carve-out from
-* the consumer-config singular-authority rule: nothing but branded
-* collections is read from an entry, an entry that fails to evaluate
-* degrades to a coded diagnostic naming it, and a collection whose export
-* name collides keeps the earlier (consumer-first) collection with a coded
-* diagnostic instead of silently reordering names.
-*/
-function mergeExternalKeyframes(scan, consumerKeyframesJson, externalEntries, rootDir) {
-	const merged = {};
-	if (consumerKeyframesJson) try {
-		Object.assign(merged, JSON.parse(consumerKeyframesJson));
-	} catch {
-		return {
-			keyframesJson: consumerKeyframesJson,
-			diagnostics: []
-		};
-	}
-	const diagnostics = [];
-	const seenEntries = /* @__PURE__ */ new Set();
-	for (const entryPath of externalEntries) {
-		if (seenEntries.has(entryPath)) continue;
-		seenEntries.add(entryPath);
-		let scanned;
-		try {
-			scanned = scan(entryPath, rootDir);
-		} catch (error) {
-			diagnostics.push({
-				file: entryPath,
-				component: "keyframes",
-				kind: "warn",
-				message: `external package entry failed the keyframes scan — its collections are invisible to extraction: ${String(error)}. Keyframe collections must be reachable from the package's definition entry without evaluating framework re-exports: export them (directly or as a named re-export) from the definition entry, and avoid \`export *\` of framework packages there (${KEYFRAMES_EXTERNAL_ENTRY_FAILED})`,
-				code: KEYFRAMES_EXTERNAL_ENTRY_FAILED,
-				severity: "warn"
-			});
-			continue;
-		}
-		if (!scanned) continue;
-		let collections;
-		try {
-			collections = JSON.parse(scanned);
-		} catch {
-			continue;
-		}
-		for (const [exportName, collection] of Object.entries(collections)) {
-			const existing = merged[exportName];
-			if (existing !== void 0) {
-				if (JSON.stringify(existing) !== JSON.stringify(collection)) diagnostics.push({
-					file: entryPath,
-					component: exportName,
-					kind: "warn",
-					message: `keyframes collection export '${exportName}' collides with an earlier collection of the same name — the earlier one wins (${KEYFRAMES_EXPORT_COLLISION})`,
-					code: KEYFRAMES_EXPORT_COLLISION,
-					severity: "warn"
-				});
-				continue;
-			}
-			merged[exportName] = collection;
-		}
+//#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 = (0, fs.readdirSync)(dir, { encoding: "utf8" });
-	} catch {
-		return results;
-	}
-	entries.sort();
-	const isExcluded = exclude ? (full, rel) => exclude.matches(full, rel) : () => false;
-	for (const entry of entries) {
-		const fullPath = (0, path.join)(dir, entry);
-		if (isExcluded(fullPath, (0, path.relative)(rootDir, fullPath))) continue;
-		let stat;
-		try {
-			stat = (0, fs.statSync)(fullPath);
-		} catch {
-			continue;
-		}
-		if (stat.isDirectory()) results.push(...discoverFiles(fullPath, rootDir, exclude, extensionsSet));
-		else if (extensionsSet.has((0, path.extname)(entry))) results.push(fullPath);
+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 = node_path.default) {
-	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 = node_path.default) {
-	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 (0, node_fs.realpathSync)(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 = node_path.default.normalize(rootDir);
-	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
-	const roots = [];
-	const aliases = /* @__PURE__ */ new Map();
-	const owningRecord = (canonicalPath) => {
-		let owner = null;
-		for (const record of roots) {
-			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
-			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
-		}
-		return owner;
+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 {
-		rootDir: normalizedRootDir,
-		canonicalRootDir,
-		registerExternalRoot(root) {
-			const asRegistered = node_path.default.normalize(root);
-			const canonical = canonicalize(asRegistered) ?? asRegistered;
-			const existing = roots.find((record) => record.canonical === canonical);
-			if (existing) return existing.canonical;
-			roots.push({
-				asRegistered,
-				canonical
-			});
-			return canonical;
-		},
-		externalRoots() {
-			return roots.map((record) => record.canonical);
-		},
-		resolveSourceId(inputPath) {
-			const lexical = node_path.default.normalize(inputPath);
-			const canonical = canonicalize(lexical);
-			if (canonical === null) return null;
-			const owner = owningRecord(canonical);
-			const ownedBy = (record) => {
-				const pathInRoot = node_path.default.relative(record.canonical, canonical);
-				return {
-					sourceKey: node_path.default.relative(normalizedRootDir, node_path.default.join(record.asRegistered, pathInRoot)),
-					owningRoot: record.canonical,
-					pathInRoot
-				};
-			};
-			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
-			let resolved;
-			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
-				const key = node_path.default.relative(canonicalRootDir, canonical);
-				resolved = {
-					sourceKey: key,
-					owningRoot: null,
-					pathInRoot: key
-				};
-			} else if (owner) resolved = ownedBy(owner);
-			else return null;
-			aliases.set(lexical, resolved);
-			aliases.set(canonical, resolved);
-			return resolved;
-		},
-		resolveDeletedSourceId(inputPath) {
-			return aliases.get(node_path.default.normalize(inputPath)) ?? null;
-		},
-		containingExternalRoot(inputPath) {
-			const lexical = node_path.default.normalize(inputPath);
-			let owner = null;
-			for (const record of roots) {
-				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
-				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+		node,
+		location: {
+			start: point(candidate.start, fallback.start),
+			end: point(candidate.end, fallback.end)
+		}
+	};
+}
+function calleeParts(node) {
+	if (node.type !== "CallExpression") return null;
+	const callee = childNode(node.callee);
+	if (!callee || callee.type !== "MemberExpression") return null;
+	const object = childNode(callee.object);
+	const property = childNode(callee.property);
+	if (!object || !property) return null;
+	if ((nodeName(property) ?? (property.type === "Literal" && property.value === "attrs" ? "attrs" : null)) !== "attrs") return null;
+	return {
+		object,
+		property,
+		computed: callee.computed === true,
+		optional: callee.optional === true || node.optional === true
+	};
+}
+function resolverImportAccess(receiver, bindings) {
+	const directName = nodeName(receiver);
+	if (directName) {
+		const binding = bindings.get(directName);
+		if (!binding) return null;
+		return {
+			binding,
+			resolver: receiver,
+			displayName: directName,
+			request: {
+				source: binding.source,
+				imported: binding.imported,
+				local: directName,
+				access: {
+					kind: "direct",
+					importKind: binding.kind
+				}
 			}
-			if (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 = (0, path.dirname)(absEntryPath);
-	while (pkgRoot !== (0, path.dirname)(pkgRoot) && !(0, fs.existsSync)((0, path.join)(pkgRoot, "package.json"))) pkgRoot = (0, path.dirname)(pkgRoot);
-	return pkgRoot;
+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((0, path.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$3) => {
-	try {
-		return (0, fs.statSync)(path$3).isFile();
-	} catch {
-		return false;
-	}
-};
-/**
-* Resolve an absolute-path specifier (a relative `includes` entry already
-* resolved against the system file) without a bundler: the path itself when it
-* is a file, otherwise the extension and directory-index candidates built from
-* the caller's extension set. Used only as a fallback — a bundler resolver that
-* answers first still wins, since it also knows aliases and `.js`→`.ts` mapping.
-*/
-function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
-	return [
-		absSpecifier,
-		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
-		...Array.from(extensionsSet, (ext) => (0, path.join)(absSpecifier, `index${ext}`))
-	].find(isFile) ?? null;
+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 ((0, path.isAbsolute)(specifier)) {
-		const resolved = resolveAbsolutePathSpecifier(specifier, extensionsSet);
-		if (!resolved) return null;
-		return isPathWithinRoot(srcDir, resolved) ? resolved : null;
-	}
-	const packageName = bareSpecifierPackageName(specifier);
-	return resolveAbsolutePathSpecifier((0, path.join)(srcDir, specifier.slice(packageName.length + 1) || "index"), extensionsSet);
+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 = (0, fs.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, (0, fs.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;
+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;
 		}
-		if (!absEntry && (0, path.isAbsolute)(specifier)) absEntry = resolveAbsolutePathSpecifier(specifier, extensionsSet);
-		if (!absEntry) {
-			outcomes.push({
-				specifier,
-				outcome: "unresolvable",
-				fileCount: 0
-			});
-			continue;
+		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;
 		}
-		const srcDir = (0, path.join)(findPackageRoot(absEntry), "src");
-		let fileCount = 0;
-		let staleDist = false;
-		if ((0, fs.existsSync)(srcDir)) {
-			packageDirs.push(srcDir);
-			claimDir(srcDir, specifier);
-			dirExtensions[srcDir] = [...extensionsSet];
-			onPackageResolved?.(specifier, srcDir);
-			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
-			if (srcEntry) {
-				packageMap[specifier] = (0, path.relative)(rootDir, srcEntry);
-				sourceEntries.set(specifier, srcEntry);
-			} else packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
-			keyframesScanEntries.set(specifier, srcEntry ?? absEntry);
-			if (!(0, path.isAbsolute)(specifier)) {
-				const packageName = bareSpecifierPackageName(specifier);
-				if (packageName !== specifier && !(packageName in packageMap)) {
-					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
-					if (rootEntry) {
-						packageMap[packageName] = (0, path.relative)(rootDir, rootEntry);
-						sourceEntries.set(packageName, rootEntry);
-						keyframesScanEntries.set(packageName, rootEntry);
-					}
-				}
-			}
-			const pkgFiles = walkPackageSources(srcDir, extensionsSet);
-			staleDist = distEntryIsStale(absEntry, srcDir, pkgFiles);
-			for (const pkgFile of pkgFiles) {
-				const relPath = (0, path.relative)(rootDir, pkgFile);
-				if (alreadyIngested(relPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = (0, fs.readFileSync)(pkgFile, "utf-8");
-				} catch (err) {
-					onUnreadable(relPath, err);
-					continue;
-				}
-				onSourceRead?.(source, relPath, pkgFile);
-				entries.push({
-					path: relPath,
-					source
-				});
-				pushed.add(relPath);
-				fileOwners[relPath] ??= specifier;
-				fileCount++;
-			}
-		} else {
-			const outputDir = (0, path.dirname)(absEntry);
-			packageDirs.push(outputDir);
-			claimDir(outputDir, specifier);
-			onPackageResolved?.(specifier, outputDir);
-			packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
-			keyframesScanEntries.set(specifier, absEntry);
-			const outputExtensions = new Set(extensionsSet);
-			outputExtensions.add((0, path.extname)(absEntry));
-			dirExtensions[outputDir] = [...outputExtensions];
-			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
-				const relToOutput = (0, path.relative)(outputDir, file);
-				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
+		if (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 = (0, path.relative)(rootDir, outputFile);
-				if (alreadyIngested(outputRelPath)) {
-					fileCount++;
-					continue;
-				}
-				let source;
-				try {
-					source = (0, fs.readFileSync)(outputFile, "utf-8");
-				} catch (err) {
-					onUnreadable(outputRelPath, err);
-					continue;
-				}
-				onSourceRead?.(source, outputRelPath, outputFile);
-				entries.push({
-					path: outputRelPath,
-					source
-				});
-				pushed.add(outputRelPath);
-				fileOwners[outputRelPath] ??= specifier;
-				fileCount++;
-			}
+			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, (0, path.resolve)(rootDir, relTarget))) continue;
-		packageMap[specifier] = relTarget;
-	}
-	const sourceEntries = /* @__PURE__ */ new Map();
-	for (const [specifier, absEntry] of collected.sourceEntries) {
-		if (targetRejected(specifier, absEntry)) continue;
-		sourceEntries.set(specifier, absEntry);
-	}
-	const keyframesScanEntries = /* @__PURE__ */ new Map();
-	for (const [specifier, absEntry] of collected.keyframesScanEntries) {
-		if (targetRejected(specifier, absEntry)) continue;
-		keyframesScanEntries.set(specifier, absEntry);
-	}
-	const dirOwnerSets = {};
-	for (const [dir, specs] of Object.entries(collected.dirOwnerSets)) {
-		const kept = specs.filter((s) => !rejectedSpecifiers.has(s));
-		if (kept.length === 0) continue;
-		dirOwnerSets[dir] = kept;
-	}
-	const dirExtensions = {};
-	for (const [dir, exts] of Object.entries(collected.dirExtensions)) {
-		if (rejectedDirs.includes(dir)) continue;
-		dirExtensions[dir] = exts;
+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 = (0, fs.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 = node_path.posix.basename(path);
+	const dot = basename.lastIndexOf(".");
+	return dot === -1 ? "" : basename.slice(dot).toLowerCase();
+}
+function canonicalResolverPath(path) {
+	return node_path.posix.normalize(path.replaceAll("\\", "/"));
+}
+const NODE_NEXT_EXTENSION_MAP = {
+	".js": [
+		".ts",
+		".tsx",
+		".jsx"
+	],
+	".mjs": [".mts"],
+	".cjs": [".cts"]
+};
+function resolveRelativeSource(importerPath, specifier, files) {
+	if (!specifier.startsWith(".")) return null;
+	const base = node_path.posix.normalize(node_path.posix.join(node_path.posix.dirname(canonicalResolverPath(importerPath)), specifier));
+	for (const suffix of RELATIVE_PROBE_SUFFIXES) {
+		const candidate = `${base}${suffix}`;
+		const actualPath = files.get(candidate);
+		if (actualPath !== void 0) return actualPath;
 	}
-	const 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 = (0, path.dirname)(systemFilePath);
-	const packages = /* @__PURE__ */ new Set();
-	for (const id of identifiers) {
-		const specifier = importMap.get(id);
-		if (!specifier) continue;
-		if (specifier.startsWith(".")) packages.add((0, path.resolve)(systemFileDir, specifier));
-		else packages.add(specifier);
+};
+/**
+* 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
+		});
 	}
-	return asciiMemoValue;
-}
-function byteOffset(source, characterOffset) {
-	if (isAsciiOnly(source)) return characterOffset;
-	return Buffer.byteLength(source.slice(0, characterOffset));
-}
-function byteSpan(source, node) {
-	return {
-		start: byteOffset(source, node.start),
-		end: byteOffset(source, node.end)
-	};
-}
-function sourcePosition(source, characterOffset) {
-	let line = 1;
-	let lineStart = 0;
-	for (let index = 0; index < characterOffset; index += 1) {
-		const code = source.charCodeAt(index);
-		if (code === 13) {
-			if (index + 1 < characterOffset && source.charCodeAt(index + 1) === 10) index += 1;
-			line += 1;
-			lineStart = index + 1;
-		} else if (code === 10 || code === 8232 || code === 8233) {
-			line += 1;
-			lineStart = index + 1;
+	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 {
-		line,
-		column: characterOffset - lineStart
+		originalEntries,
+		analysisEntries,
+		ownership,
+		diagnostics
 	};
 }
-function sourceLocation(source, node) {
+/**
+* `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 {
-		start: sourcePosition(source, node.start),
-		end: sourcePosition(source, node.end)
+		files,
+		parseCount
 	};
 }
-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.
+* Drops each named original and the analysis children it owns. Every corpus
+* path applies it — skipping it on incremental passes freezes re-analysis.
 */
-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);
-		}
+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
 	};
-	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
-			});
-		}
+/**
+* Diagnostics name ANALYSIS paths while ownership is recorded for originals,
+* so projection is required; the result REPLACES the caller's owner map.
+*/
+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;
+	return projected;
 }
-function diagnostic(code, message, originalPath, source, node, location) {
-	return {
-		code,
-		message,
-		originalPath,
-		...node ? {
-			span: byteSpan(source, node),
-			location: location ?? sourceLocation(source, node)
-		} : {}
-	};
-}
-function compilerParseErrorRange(error, source) {
-	if (typeof error !== "object" || error === null) return null;
-	const candidate = error;
-	const positions = Array.isArray(candidate.position) ? candidate.position : [];
-	const startCharacter = typeof candidate.start?.character === "number" ? candidate.start.character : typeof positions[0] === "number" ? positions[0] : null;
-	const endCharacter = typeof candidate.end?.character === "number" ? candidate.end.character : typeof positions[1] === "number" ? positions[1] : startCharacter;
-	if (startCharacter === null || endCharacter === null || startCharacter < 0 || endCharacter < startCharacter || endCharacter > source.length) return null;
-	const node = {
-		type: "SvelteParseError",
-		start: startCharacter,
-		end: endCharacter
-	};
-	const fallback = sourceLocation(source, node);
-	const point = (value, fallbackPoint) => ({
-		line: typeof value?.line === "number" ? value.line : fallbackPoint.line,
-		column: typeof value?.column === "number" ? value.column : fallbackPoint.column
-	});
+/**
+* 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";
+//#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 resolverCallSite(node, bindings) {
-	if (node.type !== "CallExpression") return null;
-	const parts = calleeParts(node);
-	if (parts) {
-		const access = resolverImportAccess(parts.object, bindings);
-		if (!access) return null;
-		return {
-			access,
-			form: "attrs",
-			computed: parts.computed,
-			optional: parts.optional
-		};
-	}
-	const callee = childNode(node.callee);
-	if (!callee) return null;
-	const access = resolverImportAccess(callee, bindings);
-	if (!access) return null;
-	return {
-		access,
-		form: "callable",
-		computed: callee.type === "MemberExpression" && callee.computed === true,
-		optional: node.optional === true || callee.type === "MemberExpression" && callee.optional === true
-	};
-}
-function argumentSpan(argumentsList, fallback) {
-	if (argumentsList.length === 0) return fallback;
-	return {
-		type: "ArgumentRange",
-		start: argumentsList[0].start,
-		end: argumentsList[argumentsList.length - 1].end
-	};
-}
-function propertyName(node) {
-	const key = childNode(node.key);
-	if (!key) return null;
-	if (key.type === "Identifier" && typeof key.name === "string") return key.name;
-	if (key.type === "Literal" && typeof key.value === "string") return key.value;
-	return null;
-}
-function isJsxAttributeName(name) {
-	return /^[A-Za-z_$][A-Za-z0-9_$-]*$/.test(name);
-}
-function tsxIncompatibleValue(value) {
-	let incompatible = null;
-	walk(value, (node) => {
-		if (incompatible) return;
-		if (node.type === "TSTypeAssertion" || node.type === "ArrowFunctionExpression" && childNode(node.typeParameters) !== null) incompatible = node;
-	});
-	return incompatible;
-}
-function readProperties(argument, source, originalPath) {
-	if (!Array.isArray(argument.properties)) return diagnostic("SVELTE_ATTRS_ARGUMENT_UNRESOLVED", "Resolver .attrs() requires an object literal with statically named properties.", originalPath, source, argument);
-	const properties = [];
-	for (const value of argument.properties) {
-		if (!isNode(value)) continue;
-		if (value.type === "SpreadElement") return diagnostic("SVELTE_ATTRS_SPREAD_UNRESOLVED", "Resolver .attrs() object spreads are unresolved; enumerate properties explicitly.", originalPath, source, value);
-		if (value.type !== "Property") return diagnostic("SVELTE_ATTRS_PROPERTY_UNSUPPORTED", "Resolver .attrs() accepts ordinary object properties only.", originalPath, source, value);
-		if (value.computed === true) return diagnostic("SVELTE_ATTRS_COMPUTED_KEY", "Resolver .attrs() computed property names cannot be attributed safely.", originalPath, source, value);
-		if (value.method === true || value.kind !== "init") return diagnostic("SVELTE_ATTRS_PROPERTY_UNSUPPORTED", "Resolver .attrs() methods and accessors cannot be projected as attributes.", originalPath, source, value);
-		const key = childNode(value.key);
-		const propertyValue = childNode(value.value);
-		const name = propertyName(value);
-		if (!key || !propertyValue || !name || !isJsxAttributeName(name)) return diagnostic("SVELTE_ATTRS_PROPERTY_UNSUPPORTED", "Resolver .attrs() property names must be JSX-compatible identifier or string names.", originalPath, source, value);
-		const incompatibleValue = tsxIncompatibleValue(propertyValue);
-		if (incompatibleValue) return diagnostic("SVELTE_ATTRS_VALUE_UNSUPPORTED", "Resolver .attrs() values using angle-bracket type assertions or generic arrow parameters cannot be projected into TSX safely.", originalPath, source, incompatibleValue);
-		properties.push({
-			name,
-			property: value,
-			key,
-			value: propertyValue
-		});
-	}
-	return properties;
-}
-var VirtualSourceBuilder = class {
-	chunks = [];
-	bytes = 0;
-	mappings = [];
-	constructor(originalSource) {
-		this.originalSource = originalSource;
-	}
-	append(text) {
-		this.chunks.push(text);
-		this.bytes += Buffer.byteLength(text);
+//#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";
 	}
-	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)
-		});
+};
+/**
+* `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;
+		}
+		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_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(", ")}.`);
 	}
-	toString() {
-		return this.chunks.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)}.`);
 	}
-};
-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);
+/**
+* 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"
 	}
-	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;
+];
+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;
 }
-/** 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 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 projectScope(script, scope, source, originalPath, options, inherited, precomputedOwnBindings) {
-	const ownBindings = precomputedOwnBindings ?? importBindings(script.content);
-	const bindings = inherited ? new Map([...inherited.bindings, ...ownBindings]) : ownBindings;
-	const witnesses = [];
-	const diagnostics = [];
-	if (bindings.size > 0) walk(script.content, (node, nestedScopeDepth) => {
-		const site = resolverCallSite(node, bindings);
-		if (!site) return;
-		const { access, form } = site;
-		const attribution = options.attributeResolver(access.request);
-		if (attribution === "other") return;
-		const resolverName = access.displayName;
-		const callDisplay = form === "attrs" ? `${resolverName}.attrs()` : `${resolverName}()`;
-		if (attribution === "unsupported-resolver-form" || !isSupportedResolverAccess(access)) {
-			diagnostics.push(diagnostic("SVELTE_ATTRS_IMPORT_UNSUPPORTED", `Resolver '${resolverName}' uses an import/access form that the extraction engine cannot attribute to its exported .asClass() binding.`, originalPath, source, access.resolver));
-			return;
-		}
-		if (nestedScopeDepth > 0) {
-			diagnostics.push(diagnostic("SVELTE_ATTRS_SCOPE_UNSUPPORTED", `Resolver '${callDisplay}' is inside a nested binding scope; move the call to the top-level script scope so its import identity is unambiguous.`, originalPath, source, access.resolver));
-			return;
-		}
-		if (site.computed || site.optional) {
-			diagnostics.push(diagnostic("SVELTE_ATTRS_CALLEE_UNSUPPORTED", `Resolver '${resolverName}' must be called directly as ${resolverName}(...) or ${resolverName}.attrs(...).`, originalPath, source, node));
-			return;
-		}
-		const argumentsList = Array.isArray(node.arguments) ? node.arguments.filter(isNode) : [];
-		if (argumentsList.length === 0) {
-			witnesses.push({
-				binding: access.binding,
-				resolver: access.resolver,
-				properties: []
-			});
-			return;
-		}
-		if (argumentsList.length !== 1 || argumentsList[0].type !== "ObjectExpression") {
-			diagnostics.push(diagnostic("SVELTE_ATTRS_ARGUMENT_UNRESOLVED", `Resolver '${callDisplay}' accepts no argument or one object literal in Svelte projection.`, originalPath, source, argumentSpan(argumentsList, node)));
-			return;
-		}
-		const properties = readProperties(argumentsList[0], source, originalPath);
-		if (!Array.isArray(properties)) {
-			diagnostics.push(properties);
-			return;
-		}
-		witnesses.push({
-			binding: access.binding,
-			resolver: access.resolver,
-			properties
-		});
-	});
-	if (diagnostics.length > 0 || witnesses.length === 0) return { diagnostics };
-	const witnessedBindings = new Set(witnesses.map((witness) => nodeName(witness.binding.local)));
-	const builder = new VirtualSourceBuilder(source);
-	const pendingNames = new Set(witnessedBindings);
-	const renderDeclarations = (declarations) => {
-		for (const declaration of declarations) {
-			if (declaration.type !== "ImportDeclaration") continue;
-			const rendered = renderImport(declaration, pendingNames, source);
-			if (!rendered) continue;
-			builder.append(rendered.text);
-			for (const local of rendered.locals) pendingNames.delete(local);
-		}
+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;
 	};
-	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("}");
+}
+/** 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;
 		}
-		builder.append(" />;\n");
 	}
-	return {
-		diagnostics: [],
-		entry: {
-			scope,
-			path: `${originalPath}.${scope}.tsx`,
-			source: builder.toString(),
-			mappings: builder.mappings
-		}
-	};
+	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 = (0, fs.readdirSync)(dir, { encoding: "utf8" });
+	} catch {
+		return results;
+	}
+	const isExcluded = exclude ? (full, rel) => exclude.matches(full, rel) : () => false;
+	for (const entry of entries) {
+		const fullPath = (0, path.join)(dir, entry);
+		if (isExcluded(fullPath, (0, path.relative)(rootDir, fullPath))) continue;
+		let stat;
+		try {
+			stat = (0, fs.statSync)(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) results.push(...walkFiles(fullPath, rootDir, exclude, extensionsSet));
+		else if (extensionsSet.has((0, path.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 = node_path.default) {
+	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 = node_path.default) {
+	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 (0, node_fs.realpathSync)(p);
+	} catch {
+		return 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";
+function createSourceIdentity(rootDir) {
+	const normalizedRootDir = node_path.default.normalize(rootDir);
+	const canonicalRootDir = canonicalize(normalizedRootDir) ?? normalizedRootDir;
+	const roots = [];
+	const aliases = /* @__PURE__ */ new Map();
+	const owningRecord = (canonicalPath) => {
+		let owner = null;
+		for (const record of roots) {
+			if (!isPathWithinRoot(record.canonical, canonicalPath)) continue;
+			if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+		}
+		return owner;
+	};
+	return {
+		rootDir: normalizedRootDir,
+		canonicalRootDir,
+		registerExternalRoot(root) {
+			const asRegistered = node_path.default.normalize(root);
+			const canonical = canonicalize(asRegistered) ?? asRegistered;
+			const existing = roots.find((record) => record.canonical === canonical);
+			if (existing) return existing.canonical;
+			roots.push({
+				asRegistered,
+				canonical
+			});
+			return canonical;
+		},
+		externalRoots() {
+			return roots.map((record) => record.canonical);
+		},
+		resolveSourceId(inputPath) {
+			const lexical = node_path.default.normalize(inputPath);
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			const owner = owningRecord(canonical);
+			const ownedBy = (record) => {
+				const pathInRoot = node_path.default.relative(record.canonical, canonical);
+				return {
+					sourceKey: node_path.default.relative(normalizedRootDir, node_path.default.join(record.asRegistered, pathInRoot)),
+					owningRoot: record.canonical,
+					pathInRoot
+				};
+			};
+			const ownerIsMoreSpecific = owner !== null && owner.canonical.length > canonicalRootDir.length;
+			let resolved;
+			if (!ownerIsMoreSpecific && isPathWithinRoot(canonicalRootDir, canonical)) {
+				const key = node_path.default.relative(canonicalRootDir, canonical);
+				resolved = {
+					sourceKey: key,
+					owningRoot: null,
+					pathInRoot: key
+				};
+			} else if (owner) resolved = ownedBy(owner);
+			else return null;
+			aliases.set(lexical, resolved);
+			aliases.set(canonical, resolved);
+			return resolved;
+		},
+		resolveDeletedSourceId(inputPath) {
+			return aliases.get(node_path.default.normalize(inputPath)) ?? null;
+		},
+		containingExternalRoot(inputPath) {
+			const lexical = node_path.default.normalize(inputPath);
+			let owner = null;
+			for (const record of roots) {
+				if (!(isPathWithinRoot(record.canonical, lexical) || isPathWithinRoot(record.asRegistered, lexical))) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			if (owner) return owner.canonical;
+			const canonical = canonicalize(lexical);
+			if (canonical === null) return null;
+			for (const record of roots) {
+				if (!isPathWithinRoot(record.canonical, canonical)) continue;
+				if (!owner || record.canonical.length > owner.canonical.length) owner = record;
+			}
+			return owner?.canonical ?? null;
+		}
+	};
 }
-const RELATIVE_PROBE_SUFFIXES = [
-	"",
-	".ts",
-	".tsx",
-	".js",
-	".jsx",
-	"/index.ts",
-	"/index.tsx",
-	"/index.js",
-	"/index.jsx"
+//#endregion
+//#region pipeline/discover-packages.ts
+function findPackageRoot(absEntryPath) {
+	let pkgRoot = (0, path.dirname)(absEntryPath);
+	while (pkgRoot !== (0, path.dirname)(pkgRoot) && !(0, fs.existsSync)((0, path.join)(pkgRoot, "package.json"))) pkgRoot = (0, path.dirname)(pkgRoot);
+	return pkgRoot;
+}
+const PACKAGE_SRC_EXCLUDES = [
+	"dist",
+	"node_modules",
+	".test.",
+	".spec."
 ];
-function extension(path) {
-	const basename = node_path.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 node_path.posix.normalize(path.replaceAll("\\", "/"));
+function walkPackageSources(packageDir, extensionsSet) {
+	return discoverFiles(packageDir, packageDir, void 0, extensionsSet).filter((absPath) => !isExcludedPackageRelativePath((0, path.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$4) => {
+	try {
+		return (0, fs.statSync)(path$4).isFile();
+	} catch {
+		return false;
+	}
 };
-function resolveRelativeSource(importerPath, specifier, files) {
-	if (!specifier.startsWith(".")) return null;
-	const base = node_path.posix.normalize(node_path.posix.join(node_path.posix.dirname(canonicalResolverPath(importerPath)), specifier));
-	for (const suffix of RELATIVE_PROBE_SUFFIXES) {
-		const candidate = `${base}${suffix}`;
-		const actualPath = files.get(candidate);
-		if (actualPath !== void 0) return actualPath;
+function resolveAbsolutePathSpecifier(absSpecifier, extensionsSet) {
+	return [
+		absSpecifier,
+		...Array.from(extensionsSet, (ext) => absSpecifier + ext),
+		...Array.from(extensionsSet, (ext) => (0, path.join)(absSpecifier, `index${ext}`))
+	].find(isFile) ?? null;
+}
+function bareSpecifierPackageName(specifier) {
+	const segments = specifier.split("/");
+	return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+}
+function sourceEntryForSpecifier(specifier, srcDir, extensionsSet) {
+	if ((0, path.isAbsolute)(specifier)) {
+		const resolved = resolveAbsolutePathSpecifier(specifier, extensionsSet);
+		if (!resolved) return null;
+		return isPathWithinRoot(srcDir, resolved) ? resolved : null;
 	}
-	const 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((0, path.join)(srcDir, subpath || "index"), extensionsSet);
+}
+function distEntryIsStale(absEntry, srcDir, srcFiles) {
+	if (isPathWithinRoot(srcDir, absEntry)) return false;
+	let distMtime;
+	try {
+		distMtime = (0, fs.statSync)(absEntry).mtimeMs;
+	} catch {
+		return false;
 	}
-	return null;
+	let newestSrcMtime = -Infinity;
+	for (const srcFile of srcFiles) try {
+		newestSrcMtime = Math.max(newestSrcMtime, (0, fs.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 && (0, path.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 = (0, path.join)(pkgRoot, "src");
+		let fileCount = 0;
+		let staleDist = false;
+		if ((0, fs.existsSync)(srcDir)) {
+			packageDirs.push(srcDir);
+			claimDir(srcDir, specifier);
+			dirExtensions[srcDir] = [...extensionsSet];
+			onPackageResolved?.(specifier, srcDir);
+			const srcEntry = sourceEntryForSpecifier(specifier, srcDir, extensionsSet);
+			if (srcEntry) {
+				packageMap[specifier] = (0, path.relative)(rootDir, srcEntry);
+				sourceEntries.set(specifier, srcEntry);
+			} else packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
+			if (!(0, path.isAbsolute)(specifier)) {
+				const packageName = bareSpecifierPackageName(specifier);
+				if (packageName !== specifier && !(packageName in packageMap)) {
+					const rootEntry = sourceEntryForSpecifier(packageName, srcDir, extensionsSet);
+					if (rootEntry) {
+						packageMap[packageName] = (0, path.relative)(rootDir, rootEntry);
+						sourceEntries.set(packageName, rootEntry);
+					}
+				}
+			}
+			const pkgFiles = walkPackageSources(srcDir, extensionsSet);
+			staleDist = distEntryIsStale(absEntry, srcDir, pkgFiles);
+			for (const pkgFile of pkgFiles) {
+				const relPath = (0, path.relative)(rootDir, pkgFile);
+				if (alreadyIngested(relPath)) {
+					fileCount++;
+					continue;
+				}
+				let source;
+				try {
+					source = (0, fs.readFileSync)(pkgFile, "utf-8");
+				} catch (err) {
+					onUnreadable(relPath, err);
+					continue;
+				}
+				onSourceRead?.(source, relPath, pkgFile);
+				entries.push({
+					path: relPath,
+					source
+				});
+				pushed.add(relPath);
+				fileOwners[relPath] ??= specifier;
+				fileCount++;
+			}
+		} else {
+			const outputDir = (0, path.dirname)(absEntry);
+			packageDirs.push(outputDir);
+			claimDir(outputDir, specifier);
+			onPackageResolved?.(specifier, outputDir);
+			packageMap[specifier] = (0, path.relative)(rootDir, absEntry);
+			const outputExtensions = new Set(extensionsSet);
+			outputExtensions.add((0, path.extname)(absEntry));
+			dirExtensions[outputDir] = [...outputExtensions];
+			const outputFiles = discoverFiles(outputDir, outputDir, void 0, outputExtensions).filter((file) => {
+				const relToOutput = (0, path.relative)(outputDir, file);
+				return !PACKAGE_OUTPUT_EXCLUDES.some((pattern) => relToOutput.includes(pattern));
+			});
+			if (!outputFiles.includes(absEntry)) outputFiles.unshift(absEntry);
+			for (const outputFile of outputFiles) {
+				const outputRelPath = (0, path.relative)(rootDir, outputFile);
+				if (alreadyIngested(outputRelPath)) {
+					fileCount++;
+					continue;
+				}
+				let source;
+				try {
+					source = (0, fs.readFileSync)(outputFile, "utf-8");
+				} catch (err) {
+					onUnreadable(outputRelPath, err);
+					continue;
+				}
+				onSourceRead?.(source, outputRelPath, outputFile);
+				entries.push({
+					path: outputRelPath,
+					source
+				});
+				pushed.add(outputRelPath);
+				fileOwners[outputRelPath] ??= specifier;
+				fileCount++;
+			}
 		}
-		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, (0, path.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 = (0, fs.readFileSync)(systemFilePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const identifiers = /* @__PURE__ */ new Set();
+	const constructorRegex = /createSystem\s*\(\s*\{[^}]*?\bincludes\s*:\s*\[([^\]]*)\]/gs;
+	const chainRegex = /\.includes\s*\(\s*\[([^\]]*)\]\s*\)/gs;
+	const collectIdentifiers = (regex) => {
+		let match;
+		while ((match = regex.exec(source)) !== null) {
+			const inner = match[1];
+			for (const token of inner.split(",")) {
+				const id = token.trim();
+				if (id && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(id)) identifiers.add(id);
 			}
-			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;
+	collectIdentifiers(constructorRegex);
+	collectIdentifiers(chainRegex);
+	const IDENT_START_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*/;
+	const skipTrivia = (from) => {
+		let pos = from;
+		for (;;) {
+			while (pos < source.length && /\s/.test(source[pos])) pos++;
+			if (source.startsWith("//", pos)) {
+				const newline = source.indexOf("\n", pos);
+				pos = newline === -1 ? source.length : newline + 1;
+				continue;
+			}
+			if (source.startsWith("/*", pos)) {
+				const close = source.indexOf("*/", pos + 2);
+				pos = close === -1 ? source.length : close + 2;
+				continue;
+			}
+			return pos;
 		}
-		if (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;
+	};
+	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;
 		}
-		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 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++;
 		}
-		if (result.kind === "error") {
-			diagnostics.push(...result.diagnostics);
-			continue;
+		consumeChainLinks(pos);
+		const bound = boundIdentifierBefore(anchorMatch.index);
+		if (bound) chainRootIdentifiers.add(bound);
+	}
+	const scannedRoots = /* @__PURE__ */ new Set();
+	for (;;) {
+		const pendingRoots = [...chainRootIdentifiers].filter((root) => !scannedRoots.has(root));
+		if (pendingRoots.length === 0) break;
+		for (const root of pendingRoots) {
+			scannedRoots.add(root);
+			const rootUse = new RegExp(`(?<![a-zA-Z0-9_$])${root.replace(/\$/g, "\\$")}(?![a-zA-Z0-9_$])`, "g");
+			let useMatch;
+			while ((useMatch = rootUse.exec(source)) !== null) {
+				const afterIdentifier = useMatch.index + useMatch[0].length;
+				if (consumeChainLinks(afterIdentifier) === afterIdentifier) continue;
+				const bound = boundIdentifierBefore(useMatch.index);
+				if (bound) chainRootIdentifiers.add(bound);
+			}
 		}
-		addAdaptedEntries(original.path, result.entries);
 	}
-	return {
-		originalEntries,
-		analysisEntries,
-		ownership,
-		diagnostics
-	};
-}
-/**
-* Run the native fact collector, re-extracting only changed entries when the
-* caller supplies a `factsCache`. `parseCount` keeps its meaning — parses
-* performed by THIS call — so a fully-memoized pass reports zero.
-*/
-function collectFileFacts(analysisEntries, options) {
-	const cache = options.factsCache;
-	if (!cache) return JSON.parse(options.extractFacts(JSON.stringify(analysisEntries)));
-	const pending = analysisEntries.filter((entry) => cache.get(entry.path)?.hash !== entry.hash);
-	let parseCount = 0;
-	if (pending.length > 0) {
-		const fresh = JSON.parse(options.extractFacts(JSON.stringify(pending)));
-		parseCount = fresh.parseCount;
-		for (const entry of pending) {
-			const facts = fresh.files[entry.path];
-			if (facts) cache.set(entry.path, {
-				hash: entry.hash,
-				facts
-			});
-			else cache.delete(entry.path);
+	if (identifiers.size === 0) return [];
+	const importMap = /* @__PURE__ */ new Map();
+	const importRegex = /^\s*import\s+(?:([a-zA-Z_$][a-zA-Z0-9_$]*)\s*,\s*)?(?:\{([^}]*)\}|([a-zA-Z_$][a-zA-Z0-9_$]*))\s+from\s+['"]([^'"]+)['"]/gm;
+	let importMatch;
+	while ((importMatch = importRegex.exec(source)) !== null) {
+		const [, comboDefault, namedImports, defaultImport, specifier] = importMatch;
+		if (comboDefault) importMap.set(comboDefault, specifier);
+		if (defaultImport) importMap.set(defaultImport, specifier);
+		if (namedImports) for (const binding of namedImports.split(",")) {
+			const parts = binding.trim().split(/\s+as\s+/);
+			const localName = (parts[1] || parts[0]).trim();
+			if (localName) importMap.set(localName, specifier);
 		}
 	}
-	const 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;
+	const systemFileDir = (0, path.dirname)(systemFilePath);
+	const packages = /* @__PURE__ */ new Set();
+	for (const id of identifiers) {
+		const specifier = importMap.get(id);
+		if (!specifier) continue;
+		if (specifier.startsWith(".")) packages.add((0, path.resolve)(systemFileDir, specifier));
+		else packages.add(specifier);
 	}
-	return {
-		files,
-		parseCount
-	};
+	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();
@@ -2223,19 +2001,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;
@@ -2250,14 +2015,8 @@ 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) {
@@ -2278,23 +2037,20 @@ function packageRootFromEntry(entry) {
 	}
 }
 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;
@@ -2311,9 +2067,8 @@ function resolveThroughPathAliases(specifier, rootDir, pathAliasesJson) {
 	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);
@@ -2344,20 +2099,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({
@@ -2388,11 +2136,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 = [];
@@ -2411,11 +2156,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 ?? "";
@@ -2443,12 +2185,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) {
@@ -2473,17 +2209,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];
@@ -2491,12 +2216,9 @@ function resolveLightningTargets(explicitTargets, rootDir) {
 		const detected = (0, browserslist.default)(void 0, { path: rootDir });
 		queries = detected.length > 0 ? detected : (0, browserslist.default)("defaults");
 	}
-	return (0, lightningcss.browserslistToTargets)(Array.isArray(queries) && typeof queries[0] === "string" && queries[0].includes(" ") ? (0, browserslist.default)(queries) : queries);
+	const [firstQuery] = queries;
+	return (0, lightningcss.browserslistToTargets)(firstQuery !== void 0 && firstQuery.includes(" ") ? (0, browserslist.default)(queries) : queries);
 }
-/**
-* Post-process CSS with Lightning CSS: autoprefixing + optional minification.
-* On failure, returns the original CSS and logs a warning.
-*/
 function postProcessCss(css, opts) {
 	if (!css) return css;
 	try {
@@ -2514,28 +2236,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;
@@ -2556,44 +2270,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 = [];
@@ -2615,11 +2376,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 ((0, _animus_ui_properties.isUnitlessProperty)(prop)) return match;
@@ -2655,13 +2411,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,
@@ -2671,11 +2428,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,
@@ -2686,17 +2439,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();
@@ -2716,8 +2465,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,
@@ -2727,9 +2476,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 {
@@ -2738,15 +2486,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);
@@ -2754,14 +2519,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,
@@ -2792,14 +2549,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();
@@ -2827,23 +2578,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");
@@ -2885,33 +2626,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"],
@@ -2925,11 +2645,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) {
@@ -2943,21 +2658,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;
@@ -3007,6 +2710,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$2) {
 	let raw;
 	try {
@@ -3014,16 +2746,20 @@ function readConfig(path$2) {
 	} catch {
 		return null;
 	}
+	let parsed;
 	try {
-		const json = JSON.parse(stripJsonc(raw));
-		return {
-			dir: (0, path.dirname)(path$2),
-			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: (0, path.dirname)(path$2),
+		baseUrl: isJsonString(compilerOptions.baseUrl) ? compilerOptions.baseUrl : null,
+		paths: decodePaths(compilerOptions.paths),
+		extends: decodeExtends(root.extends)
+	};
 }
 function resolveExtendsTarget(specifier, fromDir) {
 	if (specifier.startsWith(".") || (0, path.isAbsolute)(specifier)) {
@@ -3051,15 +2787,14 @@ function loadChain(entryPath) {
 	const visited = /* @__PURE__ */ new Set();
 	const queue = [entryPath];
 	while (queue.length > 0) {
-		const key = (0, path.resolve)(queue.shift());
+		const path$3 = queue.shift();
+		const key = (0, path.resolve)(path$3);
 		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);
 		}
@@ -3067,22 +2802,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((0, path.join)(rootDir, "tsconfig.json"));
 	if (chain.length === 0) return [];
-	const pathsOwner = chain.find((node) => node.compilerOptions.paths && typeof node.compilerOptions.paths === "object");
-	if (!pathsOwner) return [];
-	const paths = pathsOwner.compilerOptions.paths;
-	const baseOwner = chain.find((node) => typeof node.compilerOptions.baseUrl === "string");
-	const base = baseOwner ? (0, path.resolve)(baseOwner.dir, baseOwner.compilerOptions.baseUrl) : pathsOwner.dir;
+	const 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 ? (0, path.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;
@@ -3106,14 +2839,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;
@@ -3123,33 +2848,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();
@@ -3158,33 +2879,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);
@@ -3194,40 +2897,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 = (0, node_path.normalize)(input);
 	const canonical = realpathThroughNearestExistingAncestor(lexical);
 	return canonical === lexical ? [lexical] : [lexical, canonical];
 }
-/**
-* Canonicalize a path that may not exist: walk up to the nearest existing
-* ancestor, realpath it, and re-append the missing suffix. Handles deleted
-* files under still-existing (possibly symlinked) directories and atomic
-* unlink/rename saves. Falls back to the input when no ancestor resolves.
-*
-* Known limit: a symlink retargeted AFTER the system load canonicalizes to
-* the new target, which cannot match the recorded (old-target) dependency —
-* the membership test then fails open (no reset), identical to not having
-* this reconstruction at all. Retarget sensitivity is a resolution-input
-* concern, deliberately out of scope for the watch set.
-*/
+/** 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 (0, node_fs.realpathSync)(path);
@@ -3287,18 +2964,6 @@ Object.defineProperty(exports, "ENGINE_TRANSFORM_EXTENSIONS", {
 		return ENGINE_TRANSFORM_EXTENSIONS;
 	}
 });
-Object.defineProperty(exports, "KEYFRAMES_EXPORT_COLLISION", {
-	enumerable: true,
-	get: function() {
-		return KEYFRAMES_EXPORT_COLLISION;
-	}
-});
-Object.defineProperty(exports, "KEYFRAMES_EXTERNAL_ENTRY_FAILED", {
-	enumerable: true,
-	get: function() {
-		return KEYFRAMES_EXTERNAL_ENTRY_FAILED;
-	}
-});
 Object.defineProperty(exports, "REPLACEABLE_DEFAULT_EXCLUDE", {
 	enumerable: true,
 	get: function() {
@@ -3317,10 +2982,16 @@ Object.defineProperty(exports, "STRUCTURAL_EXCLUDE", {
 		return STRUCTURAL_EXCLUDE;
 	}
 });
-Object.defineProperty(exports, "__toESM", {
+Object.defineProperty(exports, "VOCABULARY_COLLISION", {
 	enumerable: true,
 	get: function() {
-		return __toESM;
+		return VOCABULARY_COLLISION;
+	}
+});
+Object.defineProperty(exports, "VOCABULARY_LEGACY_VERB", {
+	enumerable: true,
+	get: function() {
+		return VOCABULARY_LEGACY_VERB;
 	}
 });
 Object.defineProperty(exports, "adaptSvelteSource", {
@@ -3413,6 +3084,12 @@ Object.defineProperty(exports, "collectExternalPackageSources", {
 		return collectExternalPackageSources;
 	}
 });
+Object.defineProperty(exports, "compareDiscoveryOrder", {
+	enumerable: true,
+	get: function() {
+		return compareDiscoveryOrder;
+	}
+});
 Object.defineProperty(exports, "contentHash", {
 	enumerable: true,
 	get: function() {
@@ -3425,16 +3102,16 @@ Object.defineProperty(exports, "createExcludeMatcher", {
 		return createExcludeMatcher;
 	}
 });
-Object.defineProperty(exports, "createSourceIdentity", {
+Object.defineProperty(exports, "createSourceCorpus", {
 	enumerable: true,
 	get: function() {
-		return createSourceIdentity;
+		return createSourceCorpus;
 	}
 });
-Object.defineProperty(exports, "createSourceIngestor", {
+Object.defineProperty(exports, "createSourceIdentity", {
 	enumerable: true,
 	get: function() {
-		return createSourceIngestor;
+		return createSourceIdentity;
 	}
 });
 Object.defineProperty(exports, "createV2EngineApi", {
@@ -3515,6 +3192,12 @@ Object.defineProperty(exports, "isAdvisorySourceDiagnostic", {
 		return isAdvisorySourceDiagnostic;
 	}
 });
+Object.defineProperty(exports, "isEngineTransformExtension", {
+	enumerable: true,
+	get: function() {
+		return isEngineTransformExtension;
+	}
+});
 Object.defineProperty(exports, "isExcludedPackageRelativePath", {
 	enumerable: true,
 	get: function() {
@@ -3539,10 +3222,10 @@ Object.defineProperty(exports, "loadSystemConfig", {
 		return loadSystemConfig;
 	}
 });
-Object.defineProperty(exports, "mergeExternalKeyframes", {
+Object.defineProperty(exports, "parseFilesJson", {
 	enumerable: true,
 	get: function() {
-		return mergeExternalKeyframes;
+		return parseFilesJson;
 	}
 });
 Object.defineProperty(exports, "postProcessCss", {
@@ -3557,6 +3240,12 @@ Object.defineProperty(exports, "preprocessMdx", {
 		return preprocessMdx;
 	}
 });
+Object.defineProperty(exports, "projectExternalFileOwners", {
+	enumerable: true,
+	get: function() {
+		return projectExternalFileOwners;
+	}
+});
 Object.defineProperty(exports, "readTsconfigAliasPairs", {
 	enumerable: true,
 	get: function() {
@@ -3623,6 +3312,12 @@ Object.defineProperty(exports, "snapshotFilePlans", {
 		return snapshotFilePlans;
 	}
 });
+Object.defineProperty(exports, "stableStringify", {
+	enumerable: true,
+	get: function() {
+		return stableStringify;
+	}
+});
 Object.defineProperty(exports, "staleDistIncludesMessage", {
 	enumerable: true,
 	get: function() {
@@ -3653,6 +3348,12 @@ Object.defineProperty(exports, "toWatchKeys", {
 		return toWatchKeys;
 	}
 });
+Object.defineProperty(exports, "unreadableSourceDiagnostic", {
+	enumerable: true,
+	get: function() {
+		return unreadableSourceDiagnostic;
+	}
+});
 Object.defineProperty(exports, "unresolvableIncludesMessage", {
 	enumerable: true,
 	get: function() {
@@ -3671,15 +3372,15 @@ Object.defineProperty(exports, "validateLayerOrder", {
 		return validateLayerOrder;
 	}
 });
-Object.defineProperty(exports, "walkPackageSources", {
+Object.defineProperty(exports, "vocabularyWitnessDiagnostics", {
 	enumerable: true,
 	get: function() {
-		return walkPackageSources;
+		return vocabularyWitnessDiagnostics;
 	}
 });
-Object.defineProperty(exports, "withoutInvalidOriginals", {
+Object.defineProperty(exports, "walkPackageSources", {
 	enumerable: true,
 	get: function() {
-		return withoutInvalidOriginals;
+		return walkPackageSources;
 	}
 });