workspace-conformance 0.0.0 → 1.1.0

package/dist/index.d.cts

@@ -0,0 +1,723 @@
+import { ConfigFileOptions, LayoutConfig, RankSkipOptions, Section } from "@exadev/config";
+import { IViolation } from "dependency-cruiser";
+import { z } from "zod";
+import { CompilerOptions } from "ts-morph";
+//#region src/check.d.ts
+/**
+ * A position in a file, both numbers counted from 1.
+ */
+interface SourceLocation {
+  readonly line: number;
+  readonly column: number;
+}
+/**
+ * One way the workspace fails a check.
+ */
+interface Violation {
+  /**
+   * Stable identifier of the rule that was broken, `<check name>/<reason>`. Callers may match on it; the message may change.
+   */
+  readonly code: string;
+  readonly message: string;
+  /**
+   * The file the violation is about, relative to the directory the checks ran in, with `/` separators. For a violation about a file that should exist and does not, the file that is missing or the file that requires it.
+   */
+  readonly file: string;
+  readonly location?: SourceLocation;
+}
+/**
+ * What every check receives.
+ */
+interface CheckContext<Options> {
+  /**
+   * The directory the checks run in; every path option is relative to it.
+   */
+  readonly cwd: string;
+  readonly options: Options;
+  /**
+   * How config files that a check evaluates itself (the commitlint and release configs of `commit-types`) are loaded. Only `alias` and `fsCache` apply to evaluating a file; `trust` and `merge` are for `extends`. No transpile cache is written when omitted.
+   */
+  readonly configFiles?: ConfigFileOptions;
+}
+/**
+ * What a check that reads the workspace layout receives.
+ */
+interface LayoutCheckContext<Options> extends CheckContext<Options> {
+  readonly layout: LayoutConfig;
+}
+/**
+ * A check: reads the workspace and returns everything it finds wrong, in a stable order. It throws `ConformanceError` when it cannot run.
+ */
+type CheckFunction<Options> = (context: CheckContext<Options>) => Promise<readonly Violation[]>;
+/**
+ * A check that also needs the resolved workspace layout.
+ */
+type LayoutCheckFunction<Options> = (context: LayoutCheckContext<Options>) => Promise<readonly Violation[]>;
+//#endregion
+//#region src/migrations/adapters.d.ts
+/**
+ * Which of several things in a deploy tool's config the generator's output belongs to.
+ */
+interface DeploySelector {
+  /**
+   * The binding of the database, when the config declares more than one.
+   */
+  readonly database?: string;
+  /**
+   * The named environment whose settings apply instead of the top-level ones.
+   */
+  readonly environment?: string;
+}
+/**
+ * What a deploy tool's config says about the directory it applies migrations from.
+ */
+type DeployDirectory = {
+  readonly directory: string;
+  readonly none?: never;
+} | {
+  readonly none: string;
+  readonly directory?: never;
+};
+/**
+ * A schema generator, for the cross-check between where it writes migrations and where the deploy tool applies them from. The data of a config file is already read; an adapter only knows where in it the directory is.
+ */
+interface GeneratorAdapter {
+  /**
+   * The names the config file may have, by precedence. The extension decides how the file is read.
+   */
+  readonly configFiles: readonly [string, ...string[]];
+  /**
+   * Matches a shell command that applies migrations with the generator itself, bypassing the deploy tool.
+   */
+  readonly applyCommand: RegExp;
+  /**
+   * The command as it is written, for messages.
+   */
+  readonly applyCommandName: string;
+  /**
+   * The directory the generator writes migrations to, as the config writes it (relative to the config file's directory) or the generator's default when the config sets none. Throws `ConformanceError` when the config is not of a shape the adapter can read.
+   */
+  readonly outputDirectory: (config: unknown, file: string) => string;
+}
+/**
+ * A deploy tool that applies migrations from a directory.
+ */
+interface DeployToolAdapter {
+  /**
+   * The names the config file may have, by precedence. The extension decides how the file is read.
+   */
+  readonly configFiles: readonly [string, ...string[]];
+  /**
+   * The directory the tool applies migrations from, as the config writes it (relative to the config file's directory) or the tool's default when the config sets none. Throws `ConformanceError` when the config is not of a shape the adapter can read or `selector` is needed and absent.
+   */
+  readonly migrationsDirectory: (config: unknown, file: string, selector: DeploySelector) => DeployDirectory;
+}
+/**
+ * The generators that have an adapter.
+ */
+declare const generatorNames: readonly ["drizzle-kit"];
+/**
+ * The deploy tools that have an adapter.
+ */
+declare const deployToolNames: readonly ["wrangler"];
+type GeneratorName = (typeof generatorNames)[number];
+type DeployToolName = (typeof deployToolNames)[number];
+export declare const generators: Readonly<Record<GeneratorName, GeneratorAdapter>>;
+export declare const deployTools: Readonly<Record<DeployToolName, DeployToolAdapter>>;
+//#endregion
+//#region src/options.d.ts
+/**
+ * Options of the `aggregate-mappers` check: every aggregate type a contract exports has a mapper file in the place the template names.
+ */
+interface AggregateMappersOptions {
+  /**
+   * Globs of the contract files, relative to the directory the checks run in. Every exported interface and type alias in them is an aggregate.
+   */
+  readonly contracts: readonly string[];
+  /**
+   * Where the mapper of an aggregate lives. Placeholders: `{name}` (the aggregate's name), `{dir}` (the contract file's directory), `{file}` (the contract file) and, when `adapters` is set, `{adapter}` (one matched adapter directory). Relative to the directory the checks run in; `..` segments are resolved.
+   */
+  readonly mapper: string;
+  /**
+   * A glob template for the adapter directories, with the same `{dir}` and `{file}` placeholders. When set, every aggregate needs a mapper in every matched adapter, and a template that matches no directory is itself a violation.
+   */
+  readonly adapters?: string;
+  /**
+   * Names of exported types that are not aggregates and need no mapper.
+   */
+  readonly exclude?: readonly string[];
+  /**
+   * The tsconfig that supplies compiler options and module resolution, relative to the directory the checks run in; `tsconfig.json` when omitted. Its `include` is not used: only the contract files and what they import are loaded.
+   */
+  readonly tsConfig?: string;
+}
+/**
+ * Options of the `command-types` check: every command type a file exports is derived from a schema.
+ */
+interface CommandTypesOptions {
+  /**
+   * Globs of the files that declare commands, relative to the directory the checks run in. Every exported interface and type alias in them is a command.
+   */
+  readonly commands: readonly string[];
+  /**
+   * Names of exported types that are not commands, such as a union of all of them.
+   */
+  readonly exclude?: readonly string[];
+  /**
+   * The last name of the generic that turns a schema into its type, such as `infer` in `z.infer<typeof schema>`. `infer`, `input`, `output`, `TypeOf`, `InferInput` and `InferOutput` when omitted.
+   */
+  readonly inferences?: readonly string[];
+  /**
+   * The tsconfig that supplies compiler options and module resolution; `tsconfig.json` when omitted.
+   */
+  readonly tsConfig?: string;
+}
+/**
+ * Options shared by the checks that cruise the workspace's import graph.
+ */
+interface ImportGraphOptions {
+  /**
+   * Regular expressions, as source text, for paths relative to the workspace root that are left out of the graph. Anything matching one is neither a dependant nor a dependency. Installed dependencies (`node_modules`) when omitted.
+   */
+  readonly exclude?: readonly string[];
+  /**
+   * Regular expressions, as source text, for paths relative to the workspace root whose files can be imported but whose own imports are not followed, so build output is a target of imports and never a dependant. `dist` directories when omitted.
+   */
+  readonly doNotFollow?: readonly string[];
+  /**
+   * A tsconfig, relative to the directory the checks run in, for path aliases and other module resolution the imports depend on.
+   */
+  readonly tsConfig?: string;
+}
+/**
+ * Options of the `instruction-symlinks` check: agent instruction files are git symlinks to the README next to them.
+ */
+interface InstructionSymlinksOptions {
+  /**
+   * The instruction file names. `AGENTS.md` and `CLAUDE.md` when omitted.
+   */
+  readonly files?: readonly string[];
+  /**
+   * Globs of the directories that hold them, relative to the directory the checks run in. The directory itself (`.`) when omitted.
+   */
+  readonly directories?: readonly string[];
+  /**
+   * What each file links to, relative to the file. `README.md` when omitted.
+   */
+  readonly target?: string;
+}
+/**
+ * Options of the `single-storybook` check.
+ */
+interface SingleStorybookOptions {
+  /**
+   * The only directory that may hold a `.storybook` directory, relative to the directory the checks run in. The directory itself (`.`) when omitted.
+   */
+  readonly location?: string;
+  /**
+   * Globs of paths that are not searched, such as directories of test fixtures that hold a Storybook on purpose.
+   */
+  readonly exclude?: readonly string[];
+}
+/**
+ * Options of the `commit-types` check: the commit types commitlint accepts match the release rules and changelog sections of the release config.
+ */
+interface CommitTypesOptions {
+  /**
+   * The commitlint config file, relative to the directory the checks run in. `commitlint.config.ts` when omitted.
+   */
+  readonly commitlint?: string;
+  /**
+   * The semantic-release config file. `release.config.ts` when omitted.
+   */
+  readonly release?: string;
+}
+/**
+ * Options of the `dockerfile-package-manager` check: a package manager version pinned in a Dockerfile is the one `packageManager` names.
+ */
+interface DockerfilePackageManagerOptions {
+  /**
+   * Globs of the Dockerfiles, relative to the directory the checks run in. `Dockerfile`, `Dockerfile.*` and `*.Dockerfile` at any depth when omitted.
+   */
+  readonly dockerfiles?: readonly string[];
+  /**
+   * Globs of paths that are not searched, such as directories of test fixtures.
+   */
+  readonly exclude?: readonly string[];
+  /**
+   * The package.json that holds the `packageManager` field. `package.json` when omitted.
+   */
+  readonly packageJson?: string;
+}
+/**
+ * Options of the `migrations-directory` check: the directory a schema generator writes migrations to is the one the deploy tool applies them from, and no script applies them with the generator.
+ */
+interface MigrationsDirectoryOptions {
+  /**
+   * The schema generator, which has an adapter that knows its config file and where in it the output directory is.
+   */
+  readonly generator: GeneratorName;
+  /**
+   * The deploy tool, which has an adapter that knows its config file and where in it the migrations directory is.
+   */
+  readonly deployTool: DeployToolName;
+  /**
+   * The generator's config file, relative to the directory the checks run in. The first of the adapter's default file names that exists when omitted.
+   */
+  readonly generatorConfig?: string;
+  /**
+   * The deploy tool's config file. The first of the adapter's default file names that exists when omitted.
+   */
+  readonly deployConfig?: string;
+  /**
+   * The binding of the database the generator writes migrations for. Needed when the deploy config declares more than one; the only one is used when omitted.
+   */
+  readonly database?: string;
+  /**
+   * The named environment of the deploy config to read instead of its top-level settings.
+   */
+  readonly environment?: string;
+  /**
+   * Globs of the `package.json` files whose scripts are searched for the generator's apply command. Every `package.json` at any depth when omitted.
+   */
+  readonly packageJsons?: readonly string[];
+}
+/**
+ * The options of every check, by check name.
+ */
+interface CheckOptionsByName {
+  readonly "aggregate-mappers": AggregateMappersOptions;
+  readonly "command-types": CommandTypesOptions;
+  readonly "import-uphill": ImportGraphOptions;
+  readonly "import-rank-skip": ImportGraphOptions;
+  readonly "import-cross-slice": ImportGraphOptions;
+  readonly "import-isolated-groups": ImportGraphOptions;
+  readonly "import-cycles": ImportGraphOptions;
+  readonly "instruction-symlinks": InstructionSymlinksOptions;
+  readonly "single-storybook": SingleStorybookOptions;
+  readonly "commit-types": CommitTypesOptions;
+  readonly "dockerfile-package-manager": DockerfilePackageManagerOptions;
+  readonly "migrations-directory": MigrationsDirectoryOptions;
+}
+/**
+ * The name of a check.
+ */
+type CheckName = keyof CheckOptionsByName;
+//#endregion
+//#region src/checks/aggregate-mappers.d.ts
+/**
+ * Every exported interface and type alias of a contract file is an aggregate and has a mapper file where the template puts it, in each adapter directory when `adapters` is set.
+ *
+ * It looks for the file, not for what is in it, and it counts a type as exported when the contract re-exports it.
+ */
+export declare const aggregateMappers: CheckFunction<AggregateMappersOptions>;
+//#endregion
+//#region src/checks/command-types.d.ts
+/**
+ * The last names of the generics that turn a schema into its type, used when the options name none: `z.infer`, `z.input`, `z.output`, `z.TypeOf` and Valibot's `InferInput` and `InferOutput`.
+ */
+export declare const DEFAULT_INFERENCES: readonly string[];
+/**
+ * Every exported interface and type alias of a command file is derived from a schema: an alias of `infer<typeof schema>` (or another generic in `inferences`) where the type of `schema` is a Standard Schema. Interfaces and other aliases are hand-written, and so are aliases of something that is not a schema.
+ *
+ * The schema is recognised by type, so it may be imported from another file or renamed; it does not need to come from Zod. A union of the commands is not a command: list its name in `exclude`.
+ */
+export declare const commandTypes: CheckFunction<CommandTypesOptions>;
+//#endregion
+//#region src/checks/commit-types.d.ts
+/**
+ * The commit types the conventional presets know, which is the `type-enum` of `@commitlint/config-conventional` and the type list the conventional changelog presets label. Their release behaviour is the preset's own, so a preset type needs no release rule or changelog section to be accounted for; a type outside this list does.
+ */
+export declare const PRESET_COMMIT_TYPES: readonly string[];
+/**
+ * The commit types commitlint accepts are accounted for in the release config. A type no preset knows must have a release rule and, when the config lists changelog sections (`presetConfig.types` of the release notes generator), a section, or it can be committed and never released or shown; a release rule or changelog section for a type commitlint rejects can never apply. Types are enumerated only by a `type-enum` rule of the form `[level, 'always', [types]]`; a `'never'` rule forbids the types it lists and enumerates none, and a rule that is off (level 0) accepts every type. A preset type may be left out of either list: leaving out a type that does not release is how a release rule list is normally written.
+ *
+ * It compares only what is written. The check has nothing to say when the commit types are the preset's and every listed type is one of them. A commitlint config that does not set `type-enum` while the release config lists a type no preset knows is a violation, since the commit types cannot then be read. Both configs are evaluated, so a list may be derived from one shared constant.
+ */
+export declare const commitTypes: CheckFunction<CommitTypesOptions>;
+//#endregion
+//#region src/checks/dockerfile-package-manager.d.ts
+/**
+ * Every pin of the package manager that `packageManager` names, in each Dockerfile, is the version `packageManager` names, with any `+sha` integrity suffix ignored on both sides. Pins of other package managers are not the workspace's package manager and are left alone.
+ *
+ * It reads `<manager>@<version>` as written on a line that is not a comment. A version that refers to a variable is compared with the value the file gives that variable by an `ARG` or `ENV` before the pin (the latest such value, whichever build stage it was in); one whose variable has no value in the file is not compared, since the build supplies it.
+ */
+export declare const dockerfilePackageManager: CheckFunction<DockerfilePackageManagerOptions>;
+//#endregion
+//#region src/workspace/packages.d.ts
+/**
+ * A package directory found under the workspace root, before the layout classifies it.
+ */
+interface DiscoveredPackage {
+  /**
+   * Relative to the workspace root, with `/` separators.
+   */
+  readonly dir: string;
+  /**
+   * The manifest's `name`; a manifest may omit it.
+   */
+  readonly name: string | undefined;
+}
+/**
+ * A workspace package as the layout sees it.
+ */
+interface WorkspacePackage extends DiscoveredPackage {
+  /**
+   * The name of the group whose root is the longest prefix of the package directory.
+   */
+  readonly group: string;
+  /**
+   * The rank from `nameRanks`, else the group's rank, else `defaultRank`; `undefined` when none of them applies.
+   */
+  readonly rank: number | undefined;
+  /**
+   * The slice the group's `slice` rule derives; `undefined` for a group without one and for a package that yields none.
+   */
+  readonly slice: string | undefined;
+}
+/**
+ * Classify discovered packages by the layout: group, rank and slice. Pure.
+ *
+ * A package no group owns is a configuration error, because every check would otherwise skip it without saying so. Nested package directories are one too: the checks attribute a file to the package whose directory is its prefix, which is ambiguous for a package inside another. A `namePrefix` slice takes the longest slice value that a `segment` group produced and that prefixes the package's unscoped name; a package without a name has no such slice.
+ */
+export declare function classifyPackages(discovered: readonly DiscoveredPackage[], layout: LayoutConfig): readonly WorkspacePackage[];
+//#endregion
+//#region src/workspace/rules.d.ts
+/**
+ * A forbidden-dependency rule in the shape dependency-cruiser takes: a dependency from a file matching `from` to a file matching `to` is a violation.
+ */
+interface ImportRule {
+  readonly name: string;
+  readonly severity: "error";
+  readonly comment: string;
+  readonly from: {
+    readonly path?: string;
+  };
+  readonly to: {
+    readonly path?: string;
+    readonly circular?: boolean;
+    readonly couldNotResolve?: boolean;
+  };
+}
+/**
+ * A regular expression, as source text, matching every file inside any of the packages. The trailing `/` keeps `packages/a` from matching `packages/ab`.
+ */
+export declare function packagesPattern(packages: readonly WorkspacePackage[]): string;
+/**
+ * One rule per rank that has a higher rank above it: files of a package at that rank may not import a package at a strictly higher rank. A rule compares no numbers, so the ordering is expanded into path alternations here. Each rule comes with a `-by-name` rule for imports that do not resolve to a file.
+ */
+export declare function uphillRules(packages: readonly WorkspacePackage[]): readonly ImportRule[];
+/**
+ * One rule per rank with a package more than `rankSkip.maxDistance` ranks below it that is not an exempt rank.
+ */
+export declare function rankSkipRules(packages: readonly WorkspacePackage[], rankSkip: RankSkipOptions): readonly ImportRule[];
+/**
+ * One rule per slice: a package in it may not import a package that has a different slice. A package without a slice is in none and is never restricted.
+ */
+export declare function crossSliceRules(packages: readonly WorkspacePackage[]): readonly ImportRule[];
+/**
+ * Two rules per isolated pair, one for each direction.
+ */
+export declare function isolatedGroupRules(packages: readonly WorkspacePackage[], isolatedGroups: NonNullable<LayoutConfig["isolatedGroups"]>): readonly ImportRule[];
+/**
+ * The rule that forbids any import cycle among the packages' files.
+ */
+export declare function cycleRule(): ImportRule;
+//#endregion
+//#region src/checks/import-graph.d.ts
+/**
+ * What a check's report may need to know about the workspace the graph was cruised over.
+ */
+interface ImportScope {
+  readonly cwd: string;
+  /**
+   * The workspace root; finding paths are relative to it.
+   */
+  readonly root: string;
+  readonly packages: readonly WorkspacePackage[];
+}
+/**
+ * How an import check takes part in a shared cruise: the rules it adds and how it reads its own findings. Findings are routed to a check by the names of the rules it generated, so those names must differ from every other check's.
+ */
+interface ImportCheckSpec {
+  /**
+   * The check's name; the violation code is `<name>/<reason>`.
+   */
+  readonly name: string;
+  /**
+   * The forbidden rules for the workspace's packages. Throws `ConformanceError` when the layout does not configure what the check needs.
+   */
+  readonly rules: (packages: readonly WorkspacePackage[], layout: LayoutConfig) => readonly ImportRule[];
+  /**
+   * The violations for the findings of this check's rules, in a stable order.
+   */
+  readonly report: (findings: readonly IViolation[], scope: ImportScope) => readonly Violation[];
+}
+//#endregion
+//#region src/checks/import-cross-slice.d.ts
+/**
+ * A package imports a package in a different slice.
+ */
+export declare const importCrossSlice: LayoutCheckFunction<ImportGraphOptions>;
+//#endregion
+//#region src/checks/import-cycles.d.ts
+/**
+ * Files of the workspace's packages import each other in a cycle, and so do packages that import each other by a name that resolves to no file. Each cycle is reported once, at its first file (or, for packages, the file of the first import), starting from its smallest path.
+ *
+ * Cycles among packages are found only when every import in the ring is by a name that resolves to no file. A ring that mixes such imports with imports that do resolve to files has no complete path through either graph and is not seen.
+ */
+export declare const importCycles: LayoutCheckFunction<ImportGraphOptions>;
+//#endregion
+//#region src/checks/import-isolated-groups.d.ts
+/**
+ * A package imports a package in a group the layout isolates from its own.
+ */
+export declare const importIsolatedGroups: LayoutCheckFunction<ImportGraphOptions>;
+//#endregion
+//#region src/checks/import-rank-skip.d.ts
+/**
+ * A package imports a package more than `rankSkip.maxDistance` ranks below it that is not in `rankSkip.exemptRanks`.
+ */
+export declare const importRankSkip: LayoutCheckFunction<ImportGraphOptions>;
+//#endregion
+//#region src/checks/import-uphill.d.ts
+/**
+ * A package imports a package of a strictly higher rank: dependencies run downhill only.
+ */
+export declare const importUphill: LayoutCheckFunction<ImportGraphOptions>;
+//#endregion
+//#region src/checks/instruction-symlinks.d.ts
+/**
+ * Each agent instruction file is tracked by git as a symbolic link (mode 120000) whose target is the README beside it, so the two cannot diverge. The link may be written in any form that resolves there (`./README.md`), and may lead through other tracked links, as in `CLAUDE.md` to `AGENTS.md` to `README.md`. It reads the index, not the working tree, so a checkout with `core.symlinks` false, where a link is written out as a plain file, is judged by what is committed.
+ */
+export declare const instructionSymlinks: CheckFunction<InstructionSymlinksOptions>;
+//#endregion
+//#region src/checks/migrations-directory.d.ts
+/**
+ * The directory a schema generator writes migrations to is the one the deploy tool applies them from, and no script applies them with the generator instead of the deploy tool. The generator and the deploy tool are named in the options and each has an adapter that knows its config file names and where in them the directory is; both directories are resolved against the directory of the file that sets them.
+ *
+ * The config files are read as data: JSON, JSONC and TOML are parsed, and a module (a generator's TypeScript config) is evaluated, so it must be trusted.
+ */
+export declare const migrationsDirectory: CheckFunction<MigrationsDirectoryOptions>;
+//#endregion
+//#region src/checks/single-storybook.d.ts
+/**
+ * At most one Storybook exists, in the permitted directory (the workspace root unless the options say otherwise), and none in a package such as a UI package. A Storybook is a `.storybook` directory.
+ */
+export declare const singleStorybook: CheckFunction<SingleStorybookOptions>;
+//#endregion
+//#region src/config.d.ts
+/**
+ * The `checks` map of the `conformance` section: a check runs when its name is present with an options object (`{}` for the defaults), and `false` turns it off, which lets a config that extends another switch one of its checks off.
+ */
+type ChecksConfig = { readonly [Name in CheckName]?: false | CheckOptionsByName[Name]; };
+/**
+ * The `conformance` section: which checks are enabled and their options.
+ */
+interface ConformanceConfig {
+  readonly checks: ChecksConfig;
+}
+/**
+ * The Standard Schema for {@link ConformanceConfig}. It rejects unknown keys at every level, so a misspelt check name or option fails when the section loads.
+ */
+export declare const conformanceSchema: z.ZodType<ConformanceConfig, ConformanceConfig>;
+/**
+ * The `conformance` section. Pass it to `withSections` beside `layoutSection` when authoring `exadev.config.ts`.
+ */
+export declare const conformanceSection: Section<"conformance", z.ZodType<ConformanceConfig, ConformanceConfig>>;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * A problem with how the tool was used or configured rather than a finding about the workspace: an unknown or disabled check, a missing or invalid section, a layout that cannot be resolved, a repository that is not a git checkout. The command line reports it and exits 2.
+ */
+export declare class ConformanceError extends Error {
+  constructor(message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/registry.d.ts
+/**
+ * What a check needs to run once the configuration is loaded.
+ */
+interface RunInput {
+  readonly cwd: string;
+  readonly checks: ChecksConfig;
+  readonly layout: LayoutConfig | undefined;
+  readonly configFiles: ConfigFileOptions | undefined;
+}
+/**
+ * What every registered check has, whichever way it runs.
+ */
+interface RegisteredCheckBase<Name extends CheckName> {
+  readonly name: Name;
+  readonly description: string;
+  /**
+   * Whether the check reads the workspace layout, and so needs the `layout` section.
+   */
+  readonly requiresLayout: boolean;
+  /**
+   * Whether the `checks` map turns this check on.
+   */
+  readonly isEnabled: (checks: ChecksConfig) => boolean;
+}
+/**
+ * A check that runs on its own.
+ */
+interface StandaloneCheck<Name extends CheckName> extends RegisteredCheckBase<Name> {
+  readonly run: (input: RunInput) => Promise<readonly Violation[]>;
+}
+/**
+ * An import check. It has no `run` of its own: it always joins a cruise shared with the other import checks of the run, so there is one path from the registry to dependency-cruiser.
+ */
+interface ImportGraphCheck<Name extends CheckName> extends RegisteredCheckBase<Name> {
+  readonly importGraph: {
+    readonly spec: ImportCheckSpec;
+    readonly optionsOf: (checks: ChecksConfig) => ImportGraphOptions | undefined;
+  };
+}
+/**
+ * A check bound to its place in the `checks` map.
+ */
+type RegisteredCheck<Name extends CheckName> = StandaloneCheck<Name> | ImportGraphCheck<Name>;
+/**
+ * Every check, by name, in the order they run. The key is the name used in the `checks` map, on the command line and in violation codes.
+ */
+export declare const registry: { readonly [Name in CheckName]: RegisteredCheck<Name>; };
+/**
+ * The names of all checks, in the order they run.
+ */
+export declare const checkNames: readonly CheckName[];
+/**
+ * Whether `name` is the name of a check.
+ */
+export declare function isCheckName(name: string): name is CheckName;
+//#endregion
+//#region src/run-checks.d.ts
+/**
+ * The process exit codes of the command line: nothing found, something found, or the checks could not run.
+ */
+export declare const EXIT_CODES: {
+  readonly clean: 0;
+  readonly violations: 1;
+  readonly failed: 2;
+};
+/**
+ * Options of {@link runChecks}.
+ */
+interface RunChecksOptions {
+  /**
+   * The directory that holds the config files and that every path option is relative to.
+   */
+  readonly cwd: string;
+  /**
+   * Run only these checks. Each must be enabled. Every enabled check runs when omitted.
+   */
+  readonly checks?: readonly CheckName[];
+  /**
+   * The `conformance` section, instead of loading it from `cwd`. It is validated against the section's schema.
+   */
+  readonly config?: ConformanceConfig;
+  /**
+   * The `layout` section, instead of loading it from `cwd`. It is validated against the section's schema. Read only by the checks that need it.
+   */
+  readonly layout?: LayoutConfig;
+  /**
+   * How config files are loaded: the sections loaded from `cwd` and the config files a check evaluates itself, such as the commitlint and release configs of `commit-types`. Only `alias` and `fsCache` apply to the latter.
+   */
+  readonly configFiles?: ConfigFileOptions;
+}
+/**
+ * The violations of one check.
+ */
+interface CheckResult {
+  readonly check: CheckName;
+  readonly violations: readonly Violation[];
+}
+/**
+ * The outcome of running checks.
+ */
+interface RunResult {
+  /**
+   * One entry per check that ran, in the order they ran.
+   */
+  readonly results: readonly CheckResult[];
+  /**
+   * Every violation of every check, by check.
+   */
+  readonly violations: readonly Violation[];
+  /**
+   * {@link EXIT_CODES}`.clean` when there are no violations, else {@link EXIT_CODES}`.violations`.
+   */
+  readonly exitCode: typeof EXIT_CODES.clean | typeof EXIT_CODES.violations;
+}
+/**
+ * Run the enabled checks, or the enabled ones among `checks`, and return what they found. Sections not supplied in the options are loaded from `cwd` with `@exadev/config`.
+ *
+ * Violations do not throw. It throws `ConformanceError` when the checks cannot run (nothing enabled, a requested check disabled, a section missing) and `ConfigValidationError` when a section fails its schema, whether it was loaded from `cwd` or passed in.
+ */
+export declare function runChecks(options: RunChecksOptions): Promise<RunResult>;
+//#endregion
+//#region src/type-level.d.ts
+/**
+ * A compiler error found in an in-memory file.
+ */
+interface TypeErrorReport {
+  readonly file: string;
+  readonly line: number;
+  /**
+   * The TypeScript diagnostic code, such as 2741 for a property missing from an object literal.
+   */
+  readonly code: number;
+  readonly message: string;
+}
+/**
+ * The outcome of removing one case from a handler map.
+ */
+interface CaseRemoval {
+  readonly case: string;
+  /**
+   * What the compiler reports once the case is gone; never empty in a proof that held.
+   */
+  readonly errors: readonly TypeErrorReport[];
+}
+/**
+ * What {@link proveExhaustive} established: the map type-checks as written, and every case it was asked about breaks the type check when removed.
+ */
+interface ExhaustivenessProof {
+  readonly removals: readonly CaseRemoval[];
+}
+/**
+ * Raised when a handler map is not exhaustive as claimed, or when the map cannot be found.
+ */
+export declare class ExhaustivenessError extends Error {
+  constructor(message: string);
+}
+/**
+ * Compile the files in memory and return every error the type checker reports. Names are paths in the in-memory file system, so one file can import another with a relative path.
+ */
+export declare function typeErrors(files: Readonly<Record<string, string>>, options?: CompilerOptions): readonly TypeErrorReport[];
+/**
+ * The names of the cases of the handler map `map`, an object literal assigned to a variable of that name in `source`.
+ */
+export declare function handlerCases(source: string, map: string): readonly string[];
+/**
+ * `source` with the case `key` deleted from the handler map `map`.
+ */
+export declare function removeCase(source: string, map: string, key: string): string;
+/**
+ * Prove that the handler map `map` in `files[file]` is checked for exhaustiveness by the compiler: the files type-check as written, and deleting any one case (each in `cases`, else every case of the map) makes them fail. Throws {@link ExhaustivenessError} otherwise.
+ *
+ * Write the handler map's type so the compiler demands every case, for example a mapped type over the union of command types, and call this from an ordinary test:
+ *
+ * ```ts
+ * proveExhaustive({ files: { 'handlers.ts': source }, file: 'handlers.ts', map: 'handlers' });
+ * ```
+ */
+export declare function proveExhaustive(input: {
+  readonly files: Readonly<Record<string, string>>;
+  readonly file: string;
+  readonly map: string;
+  readonly cases?: readonly string[];
+  readonly compilerOptions?: CompilerOptions;
+}): ExhaustivenessProof;
+//#endregion
+export type { AggregateMappersOptions, CaseRemoval, CheckContext, CheckFunction, CheckName, CheckOptionsByName, CheckResult, ChecksConfig, CommandTypesOptions, CommitTypesOptions, ConformanceConfig, DeployDirectory, DeploySelector, DeployToolAdapter, DeployToolName, DiscoveredPackage, DockerfilePackageManagerOptions, ExhaustivenessProof, GeneratorAdapter, GeneratorName, ImportGraphOptions, InstructionSymlinksOptions, LayoutCheckContext, LayoutCheckFunction, MigrationsDirectoryOptions, RegisteredCheck, RunChecksOptions, RunResult, SingleStorybookOptions, SourceLocation, TypeErrorReport, Violation, WorkspacePackage };