@codefast/cli 0.9.0 → 0.11.0

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

@@ -0,0 +1,17 @@
+import type { CommentAuditResult } from "#/audit/domain/types";
+import { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+/**
+ * Reports every comment off the repo's conventions: divider form (which `fix` rewrites), banned
+ * content — document pointers, JSDoc types, tag misuse — `{@link}` targets nothing declares, and
+ * every diagnostic the official TSDoc parser raises against a doc block's grammar.
+ *
+ * @since 0.6.0
+ */
+export declare function runCommentAudit(fs: Filesystem, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+    readonly fix: boolean;
+}): Result<CommentAuditResult, AppError>;

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

@@ -1,9 +1,9 @@
 import path from "node:path";
-import { scanCommentContent } from "#/audit/domain/comment-content";
-import { applyCommentDividerFixes, DIVIDER_COLUMN, scanCommentDividers } from "#/audit/domain/comment-dividers";
-import { countHeadMentions, isPathLinkTarget, linkTargetHead, scanLinkReferences, } from "#/audit/domain/link-references";
-import { scanImpossibleSinceTags } from "#/audit/domain/since-versions";
-import { scanTsdocSyntax } from "#/audit/domain/tsdoc-syntax";
+import { scanCommentContent } from "#/audit/comments/domain/comment-content";
+import { applyCommentDividerFixes, DIVIDER_COLUMN, scanCommentDividers, } from "#/audit/comments/domain/comment-dividers";
+import { countHeadMentions, isPathLinkTarget, linkTargetHead, scanLinkReferences, } from "#/audit/comments/domain/link-references";
+import { scanImpossibleSinceTags } from "#/audit/comments/domain/since-versions";
+import { scanTsdocSyntax } from "#/audit/comments/domain/tsdoc-syntax";
 import { AppError, messageFrom } from "#/core/errors";
 import { err, ok } from "#/core/result";
 import { findNearestPackageVersion } from "#/core/workspace/package-version";

package/dist/audit/display-names/cli-result.d.ts

@@ -0,0 +1,13 @@
+import type { DisplayNameAuditResult } from "#/audit/domain/types";
+/**
+ * Exit `1` when any non-allowlisted display-name violation remains.
+ *
+ * @since 0.9.0
+ */
+export declare function exitCodeForDisplayNameAuditResult(result: DisplayNameAuditResult): number;
+/**
+ * Machine-readable display-name summary for `--json`.
+ *
+ * @since 0.9.0
+ */
+export declare function formatDisplayNameAuditJsonOutput(result: DisplayNameAuditResult, rootDir: string): string;

package/dist/audit/display-names/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 display-name violation remains.
+ *
+ * @since 0.9.0
+ */
+export function exitCodeForDisplayNameAuditResult(result) {
+    return result.violationCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Machine-readable display-name summary for `--json`.
+ *
+ * @since 0.9.0
+ */
+export function formatDisplayNameAuditJsonOutput(result, rootDir) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: result.violationCount === 0,
+        cwd: rootDir,
+        result,
+    });
+}

package/dist/audit/display-names/cli-schema.d.ts

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

package/dist/audit/display-names/cli-schema.js

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

package/dist/audit/display-names/domain/display-names.d.ts

@@ -0,0 +1,11 @@
+/** The display-name convention: a name is spelled like the TS symbol it stands for, under its owner's namespace. */
+import type { DisplayNameViolation } from "#/audit/domain/types";
+/**
+ * Scans one source or markdown text for `token()`, `tag()` and module display names that break the convention.
+ *
+ * @remarks Runs on markdown as well as TypeScript because a doc sample is what a reader copies:
+ * a convention the docs break is not one the docs teach.
+ *
+ * @since 0.9.0
+ */
+export declare function auditDisplayNames(sourceText: string): Array<DisplayNameViolation>;

package/dist/audit/display-names/output.d.ts

@@ -0,0 +1,7 @@
+import type { DisplayNameAuditResult } from "#/audit/domain/types";
+/**
+ * Human-readable display-name report.
+ *
+ * @since 0.9.0
+ */
+export declare function presentDisplayNameAuditResult(result: DisplayNameAuditResult): void;

package/dist/audit/display-names/output.js

@@ -0,0 +1,21 @@
+import { logger } from "#/core/logger";
+/**
+ * Human-readable display-name report.
+ *
+ * @since 0.9.0
+ */
+export function presentDisplayNameAuditResult(result) {
+    for (const file of result.files) {
+        logger.out(`\n${file.relativePath}`);
+        for (const { line, raw, reason } of file.violations) {
+            logger.out(`  ${line}: ${raw} → ${reason}`);
+        }
+    }
+    const allowlistSuffix = result.allowlistedCount > 0 ? ` (${result.allowlistedCount} allowlisted)` : "";
+    if (result.violationCount > 0) {
+        logger.out(`\n✖ ${result.violationCount} display name(s) off the convention${allowlistSuffix}`);
+    }
+    else {
+        logger.out(`✓ Every token, tag and module display name follows <namespace>:<Name> across ${result.scannedFileCount} file(s)${allowlistSuffix}`);
+    }
+}

package/dist/audit/display-names/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 display-names`.
+ *
+ * @remarks Defaults to the repo root: a display name collides across packages, so the convention
+ * has to hold across them.
+ *
+ * @since 0.9.0
+ */
+export declare function prepareDisplayNameAudit(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<AuditCommandPrelude, AppError>>;

package/dist/audit/display-names/prepare.js

@@ -0,0 +1,12 @@
+import { prepareRepoRootAudit } from "#/audit/prepare";
+/**
+ * Loads config and resolves the scan target for `audit display-names`.
+ *
+ * @remarks Defaults to the repo root: a display name collides across packages, so the convention
+ * has to hold across them.
+ *
+ * @since 0.9.0
+ */
+export async function prepareDisplayNameAudit(fs, args) {
+    return prepareRepoRootAudit(fs, args, (config) => config.audit?.displayNames?.allowlist ?? []);
+}

package/dist/audit/display-names/run.d.ts

@@ -0,0 +1,14 @@
+import type { DisplayNameAuditResult } 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 `token()`, `tag()` and module display names that break the convention.
+ *
+ * @since 0.9.0
+ */
+export declare function runDisplayNameAudit(fs: Filesystem, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+}): Result<DisplayNameAuditResult, AppError>;

package/dist/audit/{run-display-names.js → display-names/run.js}

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

package/dist/audit/domain/types.d.ts

@@ -0,0 +1,171 @@
+/**
+ * A class token parsed from a source string literal, split into variant, value, and modifier.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlClassToken = {
+    readonly raw: string;
+    readonly token: string;
+    readonly variant: string | null;
+    readonly value: string;
+    readonly modifier: string | null;
+    readonly line: number;
+};
+/**
+ * A physical class occurrence the RTL audit flags, with its suggested logical replacement.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlViolation = {
+    readonly line: number;
+    readonly raw: string;
+    readonly suggestion: string;
+};
+/**
+ * The RTL violations found in one file.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlFileViolations = {
+    readonly relativePath: string;
+    readonly violations: Array<RtlViolation>;
+};
+/**
+ * Outcome of one `audit rtl` run.
+ *
+ * @since 0.5.0-canary.6
+ */
+export type RtlAuditResult = {
+    readonly files: Array<RtlFileViolations>;
+    readonly violationCount: number;
+    readonly allowlistedCount: number;
+    readonly scannedFileCount: number;
+};
+/**
+ * An import-policy violation: a banned import form (namespace / default / named), or an implicit
+ * UMD-global type reference under a name nothing in the file imports.
+ *
+ * @since 0.10.0
+ */
+export type ImportPolicyViolation = {
+    readonly line: number;
+    /** The offending source text — the import statement or the qualified type name. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * The import-policy violations found in one file.
+ *
+ * @since 0.10.0
+ */
+export type ImportPolicyFileViolations = {
+    readonly relativePath: string;
+    readonly violations: Array<ImportPolicyViolation>;
+};
+/**
+ * Outcome of one `audit imports` run.
+ *
+ * @since 0.10.0
+ */
+export type ImportsAuditResult = {
+    readonly files: Array<ImportPolicyFileViolations>;
+    readonly violationCount: number;
+    readonly allowlistedCount: number;
+    readonly scannedFileCount: number;
+};
+/**
+ * A `token()`, `tag()` or module display name that breaks the display-name convention.
+ *
+ * @since 0.9.0
+ */
+export type DisplayNameViolation = {
+    readonly line: number;
+    /** The call as written, through its closing quote. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * The display-name violations found in one file.
+ *
+ * @since 0.9.0
+ */
+export type DisplayNameFileViolations = {
+    readonly relativePath: string;
+    readonly violations: Array<DisplayNameViolation>;
+};
+/**
+ * Outcome of one `audit display-names` run.
+ *
+ * @since 0.9.0
+ */
+export type DisplayNameAuditResult = {
+    readonly files: Array<DisplayNameFileViolations>;
+    readonly violationCount: number;
+    readonly allowlistedCount: number;
+    readonly scannedFileCount: number;
+};
+/**
+ * A broken link or anchor found by the link audit.
+ *
+ * @since 0.5.0
+ */
+export type LinkBreakage = {
+    readonly line: number;
+    /** The link target as written, fragment included. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * The link breakages found in one markdown file.
+ *
+ * @since 0.5.0
+ */
+export type LinkFileBreakages = {
+    readonly relativePath: string;
+    readonly breakages: Array<LinkBreakage>;
+};
+/**
+ * Outcome of one `audit links` run.
+ *
+ * @since 0.5.0
+ */
+export type LinkAuditResult = {
+    readonly files: Array<LinkFileBreakages>;
+    readonly breakageCount: number;
+    readonly allowlistedCount: number;
+    readonly linkCount: number;
+    readonly scannedFileCount: number;
+};
+/**
+ * A section divider that does not match the repo's one allowed form. Always `--fix`-able.
+ *
+ * @since 0.6.0
+ */
+export type DividerBreakage = {
+    readonly line: number;
+    /** The divider's opening line as written. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * @see DividerBreakage
+ *
+ * @since 0.6.0
+ */
+export type DividerFileBreakages = {
+    readonly relativePath: string;
+    readonly breakages: Array<DividerBreakage>;
+};
+/**
+ * Outcome of one `audit comments` run. `fixedCount` stays `0` unless `--fix` was passed.
+ *
+ * @since 0.6.0
+ */
+export type CommentAuditResult = {
+    readonly files: Array<DividerFileBreakages>;
+    readonly breakageCount: number;
+    readonly allowlistedCount: number;
+    readonly fixedCount: number;
+    readonly dividerCount: number;
+    readonly scannedFileCount: number;
+};

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

@@ -0,0 +1,13 @@
+import type { ImportsAuditResult } from "#/audit/domain/types";
+/**
+ * Exit `1` when any non-allowlisted import-policy violation remains.
+ *
+ * @since 0.10.0
+ */
+export declare function exitCodeForImportsAuditResult(result: ImportsAuditResult): number;
+/**
+ * Machine-readable import-policy summary for `--json`.
+ *
+ * @since 0.10.0
+ */
+export declare function formatImportsAuditJsonOutput(result: ImportsAuditResult, rootDir: string): string;

package/dist/audit/imports/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 import-policy violation remains.
+ *
+ * @since 0.10.0
+ */
+export function exitCodeForImportsAuditResult(result) {
+    return result.violationCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Machine-readable import-policy summary for `--json`.
+ *
+ * @since 0.10.0
+ */
+export function formatImportsAuditJsonOutput(result, rootDir) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: result.violationCount === 0,
+        cwd: rootDir,
+        result,
+    });
+}

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

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

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

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

package/dist/audit/imports/domain/import-policy.d.ts

@@ -0,0 +1,34 @@
+import type { ImportPolicyViolation } from "#/audit/domain/types";
+/**
+ * One library's import policy: which forms of importing `module` are banned, optionally limited to
+ * files whose repo-relative path matches `scope`, plus an optional UMD-global name to flag when the
+ * file references `<name>.*` without importing it.
+ *
+ * @since 0.10.0
+ */
+export interface ImportPolicyRule {
+    readonly module: string;
+    /** Banned forms: `namespace` (`import * as x`), `default` (`import x`), or `named:<name>`. */
+    readonly ban: ReadonlyArray<"namespace" | "default" | `named:${string}`>;
+    readonly scope?: ReadonlyArray<string> | undefined;
+    readonly umdGlobal?: string | undefined;
+    readonly message: string;
+}
+/**
+ * The import policies enforced across the monorepo: React members by name (never a namespace,
+ * default, or implicit `React.*` UMD global), and Zod as a namespace repo-wide — the house form,
+ * so a named `import { z }` never pins Zod's full locale set into a package that ships bundled.
+ *
+ * @since 0.10.0
+ */
+export declare const defaultImportPolicyRules: ReadonlyArray<ImportPolicyRule>;
+/**
+ * Scans one TypeScript source against the given import-policy rules and returns the violations.
+ *
+ * @remarks Each rule matches import declarations from its `module` and flags the banned forms;
+ * a rule with `umdGlobal` additionally flags implicit `<name>.*` type references when nothing in
+ * the file imports that name (the case tsc accepts silently through a UMD `export as namespace`).
+ *
+ * @since 0.10.0
+ */
+export declare function auditImportPolicySource(filePath: string, sourceText: string, rules: ReadonlyArray<ImportPolicyRule>): Array<ImportPolicyViolation>;

package/dist/audit/imports/domain/import-policy.js

@@ -0,0 +1,140 @@
+import { parseSync } from "oxc-parser";
+/**
+ * The import policies enforced across the monorepo: React members by name (never a namespace,
+ * default, or implicit `React.*` UMD global), and Zod as a namespace repo-wide — the house form,
+ * so a named `import { z }` never pins Zod's full locale set into a package that ships bundled.
+ *
+ * @since 0.10.0
+ */
+export const defaultImportPolicyRules = [
+    {
+        module: "react",
+        ban: ["namespace", "default"],
+        umdGlobal: "React",
+        message: 'import React members by name from "react"',
+    },
+    {
+        module: "zod",
+        ban: ["named:z"],
+        message: 'import Zod as a namespace: import * as z from "zod" (repo house form; a named import { z } pins Zod\'s full ' +
+            "locale set into any bundle that reaches it)",
+    },
+];
+function isOxcNode(value) {
+    return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function isIdentifierNamed(node, name) {
+    return isOxcNode(node) && node.type === "Identifier" && node.name === name;
+}
+function importedName(specifier) {
+    const imported = specifier.imported;
+    return isOxcNode(imported) && typeof imported.name === "string" ? imported.name : undefined;
+}
+/**
+ * Scans one TypeScript source against the given import-policy rules and returns the violations.
+ *
+ * @remarks Each rule matches import declarations from its `module` and flags the banned forms;
+ * a rule with `umdGlobal` additionally flags implicit `<name>.*` type references when nothing in
+ * the file imports that name (the case tsc accepts silently through a UMD `export as namespace`).
+ *
+ * @since 0.10.0
+ */
+export function auditImportPolicySource(filePath, sourceText, rules) {
+    const { program } = parseSync(filePath, sourceText);
+    const statements = program.body;
+    const violations = [];
+    const boundUmdNames = new Set();
+    for (const rule of rules) {
+        const bannedNamed = new Set();
+        let banNamespace = false;
+        let banDefault = false;
+        for (const form of rule.ban) {
+            if (form === "namespace") {
+                banNamespace = true;
+            }
+            else if (form === "default") {
+                banDefault = true;
+            }
+            else {
+                bannedNamed.add(form.slice("named:".length));
+            }
+        }
+        for (const statement of statements) {
+            if (statement.type !== "ImportDeclaration") {
+                continue;
+            }
+            const source = statement.source;
+            if (!isOxcNode(source) || source.value !== rule.module) {
+                continue;
+            }
+            const specifiers = Array.isArray(statement.specifiers) ? statement.specifiers.filter(isOxcNode) : [];
+            const umdGlobal = rule.umdGlobal;
+            if (umdGlobal !== undefined && specifiers.some((specifier) => isIdentifierNamed(specifier.local, umdGlobal))) {
+                boundUmdNames.add(umdGlobal);
+            }
+            for (const specifier of specifiers) {
+                if (banNamespace && specifier.type === "ImportNamespaceSpecifier") {
+                    violations.push(violationAt(sourceText, statement, `namespace import of "${rule.module}" — ${rule.message}`));
+                }
+                else if (banDefault && specifier.type === "ImportDefaultSpecifier") {
+                    violations.push(violationAt(sourceText, statement, `default import of "${rule.module}" — ${rule.message}`));
+                }
+                else if (specifier.type === "ImportSpecifier") {
+                    const name = importedName(specifier);
+                    if (name !== undefined && bannedNamed.has(name)) {
+                        violations.push(violationAt(sourceText, statement, `named import { ${name} } from "${rule.module}" — ${rule.message}`));
+                    }
+                }
+            }
+        }
+    }
+    for (const rule of rules) {
+        if (rule.umdGlobal !== undefined && !boundUmdNames.has(rule.umdGlobal)) {
+            collectUmdGlobalReferences(program, sourceText, rule, violations);
+        }
+    }
+    violations.sort((a, b) => a.line - b.line);
+    return violations;
+}
+function violationAt(sourceText, statement, reason) {
+    return {
+        line: lineOfOffset(sourceText, statement.start),
+        raw: firstLineOf(sourceText.slice(statement.start, statement.end)),
+        reason,
+    };
+}
+function collectUmdGlobalReferences(node, sourceText, rule, violations) {
+    if (node.type === "TSQualifiedName" && isIdentifierNamed(node.left, rule.umdGlobal ?? "")) {
+        violations.push({
+            line: lineOfOffset(sourceText, node.start),
+            raw: sourceText.slice(node.start, node.end),
+            reason: `implicit ${rule.umdGlobal}.* UMD global — ${rule.message}`,
+        });
+        return;
+    }
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (isOxcNode(item)) {
+                    collectUmdGlobalReferences(item, sourceText, rule, violations);
+                }
+            }
+        }
+        else if (isOxcNode(value)) {
+            collectUmdGlobalReferences(value, sourceText, rule, violations);
+        }
+    }
+}
+function lineOfOffset(sourceText, offset) {
+    let line = 1;
+    for (let index = 0; index < offset; index++) {
+        if (sourceText.charCodeAt(index) === 10) {
+            line++;
+        }
+    }
+    return line;
+}
+function firstLineOf(text) {
+    const newlineIndex = text.indexOf("\n");
+    return newlineIndex === -1 ? text : text.slice(0, newlineIndex);
+}

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

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

package/dist/audit/imports/output.js

@@ -0,0 +1,21 @@
+import { logger } from "#/core/logger";
+/**
+ * Human-readable import-policy report.
+ *
+ * @since 0.10.0
+ */
+export function presentImportsAuditResult(result) {
+    for (const file of result.files) {
+        logger.out(`\n${file.relativePath}`);
+        for (const { line, raw, reason } of file.violations) {
+            logger.out(`  ${line}: ${raw} → ${reason}`);
+        }
+    }
+    const allowlistSuffix = result.allowlistedCount > 0 ? ` (${result.allowlistedCount} allowlisted)` : "";
+    if (result.violationCount > 0) {
+        logger.out(`\n✖ ${result.violationCount} import-policy violation(s)${allowlistSuffix}`);
+    }
+    else {
+        logger.out(`✓ No import-policy violations across ${result.scannedFileCount} file(s)${allowlistSuffix}`);
+    }
+}

package/dist/audit/imports/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 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 declare function prepareImportsAudit(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<AuditCommandPrelude, AppError>>;