@codefast/cli 0.11.0 → 0.13.0

package/dist/audit/comments/output.js

@@ -1,4 +1,4 @@
-import { logger } from "#/core/logger";
+import { logger } from "#core/logger";
 /**
  * Human-readable comment-divider report.
  *

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

@@ -1,7 +1,7 @@
-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";
+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 comments`.
  *

package/dist/audit/comments/prepare.js

@@ -1,4 +1,4 @@
-import { prepareRepoRootAudit } from "#/audit/prepare";
+import { prepareRepoRootAudit } from "#audit/prepare";
 /**
  * Loads config and resolves the scan target for `audit comments`.
  *

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

@@ -1,7 +1,7 @@
-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";
+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

package/dist/audit/comments/run.js

@@ -1,13 +1,13 @@
 import path from "node:path";
-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";
-import { sourceCommentLanguage, walkSourceFiles } from "#/core/workspace/source-walk";
+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";
+import { sourceCommentLanguage, walkSourceFiles } from "#core/workspace/source-walk";
 const reasonByDefect = {
     "bad-width": `rule does not end at column ${DIVIDER_COLUMN}`,
     "dead-link": "{@link} target has no mention outside links — likely renamed",

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

@@ -0,0 +1,13 @@
+import type { ConstantAuditResult } from "#audit/domain/types";
+/**
+ * Exit `1` when any non-allowlisted numeric constant is unlabelled.
+ *
+ * @since 0.11.0
+ */
+export declare function exitCodeForConstantAuditResult(result: ConstantAuditResult): number;
+/**
+ * Machine-readable numeric-constant summary for `--json`.
+ *
+ * @since 0.11.0
+ */
+export declare function formatConstantAuditJsonOutput(result: ConstantAuditResult, rootDir: string): string;

package/dist/audit/constants/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 numeric constant is unlabelled.
+ *
+ * @since 0.11.0
+ */
+export function exitCodeForConstantAuditResult(result) {
+    return result.violationCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Machine-readable numeric-constant summary for `--json`.
+ *
+ * @since 0.11.0
+ */
+export function formatConstantAuditJsonOutput(result, rootDir) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: result.violationCount === 0,
+        cwd: rootDir,
+        result,
+    });
+}

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

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

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

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

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

@@ -0,0 +1,8 @@
+/** The numeric-constant convention: a `const NAME = <number>` in a source tree names the kind of number it is. */
+import type { ConstantViolation } from "#audit/domain/types";
+/**
+ * Scans one TypeScript source for numeric constants whose comment names none of the three kinds.
+ *
+ * @since 0.11.0
+ */
+export declare function auditNumericConstants(sourceText: string): Array<ConstantViolation>;

package/dist/audit/constants/domain/constants.js

@@ -0,0 +1,66 @@
+/**
+ * The three kinds a numeric constant may be, each named by one phrase in the comment above it.
+ *
+ * @remarks A width of the machine, a value the contract fixes, or a figure derived from the data a
+ * bind hands in. A count that merely looks reasonable is none of them, and the audit says so.
+ */
+const KIND_PHRASES = [
+    "a constant of the machine",
+    "a value the contract fixes",
+    "derived from bind-time data",
+];
+/** An upper-case `const` bound to a numeric literal, with an optional type annotation. */
+const NUMERIC_CONST = /^\s*(?:export\s+)?const\s+([A-Z][A-Z0-9_]*)\s*(?::[^=]+)?=\s*(-?\d[\d_]*(?:\.\d+)?)(?![\w.])/;
+/** Values that stand for absence or identity, never for a tuned size: any distinct value would do. */
+const SENTINEL_VALUES = new Set(["0", "1", "-1"]);
+/**
+ * Scans one TypeScript source for numeric constants whose comment names none of the three kinds.
+ *
+ * @since 0.11.0
+ */
+export function auditNumericConstants(sourceText) {
+    const lines = sourceText.split("\n");
+    const violations = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const match = NUMERIC_CONST.exec(lines[index]);
+        if (match === null || SENTINEL_VALUES.has(match[2])) {
+            continue;
+        }
+        const comment = commentAbove(lines, index);
+        if (KIND_PHRASES.some((phrase) => comment.includes(phrase))) {
+            continue;
+        }
+        violations.push({
+            line: index + 1,
+            raw: `${match[1]} = ${match[2]}`,
+            reason: `no kind named above it — say which it is: ${KIND_PHRASES.join(" · ")}`,
+        });
+    }
+    return violations;
+}
+/** The doc block or run of `//` lines directly above a line, as one text; empty when there is none. */
+function commentAbove(lines, index) {
+    let cursor = index - 1;
+    const gathered = [];
+    while (cursor >= 0) {
+        const line = lines[cursor].trim();
+        if (line.startsWith("//")) {
+            gathered.unshift(line);
+            cursor -= 1;
+            continue;
+        }
+        if (line.endsWith("*/")) {
+            // Walk back to the opening of the block, collecting it whole.
+            while (cursor >= 0) {
+                gathered.unshift(lines[cursor].trim());
+                if (lines[cursor].trim().startsWith("/*")) {
+                    break;
+                }
+                cursor -= 1;
+            }
+            break;
+        }
+        break;
+    }
+    return gathered.join(" ");
+}

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

@@ -0,0 +1,7 @@
+import type { ConstantAuditResult } from "#audit/domain/types";
+/**
+ * Human-readable numeric-constant report.
+ *
+ * @since 0.11.0
+ */
+export declare function presentConstantAuditResult(result: ConstantAuditResult): void;

package/dist/audit/constants/output.js

@@ -0,0 +1,21 @@
+import { logger } from "#core/logger";
+/**
+ * Human-readable numeric-constant report.
+ *
+ * @since 0.11.0
+ */
+export function presentConstantAuditResult(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} numeric constant(s) with no kind named${allowlistSuffix}`);
+    }
+    else {
+        logger.out(`✓ Every numeric constant names its kind across ${result.scannedFileCount} source file(s)${allowlistSuffix}`);
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { AuditCommandPrelude } from "#audit/prepare";
+import { 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 constants`.
+ *
+ * @remarks The target is the library tree the convention holds over, from `audit.constants.target`
+ * unless the command names one.
+ *
+ * @since 0.11.0
+ */
+export declare function prepareConstantAudit(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<AuditCommandPrelude, AppError>>;

package/dist/audit/constants/prepare.js

@@ -0,0 +1,37 @@
+import { resolveRepoRelativePath } from "#audit/prepare";
+import { loadCodefastConfig } from "#core/config";
+import { AppError, messageFrom } from "#core/errors";
+import { err, ok } from "#core/result";
+import { resolveProjectRoot } from "#core/workspace/resolver";
+/**
+ * Loads config and resolves the scan target for `audit constants`.
+ *
+ * @remarks The target is the library tree the convention holds over, from `audit.constants.target`
+ * unless the command names one.
+ *
+ * @since 0.11.0
+ */
+export async function prepareConstantAudit(fs, args) {
+    let rootDir;
+    try {
+        rootDir = fs.canonicalPathSync(resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir);
+    }
+    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 constantsConfig = config.audit?.constants ?? {};
+    const resolvedTargetInput = args.rawTarget ?? constantsConfig.target;
+    if (resolvedTargetInput === undefined) {
+        return err(new AppError("VALIDATION_ERROR", "audit constants needs a target: pass one, or set audit.constants.target in codefast.config"));
+    }
+    const targetPath = resolveRepoRelativePath(args.rawTarget !== 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: constantsConfig.allowlist ?? [] });
+}

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

@@ -0,0 +1,14 @@
+import type { ConstantAuditResult } 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's library sources for numeric constants that name none of the three kinds.
+ *
+ * @since 0.11.0
+ */
+export declare function runConstantAudit(fs: Filesystem, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+}): Result<ConstantAuditResult, AppError>;

package/dist/audit/constants/run.js

@@ -0,0 +1,64 @@
+import path from "node:path";
+import { auditNumericConstants } from "#audit/constants/domain/constants";
+import { AppError, messageFrom } from "#core/errors";
+import { err, ok } from "#core/result";
+import { walkTsxFiles } from "#core/workspace/typescript-walk";
+/**
+ * Trees the convention does not reach: a test fixes a value to observe it, a benchmark sizes a
+ * workload, and an app or example is a consumer, not the library.
+ */
+const SKIPPED_SEGMENTS = new Set([
+    "tests",
+    "benchmarks",
+    "apps",
+    "examples",
+    "node_modules",
+    "dist",
+]);
+/**
+ * Scans a target path's library sources for numeric constants that name none of the three kinds.
+ *
+ * @since 0.11.0
+ */
+export function runConstantAudit(fs, args) {
+    try {
+        const allowlist = new Set(args.allowlist);
+        const { rootDir, targetPath } = args;
+        const filesToScan = collectScanPaths(fs, rootDir, targetPath);
+        const files = [];
+        let violationCount = 0;
+        let allowlistedCount = 0;
+        for (const absolutePath of filesToScan) {
+            const relativePath = toPosixPath(path.relative(rootDir, absolutePath));
+            const content = fs.readFileSync(absolutePath, "utf8");
+            const remaining = auditNumericConstants(content).filter(({ raw }) => {
+                const name = raw.split(" ")[0];
+                const isAllowed = allowlist.has(name) || allowlist.has(`${relativePath}:${name}`);
+                if (isAllowed) {
+                    allowlistedCount++;
+                }
+                return !isAllowed;
+            });
+            if (remaining.length === 0) {
+                continue;
+            }
+            violationCount += remaining.length;
+            files.push({ relativePath, violations: remaining });
+        }
+        return ok({ files, violationCount, allowlistedCount, scannedFileCount: filesToScan.length });
+    }
+    catch (error) {
+        return err(new AppError("INFRA_FAILURE", messageFrom(error), error));
+    }
+}
+/** The `.ts` files under a `src` directory of a library package, below the target. */
+function collectScanPaths(fs, rootDir, targetPath) {
+    const candidates = fs.statSync(targetPath).isDirectory() ? walkTsxFiles(targetPath, fs) : [targetPath];
+    return candidates.filter((absolutePath) => {
+        const segments = toPosixPath(path.relative(rootDir, absolutePath)).split("/");
+        return segments.includes("src") && !segments.some((segment) => SKIPPED_SEGMENTS.has(segment));
+    });
+}
+function toPosixPath(filePath) {
+    return filePath.split(path.sep).join("/");
+}

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

@@ -1,4 +1,4 @@
-import type { DisplayNameAuditResult } from "#/audit/domain/types";
+import type { DisplayNameAuditResult } from "#audit/domain/types";
 /**
  * Exit `1` when any non-allowlisted display-name violation remains.
  *

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

@@ -1,4 +1,4 @@
-import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
+import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#core/exit-codes";
 /**
  * Exit `1` when any non-allowlisted display-name violation remains.
  *

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

@@ -1,5 +1,5 @@
 /** 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";
+import type { DisplayNameViolation } from "#audit/domain/types";
 /**
  * Scans one source or markdown text for `token()`, `tag()` and module display names that break the convention.
  *

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

@@ -1,3 +1,4 @@
+import { lineOfOffset } from "#core/source-position";
 /** The owner: a kebab-case package, app or feature slug, or a scoped package name. */
 const NAMESPACE = /^(?:@[a-z0-9-]+\/)?[a-z0-9]+(?:-[a-z0-9]+)*$/;
 /** A token or module stands for a type or a unit of composition. */
@@ -59,13 +60,4 @@ function reasonFor(kind, name) {
     return PASCAL_CASE.test(local)
         ? null
         : `${label} '${local}' in '${name}' is not PascalCase — a ${kind} stands for a ${kind === "token" ? "type" : "unit of composition"}`;
-}
-function lineOfOffset(sourceText, offset) {
-    let line = 1;
-    for (let index = 0; index < offset; index++) {
-        if (sourceText.charCodeAt(index) === 10) {
-            line++;
-        }
-    }
-    return line;
 }

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

@@ -1,4 +1,4 @@
-import type { DisplayNameAuditResult } from "#/audit/domain/types";
+import type { DisplayNameAuditResult } from "#audit/domain/types";
 /**
  * Human-readable display-name report.
  *

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

@@ -1,4 +1,4 @@
-import { logger } from "#/core/logger";
+import { logger } from "#core/logger";
 /**
  * Human-readable display-name report.
  *

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

@@ -1,7 +1,7 @@
-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";
+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`.
  *

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

@@ -1,4 +1,4 @@
-import { prepareRepoRootAudit } from "#/audit/prepare";
+import { prepareRepoRootAudit } from "#audit/prepare";
 /**
  * Loads config and resolves the scan target for `audit display-names`.
  *

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

@@ -1,7 +1,7 @@
-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";
+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.
  *

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

@@ -1,9 +1,9 @@
 import path from "node:path";
-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";
-import { walkTsxFiles } from "#/core/workspace/typescript-walk";
+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";
+import { walkTsxFiles } from "#core/workspace/typescript-walk";
 /**
  * Trees the convention does not reach: a test or benchmark token is scoped by its file and never
  * meets another author's, and a changelog quotes names as they were.

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

@@ -73,6 +73,37 @@ export type ImportsAuditResult = {
     readonly allowlistedCount: number;
     readonly scannedFileCount: number;
 };
+/**
+ * A double assertion through `unknown` or `any`, or a directive that keeps one without cause.
+ *
+ * @since 0.13.0
+ */
+export type AssertionViolation = {
+    readonly line: number;
+    /** The assertion or the directive as written, up to its first line break. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * The type-assertion violations found in one file.
+ *
+ * @since 0.13.0
+ */
+export type AssertionFileViolations = {
+    readonly relativePath: string;
+    readonly violations: Array<AssertionViolation>;
+};
+/**
+ * Outcome of one `audit assertions` run.
+ *
+ * @since 0.13.0
+ */
+export type AssertionAuditResult = {
+    readonly files: Array<AssertionFileViolations>;
+    readonly violationCount: number;
+    readonly allowlistedCount: number;
+    readonly scannedFileCount: number;
+};
 /**
  * A `token()`, `tag()` or module display name that breaks the display-name convention.
  *
@@ -104,6 +135,37 @@ export type DisplayNameAuditResult = {
     readonly allowlistedCount: number;
     readonly scannedFileCount: number;
 };
+/**
+ * A numeric constant whose comment names none of the three kinds.
+ *
+ * @since 0.11.0
+ */
+export type ConstantViolation = {
+    readonly line: number;
+    /** The declaration's name and value, as `NAME = 32`. */
+    readonly raw: string;
+    readonly reason: string;
+};
+/**
+ * The numeric-constant violations found in one file.
+ *
+ * @since 0.11.0
+ */
+export type ConstantFileViolations = {
+    readonly relativePath: string;
+    readonly violations: Array<ConstantViolation>;
+};
+/**
+ * Outcome of one `audit constants` run.
+ *
+ * @since 0.11.0
+ */
+export type ConstantAuditResult = {
+    readonly files: Array<ConstantFileViolations>;
+    readonly violationCount: number;
+    readonly allowlistedCount: number;
+    readonly scannedFileCount: number;
+};
 /**
  * A broken link or anchor found by the link audit.
  *
@@ -168,4 +230,70 @@ export type CommentAuditResult = {
     readonly fixedCount: number;
     readonly dividerCount: number;
     readonly scannedFileCount: number;
+};
+/**
+ * A `#/`-prefixed internal import specifier — valid to the in-repo runners but rejected by Node's ESM
+ * resolver on the supported floor, so it breaks the published package.
+ *
+ * @since 0.12.0
+ */
+export type LegacySubpathImport = {
+    readonly line: number;
+    /** The specifier as written, quotes included. */
+    readonly raw: string;
+};
+/**
+ * The `#/` imports found in one source file.
+ *
+ * @since 0.12.0
+ */
+export type LegacySubpathFile = {
+    readonly relativePath: string;
+    readonly imports: Array<LegacySubpathImport>;
+};
+/**
+ * A published package whose slimmed manifest exports or imports a target it does not ship.
+ *
+ * @since 0.12.0
+ */
+export type UnshippedTargetViolation = {
+    readonly packageName: string;
+    readonly field: string;
+    readonly subpath: string;
+    readonly target: string;
+};
+/**
+ * A path a stylesheet registers with Tailwind's `@source`, as written.
+ *
+ * @since 0.13.0
+ */
+export type StylesheetSource = {
+    readonly line: number;
+    readonly pattern: string;
+};
+/**
+ * A shipped stylesheet whose `@source` paths reach no file its package's tarball ships.
+ *
+ * @since 0.13.0
+ */
+export type UnreachableStylesheetViolation = {
+    readonly packageName: string;
+    /** Repo-relative path of the stylesheet. */
+    readonly stylesheet: string;
+    readonly sources: Array<StylesheetSource>;
+    /** The `files` entries missing on disk, which is how an unbuilt `dist` shows up. */
+    readonly missingFilesEntries: Array<string>;
+};
+/**
+ * Outcome of one `audit publish` run.
+ *
+ * @since 0.12.0
+ */
+export type PublishAuditResult = {
+    readonly legacyImportFiles: Array<LegacySubpathFile>;
+    readonly unshipped: Array<UnshippedTargetViolation>;
+    readonly unreachableStylesheets: Array<UnreachableStylesheetViolation>;
+    readonly legacyImportCount: number;
+    readonly scannedFileCount: number;
+    readonly packageCount: number;
 };

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

@@ -1,4 +1,4 @@
-import type { ImportsAuditResult } from "#/audit/domain/types";
+import type { ImportsAuditResult } from "#audit/domain/types";
 /**
  * Exit `1` when any non-allowlisted import-policy violation remains.
  *

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

@@ -1,4 +1,4 @@
-import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
+import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#core/exit-codes";
 /**
  * Exit `1` when any non-allowlisted import-policy violation remains.
  *

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

@@ -1,4 +1,4 @@
-import type { ImportPolicyViolation } from "#/audit/domain/types";
+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