@codefast/cli 0.9.0 → 0.11.0

package/dist/audit/imports/prepare.js

@@ -0,0 +1,12 @@
+import { prepareRepoRootAudit } from "#/audit/prepare";
+/**
+ * Loads config and resolves the scan target for `audit imports`.
+ *
+ * @remarks Defaults to the repo root: the import policy is repo-wide, and generated or vendored
+ * trees are already excluded by the shared walk.
+ *
+ * @since 0.10.0
+ */
+export async function prepareImportsAudit(fs, args) {
+    return prepareRepoRootAudit(fs, args, (config) => config.audit?.imports?.allowlist ?? []);
+}

package/dist/audit/imports/run.d.ts

@@ -0,0 +1,14 @@
+import type { ImportsAuditResult } from "#/audit/domain/types";
+import { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+/**
+ * Scans a target path for import-policy violations, applying each rule only to files in its scope.
+ *
+ * @since 0.10.0
+ */
+export declare function runImportsAudit(fs: Filesystem, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+}): Result<ImportsAuditResult, AppError>;

package/dist/audit/{run-react.js → imports/run.js}

@@ -1,25 +1,35 @@
 import path from "node:path";
-import { auditReactImportSource } from "#/audit/domain/react-imports";
+import { defaultImportPolicyRules } from "#/audit/imports/domain/import-policy";
+import { auditImportPolicySource } from "#/audit/imports/domain/import-policy";
 import { AppError, messageFrom } from "#/core/errors";
+import { createAnyGlobMatcher } from "#/core/glob";
 import { err, ok } from "#/core/result";
 import { walkTsxFiles } from "#/core/workspace/typescript-walk";
 /**
- * Scans a target path for React import-policy violations.
+ * Scans a target path for import-policy violations, applying each rule only to files in its scope.
  *
- * @since 0.8.0
+ * @since 0.10.0
  */
-export function runReactAudit(fs, args) {
+export function runImportsAudit(fs, args) {
     try {
         const allowlist = new Set(args.allowlist);
         const { rootDir, targetPath } = args;
+        const scopedRules = defaultImportPolicyRules.map((rule) => ({
+            rule,
+            isInScope: rule.scope ? createAnyGlobMatcher(rule.scope, { dot: true }) : () => true,
+        }));
         const filesToScan = collectScanPaths(fs, targetPath);
         const files = [];
         let violationCount = 0;
         let allowlistedCount = 0;
         for (const absolutePath of filesToScan) {
             const relativePath = toPosixPath(path.relative(rootDir, absolutePath));
+            const applicableRules = scopedRules.filter(({ isInScope }) => isInScope(relativePath)).map(({ rule }) => rule);
+            if (applicableRules.length === 0) {
+                continue;
+            }
             const content = fs.readFileSync(absolutePath, "utf8");
-            const remaining = auditReactImportSource(absolutePath, content).filter(({ raw }) => {
+            const remaining = auditImportPolicySource(absolutePath, content, applicableRules).filter(({ raw }) => {
                 const isAllowed = allowlist.has(raw) || allowlist.has(`${relativePath}:${raw}`);
                 if (isAllowed) {
                     allowlistedCount++;

package/dist/audit/links/cli-result.d.ts

@@ -0,0 +1,13 @@
+import type { LinkAuditResult } from "#/audit/domain/types";
+/**
+ * Exit `1` when any non-allowlisted broken link remains.
+ *
+ * @since 0.5.0
+ */
+export declare function exitCodeForLinkAuditResult(result: LinkAuditResult): number;
+/**
+ * Machine-readable link audit summary for `--json`.
+ *
+ * @since 0.5.0
+ */
+export declare function formatLinkAuditJsonOutput(result: LinkAuditResult, rootDir: string): string;

package/dist/audit/links/cli-result.js

@@ -0,0 +1,22 @@
+import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
+/**
+ * Exit `1` when any non-allowlisted broken link remains.
+ *
+ * @since 0.5.0
+ */
+export function exitCodeForLinkAuditResult(result) {
+    return result.breakageCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Machine-readable link audit summary for `--json`.
+ *
+ * @since 0.5.0
+ */
+export function formatLinkAuditJsonOutput(result, rootDir) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: result.breakageCount === 0,
+        cwd: rootDir,
+        result,
+    });
+}

package/dist/audit/links/cli-schema.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod";
+/**
+ * Resolved request for a single link audit run.
+ *
+ * @since 0.5.0
+ */
+export type LinkAuditRunRequest = {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist?: ReadonlyArray<string> | undefined;
+    readonly json: boolean;
+};
+/**
+ * Zod schema for {@link LinkAuditRunRequest}.
+ *
+ * @since 0.5.0
+ */
+export declare const linkAuditRunRequestSchema: z.ZodType<LinkAuditRunRequest>;

package/dist/audit/links/cli-schema.js

@@ -0,0 +1,12 @@
+import * as z from "zod";
+/**
+ * Zod schema for {@link LinkAuditRunRequest}.
+ *
+ * @since 0.5.0
+ */
+export const linkAuditRunRequestSchema = z.object({
+    rootDir: z.string().min(1),
+    targetPath: z.string().min(1),
+    allowlist: z.array(z.string()).optional(),
+    json: z.boolean(),
+});

package/dist/audit/links/domain/markdown-links.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Extracts the two things a markdown cross-reference can get wrong: where it points and what it lands on.
+ */
+/**
+ * One `[text](target)` whose target is a path in this repository.
+ *
+ * @since 0.5.0
+ */
+type MarkdownLinkReference = {
+    readonly line: number;
+    /** The path as written, with any fragment stripped. Empty when the link is fragment-only. */
+    readonly targetPath: string;
+    /** The `#fragment`, without the hash, or `null`. */
+    readonly anchor: string | null;
+};
+/**
+ * The anchors a document offers, and the references it makes.
+ *
+ * @since 0.5.0
+ */
+export type MarkdownLinkScan = {
+    readonly references: ReadonlyArray<MarkdownLinkReference>;
+    readonly anchors: ReadonlySet<string>;
+};
+/**
+ * The anchor ids a rendered document exposes: explicit `<a id>` targets plus every heading's slug.
+ *
+ * @remarks Slugging matches GitHub's — lowercase, drop everything that is not a letter, number, space
+ * or hyphen, then hyphenate spaces. Duplicate headings get a `-1` suffix there; this returns the base
+ * only, so a link to the second copy reads as dangling rather than being silently accepted.
+ *
+ * @since 0.5.0
+ */
+export declare function collectMarkdownAnchors(content: string): Set<string>;
+/**
+ * Every repo-local link a document makes, with the anchors it offers.
+ *
+ * @remarks Fenced code is stripped first: a fence showing a link is an example, not a reference, and
+ * checking it would make the audit fail on documentation that is doing its job.
+ *
+ * @since 0.5.0
+ */
+export declare function scanMarkdownLinks(content: string): MarkdownLinkScan;
+export {};

package/dist/audit/links/output.d.ts

@@ -0,0 +1,7 @@
+import type { LinkAuditResult } from "#/audit/domain/types";
+/**
+ * Human-readable link audit report.
+ *
+ * @since 0.5.0
+ */
+export declare function presentLinkAuditResult(result: LinkAuditResult): void;

package/dist/audit/links/output.js

@@ -0,0 +1,21 @@
+import { logger } from "#/core/logger";
+/**
+ * Human-readable link audit report.
+ *
+ * @since 0.5.0
+ */
+export function presentLinkAuditResult(result) {
+    for (const file of result.files) {
+        logger.out(`\n${file.relativePath}`);
+        for (const { line, raw, reason } of file.breakages) {
+            logger.out(`  ${line}: ${raw} → ${reason}`);
+        }
+    }
+    const allowlistSuffix = result.allowlistedCount > 0 ? ` (${result.allowlistedCount} allowlisted)` : "";
+    if (result.breakageCount > 0) {
+        logger.out(`\n✖ ${result.breakageCount} broken link(s)${allowlistSuffix}`);
+    }
+    else {
+        logger.out(`✓ ${result.linkCount} repo-local link(s) across ${result.scannedFileCount} document(s) all resolve${allowlistSuffix}`);
+    }
+}

package/dist/audit/links/prepare.d.ts

@@ -0,0 +1,16 @@
+import type { AuditCommandPrelude } from "#/audit/prepare";
+import type { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+/**
+ * Loads config and resolves the scan target for `audit links`.
+ *
+ * @remarks Defaults to the repo root rather than a configured path: a link audit that only covers one
+ * package cannot see the cross-package references that are the ones most likely to rot.
+ *
+ * @since 0.5.0
+ */
+export declare function prepareLinkAudit(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<AuditCommandPrelude, AppError>>;

package/dist/audit/links/prepare.js

@@ -0,0 +1,12 @@
+import { prepareRepoRootAudit } from "#/audit/prepare";
+/**
+ * Loads config and resolves the scan target for `audit links`.
+ *
+ * @remarks Defaults to the repo root rather than a configured path: a link audit that only covers one
+ * package cannot see the cross-package references that are the ones most likely to rot.
+ *
+ * @since 0.5.0
+ */
+export async function prepareLinkAudit(fs, args) {
+    return prepareRepoRootAudit(fs, args, (config) => config.audit?.links?.allowlist ?? []);
+}

package/dist/audit/links/run.d.ts

@@ -0,0 +1,14 @@
+import type { LinkAuditResult } from "#/audit/domain/types";
+import { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+/**
+ * Reports markdown links that point at nothing — a missing path, or an anchor the target does not offer.
+ *
+ * @since 0.5.0
+ */
+export declare function runLinkAudit(fs: Filesystem, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+}): Result<LinkAuditResult, AppError>;

package/dist/audit/{run-links.js → links/run.js}

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { collectMarkdownAnchors, scanMarkdownLinks } from "#/audit/domain/markdown-links";
+import { collectMarkdownAnchors, scanMarkdownLinks } from "#/audit/links/domain/markdown-links";
 import { AppError, messageFrom } from "#/core/errors";
 import { err, ok } from "#/core/result";
 import { walkMarkdownFiles } from "#/core/workspace/markdown-walk";

package/dist/audit/prepare.d.ts

@@ -0,0 +1,31 @@
+import type { CodefastConfig } from "#/core/config/schema";
+import { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+/**
+ * Shared prelude for an audit: repo root and the canonicalized scan target with its allowlist.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type AuditCommandPrelude = {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+};
+/**
+ * Resolves a path that may be absolute or relative to `rootDir`.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function resolveRepoRelativePath(rootDir: string, maybeRelative: string): string;
+/**
+ * Loads config and resolves the repo root as the scan target, taking the allowlist the caller selects.
+ *
+ * @remarks Every repo-wide audit shares this prelude; only the config key its allowlist comes from differs.
+ *
+ * @since 0.11.0
+ */
+export declare function prepareRepoRootAudit(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}, selectAllowlist: (config: CodefastConfig) => ReadonlyArray<string>): Promise<Result<AuditCommandPrelude, AppError>>;

package/dist/audit/prepare.js

@@ -1,149 +1,27 @@
-import { resolveRepoRelativePath } from "#/audit/cli-schema";
+import path from "node:path";
 import { loadCodefastConfig } from "#/core/config";
 import { AppError, messageFrom } from "#/core/errors";
 import { err, ok } from "#/core/result";
-import { findRepoRoot } from "#/core/workspace/resolver";
+import { resolveProjectRoot } from "#/core/workspace/resolver";
 /**
- * Loads config and resolves the scan target for `audit rtl`.
+ * Resolves a path that may be absolute or relative to `rootDir`.
  *
  * @since 0.5.0-canary.6
  */
-export async function prepareRtlAudit(fs, args) {
-    let rootDir;
-    try {
-        // Realpath so allowlist keys (`path.relative(rootDir, file)`) stay stable when cwd is a symlink.
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
-    }
-    catch (caughtError) {
-        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
-    }
-    const loadedOutcome = await loadCodefastConfig(rootDir, fs);
-    if (!loadedOutcome.ok) {
-        return loadedOutcome;
-    }
-    const { config } = loadedOutcome.value;
-    const rtlConfig = config.audit?.rtl ?? {};
-    const targetFromCli = args.rawTarget;
-    const targetFromConfig = rtlConfig.target;
-    const resolvedTargetInput = targetFromCli ?? targetFromConfig;
-    if (resolvedTargetInput === undefined) {
-        return err(new AppError("VALIDATION_ERROR", "Missing scan target: pass a path argument or set audit.rtl.target in codefast.config"));
-    }
-    const targetPath = resolveRepoRelativePath(targetFromCli !== undefined ? args.currentWorkingDirectory : rootDir, resolvedTargetInput);
-    if (!fs.existsSync(targetPath)) {
-        return err(new AppError("NOT_FOUND", `Not found: ${targetPath}`));
-    }
-    return ok({
-        rootDir,
-        targetPath: fs.canonicalPathSync(targetPath),
-        allowlist: rtlConfig.allowlist ?? [],
-    });
-}
-/**
- * Loads config and resolves the scan target for `audit links`.
- *
- * @remarks Defaults to the repo root rather than a configured path: a link audit that only covers one
- * package cannot see the cross-package references that are the ones most likely to rot.
- *
- * @since 0.5.0
- */
-export async function prepareLinkAudit(fs, args) {
-    let rootDir;
-    try {
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
-    }
-    catch (caughtError) {
-        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
-    }
-    const loadedOutcome = await loadCodefastConfig(rootDir, fs);
-    if (!loadedOutcome.ok) {
-        return loadedOutcome;
-    }
-    const linksConfig = loadedOutcome.value.config.audit?.links ?? {};
-    const targetPath = args.rawTarget === undefined ? rootDir : resolveRepoRelativePath(args.currentWorkingDirectory, args.rawTarget);
-    if (!fs.existsSync(targetPath)) {
-        return err(new AppError("NOT_FOUND", `Not found: ${targetPath}`));
-    }
-    return ok({
-        rootDir,
-        targetPath: fs.canonicalPathSync(targetPath),
-        allowlist: linksConfig.allowlist ?? [],
-    });
-}
-/**
- * Loads config and resolves the scan target for `audit react`.
- *
- * @remarks Defaults to the repo root: the import policy is repo-wide, and generated or vendored
- * trees are already excluded by the shared walk.
- *
- * @since 0.8.0
- */
-export async function prepareReactAudit(fs, args) {
-    let rootDir;
-    try {
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
-    }
-    catch (caughtError) {
-        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
-    }
-    const loadedOutcome = await loadCodefastConfig(rootDir, fs);
-    if (!loadedOutcome.ok) {
-        return loadedOutcome;
-    }
-    const reactConfig = loadedOutcome.value.config.audit?.react ?? {};
-    const targetPath = args.rawTarget === undefined ? rootDir : resolveRepoRelativePath(args.currentWorkingDirectory, args.rawTarget);
-    if (!fs.existsSync(targetPath)) {
-        return err(new AppError("NOT_FOUND", `Not found: ${targetPath}`));
-    }
-    return ok({
-        rootDir,
-        targetPath: fs.canonicalPathSync(targetPath),
-        allowlist: reactConfig.allowlist ?? [],
-    });
-}
-/**
- * Loads config and resolves the scan target for `audit comments`.
- *
- * @remarks Defaults to the repo root: a divider convention that only holds inside one package
- * is not a convention.
- *
- * @since 0.6.0
- */
-export async function prepareCommentAudit(fs, args) {
-    let rootDir;
-    try {
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
-    }
-    catch (caughtError) {
-        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
-    }
-    const loadedOutcome = await loadCodefastConfig(rootDir, fs);
-    if (!loadedOutcome.ok) {
-        return loadedOutcome;
-    }
-    const commentsConfig = loadedOutcome.value.config.audit?.comments ?? {};
-    const targetPath = args.rawTarget === undefined ? rootDir : resolveRepoRelativePath(args.currentWorkingDirectory, args.rawTarget);
-    if (!fs.existsSync(targetPath)) {
-        return err(new AppError("NOT_FOUND", `Not found: ${targetPath}`));
-    }
-    return ok({
-        rootDir,
-        targetPath: fs.canonicalPathSync(targetPath),
-        allowlist: commentsConfig.allowlist ?? [],
-    });
+export function resolveRepoRelativePath(rootDir, maybeRelative) {
+    return path.isAbsolute(maybeRelative) ? path.resolve(maybeRelative) : path.resolve(rootDir, maybeRelative);
 }
 /**
- * Loads config and resolves the scan target for `audit display-names`.
+ * Loads config and resolves the repo root as the scan target, taking the allowlist the caller selects.
  *
- * @remarks Defaults to the repo root: a display name collides across packages, so the convention
- * has to hold across them.
+ * @remarks Every repo-wide audit shares this prelude; only the config key its allowlist comes from differs.
  *
- * @since 0.9.0
+ * @since 0.11.0
  */
-export async function prepareDisplayNameAudit(fs, args) {
+export async function prepareRepoRootAudit(fs, args, selectAllowlist) {
     let rootDir;
     try {
-        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
+        rootDir = fs.canonicalPathSync(resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir);
     }
     catch (caughtError) {
         return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
@@ -152,7 +30,6 @@ export async function prepareDisplayNameAudit(fs, args) {
     if (!loadedOutcome.ok) {
         return loadedOutcome;
     }
-    const displayNamesConfig = loadedOutcome.value.config.audit?.displayNames ?? {};
     const targetPath = args.rawTarget === undefined ? rootDir : resolveRepoRelativePath(args.currentWorkingDirectory, args.rawTarget);
     if (!fs.existsSync(targetPath)) {
         return err(new AppError("NOT_FOUND", `Not found: ${targetPath}`));
@@ -160,6 +37,6 @@ export async function prepareDisplayNameAudit(fs, args) {
     return ok({
         rootDir,
         targetPath: fs.canonicalPathSync(targetPath),
-        allowlist: displayNamesConfig.allowlist ?? [],
+        allowlist: selectAllowlist(loadedOutcome.value.config),
     });
 }

package/dist/audit/rtl/cli-result.d.ts

@@ -0,0 +1,13 @@
+import type { RtlAuditResult } from "#/audit/domain/types";
+/**
+ * Exit `1` when any non-allowlisted violation remains.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function exitCodeForRtlAuditResult(result: RtlAuditResult): number;
+/**
+ * Machine-readable RTL audit summary for `--json`.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function formatRtlAuditJsonOutput(result: RtlAuditResult, rootDir: string): string;

package/dist/audit/rtl/cli-result.js

@@ -0,0 +1,22 @@
+import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
+/**
+ * Exit `1` when any non-allowlisted violation remains.
+ *
+ * @since 0.5.0-canary.6
+ */
+export function exitCodeForRtlAuditResult(result) {
+    return result.violationCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Machine-readable RTL audit summary for `--json`.
+ *
+ * @since 0.5.0-canary.6
+ */
+export function formatRtlAuditJsonOutput(result, rootDir) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: result.violationCount === 0,
+        cwd: rootDir,
+        result,
+    });
+}

package/dist/audit/rtl/cli-schema.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod";
+/**
+ * Resolved request for a single RTL audit run.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlAuditRunRequest = {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist?: ReadonlyArray<string> | undefined;
+    readonly json: boolean;
+};
+/**
+ * Zod schema for {@link RtlAuditRunRequest}.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare const rtlAuditRunRequestSchema: z.ZodType<RtlAuditRunRequest>;

package/dist/audit/rtl/cli-schema.js

@@ -0,0 +1,12 @@
+import * as z from "zod";
+/**
+ * Zod schema for {@link RtlAuditRunRequest}.
+ *
+ * @since 0.5.0-canary.6
+ */
+export const rtlAuditRunRequestSchema = z.object({
+    rootDir: z.string().min(1),
+    targetPath: z.string().min(1),
+    allowlist: z.array(z.string()).optional(),
+    json: z.boolean(),
+});

package/dist/audit/rtl/domain/audit-file.d.ts

@@ -0,0 +1,7 @@
+import type { RtlViolation } from "#/audit/domain/types";
+/**
+ * Detects physical-direction Tailwind classes that should be logical or rtl:-paired.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function auditFileContent(content: string): Array<RtlViolation>;

package/dist/audit/{domain → rtl/domain}/audit-file.js

@@ -1,5 +1,5 @@
-import { DIRECTION_RESOLVED_VARIANT, PHYSICAL_SIDE_VARIANT, RTL_MAPPINGS, RTL_REVERSE_MAPPINGS, RTL_SWAP_MAPPINGS, RTL_TRANSLATE_X_MAPPINGS, SLIDE_PREFIXES, } from "#/audit/domain/mappings";
-import { collectTokens } from "#/audit/domain/tokenize";
+import { DIRECTION_RESOLVED_VARIANT, PHYSICAL_SIDE_VARIANT, RTL_MAPPINGS, RTL_REVERSE_MAPPINGS, RTL_SWAP_MAPPINGS, RTL_TRANSLATE_X_MAPPINGS, SLIDE_PREFIXES, } from "#/audit/rtl/domain/mappings";
+import { collectTokens } from "#/audit/rtl/domain/tokenize";
 /**
  * A token satisfies an "rtl companion" requirement when the same file has a
  * token whose variants include `rtl` and whose value matches. Variant order

package/dist/audit/rtl/domain/mappings.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Physical → logical replacements. Order matters: negative before positive,
+ * specific corners before general edges, with-value before bare.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare const RTL_MAPPINGS: ReadonlyArray<readonly [string, string]>;
+/**
+ * translate-x has no logical equivalent — it needs an rtl:-negated twin.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare const RTL_TRANSLATE_X_MAPPINGS: ReadonlyArray<readonly [string, string]>;
+/**
+ * Classes that need an rtl:*-reverse companion.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare const RTL_REVERSE_MAPPINGS: ReadonlyArray<readonly [string, string]>;
+/**
+ * Classes that need an rtl: companion with the swapped value.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare const RTL_SWAP_MAPPINGS: ReadonlyArray<readonly [string, string]>;
+/**
+ * Anything anchored to a physical side variant stays physical: Radix resolves
+ * `side` per direction, and a border/position/slide tied to that side must follow it.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare const PHYSICAL_SIDE_VARIANT: RegExp;
+/**
+ * Slide animations under direction-resolved contexts are correct as-is:
+ * Radix flips `side`/`motion` values itself under DirectionProvider.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare const DIRECTION_RESOLVED_VARIANT: RegExp;
+/**
+ * The physical slide-animation class prefixes the RTL audit inspects.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare const SLIDE_PREFIXES: readonly ["slide-in-from-left", "slide-in-from-right", "slide-out-to-left", "slide-out-to-right"];

package/dist/audit/rtl/domain/tokenize.d.ts

@@ -0,0 +1,14 @@
+import type { RtlClassToken } from "#/audit/domain/types";
+/**
+ * Splits a class token into [variant, value, modifier], colon/slash-aware of
+ * brackets and parens (arbitrary values like data-[side=left] or calc(...)).
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function splitClassName(token: string): [string | null, string, string | null];
+/**
+ * Collects the parsed class tokens from every string literal in a file's content.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function collectTokens(content: string): Array<RtlClassToken>;

package/dist/audit/rtl/output.d.ts

@@ -0,0 +1,7 @@
+import type { RtlAuditResult } from "#/audit/domain/types";
+/**
+ * Human-readable RTL audit report (matches the former packages/ui script shape).
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function presentRtlAuditResult(result: RtlAuditResult): void;

package/dist/audit/rtl/output.js

@@ -0,0 +1,21 @@
+import { logger } from "#/core/logger";
+/**
+ * Human-readable RTL audit report (matches the former packages/ui script shape).
+ *
+ * @since 0.5.0-canary.6
+ */
+export function presentRtlAuditResult(result) {
+    for (const file of result.files) {
+        logger.out(`\n${file.relativePath}`);
+        for (const { line, raw, suggestion } of file.violations) {
+            logger.out(`  ${line}: ${raw} → ${suggestion}`);
+        }
+    }
+    const allowlistSuffix = result.allowlistedCount > 0 ? ` (${result.allowlistedCount} allowlisted)` : "";
+    if (result.violationCount > 0) {
+        logger.out(`\n✖ ${result.violationCount} RTL violation(s)${allowlistSuffix}`);
+    }
+    else {
+        logger.out(`✓ No physical-direction classes outside the allowlist${allowlistSuffix}`);
+    }
+}