@codefast/cli 0.11.0 → 0.13.0

package/dist/arrange/simplify/fold-targets.d.ts

@@ -1,7 +1,7 @@
 /** Collects cn() calls whose override classes can fold into a variant function's `className` option. */
-import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
-import type { PlannedSimplifyEdit } from "#/arrange/domain/ast/simplify-targets";
-import type { FileClassNameProbe } from "#/arrange/simplify/variant-classname-probe";
+import type { DomainSourceFile } from "#arrange/domain/ast/ast-node";
+import type { PlannedSimplifyEdit } from "#arrange/domain/ast/simplify-targets";
+import type { FileClassNameProbe } from "#arrange/simplify/variant-classname-probe";
 /**
  * Collects `className` fold edits for every foldable `cn(variant({…}), …)` call in a source file.
  *

package/dist/arrange/simplify/fold-targets.js

@@ -1,7 +1,7 @@
 /** Collects cn() calls whose override classes can fold into a variant function's `className` option. */
-import { forEachDomainChild, isDomainCallExpression, isDomainIdentifier, isDomainObjectLiteralExpression, isDomainPropertyAccessExpression, isDomainPropertyAssignment, isDomainTailwindClassLiteral, } from "#/arrange/domain/ast/ast-node";
-import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText } from "#/arrange/domain/ast/helpers";
-import { escapeTsStringLiteralContent } from "#/arrange/domain/source-text-formatters";
+import { forEachDomainChild, isDomainCallExpression, isDomainIdentifier, isDomainObjectLiteralExpression, isDomainPropertyAccessExpression, isDomainPropertyAssignment, isDomainTailwindClassLiteral, } from "#arrange/domain/ast/ast-node";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText } from "#arrange/domain/ast/helpers";
+import { escapeTsStringLiteralContent } from "#arrange/domain/source-text-formatters";
 /** Groups a run of trailing cn() arguments, coalescing adjacent static literals into one piece. */
 function coalesceTrailingArgs(args, sourceText) {
     const pieces = [];

package/dist/arrange/simplify/output.d.ts

@@ -1,4 +1,4 @@
-import type { ArrangeRunResult } from "#/arrange/domain/types";
+import type { ArrangeRunResult } from "#arrange/domain/types";
 /**
  * Presents the totals for an `arrange simplify` run.
  *

package/dist/arrange/simplify/output.js

@@ -1,4 +1,4 @@
-import { logger } from "#/core/logger";
+import { logger } from "#core/logger";
 /**
  * Presents the totals for an `arrange simplify` run.
  *

package/dist/arrange/simplify/process-file.d.ts

@@ -1,12 +1,12 @@
-import type { GroupFileResult } from "#/arrange/domain/types";
-import type { VariantClassNameProbe } from "#/arrange/simplify/variant-classname-probe";
-import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { GroupFileResult } from "#arrange/domain/types";
+import type { VariantClassNameProbe } from "#arrange/simplify/variant-classname-probe";
+import type { Filesystem } from "#core/filesystem/filesystem";
 /**
  * Runs the simplify pass on one file — flattening class expressions and pruning an unused `cn` import.
  *
  * @since 0.3.16-canary.0
  */
-export declare function processArrangeSimplifyFile(fs: Filesystem, args: {
+export declare function processArrangeSimplifyFile(fs: Pick<Filesystem, "readFileSync" | "writeFileSync">, args: {
     readonly filePath: string;
     readonly write: boolean;
     readonly probe?: VariantClassNameProbe | null;

package/dist/arrange/simplify/process-file.js

@@ -1,8 +1,8 @@
-import { collectSimplifyTargets } from "#/arrange/domain/ast/simplify-targets";
-import { dropCnImportIfUnused } from "#/arrange/domain/imports";
-import { collectClassNameFoldTargets } from "#/arrange/simplify/fold-targets";
-import { parseDomainSourceFile } from "#/arrange/source-parse";
-import { applyEditsDescending, dropOverlappingEdits } from "#/core/source-text-edit";
+import { collectSimplifyTargets } from "#arrange/domain/ast/simplify-targets";
+import { dropCnImportIfUnused } from "#arrange/domain/imports";
+import { collectClassNameFoldTargets } from "#arrange/simplify/fold-targets";
+import { parseDomainSourceFile } from "#arrange/source-parse";
+import { applyEditsDescending, dropOverlappingEdits } from "#core/source-text-edit";
 // A file simplify can act on names `cn`/`tv` (a call or an import to prune) or carries a `class`/`className`;
 // a source with none of these has nothing to flatten or fold, so it never needs parsing.
 const SIMPLIFY_MARKER = /\b(?:cn|tv)\b|className|\bclass\s*[=:]/;

package/dist/arrange/simplify/run.d.ts

@@ -1,7 +1,7 @@
-import type { ArrangeRunResult } from "#/arrange/domain/types";
-import type { AppError } from "#/core/errors";
-import type { Filesystem } from "#/core/filesystem/filesystem";
-import type { Result } from "#/core/result";
+import type { ArrangeRunResult } from "#arrange/domain/types";
+import type { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
 /**
  * Runs the simplify pass over every target file and returns the aggregated result.
  *

package/dist/arrange/simplify/run.js

@@ -1,7 +1,7 @@
-import { scanArrangeTargets } from "#/arrange/scan-target";
-import { processArrangeSimplifyFile } from "#/arrange/simplify/process-file";
-import { createVariantClassNameProbe } from "#/arrange/simplify/variant-classname-probe";
-import { ok } from "#/core/result";
+import { scanArrangeTargets } from "#arrange/scan-target";
+import { processArrangeSimplifyFile } from "#arrange/simplify/process-file";
+import { createVariantClassNameProbe } from "#arrange/simplify/variant-classname-probe";
+import { ok } from "#core/result";
 /**
  * Runs the simplify pass over every target file and returns the aggregated result.
  *

package/dist/arrange/simplify/variant-classname-probe.js

@@ -1,5 +1,5 @@
 /** Type probe that asks whether a variant function's options accept a folded `className`. */
-import { AppError, messageFrom } from "#/core/errors";
+import { AppError, messageFrom } from "#core/errors";
 // ── Type inspection ──────────────────────────────────────────────────────────────────────────────────────────────────
 /** The type of the callee's first-parameter `className` (preferred) or `class` option, if any. */
 function classNameOptionType(checker, optionsType) {

package/dist/arrange/source-parse.d.ts

@@ -1,4 +1,4 @@
-import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+import type { DomainSourceFile } from "#arrange/domain/ast/ast-node";
 /**
  * Parses source text into a domain source file via the shared `oxc-parser` translator.
  *

package/dist/arrange/source-parse.js

@@ -1,6 +1,6 @@
-import { TypeScriptAstTranslator } from "#/arrange/domain/ast/translator";
-import { messageFrom } from "#/core/errors";
-import { logger } from "#/core/logger";
+import { TypeScriptAstTranslator } from "#arrange/domain/ast/translator";
+import { messageFrom } from "#core/errors";
+import { logger } from "#core/logger";
 const translator = new TypeScriptAstTranslator();
 /**
  * Parses source text into a domain source file via the shared `oxc-parser` translator.

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

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

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

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

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

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

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

package/dist/audit/assertions/domain/double-assertion.d.ts

@@ -0,0 +1,20 @@
+import type { AssertionViolation } from "#audit/domain/types";
+/**
+ * The comment that keeps one double assertion, with the reason it has to stay.
+ *
+ * @remarks It covers an assertion on its own line or the line below it, and must carry a reason
+ * after the colon; one that covers nothing is reported, so a kept assertion cannot outlive its cause.
+ *
+ * @since 0.13.0
+ */
+export declare const DOUBLE_ASSERTION_DIRECTIVE = "codefast-allow-double-assertion";
+/**
+ * Scans one TypeScript source for double assertions through `unknown` or `any`, and for directives
+ * that keep none or give no reason.
+ *
+ * @remarks `x as unknown as T`, `(x as unknown) as T` and `<T><unknown>x` are one shape: the
+ * compiler found the two types unrelated, and the pair silences it instead of reconciling them.
+ *
+ * @since 0.13.0
+ */
+export declare function auditDoubleAssertionSource(filePath: string, sourceText: string): Array<AssertionViolation>;

package/dist/audit/assertions/domain/double-assertion.js

@@ -0,0 +1,122 @@
+import { parseSync } from "oxc-parser";
+import { isOxcNode } from "#core/oxc-node";
+import { firstLineOf, lineOfOffset } from "#core/source-position";
+/**
+ * The comment that keeps one double assertion, with the reason it has to stay.
+ *
+ * @remarks It covers an assertion on its own line or the line below it, and must carry a reason
+ * after the colon; one that covers nothing is reported, so a kept assertion cannot outlive its cause.
+ *
+ * @since 0.13.0
+ */
+export const DOUBLE_ASSERTION_DIRECTIVE = "codefast-allow-double-assertion";
+const DOUBLE_ASSERTION_REASON = "double assertion through `unknown`/`any` — make the types agree, narrow with a type guard, or keep it " +
+    `with // ${DOUBLE_ASSERTION_DIRECTIVE}: <reason>`;
+// Most files hold neither, so a text probe spares them the parse.
+const CANDIDATE_TEXT = new RegExp(`\\bas\\s+(?:unknown|any)\\b|<(?:unknown|any)>|${DOUBLE_ASSERTION_DIRECTIVE}`);
+function isAssertion(node) {
+    return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+/** The assertion an outer one wraps, through any parentheses, when it erases to `unknown` or `any`. */
+function erasingInnerAssertion(outer) {
+    let inner = outer.expression;
+    while (isOxcNode(inner) && inner.type === "ParenthesizedExpression") {
+        inner = inner.expression;
+    }
+    if (!isOxcNode(inner) || !isAssertion(inner) || !isOxcNode(inner.typeAnnotation)) {
+        return undefined;
+    }
+    const erasedTo = inner.typeAnnotation.type;
+    return erasedTo === "TSUnknownKeyword" || erasedTo === "TSAnyKeyword" ? inner : undefined;
+}
+function collectDoubleAssertions(node, found) {
+    let next = node;
+    if (isAssertion(node)) {
+        const inner = erasingInnerAssertion(node);
+        if (inner !== undefined) {
+            found.push(node);
+            // The erased pair is one finding; what it wraps is walked on its own.
+            next = inner;
+        }
+    }
+    for (const value of Object.values(next)) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (isOxcNode(item)) {
+                    collectDoubleAssertions(item, found);
+                }
+            }
+        }
+        else if (isOxcNode(value)) {
+            collectDoubleAssertions(value, found);
+        }
+    }
+}
+function parseDirective(sourceText, comment) {
+    if (comment.type !== "Line") {
+        return undefined;
+    }
+    const text = comment.value.trim();
+    if (!text.startsWith(DOUBLE_ASSERTION_DIRECTIVE)) {
+        return undefined;
+    }
+    const reason = /^:\s*(\S.*)$/.exec(text.slice(DOUBLE_ASSERTION_DIRECTIVE.length))?.[1] ?? "";
+    return {
+        line: lineOfOffset(sourceText, comment.start),
+        raw: sourceText.slice(comment.start, comment.end),
+        reason,
+        isUsed: false,
+    };
+}
+/**
+ * Scans one TypeScript source for double assertions through `unknown` or `any`, and for directives
+ * that keep none or give no reason.
+ *
+ * @remarks `x as unknown as T`, `(x as unknown) as T` and `<T><unknown>x` are one shape: the
+ * compiler found the two types unrelated, and the pair silences it instead of reconciling them.
+ *
+ * @since 0.13.0
+ */
+export function auditDoubleAssertionSource(filePath, sourceText) {
+    if (!CANDIDATE_TEXT.test(sourceText)) {
+        return [];
+    }
+    const { program, comments } = parseSync(filePath, sourceText);
+    const directives = comments.map((comment) => parseDirective(sourceText, comment)).filter((d) => d !== undefined);
+    const found = [];
+    if (isOxcNode(program)) {
+        collectDoubleAssertions(program, found);
+    }
+    const violations = [];
+    for (const assertion of found) {
+        const line = lineOfOffset(sourceText, assertion.start);
+        const directive = directives.find((candidate) => candidate.reason !== "" && (candidate.line === line || candidate.line === line - 1));
+        if (directive !== undefined) {
+            directive.isUsed = true;
+            continue;
+        }
+        violations.push({
+            line,
+            raw: firstLineOf(sourceText.slice(assertion.start, assertion.end)),
+            reason: DOUBLE_ASSERTION_REASON,
+        });
+    }
+    for (const directive of directives) {
+        if (directive.reason === "") {
+            violations.push({
+                line: directive.line,
+                raw: directive.raw,
+                reason: `a ${DOUBLE_ASSERTION_DIRECTIVE} directive states why after a colon`,
+            });
+        }
+        else if (!directive.isUsed) {
+            violations.push({
+                line: directive.line,
+                raw: directive.raw,
+                reason: `this ${DOUBLE_ASSERTION_DIRECTIVE} directive keeps no double assertion — remove it`,
+            });
+        }
+    }
+    violations.sort((a, b) => a.line - b.line);
+    return violations;
+}

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

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

package/dist/audit/assertions/output.js

@@ -0,0 +1,21 @@
+import { logger } from "#core/logger";
+/**
+ * Human-readable type-assertion report.
+ *
+ * @since 0.13.0
+ */
+export function presentAssertionAuditResult(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} type-assertion violation(s)${allowlistSuffix}`);
+    }
+    else {
+        logger.out(`✓ No double assertions across ${result.scannedFileCount} file(s)${allowlistSuffix}`);
+    }
+}

package/dist/audit/assertions/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 assertions`.
+ *
+ * @remarks Defaults to the repo root, tests included: a double assertion in a test silences the
+ * compiler on the code the test is meant to hold to its types.
+ *
+ * @since 0.13.0
+ */
+export declare function prepareAssertionAudit(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<AuditCommandPrelude, AppError>>;

package/dist/audit/assertions/prepare.js

@@ -0,0 +1,12 @@
+import { prepareRepoRootAudit } from "#audit/prepare";
+/**
+ * Loads config and resolves the scan target for `audit assertions`.
+ *
+ * @remarks Defaults to the repo root, tests included: a double assertion in a test silences the
+ * compiler on the code the test is meant to hold to its types.
+ *
+ * @since 0.13.0
+ */
+export async function prepareAssertionAudit(fs, args) {
+    return prepareRepoRootAudit(fs, args, (config) => config.audit?.assertions?.allowlist ?? []);
+}

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

@@ -0,0 +1,14 @@
+import type { AssertionAuditResult } 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 double assertions through `unknown` or `any`, tests included.
+ *
+ * @since 0.13.0
+ */
+export declare function runAssertionAudit(fs: Filesystem, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+}): Result<AssertionAuditResult, AppError>;

package/dist/audit/assertions/run.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+import { auditDoubleAssertionSource } from "#audit/assertions/domain/double-assertion";
+import { AppError, messageFrom } from "#core/errors";
+import { err, ok } from "#core/result";
+import { walkTsxFiles } from "#core/workspace/typescript-walk";
+/**
+ * Scans a target path for double assertions through `unknown` or `any`, tests included.
+ *
+ * @since 0.13.0
+ */
+export function runAssertionAudit(fs, args) {
+    try {
+        const allowlist = new Set(args.allowlist);
+        const { rootDir, targetPath } = args;
+        const filesToScan = fs.statSync(targetPath).isFile() ? [targetPath] : walkTsxFiles(targetPath, fs);
+        const files = [];
+        let violationCount = 0;
+        let allowlistedCount = 0;
+        for (const absolutePath of filesToScan) {
+            const relativePath = path.relative(rootDir, absolutePath).split(path.sep).join("/");
+            const content = fs.readFileSync(absolutePath, "utf8");
+            const remaining = auditDoubleAssertionSource(absolutePath, content).filter(({ raw }) => {
+                const isAllowed = allowlist.has(raw) || allowlist.has(`${relativePath}:${raw}`);
+                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 (caughtError) {
+        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+    }
+}

package/dist/audit/command.js

@@ -1,31 +1,46 @@
 import { Command } from "commander";
-import { exitCodeForCommentAuditResult, formatCommentAuditJsonOutput } from "#/audit/comments/cli-result";
-import { commentAuditRunRequestSchema } from "#/audit/comments/cli-schema";
-import { presentCommentAuditResult } from "#/audit/comments/output";
-import { prepareCommentAudit } from "#/audit/comments/prepare";
-import { runCommentAudit } from "#/audit/comments/run";
-import { exitCodeForDisplayNameAuditResult, formatDisplayNameAuditJsonOutput } from "#/audit/display-names/cli-result";
-import { displayNameAuditRunRequestSchema } from "#/audit/display-names/cli-schema";
-import { presentDisplayNameAuditResult } from "#/audit/display-names/output";
-import { prepareDisplayNameAudit } from "#/audit/display-names/prepare";
-import { runDisplayNameAudit } from "#/audit/display-names/run";
-import { exitCodeForImportsAuditResult, formatImportsAuditJsonOutput } from "#/audit/imports/cli-result";
-import { importsAuditRunRequestSchema } from "#/audit/imports/cli-schema";
-import { presentImportsAuditResult } from "#/audit/imports/output";
-import { prepareImportsAudit } from "#/audit/imports/prepare";
-import { runImportsAudit } from "#/audit/imports/run";
-import { exitCodeForLinkAuditResult, formatLinkAuditJsonOutput } from "#/audit/links/cli-result";
-import { linkAuditRunRequestSchema } from "#/audit/links/cli-schema";
-import { presentLinkAuditResult } from "#/audit/links/output";
-import { prepareLinkAudit } from "#/audit/links/prepare";
-import { runLinkAudit } from "#/audit/links/run";
-import { exitCodeForRtlAuditResult, formatRtlAuditJsonOutput } from "#/audit/rtl/cli-result";
-import { rtlAuditRunRequestSchema } from "#/audit/rtl/cli-schema";
-import { presentRtlAuditResult } from "#/audit/rtl/output";
-import { prepareRtlAudit } from "#/audit/rtl/prepare";
-import { runRtlAudit } from "#/audit/rtl/run";
-import { registerPipelineSubcommand } from "#/core/cli/command-pipeline";
-import { nodeFilesystem } from "#/core/filesystem/node";
+import { exitCodeForAssertionAuditResult, formatAssertionAuditJsonOutput } from "#audit/assertions/cli-result";
+import { assertionAuditRunRequestSchema } from "#audit/assertions/cli-schema";
+import { presentAssertionAuditResult } from "#audit/assertions/output";
+import { prepareAssertionAudit } from "#audit/assertions/prepare";
+import { runAssertionAudit } from "#audit/assertions/run";
+import { exitCodeForCommentAuditResult, formatCommentAuditJsonOutput } from "#audit/comments/cli-result";
+import { commentAuditRunRequestSchema } from "#audit/comments/cli-schema";
+import { presentCommentAuditResult } from "#audit/comments/output";
+import { prepareCommentAudit } from "#audit/comments/prepare";
+import { runCommentAudit } from "#audit/comments/run";
+import { exitCodeForConstantAuditResult, formatConstantAuditJsonOutput } from "#audit/constants/cli-result";
+import { constantAuditRunRequestSchema } from "#audit/constants/cli-schema";
+import { presentConstantAuditResult } from "#audit/constants/output";
+import { prepareConstantAudit } from "#audit/constants/prepare";
+import { runConstantAudit } from "#audit/constants/run";
+import { exitCodeForDisplayNameAuditResult, formatDisplayNameAuditJsonOutput } from "#audit/display-names/cli-result";
+import { displayNameAuditRunRequestSchema } from "#audit/display-names/cli-schema";
+import { presentDisplayNameAuditResult } from "#audit/display-names/output";
+import { prepareDisplayNameAudit } from "#audit/display-names/prepare";
+import { runDisplayNameAudit } from "#audit/display-names/run";
+import { exitCodeForImportsAuditResult, formatImportsAuditJsonOutput } from "#audit/imports/cli-result";
+import { importsAuditRunRequestSchema } from "#audit/imports/cli-schema";
+import { presentImportsAuditResult } from "#audit/imports/output";
+import { prepareImportsAudit } from "#audit/imports/prepare";
+import { runImportsAudit } from "#audit/imports/run";
+import { exitCodeForLinkAuditResult, formatLinkAuditJsonOutput } from "#audit/links/cli-result";
+import { linkAuditRunRequestSchema } from "#audit/links/cli-schema";
+import { presentLinkAuditResult } from "#audit/links/output";
+import { prepareLinkAudit } from "#audit/links/prepare";
+import { runLinkAudit } from "#audit/links/run";
+import { exitCodeForPublishAuditResult, formatPublishAuditJsonOutput } from "#audit/publish/cli-result";
+import { publishAuditRunRequestSchema } from "#audit/publish/cli-schema";
+import { presentPublishAuditResult } from "#audit/publish/output";
+import { preparePublishAudit } from "#audit/publish/prepare";
+import { runPublishAudit } from "#audit/publish/run";
+import { exitCodeForRtlAuditResult, formatRtlAuditJsonOutput } from "#audit/rtl/cli-result";
+import { rtlAuditRunRequestSchema } from "#audit/rtl/cli-schema";
+import { presentRtlAuditResult } from "#audit/rtl/output";
+import { prepareRtlAudit } from "#audit/rtl/prepare";
+import { runRtlAudit } from "#audit/rtl/run";
+import { registerPipelineSubcommand } from "#core/cli/command-pipeline";
+import { nodeFilesystem } from "#core/filesystem/node";
 function baseAuditRequest(prelude, opts) {
     return {
         rootDir: prelude.rootDir,
@@ -74,6 +89,22 @@ const importsCheck = {
     formatJson: formatImportsAuditJsonOutput,
     exitCode: exitCodeForImportsAuditResult,
 };
+const assertionsCheck = {
+    name: "assertions",
+    description: "Report double type assertions through unknown or any (x as unknown as T), tests included",
+    targetHelp: "Directory or file to scan (default: the repo root)",
+    schema: assertionAuditRunRequestSchema,
+    prepare: prepareAssertionAudit,
+    buildRequest: baseAuditRequest,
+    run: (fs, request) => runAssertionAudit(fs, {
+        rootDir: request.rootDir,
+        targetPath: request.targetPath,
+        allowlist: request.allowlist ?? [],
+    }),
+    present: presentAssertionAuditResult,
+    formatJson: formatAssertionAuditJsonOutput,
+    exitCode: exitCodeForAssertionAuditResult,
+};
 const displayNamesCheck = {
     name: "display-names",
     description: "Report token(), tag() and module display names that break the <namespace>:<Name> convention",
@@ -90,6 +121,22 @@ const displayNamesCheck = {
     formatJson: formatDisplayNameAuditJsonOutput,
     exitCode: exitCodeForDisplayNameAuditResult,
 };
+const constantsCheck = {
+    name: "constants",
+    description: "Report numeric constants whose comment names none of the three kinds a number may be",
+    targetHelp: "Directory or file to scan (default: audit.constants.target from config)",
+    schema: constantAuditRunRequestSchema,
+    prepare: prepareConstantAudit,
+    buildRequest: baseAuditRequest,
+    run: (fs, request) => runConstantAudit(fs, {
+        rootDir: request.rootDir,
+        targetPath: request.targetPath,
+        allowlist: request.allowlist ?? [],
+    }),
+    present: presentConstantAuditResult,
+    formatJson: formatConstantAuditJsonOutput,
+    exitCode: exitCodeForConstantAuditResult,
+};
 const commentsCheck = {
     name: "comments",
     description: "Report section dividers that are not in the repo's one allowed form",
@@ -110,6 +157,18 @@ const commentsCheck = {
         command.option("--fix", "Rewrite every mechanically fixable divider in place", false);
     },
 };
+const publishCheck = {
+    name: "publish",
+    description: "Report what breaks a consumer's install: #/ imports, unshipped exports/imports targets, and stylesheet @source paths reaching nothing shipped",
+    targetHelp: "Directory or file to scan (default: the repo root)",
+    schema: publishAuditRunRequestSchema,
+    prepare: preparePublishAudit,
+    buildRequest: baseAuditRequest,
+    run: (fs, request) => runPublishAudit(fs, { rootDir: request.rootDir, targetPath: request.targetPath }),
+    present: presentPublishAuditResult,
+    formatJson: formatPublishAuditJsonOutput,
+    exitCode: exitCodeForPublishAuditResult,
+};
 /**
  * Adapts an `AuditCheck` descriptor onto the shared command pipeline.
  */
@@ -118,7 +177,6 @@ function auditCheckToPipeline(check) {
         name: check.name,
         description: check.description,
         positional: { name: "[target]", help: check.targetHelp },
-        jsonHelp: "Print one JSON summary on stdout",
         schema: check.schema,
         configureArgv: check.extraOptions,
         prepare: (fs, input) => check.prepare(fs, { currentWorkingDirectory: input.currentWorkingDirectory, rawTarget: input.rawArg }),
@@ -140,7 +198,10 @@ export function createAuditCommand() {
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(rtlCheck));
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(linksCheck));
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(importsCheck));
+    registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(assertionsCheck));
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(displayNamesCheck));
+    registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(constantsCheck));
     registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(commentsCheck));
+    registerPipelineSubcommand(cmd, nodeFilesystem, auditCheckToPipeline(publishCheck));
     return cmd;
 }

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

@@ -1,4 +1,4 @@
-import type { CommentAuditResult } from "#/audit/domain/types";
+import type { CommentAuditResult } from "#audit/domain/types";
 /**
  * Exit `1` when any non-allowlisted divider still breaks the convention.
  *

package/dist/audit/comments/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 divider still breaks the convention.
  *

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

@@ -1,4 +1,4 @@
-import type { CommentAuditResult } from "#/audit/domain/types";
+import type { CommentAuditResult } from "#audit/domain/types";
 /**
  * Human-readable comment-divider report.
  *