@codefast/cli 0.3.13 → 0.3.14-canary.1

package/README.md

@@ -1,10 +1,37 @@
 # @codefast/cli
 
-A focused CLI for two recurring maintenance tasks in monorepos:
+A small developer CLI for maintenance tasks in a TypeScript monorepo — Tailwind class arranging, `package.json` `exports` mirroring, and `@since` JSDoc tagging.
 
-- **`arrange`** — analyze and regroup Tailwind class strings inside `cn()` / `tv()` calls according to a consistent render-pipeline order.
+---
+
+## Table of Contents
+
+- [Why @codefast/cli](#why-codefastcli)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Global options](#global-options)
+- [Exit codes](#exit-codes)
+- [`arrange`](#arrange)
+- [`mirror sync`](#mirror-sync)
+- [`tag` / `annotate`](#tag--annotate)
+- [Configuration (`codefast.config.*`)](#configuration-codefastconfig)
+- [Lifecycle hooks](#lifecycle-hooks)
+- [Grouping philosophy — Render Pipeline Order](#grouping-philosophy--render-pipeline-order)
+- [Troubleshooting](#troubleshooting)
+- [Contributing (monorepo setup)](#contributing-monorepo-setup)
+- [License](#license)
+- [Changelog](#changelog)
+
+---
+
+## Why @codefast/cli
+
+Three recurring maintenance chores you don't want to script by hand:
+
+- **`arrange`** — regroup Tailwind class strings inside `cn()` / `tv()` calls in render-pipeline order.
 - **`mirror`** — regenerate `package.json` `exports` fields from built `dist/` trees across a pnpm workspace.
-- **`tag`** (alias: **`annotate`**) — auto-add `@since <version>` to exported TypeScript declarations that are still missing version metadata.
+- **`tag`** (alias **`annotate`**) — add `@since <version>` JSDoc tags to exported declarations that are missing version metadata.
 
 ```mermaid
 flowchart LR
@@ -25,20 +52,8 @@ flowchart LR
 
 ## Requirements
 
-- Node.js `>=22.0.0`
-- pnpm (recommended)
-
----
-
-## Exit codes
-
-| Code | Meaning                                                                                                                                                         |
-| ---- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `0`  | Success.                                                                                                                                                        |
-| `1`  | General failure (missing paths, infrastructure errors, partial failures such as `mirror sync` with package errors, or hook / run errors for `tag` / `arrange`). |
-| `2`  | Invalid invocation or input (Zod / schema validation for CLI requests).                                                                                         |
-
-Human-readable errors and diagnostics go to **stderr**; primary command output goes to **stdout**.
+- Node.js `>= 22.0.0`
+- pnpm (recommended — the CLI discovers workspaces via `pnpm-workspace.yaml`)
 
 ---
 
@@ -47,9 +62,15 @@ Human-readable errors and diagnostics go to **stderr**; primary command output g
 ```bash
 # Install globally
 pnpm add -g @codefast/cli
+# or
+npm install -g @codefast/cli
+# or
+yarn global add @codefast/cli
 
 # Or run without installing
 pnpm dlx @codefast/cli --help
+# or
+npx @codefast/cli --help
 ```
 
 ---
@@ -57,28 +78,55 @@ pnpm dlx @codefast/cli --help
 ## Quick start
 
 ```bash
-# 1. Preview proposed changes — no files written
+# Analyze Tailwind classes in the nearest package
+codefast arrange analyze
+
+# Preview proposed rewrites — no files written
 codefast arrange preview packages/ui/src/components
 
-# 2. Apply after reviewing the diff
+# Apply after reviewing
 codefast arrange apply packages/ui/src/components
 
-# 3. Regenerate package exports from built dist/
+# Regenerate every package's `exports` from built dist/
 codefast mirror sync
 
-# 4. Add @since tags to exported APIs under src/
+# Add @since <version> to exported APIs under ./src
 codefast tag
 ```
 
 ---
 
+## Global options
+
+| Flag              | Effect                                                                 |
+| ----------------- | ---------------------------------------------------------------------- |
+| `--no-color`      | Disable ANSI color output (also respected by JSON output suppression). |
+| `-V`, `--version` | Print the CLI version and exit.                                        |
+| `-h`, `--help`    | Show contextual help for the invoked command.                          |
+
+---
+
+## Exit codes
+
+| Code | Meaning                                                                                                  |
+| ---- | -------------------------------------------------------------------------------------------------------- |
+| `0`  | Success.                                                                                                 |
+| `1`  | General failure (missing paths, infrastructure errors, partial failures in `mirror sync`, failed hooks). |
+| `2`  | Invalid invocation or input (Zod schema validation on CLI requests — `CLI_EXIT_USAGE`).                  |
+
+Diagnostics go to **stderr**; primary command output goes to **stdout**. When a subcommand accepts `--json`, only the JSON object is written to stdout and all human progress is suppressed, so the stream stays pipeline-safe.
+
+---
+
 ## `arrange`
 
-Reads `cn()` and `tv()` call sites, classifies each Tailwind utility, and rewrites the class strings in render-pipeline order (see [Grouping philosophy](#grouping-philosophy--render-pipeline-order) below).
+Reads `cn()` and `tv()` call sites, classifies each Tailwind utility, and rewrites the class string in render-pipeline order (see [Grouping philosophy](#grouping-philosophy--render-pipeline-order)).
 
-### Workflow
+### Target resolution
+
+When `[target]` is omitted, `arrange` auto-detects the **nearest package directory** by walking up from the current working directory until it finds a `package.json`. Pass an explicit path (file or directory) to override.
 
-Run the three subcommands in order:
+### Workflow
 
 | Step | Command                             | Effect                                |
 | ---- | ----------------------------------- | ------------------------------------- |
@@ -86,63 +134,106 @@ Run the three subcommands in order:
 | 2    | `codefast arrange preview [target]` | Show exactly what `apply` would write |
 | 3    | `codefast arrange apply [target]`   | Write the changes                     |
 
-The default `target` when omitted is `packages/ui/src/components`, resolved from `process.cwd()`.
+### Flags (preview / apply)
 
-### Flags
+| Flag                 | Description                                                                 |
+| -------------------- | --------------------------------------------------------------------------- |
+| `--with-class-name`  | Append `className` as the last argument when rewriting a `cn(...)` call.    |
+| `--cn-import <spec>` | Override the module specifier used when a missing `cn` import is added.     |
+| `--json`             | Print a single JSON object on stdout; suppresses human progress and colors. |
 
-| Flag                 | Description                                                             |
-| -------------------- | ----------------------------------------------------------------------- |
-| `--with-class-name`  | Append `className` as the last argument when rewriting a `cn(...)` call |
-| `--cn-import <spec>` | Override the module specifier used when adding a missing `cn` import    |
+`analyze` also supports `--json`.
 
-### `arrange group` — one-shot string grouping
+### `arrange group` — one-shot classification
 
-Groups a single class string without touching the filesystem. Useful for checking how a string would be classified before running `apply`:
+Groups a class string without touching the filesystem. Useful for checking how classes would be grouped before running `apply`:
 
 ```bash
+# Quoted string
 codefast arrange group "relative flex items-center h-10 w-full rounded-md bg-primary text-white hover:bg-primary/90"
+
+# Or space-separated tokens (no quotes needed)
+codefast arrange group relative flex items-center h-10 w-full rounded-md
+
+# Emit a tv()-style array instead of a cn() call
+codefast arrange group --tv "flex items-center gap-2"
 ```
 
-### `--json` (machine-readable output)
+| Flag                | Description                                                          |
+| ------------------- | -------------------------------------------------------------------- |
+| `--tv`              | Emit a `tv()`-style array literal instead of a `cn(...)` call.       |
+| `--with-class-name` | Append `className` to the emitted `cn(...)` call.                    |
+| `--json`            | Emit `{ schemaVersion, primaryLine, bucketsCommentLine }` on stdout. |
 
-Use **`--json`** on any `arrange` subcommand to print **one JSON object** on stdout (human tables / colors are suppressed):
+### `--json` payloads
 
-| Subcommand          | Payload highlights                                                                                                                   |
-| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
-| `analyze`           | `schemaVersion`, `analyzeRootPath`, full `report` (same data as the human report).                                                   |
-| `preview` / `apply` | `schemaVersion`, `write`, `ok` (false if `onAfterWrite` hook failed), full `result` (`filePaths`, `modifiedFiles`, `totalFound`, …). |
-| `group`             | `schemaVersion`, `primaryLine`, `bucketsCommentLine`.                                                                                |
+| Subcommand          | Payload highlights                                                                                                                         |
+| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `analyze`           | `schemaVersion`, `analyzeRootPath`, full `report` (same data as the human report).                                                         |
+| `preview` / `apply` | `schemaVersion`, `write`, `ok` (`false` if the `onAfterWrite` hook failed), full `result` (`filePaths`, `modifiedFiles`, `totalFound`, …). |
+| `group`             | `schemaVersion`, `primaryLine`, `bucketsCommentLine`.                                                                                      |
 
 ---
 
 ## `mirror sync`
 
-Scans built `dist/` trees and regenerates the `exports` field in each `package.json`. Run from anywhere inside the monorepo — the workspace root is discovered automatically via `pnpm-workspace.yaml`.
+Scans built `dist/` trees and regenerates the `exports` field of every workspace package. Run it from anywhere inside the monorepo — the workspace root is discovered via `pnpm-workspace.yaml`.
 
 ```bash
-codefast mirror sync              # all packages in the workspace
-codefast mirror sync packages/ui  # a single package path
-codefast mirror sync -v           # verbose output
-codefast mirror sync --json       # one JSON object on stdout (for scripts / CI)
+codefast mirror sync                 # all workspace packages
+codefast mirror sync packages/ui     # one package (path relative to repo root)
+codefast mirror sync -v              # verbose diagnostics
+codefast mirror sync --json          # JSON summary for scripts / CI
 ```
 
-`--json` prints a single line of JSON with `schemaVersion`, `ok`, `elapsedSeconds`, and `stats` (same counters as the human summary). Human progress and styling are suppressed; use normal mode for interactive runs.
+| Flag              | Description                                                           |
+| ----------------- | --------------------------------------------------------------------- |
+| `-v`, `--verbose` | Print extra diagnostics.                                              |
+| `--json`          | Print a single `{ schemaVersion, ok, elapsedSeconds, stats }` object. |
 
-> **Note:** Packages must be built first so `dist/` exists. Run your build step before `mirror sync`.
+> **Build first.** `mirror sync` reads from `dist/`. Run your build before syncing or exports will reflect stale output.
 
-### Configuration
+Exit code is `1` when any package fails (`stats.packagesErrored > 0`), `0` otherwise.
 
-Create a `codefast.config.js` (or `.mjs`, `.cjs`, `.json`) at the repo root with a `mirror` key:
+---
+
+## `tag` / `annotate`
 
-```js
+Scans `.ts` / `.tsx` sources and adds `@since <current-package-version>` to exported declarations that don't already carry one. The version is read from the nearest `package.json` walking up from the target path.
+
+```bash
+codefast tag                   # auto-discover workspace packages from cwd
+codefast tag packages/ui/src   # annotate a custom target
+codefast annotate --dry-run    # preview only, do not write
+codefast tag --json            # JSON summary for scripts / CI
+```
+
+| Flag        | Description                                                       |
+| ----------- | ----------------------------------------------------------------- |
+| `--dry-run` | Show summary without writing files.                               |
+| `--json`    | Print a single JSON summary on stdout; suppresses human progress. |
+
+What it updates:
+
+- Adds `/** @since <version> */` when an exported declaration has no JSDoc.
+- Injects `@since <version>` into an existing JSDoc block that lacks one.
+- Leaves declarations alone when `@since` is already present.
+
+---
+
+## Configuration (`codefast.config.*`)
+
+Create `codefast.config.js`, `.mjs`, `.cjs`, or `.json` at the repo root. Each command reads its own slice.
+
+```javascript
 // codefast.config.mjs
+import { execSync } from "node:child_process";
+
 export default {
   mirror: {
     skipPackages: ["@acme/internal"],
     pathTransformations: {
-      "@acme/ui": {
-        removePrefix: "./components/",
-      },
+      "@acme/ui": { removePrefix: "./components/" },
     },
     customExports: {
       "@acme/ui": {
@@ -150,80 +241,76 @@ export default {
       },
     },
     cssExports: {
+      // Shorthand: `true` enables default CSS export detection
+      "@acme/theme": true,
+      // Or configure explicitly:
       "@acme/ui": {
         enabled: true,
+        forceExportFiles: false,
         customExports: {
           "./tokens.css": "./dist/tokens.css",
         },
       },
     },
   },
+
+  tag: {
+    skipPackages: ["@acme/internal"],
+    onAfterWrite: ({ files }) => {
+      execSync(`oxfmt ${files.join(" ")}`, { stdio: "inherit" });
+    },
+  },
+
+  arrange: {
+    onAfterWrite: ({ files }) => {
+      execSync(`oxfmt ${files.join(" ")}`, { stdio: "inherit" });
+    },
+  },
 };
 ```
 
-Use your real package names from `package.json#name` (for example `@acme/ui`) and adjust entries to match your workspace.
+Notes:
 
-> **Migration:** Path-based keys (for example `packages/ui`) are deprecated for `pathTransformations`, `customExports`, `cssExports`, and `skipPackages`. Migrate to package-name keys.
+- Keys in `mirror.skipPackages` / `pathTransformations` / `customExports` / `cssExports` are **package names** from `package.json#name` (e.g. `@acme/ui`). Path-based keys such as `packages/ui` are deprecated and will be removed.
+- `cssExports[pkg]` accepts a boolean shorthand or the full `{ enabled, customExports, forceExportFiles }` object.
+- `tag.skipPackages` lists package names to skip entirely when `codefast tag` is run without an explicit target.
 
-> **Security note:** `.js`, `.mjs`, and `.cjs` config files are loaded via `import()`. Only run `mirror sync` in repositories you trust.
+> **Security.** `.js`, `.mjs`, and `.cjs` config files are loaded via `import()` — only run `codefast` inside repositories you trust.
 
 ---
 
-## Lifecycle hooks (`codefast.config.mjs`)
+## Lifecycle hooks
 
-`codefast` supports lifecycle hooks so teams can plug in their own post-write workflow (formatter, lint-fix, codemods) without hardcoding any formatter inside CLI core.
+Both `tag` and `arrange apply` expose an `onAfterWrite` hook so teams can plug in their own formatter, lint-fix step, or codemod without embedding one in the CLI core.
 
 ```javascript
-import { execSync } from "node:child_process";
-
 export default {
   tag: {
-    onAfterWrite: ({ files }) => {
-      console.log(`Formatting ${files.length} files with Oxc...`);
-      execSync(`oxfmt ${files.join(" ")}`, { stdio: "inherit" });
+    onAfterWrite: async ({ files }) => {
+      console.log(`Formatting ${files.length} files…`);
+      // sync or async work
     },
   },
   arrange: {
     onAfterWrite: ({ files }) => {
-      execSync(`oxfmt ${files.join(" ")}`, { stdio: "inherit" });
+      /* … */
     },
   },
 };
 ```
 
-Hook contract:
+Contract:
 
 - `tag.onAfterWrite?.({ files })` runs after `codefast tag` writes files.
 - `arrange.onAfterWrite?.({ files })` runs after `codefast arrange apply` writes files.
-- Hooks support both sync and async functions (`void | Promise<void>`).
-- Hook failures are reported on stderr; `tag` and `arrange apply` exit with code `1` when a hook fails (see [Exit codes](#exit-codes)).
-
----
-
-## `tag` / `annotate`
-
-Scans `.ts` / `.tsx` source files and annotates exported declarations with `@since <current-package-version>`. This keeps API evolution visible and reduces documentation drift in long-lived codebases.
-
-```bash
-codefast tag                  # annotate exports in ./src
-codefast tag packages/ui/src  # annotate a custom target
-codefast annotate --dry-run   # preview only, do not write files
-codefast tag --json           # one JSON object on stdout (for scripts / CI)
-```
-
-What it updates:
-
-- Adds `/** @since <version> */` when an exported declaration has no JSDoc.
-- Injects `@since <version>` into an existing JSDoc block when missing.
-- Leaves declarations unchanged when `@since` is already present.
-
-The `<version>` value is read from the nearest `package.json` found by walking up from the target path.
+- Hooks may be synchronous or asynchronous (`void | Promise<void>`).
+- Hook failures are reported on stderr; both commands exit with code `1` when the hook rejects.
 
 ---
 
 ## Grouping philosophy — Render Pipeline Order
 
-`arrange` does **not** sort classes alphabetically. Instead, it groups utilities in roughly the order the browser applies them — from the box's existence, through its shape and surface, to interactive behavior. This makes class strings easier to scan and reason about at a glance.
+`arrange` does **not** sort classes alphabetically. Instead, it groups utilities in roughly the order the browser applies them — from the box's existence, through its shape and surface, to interactive behavior. This makes class strings easier to scan and diff.
 
 **Existence → Position → Layout → Sizing → Spacing → Shape → Background → Shadow → Typography → Composite → Motion → Starting → Behavior → State → Selector**
 
@@ -245,9 +332,9 @@ The `<version>` value is read from the nearest `package.json` found by walking u
 | **State**      | Interactive and conditional variants (non-selector) | `hover:`, `md:`, `@md/sidebar:`, `data-[…]:`      |
 | **Selector**   | Selector-driven variants                            | `[&…]:`, `*:`, `**:`, `has-*`, `group-[…]:`       |
 
-Adjacent buckets may be merged into one string literal when declared _compatible_ (e.g. `layout` + `sizing`). This keeps `cn()` calls readable without flattening unrelated concerns into a single undifferentiated blob.
+Adjacent buckets may be merged into a single string literal when declared _compatible_ (e.g. Layout + Sizing), which keeps `cn()` calls readable without flattening unrelated concerns.
 
-To change a placement, edit `classifyBareUtility` in `src/lib/arrange/domain/tokenizer.util.ts` and add a corresponding `classifyToken` test in `src/lib/arrange/domain/tokenizer.util.test.ts`.
+To change placement, edit `classifyBareUtility` in `src/lib/arrange/domain/tokenizer.util.ts` and add a matching case in `tokenizer.util.test.ts`.
 
 ---
 
@@ -257,25 +344,44 @@ To change a placement, edit `classifyBareUtility` in `src/lib/arrange/domain/tok
 Install globally with `pnpm add -g @codefast/cli`, or run via `pnpm dlx @codefast/cli <command>`.
 
 **`mirror sync` writes little or no output**
-Packages must be built before syncing. Ensure `dist/` exists by running your build step first, then re-run `codefast mirror sync`.
+Packages must be built first. Ensure `dist/` exists by running your build step, then re-run `codefast mirror sync`.
 
 **Unexpected class reorder after `arrange apply`**
-Run `arrange preview` before applying and smoke-test the UI. Some components rely on cascade-sensitive ordering that `arrange` cannot detect automatically.
+Run `arrange preview` first and smoke-test the UI. Some components rely on cascade-sensitive ordering that `arrange` cannot detect automatically.
+
+**`--json` output mixed with progress lines**
+Some shells buffer progress writes on stderr into stdout when piping — redirect stderr explicitly: `codefast mirror sync --json 2>/dev/null | jq`.
 
 ---
 
 ## Contributing (monorepo setup)
 
 ```bash
-# Build the local CLI (produces dist/bin.js)
+# Build the local CLI (produces dist/bin.mjs)
 pnpm --filter @codefast/cli build
 
 # Run the local entrypoint
 pnpm exec codefast --help
+
+# Test + type-check
+pnpm --filter @codefast/cli test
+pnpm --filter @codefast/cli check-types
 ```
 
-A few naming conventions to keep in mind:
+A few naming conventions:
 
-- **`codefast <command>`** refers to CLI commands exposed via the `@codefast/cli` `bin` entry.
+- **`codefast <command>`** refers to CLI commands exposed via the `bin` entry in `@codefast/cli`.
 - **Scripts in `packages/cli/package.json`** (`build`, `test`, …) are package-local dev scripts, not CLI commands.
-- The root `package.json` includes optional convenience wrappers such as `cli:mirror-sync` and `cli:arrange-analyze` for common dev workflows.
+- The root `package.json` includes optional convenience wrappers (e.g. `cli:mirror-sync`, `cli:arrange-analyze`) for common dev workflows.
+
+---
+
+## License
+
+[MIT](https://opensource.org/licenses/MIT) — see [`package.json`](./package.json).
+
+---
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for the full version history. Releases are also published on [npm](https://www.npmjs.com/package/@codefast/cli?activeTab=versions).

package/dist/lib/arrange/domain/ast/ast-helpers.helper.mjs

@@ -2,7 +2,9 @@ import { EMPTY_CN_TV_BINDINGS } from "../constants.domain.mjs";
 import { applyEditsDescending, indentOfLineContaining } from "../../../shared/source-code/domain/text-edit.model.mjs";
 import { isDomainIdentifier, isDomainImportDeclaration, isDomainNamedImports, isDomainNamespaceImport, isDomainPropertyAccessExpression, isDomainStringLiteral, lineOfSourcePosition } from "./ast-node.model.mjs";
 //#region src/lib/arrange/domain/ast/ast-helpers.helper.ts
-/** Known module specifiers that export `cn` / `tv`. */ const KNOWN_CN_TV_MODULES = new Set([
+/**
+* Known module specifiers that export `cn` / `tv`.
+*/ const KNOWN_CN_TV_MODULES = new Set([
 	"@codefast/tailwind-variants",
 	"clsx",
 	"class-variance-authority",

package/dist/lib/arrange/domain/constants.domain.mjs

@@ -1,5 +1,7 @@
 //#region src/lib/arrange/domain/constants.domain.ts
-/** Analyze report: long literal threshold (token count). */ const LONG_STRING_TOKEN_THRESHOLD = 18;
+/**
+* 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
@@ -9,15 +11,25 @@
 * 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;
+/**
+* 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 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:`);
@@ -82,7 +94,9 @@
 * 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([
+/**
+* State variant stems — hoisted to module scope (not recreated per call).
+*/ const STATE_PREFIXES = new Set([
 	"hover",
 	"focus",
 	"focus-within",

package/dist/lib/arrange/domain/grouping.domain.mjs

@@ -5,7 +5,9 @@ import { bucketsCompatible, bucketsMergeCompatible, classifyToken, compositeSeco
 * `cn()` grouping: bucket sequence is {@link BUCKET_ORDER} only; tokens are classified with
 * {@link classifyToken}. Comparators here (`compareClassifiedTailwindTokensForCnGrouping`, …)
 * are the single place for variant-aware sort — do not reintroduce parallel bucket ordering.
-*/ /** Separates bucket id from variant key in {@link buildFirstVariantKeySourceIndex} map keys. */ const VARIANT_BUCKET_KEY_SEP = "\0";
+*/ /**
+* Separates bucket id from variant key in {@link buildFirstVariantKeySourceIndex} map keys.
+*/ const VARIANT_BUCKET_KEY_SEP = "\0";
 function isVariantKeyedBucket(bucket) {
 	return bucket === "selector" || bucket === "state" || bucket === "starting";
 }
@@ -70,7 +72,9 @@ function compareClassifiedTailwindTokensForCnGrouping(left, right, firstVariantK
 	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) {
+/**
+* Dominant bucket of a whitespace-delimited class group (for merge heuristics).
+*/ function dominantBucketOfGroup(groupStr) {
 	const counts = /* @__PURE__ */ new Map();
 	for (const classToken of tokenizeClassString(groupStr)) {
 		const tokenBucket = classifyToken(classToken);
@@ -88,7 +92,9 @@ function compareClassifiedTailwindTokensForCnGrouping(left, right, firstVariantK
 	}
 	return best;
 }
-/** Dynamic cap: more tokens → allow more groups, within [BASE, CAP]. */ function dynamicMaxGroups(tokenCount) {
+/**
+* Dynamic cap: more tokens → allow more groups, within [BASE, CAP].
+*/ function dynamicMaxGroups(tokenCount) {
 	const byTokens = Math.ceil(tokenCount / 2) + 2;
 	return Math.max(4, Math.min(24, byTokens));
 }
@@ -136,7 +142,9 @@ function compareClassifiedTailwindTokensForCnGrouping(left, right, firstVariantK
 	}
 	return result;
 }
-/** Tie-break when two merge candidates are both {@link bucketsMergeCompatible} (same bucket or COMPATIBLE_BUCKET_SETS). */ function capMergePenalty(leftBucket, rightBucket) {
+/**
+* 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;
@@ -246,7 +254,9 @@ function suggestCnGroups(classString) {
 	const firstVariantKeySourceIndex = buildFirstVariantKeySourceIndex(classified);
 	classified.sort((left, right) => compareClassifiedTailwindTokensForCnGrouping(left, right, firstVariantKeySourceIndex));
 	const rawGroups = [];
-	/** Bucket of the last token already placed in the current run (pairwise compat with `COMPATIBLE_BUCKET_SETS`). */ let lastBucketInRun = null;
+	/**
+	* 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 = () => {

package/dist/lib/arrange/domain/tokenizer.util.mjs

@@ -46,7 +46,9 @@ function stripVariants(token) {
 	}
 	return withoutVariants;
 }
-/** Outermost variant segment: first `:` at bracket depth 0 → text before it. */ function firstLeadingVariantPrefix(token) {
+/**
+* Outermost variant segment: first `:` at bracket depth 0 → text before it.
+*/ function firstLeadingVariantPrefix(token) {
 	const colonIdx = indexOfFirstVariantColon(token);
 	if (colonIdx === -1) return;
 	return token.slice(0, colonIdx);
@@ -93,7 +95,9 @@ function isStateToken(token) {
 	if (/^will-change/.test(b)) return 50;
 	return 99;
 }
-/** Classify a **bare** utility (no `hover:` / `md:` / … prefixes). */ function classifyBareUtility(bareUtility) {
+/**
+* Classify a **bare** utility (no `hover:` / `md:` / … prefixes).
+*/ function classifyBareUtility(bareUtility) {
 	const b = bareUtility;
 	if (/^@container(?:\/[a-z][a-z0-9-]*)?$/i.test(b)) return "existence";
 	if (/^(?:hidden|contents|sr-only|not-sr-only|list-item|flow-root)$/.test(b) || /^(?:block|inline-block|inline)$/.test(b)) return "existence";
@@ -148,11 +152,15 @@ function classifyToken(token) {
 	const match = token.match(/^data-\[([^\]]*)\]/);
 	return match ? `data-[${match[1]}]` : "data";
 }
-/** Same idea as {@link dataAttributeStem} for `aria-[…]:` variants. */ function ariaAttributeStem(token) {
+/**
+* Same idea as {@link dataAttributeStem} for `aria-[…]:` variants.
+*/ function ariaAttributeStem(token) {
 	const match = token.match(/^aria-\[([^\]]*)\]/);
 	return match ? `aria-[${match[1]}]` : "aria";
 }
-/** `in-data-[…]:` — normalize on the full bracket expression like {@link dataAttributeStem}. */ function inDataAttributeStem(token) {
+/**
+* `in-data-[…]:` — normalize on the full bracket expression like {@link dataAttributeStem}.
+*/ function inDataAttributeStem(token) {
 	const match = token.match(/^in-data-\[([^\]]*)\]/);
 	return match ? `in-data-[${match[1]}]` : "in-data";
 }
@@ -198,7 +206,9 @@ function bucketsCompatible(a, b) {
 	if (a === b) return true;
 	return COMPATIBLE_BUCKET_SETS.some((bucketSet) => bucketSet.has(a) && bucketSet.has(b));
 }
-/** Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs. */ function bucketsMergeCompatible(a, b) {
+/**
+* Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs.
+*/ function bucketsMergeCompatible(a, b) {
 	if (a === "state" && b === "state") return false;
 	if (a === "starting" && b === "starting") return false;
 	if (a === "selector" && b === "selector") return false;

package/dist/lib/arrange/infra/domain-source-parser.adapter.mjs

@@ -235,6 +235,8 @@ let _DomainSourceParserAdapter;
 		_initClass();
 	}
 });
-/** Default instance without diagnostics logging (tests and legacy imports). */ const domainSourceParserAdapter = new _DomainSourceParserAdapter();
+/**
+* Default instance without diagnostics logging (tests and legacy imports).
+*/ const domainSourceParserAdapter = new _DomainSourceParserAdapter();
 //#endregion
 export { _DomainSourceParserAdapter as DomainSourceParserAdapter, domainSourceParserAdapter };

package/dist/lib/arrange/infra/ensure-cn-import.adapter.mjs

@@ -1,7 +1,9 @@
 import { ensureCnImport as ensureCnImport$1 } from "../domain/imports.domain.mjs";
 import { parseDomainSourceFile } from "./ts-ast-translator.adapter.mjs";
 //#region src/lib/arrange/infra/ensure-cn-import.adapter.ts
-/** Parses source then applies domain cn import injection rules (public CLI-style entry). */ function ensureCnImport(sourceText, filePath, cnImportOverride) {
+/**
+* Parses source then applies domain cn import injection rules (public CLI-style entry).
+*/ function ensureCnImport(sourceText, filePath, cnImportOverride) {
 	return ensureCnImport$1(parseDomainSourceFile(filePath, sourceText), cnImportOverride);
 }
 //#endregion

package/dist/lib/infra/config-reporter.adapter.mjs

@@ -1,7 +1,9 @@
 //#region src/lib/infra/config-reporter.adapter.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) {
+/**
+* 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}`);
 }

package/dist/lib/mirror/infra/update-pkg.adapter.mjs

@@ -27,7 +27,9 @@ function compareExportSpecifiers(leftSpecifier, rightSpecifier, originalPathBySp
 	if (originalPathComparison !== 0) return originalPathComparison;
 	return leftSpecifier.localeCompare(rightSpecifier);
 }
-/** Shared rule: show `package.json#name` when it is a non-empty string; else folder basename. */ function resolvePackageDisplayName(packageJson, folderBasename) {
+/**
+* Shared rule: show `package.json#name` when it is a non-empty string; else folder basename.
+*/ function resolvePackageDisplayName(packageJson, folderBasename) {
 	const declaredName = packageJson.name;
 	return typeof declaredName === "string" && declaredName.length > 0 ? declaredName : folderBasename;
 }

package/dist/lib/mirror/infra/workspace-packages.adapter.mjs

@@ -6,7 +6,9 @@ import picomatch from "picomatch";
 import { parse } from "yaml";
 //#region src/lib/mirror/infra/workspace-packages.adapter.ts
 const PNPM_WORKSPACE = "pnpm-workspace.yaml";
-/** Default when the workspace file is missing or has no `packages` key. */ const DEFAULT_INCLUDE = ["packages/*"];
+/**
+* Default when the workspace file is missing or has no `packages` key.
+*/ const DEFAULT_INCLUDE = ["packages/*"];
 function toPosix(filePath) {
 	return filePath.split(path.sep).join("/");
 }
@@ -15,7 +17,9 @@ function isGlobPermissionError(caughtError) {
 	const code = caughtError.code;
 	return code === "EACCES" || code === "EPERM";
 }
-/** Turn a pnpm `packages` glob into a `globSync` pattern that finds `package.json` files. */ function workspacePatternToPackageJsonGlob(pattern) {
+/**
+* Turn a pnpm `packages` glob into a `globSync` pattern that finds `package.json` files.
+*/ function workspacePatternToPackageJsonGlob(pattern) {
 	const normalizedPattern = toPosix(pattern.trim()).replace(/\/+$/, "");
 	if (!normalizedPattern) return "**/package.json";
 	return `${normalizedPattern}/package.json`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/cli",
-  "version": "0.3.13",
+  "version": "0.3.14-canary.1",
   "description": "Developer CLI for the Codefast monorepo (arrange, mirror, tag)",
   "keywords": [
     "cli",
@@ -50,7 +50,7 @@
     "typescript": "^6.0.2",
     "yaml": "^2.8.3",
     "zod": "^4.3.6",
-    "@codefast/di": "0.3.13"
+    "@codefast/di": "0.3.14-canary.1"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
@@ -61,7 +61,7 @@
     "unplugin-swc": "^1.5.9",
     "vite": "^8.0.8",
     "vitest": "^4.1.4",
-    "@codefast/typescript-config": "0.3.13"
+    "@codefast/typescript-config": "0.3.14-canary.1"
   },
   "engines": {
     "node": ">=22.0.0"

package/dist/lib/core/application/architecture-boundaries.policy.mjs

@@ -1,311 +0,0 @@
-//#region src/lib/core/application/architecture-boundaries.policy.ts
-/** Product bounded contexts: no direct cross-imports between these (domain + application rules). */ const PRODUCT_BOUNDED_CONTEXTS = new Set([
-	"arrange",
-	"mirror",
-	"tag"
-]);
-const SHARED_SOURCE_CODE_CONTEXT = "shared-source-code";
-const PATH_SEPARATOR = "/";
-const LAYERS = new Set([
-	"domain",
-	"application",
-	"infra",
-	"presentation"
-]);
-/** Import roots that any product slice may depend on without going "through" another slice. */ const NEUTRAL_LIB_IMPORT_ROOTS = new Set([
-	"core",
-	"config",
-	"infra",
-	"shared"
-]);
-/** Internal imports: tsconfig `#/*` → `src/*`. */ const INTERNAL_LIB_PREFIX = "#/lib/";
-function pathAfterInternalLibPrefix(specifier) {
-	if (!specifier.startsWith(INTERNAL_LIB_PREFIX)) return null;
-	return specifier.slice(6);
-}
-function internalLibSpecifierSegmentList(specifier) {
-	const afterPrefix = pathAfterInternalLibPrefix(specifier);
-	if (afterPrefix === null) return null;
-	const segments = afterPrefix.split(PATH_SEPARATOR).filter(Boolean);
-	return segments.length === 0 ? null : segments;
-}
-function normalizePathSeparators(pathValue) {
-	return pathValue.split("\\").join(PATH_SEPARATOR);
-}
-function splitPath(pathValue) {
-	return normalizePathSeparators(pathValue).split(PATH_SEPARATOR).filter(Boolean);
-}
-function basenamePath(pathValue) {
-	const parts = splitPath(pathValue);
-	return parts.length === 0 ? "" : parts[parts.length - 1] ?? "";
-}
-function dirnamePath(pathValue) {
-	const parts = normalizePathSeparators(pathValue).split(PATH_SEPARATOR);
-	parts.pop();
-	if (parts.length === 0) return PATH_SEPARATOR;
-	const joined = parts.join(PATH_SEPARATOR);
-	return joined === "" ? PATH_SEPARATOR : joined;
-}
-function joinPath(...segments) {
-	return segments.map((segment) => normalizePathSeparators(segment)).join(PATH_SEPARATOR).replace(/\/+/g, PATH_SEPARATOR);
-}
-function normalizeDotSegments(pathValue) {
-	const normalized = normalizePathSeparators(pathValue);
-	const isAbsolute = normalized.startsWith(PATH_SEPARATOR);
-	const segments = normalized.split(PATH_SEPARATOR);
-	const stack = [];
-	for (const segment of segments) {
-		if (!segment || segment === ".") continue;
-		if (segment === "..") {
-			if (stack.length > 0) stack.pop();
-			continue;
-		}
-		stack.push(segment);
-	}
-	const suffix = stack.join(PATH_SEPARATOR);
-	return isAbsolute ? `${PATH_SEPARATOR}${suffix}` : suffix;
-}
-function sharedSourceCodeLayerFromSpecifier(segments) {
-	if (segments.length < 3 || segments[0] !== "shared" || segments[1] !== "source-code") return null;
-	return segments[2] ?? null;
-}
-/**
-* Extract `#/lib/...` and relative import specifiers from TypeScript source
-* (static `from` / `import("...")` only).
-*/ function extractImportSpecifiers(sourceText) {
-	const specifiers = [];
-	const fromPattern = /\bfrom\s+["']([^"']+)["']/g;
-	let fromMatch;
-	while ((fromMatch = fromPattern.exec(sourceText)) !== null) {
-		const cap = fromMatch[1];
-		if (cap !== void 0) specifiers.push(cap);
-	}
-	const importOnlyPattern = /^\s*import\s+["']([^"']+)["']\s*;/gm;
-	let importOnlyMatch;
-	while ((importOnlyMatch = importOnlyPattern.exec(sourceText)) !== null) {
-		const cap = importOnlyMatch[1];
-		if (cap !== void 0) specifiers.push(cap);
-	}
-	const importCallPattern = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
-	let importCallMatch;
-	while ((importCallMatch = importCallPattern.exec(sourceText)) !== null) {
-		const cap = importCallMatch[1];
-		if (cap !== void 0) specifiers.push(cap);
-	}
-	return specifiers;
-}
-function pathUnderCliSrcLib(absolutePath) {
-	const normalized = normalizePathSeparators(absolutePath);
-	const marker = `${PATH_SEPARATOR}src${PATH_SEPARATOR}lib${PATH_SEPARATOR}`;
-	const index = normalized.lastIndexOf(marker);
-	if (index === -1) return null;
-	return normalized.slice(index + marker.length);
-}
-function parseLibSourceLocation(absoluteFilePath) {
-	const tail = pathUnderCliSrcLib(absoluteFilePath);
-	if (tail === null) return null;
-	const parts = tail.split(PATH_SEPARATOR).filter(Boolean);
-	if (parts.length < 2) return null;
-	if (parts[0] === "shared" && parts[1] === "source-code" && parts.length >= 3) {
-		const layer = parts[2];
-		if (layer === void 0 || !LAYERS.has(layer)) return null;
-		const rest = parts.slice(3);
-		if (layer === "domain" && rest[0] === "__tests__") return {
-			context: SHARED_SOURCE_CODE_CONTEXT,
-			layer: "domain"
-		};
-		return {
-			context: SHARED_SOURCE_CODE_CONTEXT,
-			layer
-		};
-	}
-	const context = parts[0];
-	const layer = parts[1];
-	const rest = parts.slice(2);
-	if (context === void 0 || layer === void 0 || !LAYERS.has(layer)) return null;
-	if (layer === "domain" && rest[0] === "__tests__") return {
-		context,
-		layer
-	};
-	return {
-		context,
-		layer
-	};
-}
-function isArchitectureExcludedSourceFile(absoluteFilePath) {
-	const base = basenamePath(absoluteFilePath);
-	if (base.endsWith(".test.ts") || base.endsWith(".integration.test.ts")) return true;
-	return normalizePathSeparators(absoluteFilePath).split(PATH_SEPARATOR).includes("__tests__");
-}
-function resolveRelativeSpecifier(fromAbsoluteFile, specifier) {
-	if (!specifier.startsWith(".")) return null;
-	return normalizeDotSegments(joinPath(dirnamePath(fromAbsoluteFile), specifier));
-}
-function libTailAfterResolution(absoluteResolved) {
-	const tail = pathUnderCliSrcLib(absoluteResolved);
-	if (tail === null) return null;
-	return tail.split(PATH_SEPARATOR).filter(Boolean);
-}
-function lastSegmentOfLibSpecifier(specifier) {
-	const segments = internalLibSpecifierSegmentList(specifier);
-	if (segments === null) return null;
-	return segments[segments.length - 1] ?? null;
-}
-function importedModuleStem(specifier, fromAbsoluteFile) {
-	if (pathAfterInternalLibPrefix(specifier) !== null) return lastSegmentOfLibSpecifier(specifier);
-	const resolved = resolveRelativeSpecifier(fromAbsoluteFile, specifier);
-	if (resolved === null) return null;
-	const baseName = basenamePath(resolved.endsWith(".ts") ? resolved : `${resolved}.ts`);
-	return baseName.endsWith(".ts") ? baseName.slice(0, -3) : baseName;
-}
-function isPureDomainOrModelFileName(fileBaseName) {
-	return /\.(domain|model)\.ts$/.test(fileBaseName);
-}
-function isRuleAForbiddenImportedStem(moduleStem) {
-	return moduleStem.includes(".use-case") || moduleStem.includes(".adapter") || moduleStem.includes(".presenter");
-}
-function isRuleBForbiddenImportedStem(moduleStem) {
-	return moduleStem.includes(".adapter") || moduleStem.includes(".presenter");
-}
-function violationRuleAPureDomainModel(absoluteFilePath, fileBaseName, specifier) {
-	if (!isPureDomainOrModelFileName(fileBaseName)) return null;
-	const stem = importedModuleStem(specifier, absoluteFilePath);
-	if (stem === null || !isRuleAForbiddenImportedStem(stem)) return null;
-	return `${absoluteFilePath}: Rule A (pure domain/model) must not import orchestration or IO modules — blocked ${specifier} (stem "${stem}")`;
-}
-function violationRuleBApplicationIsolation(loc, absoluteFilePath, specifier) {
-	if (loc.layer !== "application") return null;
-	const stem = importedModuleStem(specifier, absoluteFilePath);
-	if (stem === null || !isRuleBForbiddenImportedStem(stem)) return null;
-	return `${absoluteFilePath}: Rule B (application isolation) must not import adapters or presenters — blocked ${specifier} (stem "${stem}")`;
-}
-function violationRuleCAntiCrossSlice(loc, specifier, fromAbsoluteFile) {
-	if (!PRODUCT_BOUNDED_CONTEXTS.has(loc.context)) return null;
-	const ruleCSegments = internalLibSpecifierSegmentList(specifier);
-	if (ruleCSegments !== null) {
-		const importedRoot = ruleCSegments[0];
-		if (importedRoot === void 0 || NEUTRAL_LIB_IMPORT_ROOTS.has(importedRoot)) return null;
-		if (importedRoot === loc.context) return null;
-		if (PRODUCT_BOUNDED_CONTEXTS.has(importedRoot)) return `${fromAbsoluteFile}: Rule C (slice isolation) context "${loc.context}" must not import "${specifier}" — use #/lib/shared/... or neutral roots (core, config, infra) instead`;
-		return null;
-	}
-	const resolved = resolveRelativeSpecifier(fromAbsoluteFile, specifier);
-	if (resolved === null) return null;
-	const parts = libTailAfterResolution(resolved.endsWith(".ts") ? resolved : `${resolved}.ts`);
-	if (parts === null || parts.length === 0) return null;
-	const importedContext = parts[0];
-	if (importedContext === void 0 || NEUTRAL_LIB_IMPORT_ROOTS.has(importedContext)) return null;
-	if (importedContext === loc.context) return null;
-	if (PRODUCT_BOUNDED_CONTEXTS.has(importedContext)) return `${fromAbsoluteFile}: Rule C (slice isolation) context "${loc.context}" must not resolve into sibling slice via ${specifier}`;
-	return null;
-}
-function violationDomainLayer(loc, specifier, fromAbsoluteFile) {
-	const domainSegments = internalLibSpecifierSegmentList(specifier);
-	if (domainSegments !== null) {
-		const segments = domainSegments;
-		if (segments[0] === "infra") return `${fromAbsoluteFile}: domain must not import ${specifier}`;
-		const sharedLayerImported = sharedSourceCodeLayerFromSpecifier(segments);
-		if (sharedLayerImported !== null && sharedLayerImported !== "domain") return `${fromAbsoluteFile}: domain must not import ${specifier}`;
-		if (segments[0] === loc.context && segments.length >= 2) {
-			const importLayer = segments[1];
-			if (importLayer === "application" || importLayer === "infra" || importLayer === "presentation") return `${fromAbsoluteFile}: domain must not import ${specifier}`;
-		}
-		const segmentZero = segments[0];
-		if (segments.length >= 2 && segments[1] === "domain" && segmentZero !== void 0 && PRODUCT_BOUNDED_CONTEXTS.has(segmentZero) && segmentZero !== loc.context) return `${fromAbsoluteFile}: domain (${loc.context}) must not import other bounded context domain ${specifier}`;
-		if (loc.context === "core" && segments.length >= 2 && segments[1] === "domain" && segmentZero !== void 0 && PRODUCT_BOUNDED_CONTEXTS.has(segmentZero)) return `${fromAbsoluteFile}: core/domain must not import bounded context domain ${specifier}`;
-		if (loc.context === "config" && segments.length >= 2 && segments[1] === "domain" && segmentZero !== void 0 && PRODUCT_BOUNDED_CONTEXTS.has(segmentZero)) return `${fromAbsoluteFile}: config/domain must not import bounded context domain ${specifier}`;
-		if (loc.context === SHARED_SOURCE_CODE_CONTEXT && segmentZero !== void 0 && PRODUCT_BOUNDED_CONTEXTS.has(segmentZero)) return `${fromAbsoluteFile}: shared source-code domain must not import product context ${specifier}`;
-		return null;
-	}
-	const resolved = resolveRelativeSpecifier(fromAbsoluteFile, specifier);
-	if (resolved === null) return null;
-	const parts = libTailAfterResolution(resolved);
-	if (parts === null || parts.length < 2) return null;
-	const relCtx = parts[0];
-	const relLayer = parts[1];
-	if (relCtx === void 0 || relLayer === void 0) return null;
-	if (relCtx === "infra") return `${fromAbsoluteFile}: domain must not resolve into infra via ${specifier}`;
-	if (relCtx === loc.context) {
-		if (relLayer === "application" || relLayer === "infra" || relLayer === "presentation") return `${fromAbsoluteFile}: domain must not resolve into ${relLayer} via ${specifier}`;
-	}
-	if (relLayer === "domain" && PRODUCT_BOUNDED_CONTEXTS.has(relCtx) && relCtx !== loc.context) return `${fromAbsoluteFile}: domain must not resolve into other bounded context domain via ${specifier}`;
-	if (loc.context === "core" && relLayer === "domain" && PRODUCT_BOUNDED_CONTEXTS.has(relCtx)) return `${fromAbsoluteFile}: core/domain must not resolve into bounded context domain via ${specifier}`;
-	return null;
-}
-function violationApplicationLayer(loc, specifier, fromAbsoluteFile) {
-	const applicationSegments = internalLibSpecifierSegmentList(specifier);
-	if (applicationSegments !== null) {
-		const segments = applicationSegments;
-		if (segments[0] === "infra") return `${fromAbsoluteFile}: application must not import ${specifier}`;
-		const sharedLayerImported = sharedSourceCodeLayerFromSpecifier(segments);
-		if (sharedLayerImported === "infra" || sharedLayerImported === "presentation" || sharedLayerImported === "application") return `${fromAbsoluteFile}: application must not import ${specifier}`;
-		if (segments.length >= 2 && (segments[1] === "infra" || segments[1] === "presentation")) return `${fromAbsoluteFile}: application must not import ${specifier}`;
-		const appSegmentZero = segments[0];
-		if (PRODUCT_BOUNDED_CONTEXTS.has(loc.context) && appSegmentZero !== void 0 && PRODUCT_BOUNDED_CONTEXTS.has(appSegmentZero) && appSegmentZero !== loc.context) return `${fromAbsoluteFile}: application (${loc.context}) must not import ${specifier}`;
-		return null;
-	}
-	const resolved = resolveRelativeSpecifier(fromAbsoluteFile, specifier);
-	if (resolved === null) return null;
-	const parts = libTailAfterResolution(resolved);
-	if (parts === null || parts.length < 2) return null;
-	const relCtx = parts[0];
-	const relLayer = parts[1];
-	if (relCtx === void 0 || relLayer === void 0) return null;
-	if (relCtx === "infra") return `${fromAbsoluteFile}: application must not resolve into infra via ${specifier}`;
-	if (relLayer === "infra" || relLayer === "presentation") return `${fromAbsoluteFile}: application must not resolve into ${relLayer} via ${specifier}`;
-	return null;
-}
-/**
-* Returns human-readable violations for a single file's imports (for unit tests and tooling).
-*/ function violationsForFileContent(absoluteFilePath, loc, sourceText) {
-	const violations = [];
-	const fileBaseName = basenamePath(absoluteFilePath);
-	for (const specifier of extractImportSpecifiers(sourceText)) {
-		const ruleA = violationRuleAPureDomainModel(absoluteFilePath, fileBaseName, specifier);
-		if (ruleA !== null) violations.push(ruleA);
-		const ruleB = violationRuleBApplicationIsolation(loc, absoluteFilePath, specifier);
-		if (ruleB !== null) violations.push(ruleB);
-		const ruleC = violationRuleCAntiCrossSlice(loc, specifier, absoluteFilePath);
-		if (ruleC !== null) violations.push(ruleC);
-		if (loc.layer === "domain") {
-			const domainViolation = violationDomainLayer(loc, specifier, absoluteFilePath);
-			if (domainViolation !== null) violations.push(domainViolation);
-		} else if (loc.layer === "application") {
-			const appViolation = violationApplicationLayer(loc, specifier, absoluteFilePath);
-			if (appViolation !== null) violations.push(appViolation);
-		}
-	}
-	return [...new Set(violations)];
-}
-function walkNonTestTsFiles(rootDir, fs) {
-	const results = [];
-	const scan = (dir) => {
-		for (const entryName of fs.readdirSync(dir)) {
-			const full = joinPath(dir, entryName);
-			const stat = fs.statSync(full);
-			if (stat.isDirectory()) {
-				if (entryName === "node_modules" || entryName === "dist") continue;
-				scan(full);
-			} else if (stat.isFile() && entryName.endsWith(".ts")) {
-				if (!isArchitectureExcludedSourceFile(full)) results.push(full);
-			}
-		}
-	};
-	scan(rootDir);
-	return results;
-}
-/**
-* Scans `packages/cli/src/lib` for explicit-architecture boundary violations (non-test sources only).
-*/ function scanCliPackageArchitectureViolations(cliPackageRoot, fs, pathService) {
-	const libRoot = pathService.join(cliPackageRoot, "src", "lib");
-	const violations = [];
-	for (const absoluteFilePath of walkNonTestTsFiles(libRoot, fs)) {
-		const loc = parseLibSourceLocation(absoluteFilePath);
-		if (loc === null) continue;
-		const sourceText = fs.readFileSync(absoluteFilePath, "utf8");
-		violations.push(...violationsForFileContent(absoluteFilePath, loc, sourceText));
-	}
-	return violations;
-}
-//#endregion
-export { extractImportSpecifiers, isArchitectureExcludedSourceFile, parseLibSourceLocation, scanCliPackageArchitectureViolations, violationsForFileContent };