@codefast/cli 0.3.7-canary.0 → 0.3.12

package/dist/lib/arrange/formatters.js

@@ -0,0 +1,57 @@
+import { indentOfLineContaining } from "#lib/arrange/ast/utils";
+export function escapeTsStringLiteralContent(group) {
+    return group.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+/**
+ * Multiline fragment for use *inside* an existing `cn(...)` — replaces one
+ * string argument with several, without producing `cn(cn(...))`.
+ */
+export function formatCnArguments(groups, options) {
+    const indent = options?.indent ?? "  ";
+    const commaAfterLast = options?.commaAfterLastGroup ?? options?.trailingClassName ?? false;
+    const lines = [];
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        const comma = i < groups.length - 1 || commaAfterLast ? "," : "";
+        lines.push(`${indent}"${escapeTsStringLiteralContent(group)}"${comma}`);
+    }
+    if (options?.trailingClassName) {
+        lines.push(`${indent}className,`);
+    }
+    return lines.join("\n");
+}
+export function formatCnCall(groups, options) {
+    const lines = ["cn("];
+    const commaOnEachStringLine = groups.length > 1 || Boolean(options?.trailingClassName);
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        const comma = commaOnEachStringLine ? "," : "";
+        lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+    }
+    if (options?.trailingClassName) {
+        lines.push("  className,");
+    }
+    lines.push(")");
+    return lines.join("\n");
+}
+export function formatArray(groups) {
+    const lines = ["["];
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        // Trailing comma on every element when there are multiple entries — matches
+        // Prettier's default array formatting and keeps diffs minimal on insertion.
+        const comma = i < groups.length - 1 || groups.length > 1 ? "," : "";
+        lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+    }
+    lines.push("]");
+    return lines.join("\n");
+}
+export function formatJsxCnAttributeValue(groups, source, valueNodeStart) {
+    const baseIndent = indentOfLineContaining(source, valueNodeStart);
+    const argIndent = `${baseIndent}  `;
+    const inner = formatCnArguments(groups, {
+        indent: argIndent,
+        commaAfterLastGroup: groups.length > 1,
+    });
+    return `{cn(\n${inner}\n${baseIndent})}`;
+}

package/dist/lib/arrange/group-file.d.ts

@@ -0,0 +1,4 @@
+import type { CliFs, CliLogger } from "#lib/infra/fs-contract";
+import type { ArrangeGroupFileOptions, GroupFileResult } from "#lib/arrange/types";
+export declare function groupFile(filePath: string, options: ArrangeGroupFileOptions, fs: CliFs, logger: CliLogger): GroupFileResult;
+//# sourceMappingURL=group-file.d.ts.map

package/dist/lib/arrange/group-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-file.d.ts","sourceRoot":"","sources":["../../../src/lib/arrange/group-file.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EACV,uBAAuB,EACvB,eAAe,EAEhB,MAAM,oBAAoB,CAAC;AAiH5B,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,uBAAuB,EAChC,EAAE,EAAE,KAAK,EACT,MAAM,EAAE,SAAS,GAChB,eAAe,CA8FjB"}

package/dist/lib/arrange/group-file.js

@@ -0,0 +1,115 @@
+import ts from "typescript";
+import { applyEditsDescending, buildKnownCnTvBindings, lineOf, unwrapCnInsideTvCallReplacement, } from "#lib/arrange/ast/utils";
+import { listAllCnCallsInsideTvInSourceFile } from "#lib/arrange/ast/collectors-tv";
+import { collectGroupTargets, planGroupEditForTarget, targetReplaceStart, } from "#lib/arrange/ast/targets";
+import { ensureCnImport } from "#lib/arrange/imports";
+function printGroupFilePreview(logger, args) {
+    const { out } = logger;
+    const { filePath, reportTotal, cnInTvNoReplacement, cnInTvCalls, unwrapReplacementByCall, sourceText, sf, unwrapEdits, plannedGroupEdits, } = args;
+    let header = `\n── ${filePath} (${reportTotal} site(s)`;
+    if (cnInTvNoReplacement > 0) {
+        header += `; plus ${cnInTvNoReplacement} cn() inside tv left unchanged (0 args)`;
+    }
+    header += `) ──`;
+    out(header);
+    for (const call of cnInTvCalls) {
+        const replacement = unwrapReplacementByCall.get(call);
+        if (replacement === undefined) {
+            out(`  Line ${lineOf(sf, call)} [tv ⊃ cn]: cn(...) has no arguments — skipped`);
+            continue;
+        }
+        const start = call.getStart(sf);
+        const end = call.getEnd();
+        if (sourceText.slice(start, end) === replacement)
+            continue;
+        out(`  Line ${lineOf(sf, call)} [tv ⊃ cn → string/array]:`);
+        out(`  ${replacement.split("\n").join("\n  ")}`);
+    }
+    if (unwrapEdits.length > 0 && plannedGroupEdits.length > 0) {
+        out("  ([cn] / [tv] / [JSX className] lines below reflect content after unwrap of cn inside tv.)");
+    }
+    for (const plan of plannedGroupEdits) {
+        out(`  Line ${lineOf(plan.lineSf, plan.reportNode)} [${plan.label}]:`);
+        out(`  ${plan.replacement.split("\n").join("\n  ")}`);
+        out(`  // Buckets: ${JSON.stringify(plan.bucketSummary)}`);
+    }
+}
+function applyGroupFileWrites(filePath, options, fs, logger, unwrapEdits, textAfterUnwrap, plannedGroupEdits, cnInTvNoReplacement) {
+    const groupEdits = plannedGroupEdits.map((p) => ({
+        start: p.start,
+        end: p.end,
+        replacement: p.replacement,
+        jsxCn: p.jsxCn,
+    }));
+    const touchedJsxCn = groupEdits.some((e) => e.jsxCn);
+    let newText = groupEdits.length > 0 ? applyEditsDescending(textAfterUnwrap, groupEdits) : textAfterUnwrap;
+    const changed = unwrapEdits.length + groupEdits.length;
+    if (changed > 0) {
+        if (touchedJsxCn) {
+            newText = ensureCnImport(newText, filePath, options.cnImport);
+        }
+        fs.writeFileSync(filePath, newText, "utf8");
+    }
+    return { filePath, totalFound: changed + cnInTvNoReplacement, changed };
+}
+export function groupFile(filePath, options, fs, logger) {
+    const sourceText = fs.readFileSync(filePath, "utf8");
+    const sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    const knownBindings = buildKnownCnTvBindings(sf);
+    const cnInTvCalls = listAllCnCallsInsideTvInSourceFile(sf, knownBindings);
+    const unwrapPlans = cnInTvCalls
+        .map((call) => {
+        const replacement = unwrapCnInsideTvCallReplacement(call, sourceText, sf);
+        if (replacement === undefined)
+            return undefined;
+        return { start: call.getStart(sf), end: call.getEnd(), replacement, call };
+    })
+        .filter((e) => e !== undefined);
+    const unwrapReplacementByCall = new Map(unwrapPlans.map((p) => [p.call, p.replacement]));
+    const unwrapEdits = unwrapPlans.filter((e) => sourceText.slice(e.start, e.end) !== e.replacement);
+    const textAfterUnwrap = unwrapEdits.length > 0 ? applyEditsDescending(sourceText, unwrapEdits) : sourceText;
+    // The first parse (`sf`) intentionally targets the original source text to discover unwrap edits.
+    // After `applyEditsDescending` runs, node offsets from that AST no longer match the updated text.
+    // Re-parse `textAfterUnwrap` so group-target traversal uses valid positions; reusing the first AST
+    // would produce incorrect start/end offsets for subsequent grouping edits.
+    const sfGrouped = ts.createSourceFile(filePath, textAfterUnwrap, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    const groupTargets = collectGroupTargets(sfGrouped, filePath);
+    const cnInTvNoReplacement = cnInTvCalls.length - unwrapPlans.length;
+    const sortedTargets = [...groupTargets].sort((a, b) => targetReplaceStart(b) - targetReplaceStart(a));
+    const plannedGroupEdits = [];
+    for (const t of sortedTargets) {
+        const plan = planGroupEditForTarget(t, textAfterUnwrap, options.withClassName);
+        if (plan === undefined)
+            continue;
+        if (textAfterUnwrap.slice(plan.start, plan.end) === plan.replacement)
+            continue;
+        plannedGroupEdits.push(plan);
+    }
+    const editSitesCount = unwrapEdits.length + plannedGroupEdits.length;
+    const reportTotal = editSitesCount + cnInTvNoReplacement;
+    if (cnInTvCalls.length === 0 && groupTargets.length === 0) {
+        return { filePath, totalFound: 0, changed: 0 };
+    }
+    if (!options.write) {
+        if (editSitesCount === 0 && cnInTvNoReplacement === 0) {
+            return { filePath, totalFound: 0, changed: 0 };
+        }
+        printGroupFilePreview(logger, {
+            filePath,
+            reportTotal,
+            cnInTvNoReplacement,
+            cnInTvCalls,
+            unwrapReplacementByCall,
+            sourceText,
+            sf,
+            unwrapEdits,
+            plannedGroupEdits,
+        });
+        return {
+            filePath,
+            totalFound: reportTotal,
+            changed: 0,
+        };
+    }
+    return applyGroupFileWrites(filePath, options, fs, logger, unwrapEdits, textAfterUnwrap, plannedGroupEdits, cnInTvNoReplacement);
+}

package/dist/lib/arrange/grouping.d.ts

@@ -0,0 +1,41 @@
+/**
+ * True when `staticLiteralTexts` carries the **same partition** of Tailwind tokens as
+ * `suggestedGroups` from {@link suggestCnGroups}, ignoring order of arguments and
+ * order of tokens within each chunk.
+ */
+export declare function areCnTailwindPartitionsEquivalent(staticLiteralTexts: string[], suggestedGroups: string[]): boolean;
+/**
+ * Merge singleton groups (< MIN_GROUP_TOKENS tokens) into their nearest
+ * neighbour. Prefers merging toward a bucket-compatible neighbor.
+ *
+ * Loop termination: each iteration either splices one element (shrinking the
+ * array, guaranteeing progress) or finds no singleton that can merge and exits
+ * via `changed = false`. Two mutually-incompatible singletons both hit
+ * `continue` and `changed` stays false, so the loop exits without spinning.
+ */
+export declare function mergeSingletons(groups: string[]): string[];
+/**
+ * Merge adjacent groups until total count ≤ maxGroups.
+ * Only merges pairs allowed by {@link bucketsMergeCompatible} — never glues incompatible
+ * buckets (which previously defaulted to penalty 0 and merged layout+state when over cap).
+ *
+ * Complexity: O(n²) in the number of groups — each merge pass scans all remaining adjacent
+ * pairs. In practice `n` is bounded by {@link MAX_GROUPS_CAP} (24) and typical class strings
+ * are well below that, so this is not a concern for the current usage pattern. If this ever
+ * runs in a high-throughput batch mode, consider a priority-queue approach.
+ */
+export declare function capGroups(groups: string[], maxGroups: number): string[];
+/**
+ * If a chunk is **only** bare `ease-*` timing (Motion), buffer it and prepend to the **first**
+ * **later** chunk that is predominantly `state` **and** contains some `animate-*` utility —
+ * skipping intermediate `state` chunks (`sm:…`, `group-data-[…]:…`, etc.) that sit between
+ * `ease-ui` and `data-open:animate-*`. If no such chunk exists, the ease chunk is left as-is.
+ */
+export declare function mergeEaseTimingIntoFollowingAnimatedState(groups: string[]): string[];
+export declare function suggestCnGroups(classString: string): string[];
+/**
+ * One label per suggested group: a single bucket name, or `mixed:a+b` when that chunk
+ * spans multiple Tailwind buckets (matches `codefast arrange group` stdout).
+ */
+export declare function summarizeGroupBucketLabels(groups: string[]): string[];
+//# sourceMappingURL=grouping.d.ts.map

package/dist/lib/arrange/grouping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grouping.d.ts","sourceRoot":"","sources":["../../../src/lib/arrange/grouping.ts"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,kBAAkB,EAAE,MAAM,EAAE,EAC5B,eAAe,EAAE,MAAM,EAAE,GACxB,OAAO,CAiBT;AA+BD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAyC1D;AASD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAmCvE;AAED;;;;;GAKG;AACH,wBAAgB,yCAAyC,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAwBpF;AAQD,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CA8E7D;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAKrE"}

package/dist/lib/arrange/grouping.js

@@ -0,0 +1,280 @@
+import { BUCKET_ORDER, MAX_GROUPS_BASE, MAX_GROUPS_CAP, MAX_GROUPS_HEADROOM, MIN_GROUP_TOKENS, } from "#lib/arrange/constants";
+import { bucketsCompatible, bucketsMergeCompatible, classifyToken, compositeSecondaryOrder, stateKey, stripVariants, tokenizeClassString, } from "#lib/arrange/tokenizer";
+function isVariantKeyedBucket(bucket) {
+    return bucket === "state" || bucket === "starting";
+}
+/**
+ * True when `staticLiteralTexts` carries the **same partition** of Tailwind tokens as
+ * `suggestedGroups` from {@link suggestCnGroups}, ignoring order of arguments and
+ * order of tokens within each chunk.
+ */
+export function areCnTailwindPartitionsEquivalent(staticLiteralTexts, suggestedGroups) {
+    const partitionSignatures = (chunks) => chunks
+        .map((chunk) => {
+        const toks = tokenizeClassString(chunk);
+        return toks.length === 0 ? "" : [...toks].sort().join(" ");
+    })
+        .filter((s) => s.length > 0)
+        .sort((a, b) => a.localeCompare(b));
+    const staticPartitionSigs = partitionSignatures(staticLiteralTexts);
+    const suggestedPartitionSigs = partitionSignatures(suggestedGroups);
+    if (staticPartitionSigs.length !== suggestedPartitionSigs.length)
+        return false;
+    for (let i = 0; i < staticPartitionSigs.length; i++) {
+        if (staticPartitionSigs[i] !== suggestedPartitionSigs[i])
+            return false;
+    }
+    return true;
+}
+/** Dominant bucket of a whitespace-delimited class group (for merge heuristics). */
+function dominantBucketOfGroup(groupStr) {
+    const counts = new Map();
+    for (const tok of tokenizeClassString(groupStr)) {
+        const tokenBucket = classifyToken(tok);
+        counts.set(tokenBucket, (counts.get(tokenBucket) ?? 0) + 1);
+    }
+    let best = "other";
+    let bestN = 0;
+    for (const [bucket, count] of counts) {
+        if (count > bestN) {
+            best = bucket;
+            bestN = count;
+            continue;
+        }
+        // Deterministic tie-break: prefer earlier render-pipeline bucket.
+        if (count === bestN && BUCKET_ORDER[bucket] < BUCKET_ORDER[best]) {
+            best = bucket;
+        }
+    }
+    return best;
+}
+/** Dynamic cap: more tokens → allow more groups, within [BASE, CAP]. */
+function dynamicMaxGroups(tokenCount) {
+    const byTokens = Math.ceil(tokenCount / 2) + MAX_GROUPS_HEADROOM;
+    return Math.max(MAX_GROUPS_BASE, Math.min(MAX_GROUPS_CAP, byTokens));
+}
+/**
+ * Merge singleton groups (< MIN_GROUP_TOKENS tokens) into their nearest
+ * neighbour. Prefers merging toward a bucket-compatible neighbor.
+ *
+ * Loop termination: each iteration either splices one element (shrinking the
+ * array, guaranteeing progress) or finds no singleton that can merge and exits
+ * via `changed = false`. Two mutually-incompatible singletons both hit
+ * `continue` and `changed` stays false, so the loop exits without spinning.
+ */
+export function mergeSingletons(groups) {
+    if (groups.length <= 1)
+        return groups;
+    const result = [...groups];
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let i = 0; i < result.length; i++) {
+            if (tokenizeClassString(result[i]).length < MIN_GROUP_TOKENS) {
+                if (result.length === 1)
+                    break;
+                const myBucket = dominantBucketOfGroup(result[i]);
+                const prevCompat = i > 0 && bucketsMergeCompatible(myBucket, dominantBucketOfGroup(result[i - 1]));
+                const nextCompat = i < result.length - 1 &&
+                    bucketsMergeCompatible(myBucket, dominantBucketOfGroup(result[i + 1]));
+                let mergeDir;
+                if (nextCompat && !prevCompat) {
+                    mergeDir = "forward";
+                }
+                else if (prevCompat && !nextCompat) {
+                    mergeDir = "backward";
+                }
+                else if (prevCompat && nextCompat) {
+                    mergeDir = i < result.length - 1 ? "forward" : "backward";
+                }
+                else {
+                    continue;
+                }
+                if (mergeDir === "forward") {
+                    result[i + 1] = result[i] + " " + result[i + 1];
+                }
+                else {
+                    result[i - 1] = result[i - 1] + " " + result[i];
+                }
+                result.splice(i, 1);
+                changed = true;
+                break;
+            }
+        }
+    }
+    return result;
+}
+/** Tie-break when two merge candidates are both {@link bucketsMergeCompatible} (same bucket or COMPATIBLE_BUCKET_SETS). */
+function capMergePenalty(leftBucket, rightBucket) {
+    if (leftBucket === rightBucket)
+        return 0;
+    if (bucketsCompatible(leftBucket, rightBucket))
+        return 0;
+    return 500;
+}
+/**
+ * Merge adjacent groups until total count ≤ maxGroups.
+ * Only merges pairs allowed by {@link bucketsMergeCompatible} — never glues incompatible
+ * buckets (which previously defaulted to penalty 0 and merged layout+state when over cap).
+ *
+ * Complexity: O(n²) in the number of groups — each merge pass scans all remaining adjacent
+ * pairs. In practice `n` is bounded by {@link MAX_GROUPS_CAP} (24) and typical class strings
+ * are well below that, so this is not a concern for the current usage pattern. If this ever
+ * runs in a high-throughput batch mode, consider a priority-queue approach.
+ */
+export function capGroups(groups, maxGroups) {
+    const result = [...groups];
+    const lengths = result.map((groupStr) => tokenizeClassString(groupStr).length);
+    while (result.length > maxGroups) {
+        const cands = [];
+        for (let i = 0; i < result.length - 1; i++) {
+            const dominantLeft = dominantBucketOfGroup(result[i]);
+            const dominantRight = dominantBucketOfGroup(result[i + 1]);
+            if (!bucketsMergeCompatible(dominantLeft, dominantRight))
+                continue;
+            cands.push({
+                i,
+                size: lengths[i] + lengths[i + 1],
+                penalty: capMergePenalty(dominantLeft, dominantRight),
+            });
+        }
+        if (cands.length === 0)
+            break;
+        let best = cands[0];
+        for (const candidate of cands) {
+            if (candidate.penalty < best.penalty ||
+                (candidate.penalty === best.penalty && candidate.size < best.size)) {
+                best = candidate;
+            }
+        }
+        const bestIdx = best.i;
+        result[bestIdx] = result[bestIdx] + " " + result[bestIdx + 1];
+        lengths[bestIdx] = lengths[bestIdx] + lengths[bestIdx + 1];
+        result.splice(bestIdx + 1, 1);
+        lengths.splice(bestIdx + 1, 1);
+    }
+    return result;
+}
+/**
+ * If a chunk is **only** bare `ease-*` timing (Motion), buffer it and prepend to the **first**
+ * **later** chunk that is predominantly `state` **and** contains some `animate-*` utility —
+ * skipping intermediate `state` chunks (`sm:…`, `group-data-[…]:…`, etc.) that sit between
+ * `ease-ui` and `data-open:animate-*`. If no such chunk exists, the ease chunk is left as-is.
+ */
+export function mergeEaseTimingIntoFollowingAnimatedState(groups) {
+    const result = [...groups];
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let i = 0; i < result.length; i++) {
+            if (!chunkIsOnlyEaseTimingMotion(result[i]))
+                continue;
+            const easeStr = result[i];
+            let target = -1;
+            for (let j = i + 1; j < result.length; j++) {
+                if (dominantBucketOfGroup(result[j]) !== "state")
+                    continue;
+                const toks = tokenizeClassString(result[j]);
+                if (!toks.some((t) => /^animate/.test(stripVariants(t))))
+                    continue;
+                target = j;
+                break;
+            }
+            if (target === -1)
+                continue;
+            result[target] = `${easeStr} ${result[target]}`.trim();
+            result.splice(i, 1);
+            changed = true;
+            break;
+        }
+    }
+    return result;
+}
+function chunkIsOnlyEaseTimingMotion(groupStr) {
+    const toks = tokenizeClassString(groupStr);
+    if (toks.length === 0)
+        return false;
+    return toks.every((t) => classifyToken(t) === "motion" && /^ease-/.test(stripVariants(t)));
+}
+export function suggestCnGroups(classString) {
+    const tokens = tokenizeClassString(classString);
+    if (tokens.length === 0)
+        return [];
+    const classified = tokens.map((tok, index) => ({ tok, bucket: classifyToken(tok), index }));
+    classified.sort((left, right) => {
+        const bucketOrderDiff = BUCKET_ORDER[left.bucket] - BUCKET_ORDER[right.bucket];
+        if (bucketOrderDiff !== 0)
+            return bucketOrderDiff;
+        if (left.bucket === "composite" && right.bucket === "composite") {
+            const c = compositeSecondaryOrder(stripVariants(left.tok)) -
+                compositeSecondaryOrder(stripVariants(right.tok));
+            if (c !== 0)
+                return c;
+        }
+        return left.index - right.index;
+    });
+    const rawGroups = [];
+    /** Bucket of the last token already placed in the current run (pairwise compat with `COMPATIBLE_BUCKET_SETS`). */
+    let lastBucketInRun = null;
+    let currentStateKey = null;
+    let currentTokens = [];
+    const flush = () => {
+        if (currentTokens.length > 0) {
+            rawGroups.push(currentTokens.join(" "));
+            currentTokens = [];
+        }
+        lastBucketInRun = null;
+        currentStateKey = null;
+    };
+    for (const { tok, bucket: tokenBucket } of classified) {
+        if (lastBucketInRun === null) {
+            lastBucketInRun = tokenBucket;
+            currentStateKey = isVariantKeyedBucket(tokenBucket) ? stateKey(tok) : null;
+            currentTokens.push(tok);
+            continue;
+        }
+        if (isVariantKeyedBucket(tokenBucket)) {
+            const key = stateKey(tok);
+            if (currentStateKey !== null && key !== currentStateKey) {
+                flush();
+                lastBucketInRun = tokenBucket;
+                currentStateKey = key;
+                currentTokens.push(tok);
+                continue;
+            }
+        }
+        if (!bucketsCompatible(tokenBucket, lastBucketInRun)) {
+            flush();
+            lastBucketInRun = tokenBucket;
+            currentStateKey = isVariantKeyedBucket(tokenBucket) ? stateKey(tok) : null;
+            currentTokens.push(tok);
+            continue;
+        }
+        if (isVariantKeyedBucket(tokenBucket)) {
+            currentStateKey = stateKey(tok);
+        }
+        else if (currentStateKey !== null) {
+            // Defensive reset: keeps state-key logic explicit if bucket rules evolve.
+            currentStateKey = null;
+        }
+        lastBucketInRun = tokenBucket;
+        currentTokens.push(tok);
+    }
+    flush();
+    const merged = mergeSingletons(rawGroups);
+    const withEaseMerged = mergeEaseTimingIntoFollowingAnimatedState(merged);
+    // Never cap-merge below the semantic chunk count from the tokenizer (fixes layout+state glued
+    // when `preferred` compat list was empty and unrelated pairs used penalty 0).
+    const maxAllowed = Math.max(dynamicMaxGroups(tokens.length), withEaseMerged.length);
+    return capGroups(withEaseMerged, maxAllowed);
+}
+/**
+ * One label per suggested group: a single bucket name, or `mixed:a+b` when that chunk
+ * spans multiple Tailwind buckets (matches `codefast arrange group` stdout).
+ */
+export function summarizeGroupBucketLabels(groups) {
+    return groups.map((g) => {
+        const uniq = new Set(tokenizeClassString(g).map(classifyToken));
+        return uniq.size === 1 ? [...uniq][0] : `mixed:${[...uniq].sort().join("+")}`;
+    });
+}

package/dist/lib/arrange/imports.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve the module specifier used when injecting a `cn` import into a file.
+ */
+export declare function cnModuleSpecifierForFile(filePath: string, override?: string): string;
+export declare function ensureCnImport(sourceText: string, filePath: string, cnImportOverride?: string): string;
+//# sourceMappingURL=imports.d.ts.map

package/dist/lib/arrange/imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../../src/lib/arrange/imports.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAIpF;AAgBD,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,MAAM,GACxB,MAAM,CA+CR"}

package/dist/lib/arrange/imports.js

@@ -0,0 +1,74 @@
+import ts from "typescript";
+function sourceFileImportsCn(sf) {
+    for (const st of sf.statements) {
+        if (!ts.isImportDeclaration(st) || !st.importClause)
+            continue;
+        const clause = st.importClause;
+        if (clause.name?.text === "cn")
+            return true;
+        if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+            for (const el of clause.namedBindings.elements) {
+                if (el.name.text === "cn")
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Resolve the module specifier used when injecting a `cn` import into a file.
+ */
+export function cnModuleSpecifierForFile(filePath, override) {
+    void filePath;
+    if (override)
+        return override;
+    return "@codefast/tailwind-variants";
+}
+function findImportDeclarationFromModule(sf, moduleSpecifier) {
+    for (const st of sf.statements) {
+        if (!ts.isImportDeclaration(st))
+            continue;
+        const spec = st.moduleSpecifier;
+        if (ts.isStringLiteral(spec) && spec.text === moduleSpecifier) {
+            return st;
+        }
+    }
+    return undefined;
+}
+export function ensureCnImport(sourceText, filePath, cnImportOverride) {
+    const sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    if (sourceFileImportsCn(sf))
+        return sourceText;
+    const moduleSpecifier = cnModuleSpecifierForFile(filePath, cnImportOverride);
+    const decl = findImportDeclarationFromModule(sf, moduleSpecifier);
+    if (decl?.importClause &&
+        !decl.importClause.isTypeOnly &&
+        decl.importClause.namedBindings &&
+        ts.isNamedImports(decl.importClause.namedBindings)) {
+        const elements = decl.importClause.namedBindings.elements;
+        if (elements.length > 0) {
+            const pos = elements[0].getStart(sf);
+            return `${sourceText.slice(0, pos)}cn, ${sourceText.slice(pos)}`;
+        }
+    }
+    const importLine = `import { cn } from "${moduleSpecifier}";`;
+    let firstImport = -1;
+    for (const st of sf.statements) {
+        if (ts.isImportDeclaration(st)) {
+            firstImport = st.getStart(sf);
+            break;
+        }
+    }
+    const useClient = /^["']use client["'];?\s*\r?\n/.exec(sourceText);
+    let insertAt;
+    if (useClient) {
+        insertAt = useClient[0].length;
+    }
+    else if (firstImport !== -1) {
+        insertAt = firstImport;
+    }
+    else {
+        insertAt = 0;
+    }
+    return `${sourceText.slice(0, insertAt)}${importLine}\n${sourceText.slice(insertAt)}`;
+}

package/dist/lib/arrange/report.d.ts

@@ -0,0 +1,4 @@
+import type { CliLogger } from "#lib/infra/fs-contract";
+import type { AnalyzeReport } from "#lib/arrange/types";
+export declare function printAnalyzeReport(dir: string, r: AnalyzeReport, logger: CliLogger): void;
+//# sourceMappingURL=report.d.ts.map

package/dist/lib/arrange/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/lib/arrange/report.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CA0CzF"}

package/dist/lib/arrange/report.js

@@ -0,0 +1,37 @@
+import path from "node:path";
+import { LONG_STRING_TOKEN_THRESHOLD, MAX_REPORT_LINES } from "#lib/arrange/constants";
+export function printAnalyzeReport(dir, r, logger) {
+    const { out } = logger;
+    out(`Path: ${path.resolve(dir)}`);
+    out(`.ts/.tsx files: ${r.files}`);
+    out(`cn(...) call sites: ${r.cnCallExpressions}`);
+    out(`tv(...) call sites: ${r.tvCallExpressions}`);
+    out(`\nLong cn(...) string literals (≥${LONG_STRING_TOKEN_THRESHOLD} tokens — consider splitting arguments): ${r.longCnStringLiterals.length}`);
+    for (const x of r.longCnStringLiterals.slice(0, MAX_REPORT_LINES)) {
+        out(`  ${x.file}:${x.line}  (${x.tokenCount} tokens)  ${x.preview}`);
+    }
+    if (r.longCnStringLiterals.length > MAX_REPORT_LINES) {
+        out(`  … and ${r.longCnStringLiterals.length - MAX_REPORT_LINES} more`);
+    }
+    out(`\nLong tv({...}) string literals in base/variants/… (≥${LONG_STRING_TOKEN_THRESHOLD} tokens): ${r.longTvStringLiterals.length}`);
+    for (const x of r.longTvStringLiterals.slice(0, MAX_REPORT_LINES)) {
+        out(`  ${x.file}:${x.line}  (${x.tokenCount} tokens)  ${x.preview}`);
+    }
+    if (r.longTvStringLiterals.length > MAX_REPORT_LINES) {
+        out(`  … and ${r.longTvStringLiterals.length - MAX_REPORT_LINES} more`);
+    }
+    out(`\nJSX className="..." or className={'...'} (static strings, ≥${LONG_STRING_TOKEN_THRESHOLD} tokens): ${r.longJsxClassNameLiterals.length}`);
+    for (const x of r.longJsxClassNameLiterals.slice(0, MAX_REPORT_LINES)) {
+        out(`  ${x.file}:${x.line}  (${x.tokenCount} tokens)  ${x.preview}`);
+    }
+    if (r.longJsxClassNameLiterals.length > MAX_REPORT_LINES) {
+        out(`  … and ${r.longJsxClassNameLiterals.length - MAX_REPORT_LINES} more`);
+    }
+    out(`\ncn(...) nested inside tv({...}) (prefer a string or array — preview/apply can rewrite): ${r.cnInsideTvCalls.length}`);
+    for (const x of r.cnInsideTvCalls.slice(0, MAX_REPORT_LINES)) {
+        out(`  ${x.file}:${x.line}  (${x.argCount} args)  ${x.preview}`);
+    }
+    if (r.cnInsideTvCalls.length > MAX_REPORT_LINES) {
+        out(`  … and ${r.cnInsideTvCalls.length - MAX_REPORT_LINES} more`);
+    }
+}

package/dist/lib/arrange/run-target.d.ts

@@ -0,0 +1,4 @@
+import type { CliFs, CliLogger } from "#lib/infra/fs-contract";
+import type { ArrangeRunOnTargetOptions } from "#lib/arrange/types";
+export declare function runOnTarget(target: string, options: ArrangeRunOnTargetOptions, fs: CliFs, logger: CliLogger): void;
+//# sourceMappingURL=run-target.d.ts.map

package/dist/lib/arrange/run-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-target.d.ts","sourceRoot":"","sources":["../../../src/lib/arrange/run-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAE/D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAIpE,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,EAClC,EAAE,EAAE,KAAK,EACT,MAAM,EAAE,SAAS,GAChB,IAAI,CAkCN"}