praxis-kit 0.1.0

package/dist/vite-plugin/index.js

@@ -0,0 +1,2106 @@
+import ts from "typescript";
+import { DiagnosticCategory, DiagnosticCode } from "../_shared/diagnostics.js";
+import { writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+//#region ../../lib/foundation/src/iterate.ts
+function find(iterable, callback) {
+	for (const value of iterable) {
+		const result = callback(value);
+		if (result != null) return result;
+	}
+	return null;
+}
+function some(iterable, predicate) {
+	for (const value of iterable) if (predicate(value)) return true;
+	return false;
+}
+function every(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (!predicate(value, index++)) return false;
+	return true;
+}
+function* filter(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (predicate(value, index++)) yield value;
+}
+function* map(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) yield callback(value, index++);
+}
+function forEach(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) callback(value, index++);
+}
+function reduce(iterable, initial, callback) {
+	let accumulator = initial;
+	let index = 0;
+	for (const value of iterable) accumulator = callback(accumulator, value, index++);
+	return accumulator;
+}
+/**
+* Transforms an iterable into a Record.
+*
+* The callback returns a `[key, value]` tuple for each element. Returning
+* `null` aborts the collection and causes `collect()` to return `null`.
+*/
+function collect(iterable, callback) {
+	const result = {};
+	let index = 0;
+	for (const value of iterable) {
+		const entry = callback(value, index++);
+		if (entry === null) return null;
+		result[entry[0]] = entry[1];
+	}
+	return result;
+}
+function findLast(value, callback) {
+	for (let index = value.length - 1; index >= 0; index--) {
+		const result = callback(value[index], index);
+		if (result != null) return result;
+	}
+	return null;
+}
+function* items(collection) {
+	for (let i = 0; i < collection.length; i++) {
+		const item = collection.item(i);
+		if (item !== null) yield item;
+	}
+}
+function nodeList(list) {
+	return { *[Symbol.iterator]() {
+		for (let i = 0; i < list.length; i++) {
+			const node = list.item(i);
+			if (node !== null) yield node;
+		}
+	} };
+}
+function mapEntries(m) {
+	return m.entries();
+}
+function set(s) {
+	return s.values();
+}
+function hasOwn(object, key) {
+	return Object.hasOwn(object, key);
+}
+function* entries(object) {
+	for (const key in object) {
+		if (!hasOwn(object, key)) continue;
+		yield [key, object[key]];
+	}
+}
+function* keys(object) {
+	for (const [key] of entries(object)) yield key;
+}
+function* values(object) {
+	for (const [, value] of entries(object)) yield value;
+}
+function mapValues(object, callback) {
+	const result = {};
+	for (const [key, value] of entries(object)) result[key] = callback(value, key);
+	return result;
+}
+function forEachEntry(object, callback) {
+	for (const [key, value] of entries(object)) callback(key, value);
+}
+function forEachKey(object, callback) {
+	for (const key of keys(object)) callback(key);
+}
+function forEachValue(object, callback) {
+	for (const value of values(object)) callback(value);
+}
+function forEachSet(s, callback) {
+	for (const value of s) callback(value);
+}
+const iterate = Object.freeze({
+	entries,
+	filter,
+	find,
+	findLast,
+	forEach,
+	forEachEntry,
+	forEachKey,
+	forEachSet,
+	forEachValue,
+	items,
+	keys,
+	map,
+	mapEntries,
+	mapValues,
+	nodeList,
+	reduce,
+	collect,
+	set,
+	some,
+	every,
+	values
+});
+//#endregion
+//#region ../../lib/primitive/src/utils/lazy.ts
+/**
+* Lazily initializes a value. The factory is invoked exactly once on the first
+* call, and every subsequent call returns the cached result, even if the
+* result is `undefined`, `null`, `false`, `0`, or `''`.
+*/
+function lazy(factory) {
+	let initialized = false;
+	let value;
+	return () => {
+		if (!initialized) {
+			value = factory();
+			initialized = true;
+		}
+		return value;
+	};
+}
+//#endregion
+//#region ../../plugins/vite/src/ast.ts
+/**
+* Returns the initializer of a named property from an object literal.
+*
+* Only direct `PropertyAssignment` nodes are considered. Shorthand
+* properties, spread assignments, getters, setters, and methods are ignored.
+*
+* @param obj Object literal to search.
+* @param key Property name to locate.
+* @returns The property's initializer expression, or `undefined` if the
+* property is not present or is not a standard property assignment.
+*/
+function getProperty(obj, key) {
+	return iterate.find(obj.properties, (prop) => {
+		if (!ts.isPropertyAssignment(prop)) return null;
+		const { name } = prop;
+		if ((ts.isIdentifier(name) || ts.isStringLiteral(name)) && name.text === key) return prop.initializer;
+		return null;
+	}) ?? void 0;
+}
+/**
+* Narrows a node to an ObjectLiteralExpression.
+*
+* This is a convenience type guard for optional AST nodes.
+*
+* @param node Node to inspect.
+* @returns The same node when it is an object literal; otherwise `undefined`.
+*/
+function asObject(node) {
+	if (!node) return void 0;
+	return ts.isObjectLiteralExpression(node) ? node : void 0;
+}
+/**
+* Narrows a node to an ArrayLiteralExpression.
+*
+* @param node Node to inspect.
+* @returns The same node when it is an array literal; otherwise `undefined`.
+*/
+function asArray(node) {
+	if (!node) return void 0;
+	return ts.isArrayLiteralExpression(node) ? node : void 0;
+}
+/**
+* Extracts a non-negative integer from a numeric literal.
+*
+* Accepts only literal numeric values present in the AST.
+* Expressions such as `1 + 2`, identifiers, and function calls
+* are intentionally ignored.
+*
+* @remarks
+* This helper does not evaluate constant expressions. It only
+* reads literal values already present in the syntax tree.
+*
+* @param node Node to inspect.
+* @returns A non-negative integer, or `undefined` when the node
+* is not a numeric literal or represents a negative value.
+*/
+function asNonNegativeInt(node) {
+	if (!node) return void 0;
+	if (ts.isNumericLiteral(node)) {
+		const n = Number(node.text);
+		return Number.isFinite(n) && n >= 0 ? n : void 0;
+	}
+}
+/**
+* Extracts a boolean literal from an AST node.
+*
+* Only the `true` and `false` keyword nodes are recognized.
+*
+* @param node Node to inspect.
+* @returns `true`, `false`, or `undefined`.
+*/
+function asBooleanLiteral(node) {
+	if (!node) return void 0;
+	switch (node.kind) {
+		case ts.SyntaxKind.TrueKeyword: return true;
+		case ts.SyntaxKind.FalseKeyword: return false;
+		default: return;
+	}
+}
+/**
+* Determines whether a call expression invokes one of the known
+* Praxis Kit factory functions.
+*
+* Supports both direct identifiers and property access expressions.
+*
+* Examples:
+*
+* ```ts
+* defineComponent(...)
+* factory.defineComponent(...)
+* ```
+*
+* @param call Call expression to inspect.
+* @param names Set of accepted factory names.
+* @returns `true` when the call targets one of the supplied names.
+*/
+function isFactoryCall(call, names) {
+	const { expression } = call;
+	if (ts.isIdentifier(expression)) return names.has(expression.text);
+	if (ts.isPropertyAccessExpression(expression)) return names.has(expression.name.text);
+	return false;
+}
+/**
+* Returns the first argument when it is an object literal.
+*
+* Useful for parsing APIs that accept an options object as their
+* first parameter.
+*
+* @param call Call expression to inspect.
+* @returns The first argument if it is an object literal;
+* otherwise `undefined`.
+*/
+function firstObjectArg(call) {
+	const first = call.arguments[0];
+	return first && ts.isObjectLiteralExpression(first) ? first : void 0;
+}
+/**
+* Performs a depth-first traversal of an AST subtree.
+*
+* The starting node is yielded first, followed by every
+* descendant in lexical order.
+*
+* @remarks
+* This is implemented as a generator, allowing consumers to
+* iterate lazily using `for...of`.
+*
+* @param node Root node.
+* @returns An iterator over every node in the subtree.
+*/
+function* walk(node) {
+	yield node;
+	const children = [];
+	ts.forEachChild(node, (child) => {
+		children.push(child);
+	});
+	for (const child of children) yield* walk(child);
+}
+/**
+* Traverses an AST subtree depth-first, invoking a visitor for
+* every node encountered.
+*
+* This is a callback-oriented alternative to {@link walk}.
+*
+* @param node Root node.
+* @param visitor Function invoked for every visited node.
+*/
+function walkEach(node, visitor) {
+	for (const child of walk(node)) visitor(child);
+}
+const SCRIPT_KIND_BY_EXT = {
+	tsx: ts.ScriptKind.TSX,
+	jsx: ts.ScriptKind.JSX,
+	ts: ts.ScriptKind.TS,
+	mts: ts.ScriptKind.TS,
+	cts: ts.ScriptKind.TS,
+	js: ts.ScriptKind.JS,
+	mjs: ts.ScriptKind.JS,
+	cjs: ts.ScriptKind.JS
+};
+/**
+* Parses source text into a TypeScript SourceFile.
+*
+* The `ScriptKind` is derived from the filename extension so each source is
+* parsed with its real syntax semantics — a `.ts` file's `<T>expr` is a type
+* assertion, not a broken JSX element. Unknown extensions fall back to TSX (the
+* most permissive). Latest language version, parent pointers enabled.
+*
+* @param filename Virtual filename used for diagnostics and to pick the ScriptKind.
+* @param code Source code to parse.
+* @returns Parsed SourceFile.
+*/
+function parseSource(filename, code) {
+	const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+	const scriptKind = SCRIPT_KIND_BY_EXT[ext] ?? ts.ScriptKind.TSX;
+	return ts.createSourceFile(filename, code, ts.ScriptTarget.Latest, true, scriptKind);
+}
+//#endregion
+//#region ../../plugins/vite/src/class-extract.ts
+/**
+* Compile-time variant class precomputation.
+*
+* Extracts `styling.variants`, `styling.defaults`, and `styling.compounds` from
+* factory call ASTs, enumerates all statically-known prop combinations, computes
+* the variant class string for each, and injects the resulting map as
+* `styling.precomputedClasses` directly into the source.
+*
+* At runtime, `VariantClassResolver` checks `precomputedClasses` before
+* calling CVA — a plain object lookup replaces a CVA invocation + LRU cache
+* write for every covered combination.
+*
+* **Skipped when any of the following are true:**
+* - `styling.variants` is absent or contains non-literal values
+* - `styling.compounds` contains non-literal conditions or class values
+* - The total number of combinations exceeds MAX_COMBINATIONS
+* - The styling object already has a `precomputedClasses` property
+*
+* @example
+* Before:
+* ```ts
+* styling: {
+*   variants: { size: { sm: 'text-sm', lg: 'text-lg' } },
+* }
+* ```
+* After:
+* ```ts
+* styling: {
+*   variants: { size: { sm: 'text-sm', lg: 'text-lg' } },
+*   precomputedClasses: {
+*     '__none__:': '',
+*     '__none__:size:s:sm': 'text-sm',
+*     '__none__:size:s:lg': 'text-lg',
+*   },
+* }
+* ```
+*/
+const MAX_COMBINATIONS = 512;
+/** Returns the text of a string literal node, or undefined. */
+function asString(node) {
+	return node && ts.isStringLiteral(node) ? node.text : void 0;
+}
+/**
+* Returns the text of a string literal, the texts of all elements of an array literal
+* (every element must be a string literal), or undefined for any other shape.
+*/
+function asStringOrStringArray(node) {
+	if (!node) return void 0;
+	if (ts.isStringLiteral(node)) return node.text;
+	if (ts.isArrayLiteralExpression(node)) {
+		const items = [];
+		if (!iterate.every(node.elements, (elem) => {
+			if (!ts.isStringLiteral(elem)) return false;
+			items.push(elem.text);
+			return true;
+		})) return void 0;
+		return items;
+	}
+}
+/** Returns the name text of a property assignment with an identifier or string literal key, or undefined. */
+function propKey(prop) {
+	if (!ts.isPropertyAssignment(prop)) return void 0;
+	const n = prop.name;
+	return ts.isIdentifier(n) || ts.isStringLiteral(n) ? n.text : void 0;
+}
+/**
+* Extracts `styling.variants` into a nested `VariantMap`.
+* Returns null when any variant key or value entry is non-literal (bail — can't enumerate).
+*/
+function extractVariantMap$1(stylingObj) {
+	const variantsObj = asObject(getProperty(stylingObj, "variants"));
+	if (!variantsObj) return null;
+	return iterate.collect(variantsObj.properties, (prop) => {
+		const key = propKey(prop);
+		if (!key || !ts.isPropertyAssignment(prop)) return null;
+		const valuesObj = asObject(prop.initializer);
+		if (!valuesObj) return null;
+		const values = iterate.collect(valuesObj.properties, (vp) => {
+			const vk = propKey(vp);
+			if (!vk || !ts.isPropertyAssignment(vp)) return null;
+			const value = asStringOrStringArray(vp.initializer);
+			if (value === void 0) return null;
+			return [vk, value];
+		});
+		if (!values) return null;
+		return [key, values];
+	});
+}
+/** Extracts `styling.defaults` as a `Record<variantKey, defaultValue>`. Returns `{}` when absent or non-literal. */
+function extractDefaults(stylingObj) {
+	const defaultsObj = asObject(getProperty(stylingObj, "defaults"));
+	if (!defaultsObj) return {};
+	return iterate.collect(defaultsObj.properties, (prop) => {
+		const key = propKey(prop);
+		if (!key || !ts.isPropertyAssignment(prop)) return null;
+		const value = asString(prop.initializer);
+		if (value === void 0) return null;
+		return [key, value];
+	}) ?? {};
+}
+/**
+* Extracts `styling.compounds` as a typed array.
+* Returns null when any entry has a non-literal condition value or class — signals bail to the caller.
+*/
+function extractCompounds(stylingObj) {
+	const compoundsArr = asArray(getProperty(stylingObj, "compounds"));
+	if (!compoundsArr) return [];
+	const result = [];
+	return iterate.every(compoundsArr.elements, (elem) => {
+		const obj = asObject(elem);
+		if (!obj) return false;
+		const cls = asStringOrStringArray(getProperty(obj, "class"));
+		if (cls === void 0) return false;
+		const conditions = {};
+		if (!iterate.every(obj.properties, (cp) => {
+			const key = propKey(cp);
+			if (!key || !ts.isPropertyAssignment(cp)) return false;
+			if (key === "class") return true;
+			const v = asStringOrStringArray(cp.initializer);
+			if (v === void 0) return false;
+			conditions[key] = v;
+			return true;
+		})) return false;
+		result.push({
+			conditions,
+			cls
+		});
+		return true;
+	}) ? result : null;
+}
+/**
+* Enumerates every subset of variant props (each dimension either absent or set
+* to one of its declared values). Returns null if total would exceed MAX_COMBINATIONS.
+*/
+function enumerateCombinations(variantMap) {
+	const keys = Object.keys(variantMap);
+	if (keys.length === 0) return [{}];
+	let total = 1;
+	if (!iterate.every(keys, (key) => {
+		total *= Object.keys(variantMap[key]).length + 1;
+		return total <= MAX_COMBINATIONS;
+	})) return null;
+	function enumerateRecursive(remaining) {
+		if (remaining.length === 0) return [{}];
+		const first = remaining[0];
+		const restCombos = enumerateRecursive(remaining.slice(1));
+		const valueKeys = Object.keys(variantMap[first]);
+		const out = [];
+		iterate.forEach(restCombos, (combo) => {
+			out.push(combo);
+			iterate.forEach(valueKeys, (v) => {
+				out.push({
+					[first]: v,
+					...combo
+				});
+			});
+		});
+		return out;
+	}
+	return enumerateRecursive(keys);
+}
+/**
+* Builds the VariantClassResolver cache key for a given explicit prop combination.
+* Absent variant dimensions are excluded from the key (defaults apply in compute).
+*/
+function buildCacheKey(props) {
+	return `__none__:${Object.keys(props).sort().map((k) => `${k}:s:${props[k]}`).join("|")}`;
+}
+/** Computes the final class string for a given explicit prop combination against a resolved styling config. */
+function computeClasses(config, props) {
+	const { variantMap, defaults, compounds } = config;
+	const effective = {
+		...defaults,
+		...props
+	};
+	const classes = [];
+	iterate.forEachEntry(variantMap, (key, values) => {
+		const v = effective[key];
+		if (v === void 0) return;
+		const cls = values[v];
+		if (cls === void 0) return;
+		if (Array.isArray(cls)) classes.push(...cls);
+		else classes.push(cls);
+	});
+	iterate.forEach(compounds, ({ conditions, cls }) => {
+		if (iterate.every(iterate.entries(conditions), ([key, cond]) => {
+			const value = effective[key];
+			return Array.isArray(cond) ? value !== void 0 && cond.includes(value) : value === cond;
+		})) {
+			if (Array.isArray(cls)) classes.push(...cls);
+			else classes.push(cls);
+		}
+	});
+	return classes.filter(Boolean).join(" ");
+}
+/**
+* Builds a precomputed class map for the given styling object literal.
+*
+* Returns null when static extraction is not possible (non-literal values,
+* no variants, or combination count exceeds MAX_COMBINATIONS).
+*/
+function buildPrecomputedClasses(stylingObj) {
+	if (getProperty(stylingObj, "precomputedClasses") !== void 0) return null;
+	const variantMap = extractVariantMap$1(stylingObj);
+	if (!variantMap || Object.keys(variantMap).length === 0) return null;
+	const defaults = extractDefaults(stylingObj);
+	const compounds = extractCompounds(stylingObj);
+	if (!compounds) return null;
+	const combos = enumerateCombinations(variantMap);
+	if (!combos) return null;
+	const config = {
+		variantMap,
+		defaults,
+		compounds
+	};
+	return iterate.collect(combos, (combo) => [buildCacheKey(combo), computeClasses(config, combo)]);
+}
+/** Returns a TS transformer that injects a `precomputedClasses` property into each eligible factory call's `styling` object. */
+function createClassExtractTransformer(factory, calleeNames, onInjected) {
+	return (context) => {
+		function visit(node) {
+			if (!ts.isCallExpression(node)) return ts.visitEachChild(node, visit, context);
+			if (!isFactoryCall(node, calleeNames)) return ts.visitEachChild(node, visit, context);
+			const arg = firstObjectArg(node);
+			if (!arg) return node;
+			const stylingObj = asObject(getProperty(arg, "styling"));
+			if (!stylingObj) return ts.visitEachChild(node, visit, context);
+			const map = buildPrecomputedClasses(stylingObj);
+			if (!map) return ts.visitEachChild(node, visit, context);
+			onInjected();
+			const mapProps = Array.from(iterate.map(iterate.entries(map), ([key, value]) => factory.createPropertyAssignment(factory.createStringLiteral(key), factory.createStringLiteral(value))));
+			const mapLiteral = factory.createObjectLiteralExpression(mapProps, true);
+			const precomputedProp = factory.createPropertyAssignment(factory.createIdentifier("precomputedClasses"), mapLiteral);
+			const newStylingObj = factory.createObjectLiteralExpression([...stylingObj.properties, precomputedProp], true);
+			const newArgProps = arg.properties.map((p) => {
+				if (ts.isPropertyAssignment(p) && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === "styling") return factory.createPropertyAssignment(p.name, newStylingObj);
+				return p;
+			});
+			const newArg = factory.createObjectLiteralExpression(newArgProps, true);
+			return factory.createCallExpression(node.expression, node.typeArguments, [newArg, ...node.arguments.slice(1)]);
+		}
+		return (sourceFile) => ts.visitEachChild(sourceFile, visit, context);
+	};
+}
+/**
+* Injects precomputed variant class maps into all factory calls in the given
+* source file that have fully-static `styling.variants` configurations.
+*
+* Returns null when no factory calls with injectable variants are found.
+*/
+function injectPrecomputedClasses(source, calleeNames) {
+	if (!iterate.some(walk(source), (node) => ts.isPropertyAssignment(node) && (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name)) && node.name.text === "variants")) return null;
+	let didInject = false;
+	const result = ts.transform(source, [createClassExtractTransformer(ts.factory, calleeNames, () => {
+		didInject = true;
+	})], { target: ts.ScriptTarget.Latest });
+	if (!didInject) {
+		result.dispose();
+		return null;
+	}
+	const output = ts.createPrinter({
+		newLine: ts.NewLineKind.LineFeed,
+		removeComments: false
+	}).printFile(result.transformed[0]);
+	result.dispose();
+	return output;
+}
+//#endregion
+//#region ../../plugins/vite/src/collect.ts
+/**
+* Extracts a StaticBound from one element of the enforcement.children array,
+* if and only if the element is an object literal with a statically-readable
+* cardinality. Returns undefined for elements that use dynamic values.
+*/
+function extractBound(element) {
+	const obj = asObject(element);
+	if (!obj) return void 0;
+	const cardObj = asObject(getProperty(obj, "cardinality"));
+	let cardinality;
+	if (cardObj) {
+		const minNode = getProperty(cardObj, "min");
+		const maxNode = getProperty(cardObj, "max");
+		const min = asNonNegativeInt(minNode) ?? 0;
+		const max = asNonNegativeInt(maxNode);
+		if (min === 0 && max === void 0) cardinality = { kind: "unbounded" };
+		else cardinality = {
+			kind: "bounded",
+			min,
+			max: max ?? Infinity
+		};
+	} else cardinality = { kind: "unbounded" };
+	const positionNode = getProperty(obj, "position");
+	let position = "any";
+	if (positionNode && ts.isStringLiteral(positionNode)) {
+		const p = positionNode.text;
+		if (p === "first" || p === "last" || p === "any") position = p;
+	}
+	return {
+		cardinality,
+		position
+	};
+}
+/** Returns the lower bound of a Cardinality as an integer (unbounded → 0). */
+function cardinalityMin(c) {
+	return c.kind === "bounded" ? c.min : 0;
+}
+/** Returns the upper bound of a Cardinality (unbounded → Infinity). */
+function cardinalityMax(c) {
+	return c.kind === "bounded" ? c.max : Infinity;
+}
+/**
+* Walks a SourceFile and returns one ComponentConstraint for each
+* `const X = createPolymorphicComponent({ enforcement: { children: [...] } })`
+* where at least one children rule has a statically-extractable cardinality.
+*
+* Only handles simple `const X = factory(...)` declarations — named exports,
+* default exports, and destructured patterns are not collected. Cross-file
+* constraint collection (factory defined in module A, consumed in module B)
+* is handled separately via the registry + import resolver path in the plugin.
+* Dynamic cardinality values (computed variables, spreads) are silently skipped;
+* extending to data-flow patterns is deferred.
+*/
+function processVariableStatement(node, calleeNames, out) {
+	iterate.forEach(node.declarationList.declarations, (decl) => {
+		const { initializer, name } = decl;
+		if (!initializer || !ts.isCallExpression(initializer)) return;
+		if (!isFactoryCall(initializer, calleeNames)) return;
+		const arg = firstObjectArg(initializer);
+		if (!arg) return;
+		const tagNode = getProperty(arg, "tag");
+		const defaultTag = tagNode && ts.isStringLiteral(tagNode) ? tagNode.text : void 0;
+		const enfObj = asObject(getProperty(arg, "enforcement"));
+		const ariaArr = asArray(enfObj ? getProperty(enfObj, "aria") : void 0);
+		const hasAriaRules = ariaArr !== void 0 && ariaArr.elements.length > 0;
+		const exclusiveChildren = asBooleanLiteral(enfObj ? getProperty(enfObj, "exclusiveChildren") : void 0) ?? false;
+		const childrenArr = asArray(enfObj ? getProperty(enfObj, "children") : void 0);
+		const rules = [];
+		if (childrenArr) iterate.forEach(childrenArr.elements, (element) => {
+			const bound = extractBound(element);
+			if (bound) rules.push(bound);
+		});
+		if (rules.length === 0 && !hasAriaRules && !defaultTag && !exclusiveChildren) return;
+		let totalMin = 0;
+		let totalMax = 0;
+		iterate.forEach(rules, (rule) => {
+			totalMin += cardinalityMin(rule.cardinality);
+			const max = cardinalityMax(rule.cardinality);
+			totalMax = totalMax === Infinity || max === Infinity ? Infinity : totalMax + max;
+		});
+		const componentName = ts.isIdentifier(name) ? name.text : void 0;
+		if (!componentName) return;
+		out.push({
+			name: componentName,
+			rules,
+			totalMin,
+			totalMax,
+			...defaultTag !== void 0 && { defaultTag },
+			hasAriaRules,
+			exclusiveChildren
+		});
+	});
+}
+/**
+* Single-pass variant of collectConstraints + extractImportSpecifiers.
+* Collects factory constraints and named import bindings in one AST walk
+* instead of two, for use in the hot Vite transform hook.
+*/
+function collectFileDeclarations(source, calleeNames) {
+	const constraints = [];
+	const importSpecifiers = /* @__PURE__ */ new Map();
+	walkEach(source, (node) => {
+		if (ts.isVariableStatement(node)) processVariableStatement(node, calleeNames, constraints);
+		else if (ts.isImportDeclaration(node)) {
+			const spec = node.moduleSpecifier;
+			if (!ts.isStringLiteral(spec)) return;
+			const namedBindings = node.importClause?.namedBindings;
+			if (!namedBindings || !ts.isNamedImports(namedBindings)) return;
+			const specifier = spec.text;
+			iterate.forEach(namedBindings.elements, ({ isTypeOnly, name, propertyName }) => {
+				if (isTypeOnly) return;
+				const localName = name.text;
+				const importedName = propertyName?.text ?? localName;
+				importSpecifiers.set(localName, {
+					importedName,
+					specifier
+				});
+			});
+		}
+	});
+	return {
+		constraints,
+		importSpecifiers
+	};
+}
+//#endregion
+//#region ../../plugins/vite/src/compound-prune.ts
+/**
+* Compile-time dead compound variant pruning.
+*
+* Removes entries from `styling.compounds` whose conditions can never fire:
+*   - condition key is not in `styling.variants`
+*   - condition value (string) is not a valid value for that variant key
+*   - condition value (array) has no element that is a valid value
+*
+* Only entries whose conditions are all statically evaluable (string/array
+* literals throughout) are candidates for pruning — dynamic conditions (variable
+* references, computed values) are left unchanged.
+*
+* Returns null if no factory calls with `styling.compounds` are found, or if
+* every compound in every factory call passes the validity check.
+*/
+/** Builds a variant map from a `styling.variants` object literal.  */
+function extractVariantMap(stylingObj) {
+	const result = /* @__PURE__ */ new Map();
+	const variantsObj = asObject(getProperty(stylingObj, "variants"));
+	if (!variantsObj) return result;
+	iterate.forEach(variantsObj.properties, (prop) => {
+		if (!ts.isPropertyAssignment(prop)) return;
+		const { name } = prop;
+		const key = ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : void 0;
+		if (!key) return;
+		const valuesObj = asObject(prop.initializer);
+		if (!valuesObj) return;
+		const valid = /* @__PURE__ */ new Set();
+		iterate.forEach(valuesObj.properties, (vp) => {
+			if (!ts.isPropertyAssignment(vp)) return;
+			const { name } = vp;
+			const vk = ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : void 0;
+			if (vk) valid.add(vk);
+		});
+		result.set(key, valid);
+	});
+	return result;
+}
+/**
+* Returns true if the compound object literal entry is dead given `variantMap`.
+*
+* Conservative: returns false (not dead) whenever a condition cannot be fully
+* evaluated as string/array literals.
+*/
+function isDeadCompound(entry, variantMap) {
+	return iterate.find(entry.properties, (prop) => {
+		if (!ts.isPropertyAssignment(prop)) return null;
+		const { name } = prop;
+		const key = ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : void 0;
+		if (!key || key === "class") return null;
+		const validValues = variantMap.get(key);
+		if (!validValues) return true;
+		const { initializer: val } = prop;
+		if (ts.isStringLiteral(val)) {
+			if (!validValues.has(val.text)) return true;
+		} else if (ts.isArrayLiteralExpression(val)) {
+			if (!val.elements.every(ts.isStringLiteral)) return null;
+			if (!val.elements.some((e) => ts.isStringLiteral(e) && validValues.has(e.text))) return true;
+		}
+		return null;
+	}) ?? false;
+}
+/** Returns a TS transformer that removes dead compound entries from every eligible factory call in a source file. */
+function createCompoundPruner(factory, calleeNames, onPruned) {
+	return (context) => {
+		function visit(node) {
+			if (!ts.isCallExpression(node)) return ts.visitEachChild(node, visit, context);
+			if (!isFactoryCall(node, calleeNames)) return ts.visitEachChild(node, visit, context);
+			const arg = firstObjectArg(node);
+			if (!arg) return node;
+			const stylingObj = asObject(getProperty(arg, "styling"));
+			if (!stylingObj) return ts.visitEachChild(node, visit, context);
+			const compoundsArr = asArray(getProperty(stylingObj, "compounds"));
+			if (!compoundsArr || compoundsArr.elements.length === 0) return ts.visitEachChild(node, visit, context);
+			const variantMap = extractVariantMap(stylingObj);
+			if (variantMap.size === 0) return ts.visitEachChild(node, visit, context);
+			const liveEntries = compoundsArr.elements.filter((elem) => {
+				const obj = asObject(elem);
+				return !obj || !isDeadCompound(obj, variantMap);
+			});
+			if (liveEntries.length === compoundsArr.elements.length) return ts.visitEachChild(node, visit, context);
+			onPruned();
+			const newCompoundsArr = factory.createArrayLiteralExpression(liveEntries, true);
+			const newStylingProps = stylingObj.properties.map((p) => {
+				if (ts.isPropertyAssignment(p) && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === "compounds") return factory.createPropertyAssignment(p.name, newCompoundsArr);
+				return p;
+			});
+			const newStylingObj = factory.createObjectLiteralExpression(newStylingProps, true);
+			const newArgProps = arg.properties.map((p) => {
+				if (ts.isPropertyAssignment(p) && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === "styling") return factory.createPropertyAssignment(p.name, newStylingObj);
+				return p;
+			});
+			const newArg = factory.createObjectLiteralExpression(newArgProps, true);
+			return factory.createCallExpression(node.expression, node.typeArguments, [newArg, ...node.arguments.slice(1)]);
+		}
+		return (sourceFile) => ts.visitEachChild(sourceFile, visit, context);
+	};
+}
+/**
+* Applies dead-compound pruning to the given TypeScript source file.
+*
+* Returns null when the file has no factory calls with `styling.compounds`, or
+* when every compound entry passes validity — i.e., when no pruning is needed.
+*/
+function pruneDeadCompounds(source, calleeNames) {
+	let hasCompounds = false;
+	walkEach(source, (n) => {
+		if (hasCompounds) return;
+		if (ts.isPropertyAssignment(n)) {
+			if ((ts.isIdentifier(n.name) || ts.isStringLiteral(n.name) ? n.name.text : void 0) === "compounds") hasCompounds = true;
+		}
+	});
+	if (!hasCompounds) return null;
+	let didPrune = false;
+	const result = ts.transform(source, [createCompoundPruner(ts.factory, calleeNames, () => {
+		didPrune = true;
+	})], { target: ts.ScriptTarget.Latest });
+	if (!didPrune) {
+		result.dispose();
+		return null;
+	}
+	const output = ts.createPrinter({
+		newLine: ts.NewLineKind.LineFeed,
+		removeComments: false
+	}).printFile(result.transformed[0]);
+	result.dispose();
+	return output;
+}
+//#endregion
+//#region ../../plugins/vite/src/constants.ts
+const DEFAULT_CALLEE_NAMES = ["createContractComponent", "createPolymorphicComponent"];
+const JSX_EXTS = /* @__PURE__ */ new Set(["tsx", "jsx"]);
+const ALL_EXTS = /* @__PURE__ */ new Set([
+	"ts",
+	"tsx",
+	"js",
+	"jsx"
+]);
+//#endregion
+//#region ../../plugins/vite/src/vite-diagnostics.ts
+const ViteDiagnostics = {
+	cardinalityViolation(name, totalMin, totalMax, receivedMin, receivedMax) {
+		const rangeText = totalMax === Infinity ? `at least ${totalMin}` : totalMin === totalMax ? `exactly ${totalMin}` : `${totalMin}–${totalMax}`;
+		const childWord = totalMax === 1 && totalMin === 1 ? "child" : "children";
+		const receivedText = receivedMin === receivedMax ? `${receivedMin}` : `${receivedMin}–${receivedMax}`;
+		return {
+			code: DiagnosticCode.LintCardinalityViolation,
+			category: DiagnosticCategory.Lint,
+			message: `<${name}> expects ${rangeText} ${childWord} but received ${receivedText}.`
+		};
+	},
+	ariaTagOverride(tagName, asValue, defaultTag) {
+		return {
+			code: DiagnosticCode.LintAriaTagOverride,
+			category: DiagnosticCategory.Lint,
+			message: `<${tagName} as="${asValue}"> changes the element type from '${defaultTag}' — ARIA enforcement rules may not apply as expected.`
+		};
+	}
+};
+//#endregion
+//#region ../../plugins/vite/src/diagnose.ts
+/**
+* Single-pass variant of diagnoseUsages + diagnoseAriaTagOverrides + collectJsxUsages.
+* Visits each JSX node once and dispatches to all three checks, rather than walking
+* the source three times. For use in the hot Vite transform hook.
+*/
+function analyzeJsxSites(source, constraints, severity) {
+	const byName = new Map(constraints.filter((c) => c.rules.length > 0).map((c) => [c.name, c]));
+	const byNameAria = new Map(constraints.filter((c) => c.hasAriaRules && c.defaultTag !== void 0).map((c) => [c.name, c]));
+	const diagnostics = [];
+	const usages = [];
+	walkEach(source, (node) => {
+		let tagName;
+		let attributes;
+		let count;
+		if (ts.isJsxElement(node)) {
+			const opening = node.openingElement;
+			tagName = ts.isIdentifier(opening.tagName) ? opening.tagName.text : void 0;
+			attributes = opening.attributes;
+			count = countJsxChildren(node.children);
+		} else if (ts.isJsxSelfClosingElement(node)) {
+			tagName = ts.isIdentifier(node.tagName) ? node.tagName.text : void 0;
+			attributes = node.attributes;
+			count = ZERO;
+		}
+		if (!tagName) return;
+		const getPos = lazy(() => source.getLineAndCharacterOfPosition(node.getStart(source)));
+		if (count !== void 0) {
+			const c = byName.get(tagName);
+			if (c && (count.max < c.totalMin || c.exclusiveChildren && count.min > c.totalMax)) {
+				const { line, character } = getPos();
+				diagnostics.push({
+					diagnostic: ViteDiagnostics.cardinalityViolation(c.name, c.totalMin, c.totalMax, count.min, count.max),
+					line: line + 1,
+					col: character + 1,
+					severity
+				});
+			}
+		}
+		if (attributes) {
+			const c = byNameAria.get(tagName);
+			if (c) iterate.forEach(attributes.properties, (attr) => {
+				if (!ts.isJsxAttribute(attr)) return;
+				const { initializer, name } = attr;
+				if ((ts.isIdentifier(name) ? name.text : void 0) !== "as" || !initializer) return;
+				let asValue;
+				if (ts.isStringLiteral(initializer)) asValue = initializer.text;
+				else if (ts.isJsxExpression(initializer) && initializer.expression !== void 0 && ts.isStringLiteral(initializer.expression)) asValue = initializer.expression.text;
+				if (asValue !== void 0 && asValue !== c.defaultTag) {
+					const { line, character } = getPos();
+					diagnostics.push({
+						diagnostic: ViteDiagnostics.ariaTagOverride(tagName, asValue, c.defaultTag),
+						line: line + 1,
+						col: character + 1,
+						severity
+					});
+				}
+			});
+		}
+		if (/^[A-Z]/.test(tagName)) {
+			const { line, character } = getPos();
+			usages.push({
+				tagName,
+				count,
+				line: line + 1,
+				col: character + 1
+			});
+		}
+	});
+	return {
+		diagnostics,
+		usages
+	};
+}
+const ZERO = {
+	min: 0,
+	max: 0
+};
+const ONE = {
+	min: 1,
+	max: 1
+};
+/**
+* Analyzes an expression to determine how many JSX children it renders.
+*
+* Returns a `ChildCount` range when the count is statically determinable —
+* including partially-dynamic patterns like conditionals and array literals.
+* Returns `undefined` for unknowable cases (`.map()`, variable references,
+* spread elements).
+*
+* Handles:
+* - `null`, `false`, `undefined`, empty `{}` → 0
+* - `cond && <El />` → [0, 1]
+* - `cond || <El />` / `cond ?? <El />` → [min(sides), max(sides)]
+* - `cond ? <A /> : <B />` → [min(branches), max(branches)]
+* - `[<A />, <B />]` (no spreads) → exact array count
+* - JSX element / fragment → 1 / fragment child count
+* - Parenthesized expressions → delegate to inner
+*/
+function countExpression(node) {
+	if (node.kind === ts.SyntaxKind.NullKeyword) return ZERO;
+	if (node.kind === ts.SyntaxKind.FalseKeyword) return ZERO;
+	if (ts.isIdentifier(node) && node.text === "undefined") return ZERO;
+	if (ts.isParenthesizedExpression(node)) return countExpression(node.expression);
+	if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) return ONE;
+	if (ts.isJsxFragment(node)) return countJsxChildren(node.children);
+	if (ts.isArrayLiteralExpression(node)) {
+		let min = 0;
+		let max = 0;
+		for (const el of node.elements) {
+			if (ts.isSpreadElement(el)) return void 0;
+			const c = countExpression(el);
+			if (!c) return void 0;
+			min += c.min;
+			max += c.max;
+		}
+		return {
+			min,
+			max
+		};
+	}
+	if (ts.isBinaryExpression(node)) {
+		const op = node.operatorToken.kind;
+		if (op === ts.SyntaxKind.AmpersandAmpersandToken) {
+			const right = countExpression(node.right);
+			if (!right) return void 0;
+			return {
+				min: 0,
+				max: right.max
+			};
+		}
+		if (op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken) {
+			const left = countExpression(node.left);
+			const right = countExpression(node.right);
+			if (!left || !right) return void 0;
+			return {
+				min: Math.min(left.min, right.min),
+				max: Math.max(left.max, right.max)
+			};
+		}
+	}
+	if (ts.isConditionalExpression(node)) {
+		const whenTrue = countExpression(node.whenTrue);
+		const whenFalse = countExpression(node.whenFalse);
+		if (!whenTrue || !whenFalse) return void 0;
+		return {
+			min: Math.min(whenTrue.min, whenFalse.min),
+			max: Math.max(whenTrue.max, whenFalse.max)
+		};
+	}
+}
+/**
+* Counts the meaningful children of a JSX element's child list.
+* Whitespace-only `JsxText` nodes are ignored. Fragments are flattened.
+* Returns `undefined` if any child contribution is unknowable.
+*/
+function countJsxChildren(children) {
+	let min = 0;
+	let max = 0;
+	for (const child of children) {
+		let c;
+		if (ts.isJsxExpression(child)) c = child.expression === void 0 ? ZERO : countExpression(child.expression);
+		else if (ts.isJsxText(child)) c = child.text.trim().length > 0 ? ONE : ZERO;
+		else if (ts.isJsxFragment(child)) c = countJsxChildren(child.children);
+		else c = ONE;
+		if (!c) return void 0;
+		min += c.min;
+		max += c.max;
+	}
+	return {
+		min,
+		max
+	};
+}
+//#endregion
+//#region ../../plugins/vite/src/imports.ts
+/**
+* Extracts named import bindings from a source file.
+* Returns a Map from local binding name to its ImportBinding.
+*
+* `import { Button } from './button'`         → Map { 'Button'   => { importedName: 'Button',   specifier: './button' } }
+* `import { Button as MyBtn } from './button'` → Map { 'MyBtn'   => { importedName: 'Button',   specifier: './button' } }
+* `import { Btn as Button } from './button'`   → Map { 'Button'  => { importedName: 'Btn',      specifier: './button' } }
+*
+* Default imports and namespace imports (`* as X`) are ignored — only named
+* bindings that could correspond to component identifiers in JSX are collected.
+*/
+function extractImportSpecifiers(source) {
+	const result = /* @__PURE__ */ new Map();
+	walkEach(source, (node) => {
+		if (!ts.isImportDeclaration(node)) return;
+		const moduleSpecifier = node.moduleSpecifier;
+		if (!ts.isStringLiteral(moduleSpecifier)) return;
+		const specifier = moduleSpecifier.text;
+		const namedBindings = node.importClause?.namedBindings;
+		if (!namedBindings || !ts.isNamedImports(namedBindings)) return;
+		iterate.forEach(namedBindings.elements, (element) => {
+			const { isTypeOnly, name, propertyName } = element;
+			if (isTypeOnly) return;
+			const { text: localName } = name;
+			const importedName = propertyName?.text ?? localName;
+			result.set(localName, {
+				importedName,
+				specifier
+			});
+		});
+	});
+	return result;
+}
+//#endregion
+//#region ../../plugins/vite/src/registry.ts
+/**
+* Accumulates constraint and import data across multiple `transform` calls so
+* that cross-file cardinality violations can be detected in `buildEnd`.
+*
+* Lifecycle:
+* 1. `registerConstraints(id, ...)` — called for every TSX/JSX file that
+*    defines constrained components.
+* 2. `registerImports(id, resolvedMap)` — called when a file imports component
+*    names that appear in JSX; the map keys are local binding names, values are
+*    the absolute file IDs returned by `this.resolve()`.
+* 3. `addPendingUsage(id, usage)` — records a JSX usage whose tag name is
+*    imported from another file, for deferred validation.
+* 4. `diagnostics(severity)` — called once in `buildEnd`; resolves each pending
+*    usage to its source constraint and emits a `FileDiagnostic` for any
+*    cardinality violation.
+*/
+var ConstraintRegistry = class {
+	constraints = /* @__PURE__ */ new Map();
+	importMap = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	/** Records the component constraints declared in a source file, keyed by component name. */
+	registerConstraints(fileId, cs) {
+		this.constraints.set(fileId, new Map(cs.map((c) => [c.name, c])));
+	}
+	/** resolvedImports: local name → absolute file ID of the exporting module. */
+	registerImports(fileId, resolvedImports) {
+		this.importMap.set(fileId, resolvedImports);
+	}
+	/** Queues a JSX usage site whose constraint lives in another file for deferred cross-file validation at buildEnd. */
+	addPendingUsage(fileId, usage) {
+		let list = this.pending.get(fileId);
+		if (!list) {
+			list = [];
+			this.pending.set(fileId, list);
+		}
+		list.push(usage);
+	}
+	/** Resolves a component name used in `fileId` to its constraint definition. */
+	resolveConstraint(fileId, name) {
+		const imports = this.importMap.get(fileId);
+		if (!imports) return void 0;
+		const sourceId = imports.get(name);
+		if (!sourceId) return void 0;
+		return this.constraints.get(sourceId)?.get(name);
+	}
+	/** Returns cardinality violations across all pending cross-file usages. */
+	diagnostics(severity) {
+		const result = [];
+		iterate.forEach(this.pending, ([fileId, usages]) => {
+			iterate.forEach(usages, ({ col, count, line, tagName }) => {
+				if (count === void 0) return;
+				const constraint = this.resolveConstraint(fileId, tagName);
+				if (!constraint) return;
+				const { totalMin, totalMax, name, exclusiveChildren } = constraint;
+				const { min, max } = count;
+				if (!(max < totalMin) && !(exclusiveChildren && min > totalMax)) return;
+				result.push({
+					fileId,
+					diagnostic: ViteDiagnostics.cardinalityViolation(name, totalMin, totalMax, min, max),
+					line,
+					col,
+					severity
+				});
+			});
+		});
+		return result;
+	}
+};
+//#endregion
+//#region ../../plugins/vite/src/slot-transform.ts
+/**
+* Compile-time asChild → render-prop transform.
+*
+* Rewrites JSX usage sites of the form:
+*   <Component asChild ...props>
+*     <childTag ...childProps>children</childTag>
+*   </Component>
+*
+* to the render-prop form:
+*   <Component render={(_p) => <childTag ...childProps {..._p} />} ...props />
+*
+* The render-prop form eliminates the Slot/cloneElement/mergeProps path at
+* runtime — resolved props are passed directly to the render callback with no
+* element cloning.
+*
+* **Safety conditions** — the transform is skipped if any of these are true:
+*   1. The child has a dynamic `className` expression (cannot merge safely).
+*      A string-literal `className` IS handled: the transform generates
+*      `{..._p, className: _p.className + ' childCls'}`.
+*   2. The child has a bare `style` or `on*` attribute without an initializer.
+*      Static object-literal and expression-valued `style` props are merged:
+*      `style={{..._p.style, ...childStyle}}`.  Event handlers are composed:
+*      `onClick={(_e) => { (childHandler)(_e); _p.onClick?.(_e); }}`.
+*   3. The component name starts with a lowercase letter (HTML intrinsic — not
+*      a polymorphic component).
+*   4. There are zero or more than one meaningful child elements.
+*
+* The transform is conservative: any condition that is not statically clear
+* causes the node to be left unchanged.
+*/
+/** Returns true when the first character of `s` is an uppercase ASCII letter (A–Z). */
+function isUpperCase(s) {
+	return s.charCodeAt(0) >= 65 && s.charCodeAt(0) <= 90;
+}
+/** Returns the attribute name string; empty string for namespaced names. */
+function jsxAttrName(attr) {
+	return ts.isIdentifier(attr.name) ? attr.name.text : "";
+}
+function getStaticClassName(child) {
+	const attrs = ts.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties;
+	for (const attr of attrs) {
+		if (!ts.isJsxAttribute(attr) || jsxAttrName(attr) !== "className") continue;
+		const init = attr.initializer;
+		if (!init) return {
+			absent: false,
+			value: ""
+		};
+		if (ts.isStringLiteral(init)) return {
+			absent: false,
+			value: init.text
+		};
+		if (ts.isJsxExpression(init) && init.expression !== void 0 && ts.isStringLiteral(init.expression)) return {
+			absent: false,
+			value: init.expression.text
+		};
+		return null;
+	}
+	return { absent: true };
+}
+function getStyleInfo(child) {
+	const attrs = ts.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties;
+	for (const attr of attrs) {
+		if (!ts.isJsxAttribute(attr) || jsxAttrName(attr) !== "style") continue;
+		const init = attr.initializer;
+		if (!init || ts.isStringLiteral(init)) return null;
+		if (ts.isJsxExpression(init) && init.expression !== void 0) return {
+			absent: false,
+			expr: init.expression
+		};
+		return null;
+	}
+	return { absent: true };
+}
+function getEventHandlers(child) {
+	const attrs = ts.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties;
+	const handlers = [];
+	for (const attr of attrs) {
+		if (!ts.isJsxAttribute(attr)) continue;
+		const name = jsxAttrName(attr);
+		if (!/^on[A-Z]/.test(name)) continue;
+		const init = attr.initializer;
+		if (!init) return null;
+		if (ts.isJsxExpression(init) && init.expression !== void 0) {
+			handlers.push({
+				name,
+				expr: init.expression
+			});
+			continue;
+		}
+		return null;
+	}
+	return handlers;
+}
+/** Returns true if the opening element has an `asChild` attribute (bare or `={true}`). */
+function hasAsChild(opening) {
+	for (const attr of opening.attributes.properties) {
+		if (!ts.isJsxAttribute(attr)) continue;
+		if (jsxAttrName(attr) !== "asChild") continue;
+		if (attr.initializer === void 0) return true;
+		if (ts.isJsxExpression(attr.initializer) && attr.initializer.expression !== void 0 && attr.initializer.expression.kind === ts.SyntaxKind.TrueKeyword) return true;
+	}
+	return false;
+}
+/** Returns the single meaningful JSX element child, or undefined if there isn't exactly one. */
+function getSingleElementChild(node) {
+	const meaningful = [];
+	for (const child of node.children) {
+		if (ts.isJsxText(child)) {
+			if (child.text.trim().length > 0) return void 0;
+			continue;
+		}
+		if (ts.isJsxExpression(child)) return void 0;
+		if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
+			meaningful.push(child);
+			continue;
+		}
+		return;
+	}
+	return meaningful.length === 1 ? meaningful[0] : void 0;
+}
+/** Returns the tag name string if the opening element has a simple identifier tag. */
+function getTagName(child) {
+	const tag = ts.isJsxElement(child) ? child.openingElement.tagName : child.tagName;
+	return ts.isIdentifier(tag) ? tag.text : void 0;
+}
+/**
+* Builds the attribute list for the transformed parent, omitting `asChild`
+* and adding `render={(_p) => <childTag ...childAttrs {..._p} />}`.
+*
+* Merged props are placed after the `{..._p}` spread so they override _p:
+* - Static `className` → `className={_p.className + ' childCls'}`
+* - `style` → `style={{..._p.style, ...childStyleExpr}}`
+* - `on*` handlers → `onClick={(_e) => { (childHandler)(_e); _p.onClick?.(_e); }}`
+*/
+function buildTransformedAttributes(factory, original, child, tagName, clsResult, styleInfo, handlers) {
+	const parentAttrs = original.attributes.properties.filter((attr) => !(ts.isJsxAttribute(attr) && jsxAttrName(attr) === "asChild"));
+	const hasStaticCls = !clsResult.absent;
+	const hasStyle = !styleInfo.absent;
+	const handlerNames = new Set(iterate.map(handlers, (h) => h.name));
+	const childOpeningAttrs = (ts.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties).filter((attr) => !(ts.isJsxAttribute(attr) && (jsxAttrName(attr) === "ref" || hasStaticCls && jsxAttrName(attr) === "className" || hasStyle && jsxAttrName(attr) === "style" || handlerNames.has(jsxAttrName(attr)))));
+	const childContent = ts.isJsxElement(child) ? child.children : void 0;
+	const spreadProp = factory.createJsxSpreadAttribute(factory.createIdentifier("_p"));
+	const extraAttrs = [];
+	if (hasStaticCls && clsResult.value !== "") {
+		const mergedExpr = factory.createBinaryExpression(factory.createPropertyAccessExpression(factory.createIdentifier("_p"), "className"), ts.SyntaxKind.PlusToken, factory.createStringLiteral(` ${clsResult.value}`));
+		extraAttrs.push(factory.createJsxAttribute(factory.createIdentifier("className"), factory.createJsxExpression(void 0, mergedExpr)));
+	}
+	if (hasStyle) {
+		const styleExpr = styleInfo.expr;
+		const pStyleSpread = factory.createSpreadAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("_p"), "style"));
+		let mergedStyleObj;
+		if (ts.isObjectLiteralExpression(styleExpr)) mergedStyleObj = factory.createObjectLiteralExpression([pStyleSpread, ...styleExpr.properties], false);
+		else mergedStyleObj = factory.createObjectLiteralExpression([pStyleSpread, factory.createSpreadAssignment(styleExpr)], false);
+		extraAttrs.push(factory.createJsxAttribute(factory.createIdentifier("style"), factory.createJsxExpression(void 0, mergedStyleObj)));
+	}
+	for (const { name, expr } of handlers) {
+		const eParam = factory.createParameterDeclaration(void 0, void 0, "_e");
+		const callChild = factory.createExpressionStatement(factory.createCallExpression(factory.createParenthesizedExpression(expr), void 0, [factory.createIdentifier("_e")]));
+		const callParent = factory.createExpressionStatement(factory.createCallChain(factory.createPropertyAccessExpression(factory.createIdentifier("_p"), name), factory.createToken(ts.SyntaxKind.QuestionDotToken), void 0, [factory.createIdentifier("_e")]));
+		const composedFn = factory.createArrowFunction(void 0, void 0, [eParam], void 0, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createBlock([callChild, callParent], true));
+		extraAttrs.push(factory.createJsxAttribute(factory.createIdentifier(name), factory.createJsxExpression(void 0, composedFn)));
+	}
+	const childAttrsWithSpread = factory.createJsxAttributes([
+		...childOpeningAttrs,
+		spreadProp,
+		...extraAttrs
+	]);
+	const childElement = ts.isJsxElement(child) ? factory.createJsxElement(factory.createJsxOpeningElement(factory.createIdentifier(tagName), void 0, childAttrsWithSpread), childContent ?? [], factory.createJsxClosingElement(factory.createIdentifier(tagName))) : factory.createJsxSelfClosingElement(factory.createIdentifier(tagName), void 0, childAttrsWithSpread);
+	const renderArrow = factory.createArrowFunction(void 0, void 0, [factory.createParameterDeclaration(void 0, void 0, "_p")], void 0, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createParenthesizedExpression(childElement));
+	const renderAttr = factory.createJsxAttribute(factory.createIdentifier("render"), factory.createJsxExpression(void 0, renderArrow));
+	return factory.createJsxAttributes([renderAttr, ...parentAttrs]);
+}
+/**
+* Returns a TypeScript transformer that rewrites safe `asChild` JSX patterns
+* to the render-prop form in a single source file.
+*/
+function createAsChildTransformer(factory) {
+	return (context) => {
+		function visit(node) {
+			if (!ts.isJsxElement(node)) return ts.visitEachChild(node, visit, context);
+			const opening = node.openingElement;
+			const tagName = ts.isIdentifier(opening.tagName) ? opening.tagName.text : void 0;
+			if (!tagName || !isUpperCase(tagName)) return ts.visitEachChild(node, visit, context);
+			if (!hasAsChild(opening)) return ts.visitEachChild(node, visit, context);
+			const child = getSingleElementChild(node);
+			if (!child) return ts.visitEachChild(node, visit, context);
+			const clsResult = getStaticClassName(child);
+			if (clsResult === null) return ts.visitEachChild(node, visit, context);
+			const styleInfo = getStyleInfo(child);
+			if (styleInfo === null) return ts.visitEachChild(node, visit, context);
+			const handlers = getEventHandlers(child);
+			if (handlers === null) return ts.visitEachChild(node, visit, context);
+			const childTag = getTagName(child);
+			if (!childTag) return ts.visitEachChild(node, visit, context);
+			const newAttrs = buildTransformedAttributes(factory, opening, child, childTag, clsResult, styleInfo, handlers);
+			return factory.createJsxSelfClosingElement(opening.tagName, opening.typeArguments, newAttrs);
+		}
+		return (sourceFile) => ts.visitEachChild(sourceFile, visit, context);
+	};
+}
+/**
+* Applies the asChild → render-prop transform to the given TypeScript source
+* file and returns the printed output.
+*
+* Returns null if no `asChild` attribute is found in the source (fast path —
+* avoids parsing overhead for files that don't use the pattern).
+*/
+function transformAsChild(source) {
+	if (!iterate.some(walk(source), (node) => ts.isJsxAttribute(node) && jsxAttrName(node) === "asChild")) return null;
+	const result = ts.transform(source, [createAsChildTransformer(ts.factory)], {
+		jsx: ts.JsxEmit.Preserve,
+		target: ts.ScriptTarget.Latest
+	});
+	const output = ts.createPrinter({
+		newLine: ts.NewLineKind.LineFeed,
+		removeComments: false
+	}).printFile(result.transformed[0]);
+	result.dispose();
+	return output;
+}
+//#endregion
+//#region ../../plugins/vite/src/static-compose.ts
+/**
+* Compile-time static composition transform.
+*
+* For factory calls that have `precomputedClasses` injected (by classExtractPlugin),
+* replaces static JSX usage sites with direct element creation — bypassing the
+* runtime render pipeline entirely.
+*
+* Example:
+*   // Source (same file defines Button and uses it)
+*   const Button = createContractComponent({ tag: 'button', styling: { precomputedClasses: {...} } })
+*   <Button size="lg">Click</Button>
+*
+*   // Output
+*   const Button = createContractComponent({ ... }) // unchanged — still exported
+*   <button className="btn btn-lg">Click</button>  // inlined!
+*
+* **Eligibility conditions** — a usage site is inlined only when:
+*   1. The component is defined in the same file or imported from a file already
+*      transformed by this plugin, with `precomputedClasses` injected
+*   2. No `as`, `asChild`, `render`, or spread attributes at the usage site
+*   3. All variant props are static string literals
+*   4. `className` is absent or a static string literal
+*   5. The factory config has no top-level `defaults` and no `enforcement`
+*      (either would require runtime prop normalization that inlining skips)
+*
+* The factory call itself is intentionally left in the output so the component
+* remains exportable for cross-file consumption that falls back to the runtime
+* path. Dead-code elimination at the bundler level can remove it when no
+* runtime path remains.
+*
+* **Cross-file known limitations:**
+* - Barrel re-exports are not resolved (import from index.ts re-exporting ./Button)
+* - Aliased imports are not matched (`export { Btn as Button }` won't be found)
+* - Dev-mode ordering: definition file may not yet be transformed when consumer runs
+* All three degrade gracefully to the runtime path — no error, no broken output.
+*/
+/** Returns the text of a string literal node, or undefined. */
+function asStringLiteral(node) {
+	return node !== void 0 && ts.isStringLiteral(node) ? node.text : void 0;
+}
+/**
+* Walks the source file and extracts metadata for each same-file factory call
+* that is eligible for static composition.
+*/
+function extractStaticComponents(source, calleeNames) {
+	const result = /* @__PURE__ */ new Map();
+	walkEach(source, (node) => {
+		if (!ts.isVariableDeclaration(node)) return;
+		if (!ts.isIdentifier(node.name)) return;
+		const varName = node.name.text;
+		const init = node.initializer;
+		if (!init) return;
+		let call;
+		if (ts.isCallExpression(init) && isFactoryCall(init, calleeNames)) call = init;
+		else if (ts.isAsExpression(init) && ts.isCallExpression(init.expression) && isFactoryCall(init.expression, calleeNames)) call = init.expression;
+		if (!call) return;
+		const arg = firstObjectArg(call);
+		if (!arg) return;
+		const defaultTag = asStringLiteral(getProperty(arg, "tag"));
+		if (!defaultTag) return;
+		const stylingObj = asObject(getProperty(arg, "styling"));
+		if (!stylingObj) return;
+		const precomputedNode = asObject(getProperty(stylingObj, "precomputedClasses"));
+		if (!precomputedNode) return;
+		const precomputedClasses = {};
+		if (iterate.find(precomputedNode.properties, (prop) => {
+			if (!ts.isPropertyAssignment(prop)) return true;
+			const { initializer, name } = prop;
+			const key = ts.isStringLiteral(name) ? name.text : void 0;
+			const val = asStringLiteral(initializer);
+			if (key === void 0 || val === void 0) return true;
+			precomputedClasses[key] = val;
+			return null;
+		})) return;
+		if (getProperty(arg, "defaults") !== void 0) return;
+		if (getProperty(arg, "enforcement") !== void 0) return;
+		const variantKeys = /* @__PURE__ */ new Set();
+		const variantsObj = asObject(getProperty(stylingObj, "variants"));
+		if (variantsObj) iterate.forEach(variantsObj.properties, (prop) => {
+			if (ts.isPropertyAssignment(prop) && (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name))) variantKeys.add(prop.name.text);
+		});
+		result.set(varName, {
+			defaultTag,
+			variantKeys,
+			precomputedClasses
+		});
+	});
+	return result;
+}
+/** Reads the value of a named JSX attribute from the attribute list: absent, a static string, or dynamic. */
+function readAttrValue(attrs, name) {
+	for (const attr of attrs) {
+		if (!ts.isJsxAttribute(attr)) continue;
+		if (!(ts.isIdentifier(attr.name) && attr.name.text === name)) continue;
+		const init = attr.initializer;
+		if (!init) return {
+			kind: "string",
+			value: ""
+		};
+		if (ts.isStringLiteral(init)) return {
+			kind: "string",
+			value: init.text
+		};
+		if (ts.isJsxExpression(init) && init.expression !== void 0) {
+			if (ts.isStringLiteral(init.expression)) return {
+				kind: "string",
+				value: init.expression.text
+			};
+			return { kind: "dynamic" };
+		}
+		return { kind: "dynamic" };
+	}
+	return { kind: "absent" };
+}
+/** Returns a TS transformer that replaces eligible JSX usage sites with direct element creation. */
+function createStaticCompositionTransformer(factory, components, onInlined) {
+	return (context) => {
+		function visit(node) {
+			const isSelfClose = ts.isJsxSelfClosingElement(node);
+			const isOpen = ts.isJsxElement(node);
+			if (!isSelfClose && !isOpen) return ts.visitEachChild(node, visit, context);
+			const tagNode = isOpen ? node.openingElement.tagName : node.tagName;
+			if (!ts.isIdentifier(tagNode)) return ts.visitEachChild(node, visit, context);
+			const info = components.get(tagNode.text);
+			if (!info) return ts.visitEachChild(node, visit, context);
+			const attrList = isOpen ? node.openingElement.attributes.properties : node.attributes.properties;
+			if (attrList.some(ts.isJsxSpreadAttribute)) return ts.visitEachChild(node, visit, context);
+			if (readAttrValue(attrList, "asChild").kind !== "absent") return ts.visitEachChild(node, visit, context);
+			if (readAttrValue(attrList, "render").kind !== "absent") return ts.visitEachChild(node, visit, context);
+			const asVal = readAttrValue(attrList, "as");
+			if (asVal.kind === "dynamic") return ts.visitEachChild(node, visit, context);
+			const outputTag = asVal.kind === "string" ? asVal.value : info.defaultTag;
+			const variantProps = {};
+			for (const propName of info.variantKeys) {
+				const val = readAttrValue(attrList, propName);
+				if (val.kind === "absent") continue;
+				if (val.kind === "string") {
+					variantProps[propName] = val.value;
+					continue;
+				}
+				return ts.visitEachChild(node, visit, context);
+			}
+			const cacheKey = buildCacheKey(variantProps);
+			const baseClass = info.precomputedClasses[cacheKey];
+			if (baseClass === void 0) return ts.visitEachChild(node, visit, context);
+			const clsVal = readAttrValue(attrList, "className");
+			if (clsVal.kind === "dynamic") return ts.visitEachChild(node, visit, context);
+			const finalClass = clsVal.kind === "string" && clsVal.value ? `${baseClass} ${clsVal.value}` : baseClass;
+			const strip = /* @__PURE__ */ new Set([
+				...info.variantKeys,
+				"as",
+				"asChild",
+				"render",
+				"className"
+			]);
+			const outputAttrs = [factory.createJsxAttribute(factory.createIdentifier("className"), factory.createStringLiteral(finalClass))];
+			for (const attr of attrList) {
+				if (ts.isJsxSpreadAttribute(attr)) continue;
+				if (!ts.isJsxAttribute(attr)) continue;
+				const name = ts.isIdentifier(attr.name) ? attr.name.text : "";
+				if (strip.has(name)) continue;
+				outputAttrs.push(attr);
+			}
+			const newAttrs = factory.createJsxAttributes(outputAttrs);
+			const outputTagIdent = factory.createIdentifier(outputTag);
+			onInlined();
+			if (isSelfClose) return factory.createJsxSelfClosingElement(outputTagIdent, void 0, newAttrs);
+			const visitedChildren = node.children.map((c) => ts.visitNode(c, visit));
+			return factory.createJsxElement(factory.createJsxOpeningElement(outputTagIdent, void 0, newAttrs), visitedChildren, factory.createJsxClosingElement(outputTagIdent));
+		}
+		return (sourceFile) => ts.visitEachChild(sourceFile, visit, context);
+	};
+}
+/**
+* Applies the static composition transform to the given source file.
+*
+* `importedComponents` contains cross-file metadata resolved by the plugin
+* registry — components defined in other files that were already transformed.
+* When empty (dev mode ordering race or barrel re-export), same-file components
+* still inline normally; cross-file sites fall through to the runtime path.
+*
+* Returns null when:
+* - No eligible factory calls or imported components are present
+* - No eligible usage sites are found after analysis
+*/
+function composeStatically(source, calleeNames, importedComponents = /* @__PURE__ */ new Map()) {
+	const sameFile = extractStaticComponents(source, calleeNames);
+	const components = importedComponents.size > 0 ? new Map([...importedComponents, ...sameFile]) : sameFile;
+	if (components.size === 0) return null;
+	const componentNames = new Set(components.keys());
+	let hasEligibleTag = false;
+	walkEach(source, (n) => {
+		if (hasEligibleTag) return;
+		const tagNode = ts.isJsxElement(n) ? n.openingElement.tagName : ts.isJsxSelfClosingElement(n) ? n.tagName : void 0;
+		if (tagNode && ts.isIdentifier(tagNode) && componentNames.has(tagNode.text)) hasEligibleTag = true;
+	});
+	if (!hasEligibleTag) return null;
+	let didInline = false;
+	const transformResult = ts.transform(source, [createStaticCompositionTransformer(ts.factory, components, () => {
+		didInline = true;
+	})], {
+		jsx: ts.JsxEmit.Preserve,
+		target: ts.ScriptTarget.Latest
+	});
+	if (!didInline) {
+		transformResult.dispose();
+		return null;
+	}
+	const output = ts.createPrinter({
+		newLine: ts.NewLineKind.LineFeed,
+		removeComments: false
+	}).printFile(transformResult.transformed[0]);
+	transformResult.dispose();
+	return output;
+}
+//#endregion
+//#region ../../lib/tailwind/src/layout-keys.ts
+/**
+* Canonical list of reserved layout prop names.
+*
+* This array is the single source of truth for every supported CSS `display`
+* value exposed as a boolean prop. The `LayoutKey` type is derived directly
+* from this list.
+*
+* To add a new display mode:
+*   1. Add the display value here.
+*   2. Register its layout family in `LAYOUT_FAMILY_MAP`.
+*
+* Prop names intentionally match the corresponding Tailwind/CSS display
+* utilities, so no additional prop-to-class mapping is required.
+*/
+const layoutKeys = [
+	"flex",
+	"inline-flex",
+	"grid",
+	"inline-grid",
+	"block",
+	"inline-block",
+	"inline",
+	"hidden",
+	"contents",
+	"flow-root",
+	"list-item",
+	"table",
+	"inline-table",
+	"table-caption",
+	"table-cell",
+	"table-column",
+	"table-column-group",
+	"table-footer-group",
+	"table-header-group",
+	"table-row-group",
+	"table-row"
+];
+//#endregion
+//#region ../../plugins/vite/src/design-tokens.ts
+/**
+* Compile-time design token collection.
+*
+* Walks factory call ASTs and extracts every statically-declared class string
+* used in `styling.base`, `styling.variants`, `styling.compounds`, and
+* `styling.tags`. Collects them into a per-component manifest and writes a
+* JSON file on `writeBundle`.
+*
+* The primary use case is Tailwind's `safelist` — point the emitted file at
+* Tailwind's content so none of the variant classes are purged:
+*
+*   // tailwind.config.js
+*   export default { content: ['./src/**', './praxis-tokens.json'] }
+*
+* This is a Tailwind v3-style `content`-array mechanism: v4 does not scan
+* `tailwind.config.js` unless the app explicitly adds `@config` to its CSS,
+* which is not the standard v4 setup. On v4, display classes (flex, grid,
+* inline-block, etc.) are not covered by this manifest at all — those are
+* runtime-assembled and require importing `praxis-kit/tailwind.css` instead
+* (see lib/tailwind/src/tailwind-safelist.css).
+*
+* The JSON schema is intentionally stable and human-readable:
+*
+*   {
+*     "components": {
+*       "Button": {
+*         "base": "btn",
+*         "variantClasses": ["btn-sm", "btn-md", "btn-lg"],
+*         "compoundClasses": ["btn-compact"],
+*         "tagClasses": ["link-style"]
+*       }
+*     },
+*     "allClasses": ["btn", "btn-sm", ...]
+*   }
+*/
+/** Recursively appends non-empty string literals from `node` into `out`. Handles string and array literals; ignores other shapes. */
+function collectStringValues(node, out) {
+	if (!node) return;
+	if (ts.isStringLiteral(node)) {
+		if (node.text.trim()) out.push(node.text);
+		return;
+	}
+	if (ts.isArrayLiteralExpression(node)) iterate.forEach(node.elements, (elem) => {
+		collectStringValues(elem, out);
+	});
+}
+/** Extracts all statically-declared class strings from a `styling` object's `base`, `variants`, `compounds`, and `tags` fields. */
+function extractStylingTokens(stylingObj) {
+	const base = [];
+	const variantClasses = [];
+	const compoundClasses = [];
+	const tagClasses = [];
+	collectStringValues(getProperty(stylingObj, "base"), base);
+	const variantsObj = asObject(getProperty(stylingObj, "variants"));
+	if (variantsObj) iterate.forEach(variantsObj.properties, (dimProp) => {
+		if (!ts.isPropertyAssignment(dimProp)) return;
+		const valuesObj = asObject(dimProp.initializer);
+		if (!valuesObj) return;
+		iterate.forEach(valuesObj.properties, (vp) => {
+			if (!ts.isPropertyAssignment(vp)) return;
+			collectStringValues(vp.initializer, variantClasses);
+		});
+	});
+	const compoundsArr = asArray(getProperty(stylingObj, "compounds"));
+	if (compoundsArr) iterate.forEach(compoundsArr.elements, (elem) => {
+		const obj = asObject(elem);
+		if (!obj) return;
+		collectStringValues(getProperty(obj, "class"), compoundClasses);
+	});
+	const tagsObj = asObject(getProperty(stylingObj, "tags"));
+	if (tagsObj) iterate.forEach(tagsObj.properties, (tp) => {
+		if (!ts.isPropertyAssignment(tp)) return;
+		collectStringValues(tp.initializer, tagClasses);
+	});
+	return {
+		base,
+		variantClasses,
+		compoundClasses,
+		tagClasses
+	};
+}
+/**
+* Collects design tokens from all factory calls in a single source file.
+* Each entry in the returned map is keyed by the component variable name.
+*
+* Only `const X = factory(...)` declarations are handled; exported or
+* destructured patterns fall through (same scope as `collectConstraints`).
+*/
+function collectFileTokens(source, calleeNames) {
+	const result = /* @__PURE__ */ new Map();
+	ts.forEachChild(source, (stmt) => {
+		if (!ts.isVariableStatement(stmt)) return;
+		iterate.forEach(stmt.declarationList.declarations, (decl) => {
+			const { initializer, name } = decl;
+			if (!initializer || !ts.isCallExpression(initializer)) return;
+			if (!isFactoryCall(initializer, calleeNames)) return;
+			const arg = firstObjectArg(initializer);
+			if (!arg) return;
+			const stylingObj = asObject(getProperty(arg, "styling"));
+			if (!stylingObj) return;
+			const definedName = ts.isIdentifier(name) ? name.text : void 0;
+			if (!definedName) return;
+			result.set(definedName, extractStylingTokens(stylingObj));
+		});
+	});
+	return result;
+}
+/** Merges two ComponentTokens with deduplication per class list. Returns `incoming` when `existing` is undefined. */
+function mergeTokens(existing, incoming) {
+	if (!existing) return incoming;
+	return {
+		base: [.../* @__PURE__ */ new Set([...existing.base, ...incoming.base])],
+		variantClasses: [.../* @__PURE__ */ new Set([...existing.variantClasses, ...incoming.variantClasses])],
+		compoundClasses: [.../* @__PURE__ */ new Set([...existing.compoundClasses, ...incoming.compoundClasses])],
+		tagClasses: [.../* @__PURE__ */ new Set([...existing.tagClasses, ...incoming.tagClasses])]
+	};
+}
+/**
+* Builds a DesignTokenManifest from the accumulated per-component token maps,
+* including a flat sorted `allClasses` union.
+*
+* `allClasses` always includes every `layoutKeys` display value (`flex`,
+* `inline-flex`, `grid`, `hidden`, etc.) even when no scanned component uses
+* them literally. Those classes are only ever assembled at runtime by
+* `createTailwindPipeline` from boolean props, so they never appear as a
+* string literal for Tailwind's content scanner (or this manifest) to find
+* on its own — without this, Tailwind silently drops their generated CSS.
+*/
+function buildManifest(allTokens) {
+	const components = {};
+	const seen = new Set(layoutKeys);
+	iterate.forEach(allTokens, ([name, tokens]) => {
+		components[name] = tokens;
+		iterate.forEach([
+			...tokens.base,
+			...tokens.variantClasses,
+			...tokens.compoundClasses,
+			...tokens.tagClasses
+		], (cls) => {
+			iterate.forEach(cls.split(/\s+/), (part) => {
+				if (part) seen.add(part);
+			});
+		});
+	});
+	return {
+		components,
+		allClasses: [...seen].sort()
+	};
+}
+/**
+* Vite plugin that collects every statically-declared class string from
+* `createContractComponent` factory calls and writes a design token manifest
+* to a JSON file on each build.
+*
+* The manifest contains per-component class lists and a flat `allClasses`
+* union that can be used as a Tailwind content source to prevent purging of
+* variant classes.
+*
+* @example
+* // vite.config.ts
+* import { designTokensPlugin } from 'praxis-kit/vite-plugin'
+* export default { plugins: [designTokensPlugin({ outFile: 'praxis-tokens.json' })] }
+*
+* @example
+* // tailwind.config.js
+* export default { content: ['./src/**', './praxis-tokens.json'] }
+*/
+function designTokensPlugin(options) {
+	const calleeNames = new Set(options?.calleeNames ?? DEFAULT_CALLEE_NAMES);
+	const outFile = options?.outFile ?? "praxis-tokens.json";
+	const accumulated = /* @__PURE__ */ new Map();
+	let root = process.cwd();
+	return {
+		name: "praxis-kit:design-tokens",
+		configResolved(config) {
+			root = config.root;
+		},
+		buildStart() {
+			accumulated.clear();
+		},
+		transform(code, id) {
+			const ext = id.split(".").pop() ?? "";
+			if (!ALL_EXTS.has(ext)) return null;
+			const source = parseSource(id, code);
+			iterate.forEach(collectFileTokens(source, calleeNames), ([name, tokens]) => {
+				accumulated.set(name, mergeTokens(accumulated.get(name), tokens));
+			});
+			return null;
+		},
+		writeBundle() {
+			if (accumulated.size === 0) return;
+			const manifest = buildManifest(accumulated);
+			writeFileSync(resolve(root, outFile), JSON.stringify(manifest, null, 2));
+		}
+	};
+}
+//#endregion
+//#region ../../plugins/vite/src/index.ts
+/**
+* Vite plugin that performs static enforcement.children cardinality checks at
+* build time for components created with createContractComponent.
+*
+* **Single-file scope:** Components defined and used in the same `.tsx` / `.jsx`
+* file are validated during `transform`. JSX children containing expressions
+* (`{...}`) are skipped — their count is unknowable at compile time.
+*
+* **Cross-file scope:** Components imported from other files are validated in
+* `buildEnd` once the full constraint registry is populated. Only named imports
+* whose source file was also transformed by this plugin are checked.
+*
+* @example
+* // vite.config.ts
+* import { contractPlugin } from 'praxis-kit/vite-plugin'
+* export default { plugins: [contractPlugin()] }
+*/
+function contractPlugin(options) {
+	const registry = new ConstraintRegistry();
+	const calleeNames = new Set(options?.calleeNames ?? DEFAULT_CALLEE_NAMES);
+	const severity = options?.severity ?? "warning";
+	return {
+		name: "praxis-kit:contract",
+		async transform(code, id) {
+			const ext = id.split(".").pop() ?? "";
+			if (!JSX_EXTS.has(ext)) return null;
+			const source = parseSource(id, code);
+			const { constraints, importSpecifiers } = collectFileDeclarations(source, calleeNames);
+			registry.registerConstraints(id, constraints);
+			const { diagnostics, usages: allUsages } = analyzeJsxSites(source, constraints, severity);
+			iterate.forEach(diagnostics, ({ col, diagnostic, line, severity }) => {
+				const loc = {
+					file: id,
+					line,
+					column: col
+				};
+				if (severity === "error") this.error({
+					message: diagnostic.message,
+					loc
+				});
+				else this.warn({
+					message: diagnostic.message,
+					loc
+				});
+			});
+			const localNames = new Set(constraints.map((c) => c.name));
+			const importedTagsInUse = new Set(allUsages.filter((u) => !localNames.has(u.tagName) && importSpecifiers.has(u.tagName)).map((u) => u.tagName));
+			if (importedTagsInUse.size > 0) {
+				const resolvedImports = /* @__PURE__ */ new Map();
+				for (const [localName, { specifier }] of importSpecifiers) {
+					if (!importedTagsInUse.has(localName)) continue;
+					const resolved = await this.resolve(specifier, id);
+					if (resolved) resolvedImports.set(localName, resolved.id);
+				}
+				registry.registerImports(id, resolvedImports);
+				iterate.forEach(allUsages, (usage) => {
+					if (importedTagsInUse.has(usage.tagName)) registry.addPendingUsage(id, usage);
+				});
+			}
+		},
+		buildEnd() {
+			iterate.forEach(registry.diagnostics(severity), ({ col, diagnostic, fileId, line, severity }) => {
+				const loc = {
+					file: fileId,
+					line,
+					column: col
+				};
+				if (severity === "error") this.error({
+					message: diagnostic.message,
+					loc
+				});
+				else this.warn({
+					message: diagnostic.message,
+					loc
+				});
+			});
+		}
+	};
+}
+/**
+* Vite plugin that removes dead `styling.compounds` entries from factory calls
+* at build time, reducing bundle size and eliminating unreachable CVA compound
+* checks at runtime.
+*
+* A compound entry is dead when any of its conditions reference a variant key
+* that does not exist in `styling.variants`, or a value that is not valid for
+* that key. Only entries whose conditions are fully static (string/array
+* literals) are pruned — dynamic conditions are left unchanged.
+*
+* Place before `contractPlugin` so the pruned source is what gets analyzed.
+*
+* @example
+* // vite.config.ts
+* import { compoundPrunePlugin, contractPlugin } from 'praxis-kit/vite-plugin'
+* export default { plugins: [compoundPrunePlugin(), contractPlugin()] }
+*/
+function compoundPrunePlugin(options) {
+	const calleeNames = new Set(options?.calleeNames ?? DEFAULT_CALLEE_NAMES);
+	return {
+		name: "praxis-kit:compound-prune",
+		transform(code, id) {
+			const ext = id.split(".").pop() ?? "";
+			if (!ALL_EXTS.has(ext)) return null;
+			const result = pruneDeadCompounds(parseSource(id, code), calleeNames);
+			return result !== null ? { code: result } : null;
+		}
+	};
+}
+/**
+* Vite plugin that pre-computes variant class strings at build time and injects
+* them as a static `precomputedClasses` map into each factory call's `styling`
+* object.
+*
+* At runtime, `VariantClassResolver` checks this map before calling CVA — a
+* plain object lookup replaces a CVA invocation + LRU cache write for every
+* statically-known combination. Only combinations that appear in the map are
+* accelerated; invalid or dynamic variant values fall through to the existing
+* compute path unchanged.
+*
+* Injection is skipped when:
+* - `styling.variants` is absent or contains non-literal values
+* - `styling.compounds` contains non-literal conditions or classes
+* - The number of valid combinations exceeds 512
+*
+* Place after `compoundPrunePlugin` so the injected map reflects the live
+* compound set.
+*
+* @example
+* // vite.config.ts
+* import { compoundPrunePlugin, classExtractPlugin, contractPlugin } from 'praxis-kit/vite-plugin'
+* export default { plugins: [compoundPrunePlugin(), classExtractPlugin(), contractPlugin()] }
+*/
+function classExtractPlugin(options) {
+	const calleeNames = new Set(options?.calleeNames ?? DEFAULT_CALLEE_NAMES);
+	return {
+		name: "praxis-kit:class-extract",
+		transform(code, id) {
+			const ext = id.split(".").pop() ?? "";
+			if (!ALL_EXTS.has(ext)) return null;
+			const result = injectPrecomputedClasses(parseSource(id, code), calleeNames);
+			return result !== null ? { code: result } : null;
+		}
+	};
+}
+/**
+* Vite plugin that transforms `asChild` JSX usage sites to the render-prop form
+* at build time, eliminating the Slot/cloneElement/mergeProps runtime path.
+*
+* Only transforms sites where the transform is semantically safe:
+* - Exactly one static child element
+* - Child has no `className`, `style`, or event handler props
+*
+* Complex asChild patterns (conflicting props, dynamic children, Slottable
+* siblings) are left unchanged and handled by the runtime Slot path.
+*
+* Place before `contractPlugin` so cardinality analysis sees the transformed
+* source.
+*
+* @example
+* // vite.config.ts
+* import { slotTransformPlugin, contractPlugin } from 'praxis-kit/vite-plugin'
+* export default { plugins: [slotTransformPlugin(), contractPlugin()] }
+*/
+function slotTransformPlugin() {
+	return {
+		name: "praxis-kit:slot-transform",
+		transform(code, id) {
+			const ext = id.split(".").pop() ?? "";
+			if (!JSX_EXTS.has(ext)) return null;
+			const result = transformAsChild(parseSource(id, code));
+			return result !== null ? { code: result } : null;
+		}
+	};
+}
+/**
+* Vite plugin that replaces polymorphic component usage sites with direct
+* element creation at build time, eliminating the runtime render pipeline for
+* statically-analyzable usages.
+*
+* **Requires classExtractPlugin to run first** so that `precomputedClasses` is
+* present in the factory call before this plugin reads it. Place after
+* `classExtractPlugin` in the plugins array.
+*
+* A usage site is inlined when:
+* - The component is defined in the same file or imported from a file already
+*   transformed by this plugin, with `precomputedClasses` injected
+* - No `as`, `asChild`, `render`, or spread attributes at the site
+* - All variant props are static string literals
+* - `className` is absent or a static string literal
+* - The factory config has no `defaults` or `enforcement`
+*
+* Cross-file inlining degrades gracefully when the definition file has not yet
+* been transformed (dev mode ordering, barrel re-exports, aliased imports).
+*
+* @example
+* // vite.config.ts
+* import { classExtractPlugin, staticCompositionPlugin } from 'praxis-kit/vite-plugin'
+* export default { plugins: [classExtractPlugin(), staticCompositionPlugin()] }
+*/
+function staticCompositionPlugin(options) {
+	const calleeNames = new Set(options?.calleeNames ?? DEFAULT_CALLEE_NAMES);
+	const registry = /* @__PURE__ */ new Map();
+	return {
+		name: "praxis-kit:static-compose",
+		buildStart() {
+			registry.clear();
+		},
+		async transform(code, id) {
+			const ext = id.split(".").pop() ?? "";
+			if (!JSX_EXTS.has(ext)) return null;
+			const source = parseSource(id, code);
+			const sameFile = extractStaticComponents(source, calleeNames);
+			if (sameFile.size > 0) registry.set(id, sameFile);
+			const importedComponents = /* @__PURE__ */ new Map();
+			const importSpecifiers = extractImportSpecifiers(source);
+			for (const [localName, { importedName, specifier }] of importSpecifiers) {
+				const resolved = await this.resolve(specifier, id);
+				if (!resolved) continue;
+				const entry = registry.get(resolved.id);
+				if (!entry) continue;
+				const component = entry.get(importedName);
+				if (component) importedComponents.set(localName, component);
+			}
+			const result = composeStatically(source, calleeNames, importedComponents);
+			return result !== null ? { code: result } : null;
+		}
+	};
+}
+/**
+* Convenience plugin bundle that applies all three build-time rendering
+* optimisations in the correct dependency order:
+*
+*   1. `slotTransformPlugin`       — rewrites `asChild` → render-prop form,
+*                                    eliminating `cloneElement` for static sites
+*   2. `classExtractPlugin`        — injects `precomputedClasses` into factory
+*                                    calls for O(1) variant class resolution
+*   3. `staticCompositionPlugin`   — inlines same-file static usages into direct
+*                                    element creation, bypassing the runtime
+*                                    pipeline entirely
+*
+* Place before `contractPlugin` so cardinality analysis sees the transformed
+* source. Especially effective for SSR builds where each component renders
+* exactly once per request and eliminates per-render pipeline overhead.
+*
+* @example
+* // vite.config.ts
+* import { ssrOptimizePlugin, contractPlugin } from 'praxis-kit/vite-plugin'
+* export default { plugins: [ssrOptimizePlugin(), contractPlugin()] }
+*/
+function ssrOptimizePlugin(options) {
+	return [
+		slotTransformPlugin(),
+		classExtractPlugin(options),
+		staticCompositionPlugin(options)
+	];
+}
+//#endregion
+export { classExtractPlugin, compoundPrunePlugin, contractPlugin, designTokensPlugin, slotTransformPlugin, ssrOptimizePlugin, staticCompositionPlugin };