@codefast/cli 0.3.12 → 0.3.13-canary.0

package/dist/collectors-cn-BS8TTQ8O.mjs

@@ -0,0 +1,61 @@
+import "./constants-AtPhF-Ct.mjs";
+import ts from "typescript";
+//#region src/lib/arrange/domain/ast/collectors-cn.ts
+function forEachStringLiteralInClassExpression(expr, sink, depth = 0, options) {
+	if (depth > 12) return;
+	if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
+		sink(expr);
+		return;
+	}
+	if (ts.isParenthesizedExpression(expr)) {
+		forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) {
+		forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isNonNullExpression(expr)) {
+		forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isConditionalExpression(expr)) {
+		if (options?.descendIntoConditional === false) return;
+		forEachStringLiteralInClassExpression(expr.whenTrue, sink, depth + 1, options);
+		forEachStringLiteralInClassExpression(expr.whenFalse, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+		forEachStringLiteralInClassExpression(expr.left, sink, depth + 1, options);
+		forEachStringLiteralInClassExpression(expr.right, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isArrayLiteralExpression(expr)) for (const arrayElement of expr.elements) {
+		if (ts.isSpreadElement(arrayElement)) continue;
+		forEachStringLiteralInClassExpression(arrayElement, sink, depth + 1, options);
+	}
+}
+function isUnsafeLiteralForCnStyleApplySplit(classLiteral) {
+	return ts.isArrayLiteralExpression(classLiteral.parent);
+}
+const CN_APPLY_LITERAL_WALK_OPTS = { descendIntoConditional: false };
+function collectUnconditionalTailwindLiteralsFromCnArguments(args) {
+	const staticLits = [];
+	for (const arg of args) if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+		if (!isUnsafeLiteralForCnStyleApplySplit(arg)) staticLits.push(arg);
+	} else forEachStringLiteralInClassExpression(arg, (lit) => {
+		if (!isUnsafeLiteralForCnStyleApplySplit(lit)) staticLits.push(lit);
+	}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+	return staticLits;
+}
+function mergeCnUnconditionalLiteralPoolForTest(argsSnippet, options) {
+	const callee = options?.callee ?? "cn";
+	const sourceText = `${callee}(${argsSnippet});`;
+	const stmt = ts.createSourceFile("mergeCnUnconditionalLiteralPoolForTest.ts", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).statements[0];
+	if (!ts.isExpressionStatement(stmt)) throw new Error("expected expression statement");
+	const call = stmt.expression;
+	if (!ts.isCallExpression(call) || !ts.isIdentifier(call.expression) || call.expression.text !== callee) throw new Error(`expected ${callee}(...) call`);
+	return collectUnconditionalTailwindLiteralsFromCnArguments(call.arguments).map((literal) => literal.text).join(" ");
+}
+//#endregion
+export { mergeCnUnconditionalLiteralPoolForTest as a, isUnsafeLiteralForCnStyleApplySplit as i, collectUnconditionalTailwindLiteralsFromCnArguments as n, forEachStringLiteralInClassExpression as r, CN_APPLY_LITERAL_WALK_OPTS as t };

package/dist/collectors-jsx-D9tL2ZPM.mjs

@@ -0,0 +1,20 @@
+import ts from "typescript";
+//#region src/lib/arrange/domain/ast/collectors-jsx.ts
+function jsxClassNameStaticLiteral(jsxClassNameAttribute) {
+	if (!ts.isIdentifier(jsxClassNameAttribute.name) || jsxClassNameAttribute.name.text !== "className") return void 0;
+	const init = jsxClassNameAttribute.initializer;
+	if (!init) return void 0;
+	if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) return {
+		lit: init,
+		valueNode: init
+	};
+	if (ts.isJsxExpression(init) && init.expression) {
+		const jsxExpressionBody = init.expression;
+		if (ts.isStringLiteral(jsxExpressionBody) || ts.isNoSubstitutionTemplateLiteral(jsxExpressionBody)) return {
+			lit: jsxExpressionBody,
+			valueNode: init
+		};
+	}
+}
+//#endregion
+export { jsxClassNameStaticLiteral as t };

package/dist/collectors-tv-D2PXZaRt.mjs

@@ -0,0 +1,170 @@
+import "./constants-AtPhF-Ct.mjs";
+import { d as tokenizeClassString } from "./tokenizer-CeZx73Zu.mjs";
+import { i as isUnsafeLiteralForCnStyleApplySplit, n as collectUnconditionalTailwindLiteralsFromCnArguments, r as forEachStringLiteralInClassExpression, t as CN_APPLY_LITERAL_WALK_OPTS } from "./collectors-cn-BS8TTQ8O.mjs";
+import { a as isCnOrTvIdentifier, c as propertyAssignmentNameText, r as buildKnownCnTvBindings } from "./ast-helpers-MDRYuIAk.mjs";
+import ts from "typescript";
+//#region src/lib/arrange/domain/ast/collectors-tv.ts
+function traverseTvObject(sf, obj, visitor, depth = 0, knownBindings) {
+	if (depth > 12) return;
+	for (const prop of obj.properties) {
+		if (!ts.isPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) visitor(init, sf, void 0);
+		else if (ts.isArrayLiteralExpression(init)) for (const arrayElement of init.elements) {
+			if (ts.isSpreadElement(arrayElement)) continue;
+			if (ts.isStringLiteral(arrayElement) || ts.isNoSubstitutionTemplateLiteral(arrayElement)) visitor(arrayElement, sf, void 0);
+			else if (ts.isCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) for (const arg of arrayElement.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+				visitor(lit, sf, arrayElement);
+			});
+			else if (ts.isObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+				if (!ts.isPropertyAssignment(objectProperty)) continue;
+				const propName = propertyAssignmentNameText(objectProperty);
+				if (propName !== "className" && propName !== "class") continue;
+				const innerInit = objectProperty.initializer;
+				if (ts.isStringLiteral(innerInit) || ts.isNoSubstitutionTemplateLiteral(innerInit)) visitor(innerInit, sf, void 0);
+				else if (ts.isArrayLiteralExpression(innerInit)) for (const nestedArrayElement of innerInit.elements) {
+					if (ts.isSpreadElement(nestedArrayElement)) continue;
+					if (ts.isStringLiteral(nestedArrayElement) || ts.isNoSubstitutionTemplateLiteral(nestedArrayElement)) visitor(nestedArrayElement, sf, void 0);
+				}
+				else if (ts.isCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) for (const arg of innerInit.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+					visitor(lit, sf, innerInit);
+				});
+			}
+		}
+		else if (ts.isObjectLiteralExpression(init)) traverseTvObject(sf, init, visitor, depth + 1, knownBindings);
+		else if (ts.isCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) for (const arg of init.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+			visitor(lit, sf, init);
+		});
+	}
+}
+function collectCnCallsInsideTv(sf, obj, knownBindings, depth = 0) {
+	if (depth > 12) return [];
+	const calls = [];
+	for (const prop of obj.properties) {
+		if (!ts.isPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (ts.isArrayLiteralExpression(init)) for (const arrayElement of init.elements) {
+			if (ts.isSpreadElement(arrayElement)) continue;
+			if (ts.isCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) calls.push(arrayElement);
+			else if (ts.isObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+				if (!ts.isPropertyAssignment(objectProperty)) continue;
+				const propName = propertyAssignmentNameText(objectProperty);
+				if (propName !== "className" && propName !== "class") continue;
+				const innerInit = objectProperty.initializer;
+				if (ts.isCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) calls.push(innerInit);
+			}
+		}
+		else if (ts.isObjectLiteralExpression(init)) calls.push(...collectCnCallsInsideTv(sf, init, knownBindings, depth + 1));
+		else if (ts.isCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) calls.push(init);
+	}
+	return calls;
+}
+function listAllCnCallsInsideTvInSourceFile(sf, knownBindings) {
+	const calls = [];
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (ts.isCallExpression(tsNode) && isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+			const arg0 = tsNode.arguments[0];
+			if (arg0 && ts.isObjectLiteralExpression(arg0)) calls.push(...collectCnCallsInsideTv(sf, arg0, knownBindings, 0));
+		}
+		ts.forEachChild(tsNode, visitTypeScriptSubtree);
+	};
+	visitTypeScriptSubtree(sf);
+	return calls;
+}
+function makeStringNode(nodes, sf, isTvContext, cnCall) {
+	return {
+		nodes,
+		sf,
+		isTvContext,
+		cnCall,
+		get primaryClassLiteral() {
+			return this.nodes[0];
+		}
+	};
+}
+function slotClassString(stringNode) {
+	return stringNode.nodes.map((literal) => literal.text).join(" ");
+}
+function emitTvSlot(lits, sf, cnCall, results, seenNodePos) {
+	if (lits.length === 0) return;
+	const firstPos = lits[0].getStart(sf);
+	if (seenNodePos.has(firstPos)) return;
+	seenNodePos.add(firstPos);
+	if (lits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0) < 2) return;
+	results.push(makeStringNode(lits, sf, true, cnCall));
+}
+function collectTvSlots(sf, obj, knownBindings, results, seenNodePos, depth = 0) {
+	if (depth > 12) return;
+	for (const prop of obj.properties) {
+		if (!ts.isPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) emitTvSlot([init], sf, void 0, results, seenNodePos);
+		else if (ts.isArrayLiteralExpression(init)) {
+			const arrayPos = init.getStart(sf);
+			if (seenNodePos.has(arrayPos)) continue;
+			seenNodePos.add(arrayPos);
+			const staticLits = [];
+			for (const arrayElement of init.elements) {
+				if (ts.isSpreadElement(arrayElement)) continue;
+				if (ts.isStringLiteral(arrayElement) || ts.isNoSubstitutionTemplateLiteral(arrayElement)) staticLits.push(arrayElement);
+				else if (ts.isCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) for (const arg of arrayElement.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+					if (!isUnsafeLiteralForCnStyleApplySplit(lit)) staticLits.push(lit);
+				}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+				else if (ts.isObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+					if (!ts.isPropertyAssignment(objectProperty)) continue;
+					const propName = propertyAssignmentNameText(objectProperty);
+					if (propName !== "className" && propName !== "class") continue;
+					const innerInit = objectProperty.initializer;
+					if (ts.isStringLiteral(innerInit) || ts.isNoSubstitutionTemplateLiteral(innerInit)) emitTvSlot([innerInit], sf, void 0, results, seenNodePos);
+					else if (ts.isArrayLiteralExpression(innerInit)) {
+						const innerLits = [];
+						for (const nestedArrayElement of innerInit.elements) if (!ts.isSpreadElement(nestedArrayElement) && (ts.isStringLiteral(nestedArrayElement) || ts.isNoSubstitutionTemplateLiteral(nestedArrayElement))) innerLits.push(nestedArrayElement);
+						emitTvSlot(innerLits, sf, void 0, results, seenNodePos);
+					} else if (ts.isCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) {
+						const cnLits = [];
+						for (const arg of innerInit.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+							if (!isUnsafeLiteralForCnStyleApplySplit(lit)) cnLits.push(lit);
+						}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+						emitTvSlot(cnLits, sf, innerInit, results, seenNodePos);
+					}
+				}
+			}
+			if (staticLits.length > 0) emitTvSlot(staticLits, sf, void 0, results, seenNodePos);
+		} else if (ts.isObjectLiteralExpression(init)) collectTvSlots(sf, init, knownBindings, results, seenNodePos, depth + 1);
+		else if (ts.isCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) {
+			const cnLits = [];
+			for (const arg of init.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+				if (!isUnsafeLiteralForCnStyleApplySplit(lit)) cnLits.push(lit);
+			}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+			emitTvSlot(cnLits, sf, init, results, seenNodePos);
+		}
+	}
+}
+function collectGroupableStringNodes(sf) {
+	const results = [];
+	const seenNodePos = /* @__PURE__ */ new Set();
+	const knownBindings = buildKnownCnTvBindings(sf);
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (ts.isCallExpression(tsNode)) {
+			if (isCnOrTvIdentifier(tsNode.expression, "cn", knownBindings)) {
+				const callPos = tsNode.getStart(sf);
+				if (seenNodePos.has(callPos)) {
+					ts.forEachChild(tsNode, visitTypeScriptSubtree);
+					return;
+				}
+				seenNodePos.add(callPos);
+				const staticLits = collectUnconditionalTailwindLiteralsFromCnArguments(tsNode.arguments);
+				const totalTokens = staticLits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0);
+				if (staticLits.length > 0 && totalTokens >= 2) results.push(makeStringNode(staticLits, sf, false, tsNode));
+			} else if (isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+				const arg0 = tsNode.arguments[0];
+				if (arg0 && ts.isObjectLiteralExpression(arg0)) collectTvSlots(sf, arg0, knownBindings, results, seenNodePos);
+			}
+		}
+		ts.forEachChild(tsNode, visitTypeScriptSubtree);
+	};
+	visitTypeScriptSubtree(sf);
+	return results;
+}
+//#endregion
+export { listAllCnCallsInsideTvInSourceFile as a, traverseTvObject as c, emitTvSlot as i, collectGroupableStringNodes as n, makeStringNode as o, collectTvSlots as r, slotClassString as s, collectCnCallsInsideTv as t };

package/dist/colors-BjdkCfGK.mjs

@@ -0,0 +1,12 @@
+//#region src/lib/tag/presentation/colors.ts
+const TAG_COLORS = {
+	RESET: "\x1B[0m",
+	RED: "\x1B[31m",
+	GREEN: "\x1B[32m",
+	YELLOW: "\x1B[33m"
+};
+function withTagColor(line, colorCode) {
+	return `${colorCode}${line}${TAG_COLORS.RESET}`;
+}
+//#endregion
+export { withTagColor as n, TAG_COLORS as t };

package/dist/commands/arrange.mjs

@@ -0,0 +1,2 @@
+import { t as registerArrangeCommand } from "../arrange-Bbh62DrU.mjs";
+export { registerArrangeCommand };

package/dist/commands/mirror.mjs

@@ -0,0 +1,2 @@
+import { n as registerMirrorCommand, t as packageArgToRelative } from "../mirror-DqJE3ejL.mjs";
+export { packageArgToRelative, registerMirrorCommand };

package/dist/commands/mirror.test.mjs

@@ -0,0 +1,48 @@
+import { t as packageArgToRelative } from "../mirror-DqJE3ejL.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/commands/mirror.test.ts
+describe("packageArgToRelative", () => {
+	it("returns undefined when arg is undefined", () => {
+		expect(packageArgToRelative("/repo", void 0)).toBeUndefined();
+	});
+	it("returns a normalized path for a package under the repo root", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "mirror-pkg-"));
+		const pkgDir = path.join(root, "packages", "widget");
+		fs.mkdirSync(pkgDir, { recursive: true });
+		const prev = process.cwd();
+		try {
+			process.chdir(root);
+			expect(packageArgToRelative(root, "packages/widget")).toBe("packages/widget");
+			expect(packageArgToRelative(root, pkgDir)).toBe("packages/widget");
+		} finally {
+			process.chdir(prev);
+		}
+	});
+	it("rejects '.' and other paths that resolve to the repo root", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "mirror-root-dot-"));
+		fs.mkdirSync(path.join(root, "packages", "x"), { recursive: true });
+		const prev = process.cwd();
+		try {
+			process.chdir(root);
+			expect(() => packageArgToRelative(root, ".")).toThrow(/subdirectory under monorepo root/);
+			expect(() => packageArgToRelative(root, "./")).toThrow(/subdirectory under monorepo root/);
+		} finally {
+			process.chdir(prev);
+		}
+	});
+	it("rejects paths outside the monorepo root", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "mirror-out-"));
+		const outside = fs.mkdtempSync(path.join(os.tmpdir(), "mirror-outside-"));
+		const prev = process.cwd();
+		try {
+			process.chdir(root);
+			expect(() => packageArgToRelative(root, outside)).toThrow(/subdirectory under monorepo root/);
+		} finally {
+			process.chdir(prev);
+		}
+	});
+});
+//#endregion
+export {};

package/dist/commands/tag.mjs

@@ -0,0 +1,2 @@
+import { t as registerTagCommand } from "../tag-hEKVZ_-7.mjs";
+export { registerTagCommand };

package/dist/config-DVia_f9a.mjs

@@ -0,0 +1,3 @@
+import "./schema-Or8RAARd.mjs";
+import "./loader-DpN-zl5g.mjs";
+export {};

package/dist/config-reporter-SCcWDZc1.mjs

@@ -0,0 +1,10 @@
+//#region src/lib/infra/config-reporter.ts
+const YELLOW = "\x1B[33m";
+const RESET = "\x1B[0m";
+/** User-visible lines for non-fatal issues returned with a successfully parsed config. */
+function printConfigSchemaWarnings(logger, warnings) {
+	const { out } = logger;
+	for (const warningMessage of warnings) out(`${YELLOW}\u26A0\uFE0F ${warningMessage}${RESET}`);
+}
+//#endregion
+export { printConfigSchemaWarnings as t };

package/dist/constants-AtPhF-Ct.mjs

@@ -0,0 +1,169 @@
+//#region src/lib/arrange/domain/constants.ts
+/** Analyze report: long literal threshold (token count). */
+const LONG_STRING_TOKEN_THRESHOLD = 18;
+/**
+* Minimum token count for a string to be considered a candidate for grouping
+* in the apply/preview pipeline. Intentionally much lower than
+* {@link LONG_STRING_TOKEN_THRESHOLD} (analyze only).
+*/
+const APPLY_MIN_TOKENS = 2;
+/**
+* Minimum tokens a group must have to stand alone before singleton-merging.
+* Set to 2 so single-token groups are not collapsed into unrelated buckets by the merger.
+*/
+const MIN_GROUP_TOKENS = 2;
+/** Dynamic max groups clamp: base bound. */
+const MAX_GROUPS_BASE = 4;
+/** Dynamic max groups clamp: upper cap. */
+const MAX_GROUPS_CAP = 24;
+/**
+* Extra slots so a few state / aria groups do not force `capGroups` to merge
+* unrelated buckets (e.g. `bg-border` + `outline-hidden`).
+*/
+const MAX_GROUPS_HEADROOM = 2;
+/** Maximum findings printed per category in the analyze report. */
+const MAX_REPORT_LINES = 40;
+/** Maximum recursion depth when traversing `tv()` object literals. */
+const MAX_OBJECT_DEPTH = 12;
+/** Maximum depth when peeling conditional / parens / arrays inside `cn(...)` args. */
+const MAX_CLASS_EXPR_DEPTH = 12;
+/**
+* Maximum variant-stripping passes in {@link stripVariants}.
+* Real-world Tailwind stacks rarely exceed 4–5 segments (e.g. `@md/sidebar:group-hover:dark:focus-visible:`);
+* 12 is a conservative safety cap that prevents runaway loops on malformed input.
+*/
+const MAX_STRIP_VARIANT_PASSES = 12;
+/**
+* Passed when optional `knownBindings` is missing — size 0 disables matching
+* for `cn` / `tv` identifier resolution.
+*/
+const EMPTY_CN_TV_BINDINGS = /* @__PURE__ */ new Set();
+/**
+* Bucket sort order — **render pipeline** (lower → earlier in output).
+* Existence → Position → Layout → Sizing → Spacing → Shape → Background → Shadow
+* → Typography → Composite → Motion → Starting → Behavior → State (variants) → Selector variants.
+*/
+const BUCKET_ORDER = {
+	existence: 0,
+	position: 1,
+	layout: 2,
+	sizing: 3,
+	spacing: 4,
+	shape: 5,
+	background: 6,
+	shadow: 7,
+	typography: 8,
+	composite: 9,
+	motion: 10,
+	starting: 11,
+	behavior: 12,
+	state: 13,
+	selector: 14,
+	other: 15,
+	arbitrary: 16
+};
+/**
+* Compatible bucket **pairs** — two adjacent tokens whose buckets appear in the same
+* `Set` may stay in one `cn()` string chunk. Compatibility is **not transitive**: there is
+* no `{position, sizing}` pair, so `fixed inset-0` and `overflow-auto` become **separate**
+* literals unless **layout** tokens sit between them in sorted order; then
+* `position↔layout` and `layout↔sizing` each justify one hop and the whole “box in flow”
+* (place + tracks + scrollport) stays in one chunk — co-located because they jointly define
+* stacking and scroll behavior for the same surface.
+*/
+const COMPATIBLE_BUCKET_SETS = [
+	new Set(["existence", "position"]),
+	new Set(["existence", "layout"]),
+	new Set(["position", "layout"]),
+	new Set(["layout", "sizing"]),
+	new Set(["shape", "shadow"]),
+	new Set(["background", "shadow"]),
+	new Set(["background", "typography"]),
+	new Set(["layout", "typography"]),
+	new Set(["sizing", "typography"]),
+	new Set(["motion", "behavior"]),
+	new Set(["motion", "starting"]),
+	new Set(["composite", "motion"]),
+	new Set(["sizing", "composite"]),
+	new Set(["sizing", "spacing"])
+];
+/**
+* Responsive / variant prefix — Tailwind v4 aware.
+*
+* v3: sm: md: … — v4: @sm:, @min-[600px]:, @[480px]:, named @md/sidebar:,
+* viewport md/sidebar:, min-[100px]: / max-[100px]:, …
+*/
+const RESPONSIVE_PREFIX = /^(?:@(?:min|max)-\[[^\]]+\]:|@\[[^\]]+\]:|@(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/[a-z][a-z0-9-]*)?:|(?:max-|min-)?(?:sm|md|lg|xl|2xl|3xl)(?:\/[a-z][a-z0-9-]*)?:|(?:max-|min-)\[[^\]]+\]:)/;
+/** State variant stems — hoisted to module scope (not recreated per call). */
+const STATE_PREFIXES = new Set([
+	"hover",
+	"focus",
+	"focus-within",
+	"focus-visible",
+	"active",
+	"visited",
+	"link",
+	"any-link",
+	"disabled",
+	"enabled",
+	"checked",
+	"indeterminate",
+	"required",
+	"optional",
+	"valid",
+	"invalid",
+	"in-range",
+	"out-of-range",
+	"read-only",
+	"read-write",
+	"placeholder-shown",
+	"default",
+	"autofill",
+	"open",
+	"closed",
+	"first",
+	"last",
+	"only",
+	"odd",
+	"even",
+	"first-of-type",
+	"last-of-type",
+	"only-of-type",
+	"first-child",
+	"last-child",
+	"only-child",
+	"empty",
+	"target",
+	"group",
+	"peer",
+	"aria",
+	"data",
+	"dark",
+	"light",
+	"supports",
+	"motion-reduce",
+	"motion-safe",
+	"print",
+	"screen",
+	"ltr",
+	"rtl",
+	"not",
+	"has",
+	"in",
+	"nth",
+	"file",
+	"selection",
+	"marker",
+	"placeholder",
+	"before",
+	"after",
+	"first-line",
+	"first-letter",
+	"backdrop",
+	"details-content",
+	"popover-open"
+]);
+/** Default directory for arrange analyze/preview/apply when no target is passed. */
+const DEFAULT_ARRANGE_TARGET = "packages/ui/src/components";
+//#endregion
+export { EMPTY_CN_TV_BINDINGS as a, MAX_GROUPS_BASE as c, MAX_OBJECT_DEPTH as d, MAX_REPORT_LINES as f, STATE_PREFIXES as g, RESPONSIVE_PREFIX as h, DEFAULT_ARRANGE_TARGET as i, MAX_GROUPS_CAP as l, MIN_GROUP_TOKENS as m, BUCKET_ORDER as n, LONG_STRING_TOKEN_THRESHOLD as o, MAX_STRIP_VARIANT_PASSES as p, COMPATIBLE_BUCKET_SETS as r, MAX_CLASS_EXPR_DEPTH as s, APPLY_MIN_TOKENS as t, MAX_GROUPS_HEADROOM as u };

package/dist/constants-Bq5wdyLC.mjs

@@ -0,0 +1,8 @@
+//#region src/lib/mirror/domain/constants.ts
+const DIST_DIR = "dist";
+const PACKAGE_JSON = "package.json";
+const VALID_JS_EXTENSIONS = new Set([".js", ".cjs"]);
+const DTS_EXTENSION = ".d.ts";
+const PACKAGE_JSON_EXPORT = "./package.json";
+//#endregion
+export { VALID_JS_EXTENSIONS as a, PACKAGE_JSON_EXPORT as i, DTS_EXTENSION as n, PACKAGE_JSON as r, DIST_DIR as t };

package/dist/dirent-list-BSDeRG5i.mjs

@@ -0,0 +1,14 @@
+//#region src/lib/mirror/infra/dirent-list.ts
+/**
+* Narrow `fs.promises.readdir` overload result to `Dirent[]` when `withFileTypes: true`.
+* Accepts both historical checks (`isFile` / `isDirectory`) in one guard.
+* Returning `true` for an empty array is intentional: callers treat empty lists
+* the same regardless of the element type, so `[]` is safely accepted as `Dirent[]`.
+*/
+function isDirentList(x) {
+	if (x.length === 0) return true;
+	const first = x[0];
+	return typeof first === "object" && first !== null && "isFile" in first && "isDirectory" in first;
+}
+//#endregion
+export { isDirentList as t };