limina 0.0.6 → 0.1.1

package/index.d.ts

@@ -1,169 +1,686 @@
-import { BuiltinCheckerPreset, BuiltinTaskName, CheckerConfig, CheckerExecutionKind, CheckerPreset, GraphConditionDomain, GraphConfig, GraphRule, GraphRuleAllowConfig, GraphRuleDenyConfig, GraphRuleDepDenyEntry, GraphRuleRefAllowEntry, GraphRuleRefDenyEntry, LiminaCommand, LiminaConfig, LiminaConfigEnv, LiminaConfigExport, LiminaConfigFn, LiminaConfigFnObject, LiminaConfigFnPromise, LoadConfigOptions, PackageAttwCheckConfig, PackageAttwIgnoreRule, PackageAttwLevel, PackageAttwProfile, PackageBoundaryCheckConfig, PackageCheckTool, PackageCheckToolSelection, PackageConfig, PackageEntry, PackagePublintCheckConfig, PackagePublintLevel, PipelineStep, ProofAllowlistEntry, ProofConfig, ResolvedCheckerConfig, ResolvedLiminaConfig, RuntimeEnvironment, SharedLiminaConfig, SourceBoundaryConfig, SourceCheckConfig, SourceKnipCheckConfig, SourceKnipEntryConfig, SourceKnipIgnoredDependencyConfig, SourceKnipIgnoredFileConfig, SourceKnipWorkspaceConfig, defineConfig, getActiveCheckerExtensions, getActiveCheckers, loadConfig, validateLiminaConfig } from "./config.js";
-//#region src/flow.d.ts
-interface ClackLogAdapter {
-  error: (message: string) => void;
-  info: (message: string) => void;
-  step: (message: string) => void;
-  success: (message: string) => void;
-  warn: (message: string) => void;
-}
-interface ClackAdapter {
-  intro: (message: string) => void;
-  log: ClackLogAdapter;
-  outro: (message: string) => void;
-}
-interface FlowOutput {
-  write: (message: string) => void;
-}
-interface FlowWriteStream {
-  columns?: number;
-  isTTY?: boolean;
-  write?: unknown;
-}
-interface LiminaFlowReporterOptions {
-  clack?: ClackAdapter;
-  env?: NodeJS.ProcessEnv;
-  forceTty?: boolean;
-  output?: FlowOutput;
-  stderr?: FlowWriteStream;
-  stdout?: FlowWriteStream;
-}
-interface LiminaFlowMessageOptions {
-  collapseOnSuccess?: boolean;
-  depth?: number;
-  elapsedTimeMs?: number;
-}
-interface LiminaFlowFailureOptions extends LiminaFlowMessageOptions {
-  error?: unknown;
-}
-interface LiminaFlowTask {
-  fail: (message?: string, options?: LiminaFlowFailureOptions) => void;
-  info: (message: string, options?: LiminaFlowMessageOptions) => void;
-  pass: (message?: string, options?: LiminaFlowMessageOptions) => void;
-  skip: (message?: string, options?: LiminaFlowMessageOptions) => void;
-  warn: (message: string, options?: LiminaFlowMessageOptions) => void;
-}
-interface LiminaFlowOutputOptions {
-  stream?: "stderr" | "stdout";
-}
-declare class LiminaFlowReporter {
-  #private;
-  constructor(options?: LiminaFlowReporterOptions);
-  get interactive(): boolean;
-  intro(message: string): void;
-  outro(message: string): void;
-  start(message: string, options?: LiminaFlowMessageOptions): LiminaFlowTask;
-  fail(message: string, options?: LiminaFlowFailureOptions): void;
-  info(message: string, options?: LiminaFlowMessageOptions): void;
-  pass(message: string, options?: LiminaFlowMessageOptions): void;
-  skip(message: string, options?: LiminaFlowMessageOptions): void;
-  warn(message: string, options?: LiminaFlowMessageOptions): void;
-  writeOutput(message: string | Uint8Array, options?: LiminaFlowOutputOptions): void;
-}
-declare function createLiminaFlowReporter(options?: LiminaFlowReporterOptions): LiminaFlowReporter;
+//#region src/execution/config.d.ts
+type ExecutionConcurrency = number | "auto";
+interface ExecutionConfig {
+  checkerBuild?: ExecutionConcurrency;
+  checkerTypecheck?: ExecutionConcurrency;
+  failFast?: boolean;
+  packageEntries?: ExecutionConcurrency;
+  releaseEntries?: ExecutionConcurrency;
+  tasks?: ExecutionConcurrency;
+}
 //#endregion
-//#region src/commands/graph.d.ts
-interface RunGraphCheckOptions {
-  clearScreen?: boolean;
-  flow?: LiminaFlowReporter;
-  flowDepth?: number;
-}
-interface RunGraphSyncOptions {
-  clearScreen?: boolean;
+//#region src/config/runner.d.ts
+/**
+* Runtime label used by package boundary checks.
+*
+* Use `browser` for code that must stay free of Node.js runtime imports,
+* `node` for server-only output, or a custom string when a package has its own
+* environment naming.
+*/
+type RuntimeEnvironment = "browser" | "node" | string;
+/**
+* One step in a named Limina pipeline.
+*
+* A string can be either a built-in task such as `graph:check`, or a command
+* split on whitespace. Use the object form when you need args, cwd, or env to
+* be unambiguous.
+*/
+type PipelineStep = string | {
+  /**
+  * Arguments passed to the command.
+  *
+  * Prefer this over a single command string when an argument contains
+  * spaces or when you want the config to be easy to review.
+  */
+  args?: string[];
+  /**
+  * Executable name, for example `pnpm`, `tsc`, `tsgo`, `vue-tsc`, or `vue-tsgo`.
+  *
+  * The command runs from the inferred workspace root unless `cwd` is set.
+  */
+  command: string;
+  /**
+  * Working directory for this step, relative to the inferred workspace root.
+  */
   cwd?: string;
-  entryPath?: string;
-  flow?: LiminaFlowReporter;
-  flowDepth?: number;
+  /**
+  * Extra environment variables for this step.
+  *
+  * Values are merged on top of `process.env`.
+  */
+  env?: Record<string, string>;
+  /**
+  * Marks this pipeline step as an external command.
+  */
+  type: "command";
+} | {
+  /**
+  * Built-in Limina task to run.
+  */
+  name: BuiltinTaskName;
+  /**
+  * Marks this pipeline step as a built-in task.
+  */
+  type: "task";
+};
+/**
+* Built-in task names understood by Limina pipelines.
+*/
+type BuiltinTaskName = "checker:build" | "checker:typecheck" | "graph:prepare" | "graph:check" | "package:check" | "proof:check" | "release:check" | "source:check";
+type BuiltinCheckerPreset = "svelte-check" | "tsc" | "tsgo" | "vue-tsc" | "vue-tsgo";
+type CheckerPreset = BuiltinCheckerPreset;
+type BuildCheckerPreset = Extract<BuiltinCheckerPreset, "tsc" | "tsgo" | "vue-tsc">;
+type CheckerExecutionKind = "build" | "typecheck";
+/**
+* Checker capability for one source module family.
+*/
+interface CheckerConfig {
+  /**
+  * Built-in checker preset, such as `tsc`, `tsgo`, `vue-tsc`, `vue-tsgo`, or `svelte-check`.
+  */
+  preset: CheckerPreset;
+  /**
+  * Source-level ordinary tsconfig selectors covered by this checker.
+  */
+  include: string[];
+  /**
+  * Optional source-level tsconfig exclusion patterns.
+  */
+  exclude?: string[];
 }
-interface RunGraphSyncResult {
-  changed: boolean;
-  projectCount: number;
+interface AutoCheckerConfig {
+  /**
+  * Enables automatic checker discovery from ordinary source tsconfig.json
+  * scopes.
+  */
+  mode: "auto";
+  /**
+  * Optional source-level tsconfig exclusion patterns used during automatic
+  * checker discovery.
+  */
+  exclude?: string[];
 }
-declare function runGraphCheck(config: ResolvedLiminaConfig, options?: RunGraphCheckOptions): Promise<boolean>;
-declare function runGraphSync(config: ResolvedLiminaConfig, options?: RunGraphSyncOptions): Promise<RunGraphSyncResult>;
-//#endregion
-//#region src/commands/init.d.ts
-interface RunInitOptions {
-  clearScreen?: boolean;
-  cwd?: string;
-  flow?: LiminaFlowReporter;
-  flowDepth?: number;
-  yes?: boolean;
-}
-interface RunInitResult {
-  checkCommand: string;
-  installRequired: boolean;
-  rootDir: string;
-  skippedFiles: string[];
-  workspacePackageCount: number;
-  writtenFiles: string[];
-}
-declare function runInit(options?: RunInitOptions): Promise<RunInitResult>;
-//#endregion
-//#region src/commands/source.d.ts
-interface RunSourceCheckOptions {
-  clearScreen?: boolean;
-  flow?: LiminaFlowReporter;
-  flowDepth?: number;
+type CheckerConfigMode = AutoCheckerConfig | Record<string, CheckerConfig>;
+type VueImportParser = "compiler-sfc" | "heuristic";
+/**
+* Source import analysis settings shared by graph, proof, source, and checker
+* tasks.
+*/
+interface ImportAnalysisConfig {
+  /**
+  * Parser used to extract imports from Vue SFC script blocks.
+  *
+  * @default 'heuristic'
+  */
+  vue?: VueImportParser;
 }
-declare function runSourceCheck(config: ResolvedLiminaConfig, options?: RunSourceCheckOptions): Promise<boolean>;
-//#endregion
-//#region src/checkers.d.ts
-type CheckerPackageResolver = (options: {
-  packageName: string;
-  projectRootDir: string;
-}) => string | undefined;
-//#endregion
-//#region src/commands/typecheck.d.ts
-interface TypecheckTarget {
-  args: string[];
-  checkerName?: string;
-  configPath: string;
-  cwd: string;
-  command: string;
-  executionKind?: CheckerExecutionKind;
-  label?: string;
-}
-interface TypecheckTargetResult {
-  configPath: string;
-  error?: Error;
-  status: number;
-}
-type TypecheckRunner = (target: TypecheckTarget) => Promise<TypecheckTargetResult> | TypecheckTargetResult;
-interface RunCheckerBuildOptions {
-  clearScreen?: boolean;
-  config: ResolvedLiminaConfig;
-  cwd?: string;
-  flow?: LiminaFlowReporter;
-  flowDepth?: number;
-  checkerPackageResolver?: CheckerPackageResolver;
-  runner?: TypecheckRunner;
-  tscCommand?: string;
-}
-interface RunCheckerBuildResult {
-  passed: boolean;
-  projectRootDir: string;
-  rootConfigPaths: string[];
-}
-interface RunCheckerTypecheckOptions {
-  clearScreen?: boolean;
-  config: ResolvedLiminaConfig;
-  cwd?: string;
-  flow?: LiminaFlowReporter;
-  flowDepth?: number;
-  checkerPackageResolver?: CheckerPackageResolver;
-  runner?: TypecheckRunner;
-  tscCommand?: string;
-}
-interface RunCheckerTypecheckResult {
-  passed: boolean;
-  projectRootDir: string;
-  rootConfigPaths: string[];
-}
-declare function runCheckerBuild(options: RunCheckerBuildOptions): Promise<RunCheckerBuildResult>;
-declare function runCheckerTypecheck(options: RunCheckerTypecheckOptions): Promise<RunCheckerTypecheckResult>;
-//#endregion
-//#region src/tsconfig.d.ts
-declare function isOrdinaryTypecheckConfigPath(configPath: string): boolean;
+/**
+* Explicit exception for a declared workspace package dependency that is used
+* through generated code, runtime strings, or another path that Knip
+* dependency analysis cannot see.
+*/
+interface SourceKnipIgnoredDependencyConfig {
+  /**
+  * Declared workspace dependency package name.
+  */
+  dep: string;
+  /**
+  * Why the dependency is safe to keep even when Knip cannot prove it is
+  * reachable from package entries, binaries, or scripts.
+  */
+  reason: string;
+}
+/**
+* Explicit exception for a source module that is owned by a package but is
+* intentionally not reachable from Knip's package entry graph.
+*/
+interface SourceKnipIgnoredFileConfig {
+  /**
+  * Workspace-root-relative source module path.
+  */
+  file: string;
+  /**
+  * Why the source module is safe to keep even when Knip cannot prove it is
+  * reachable from package entries, binaries, or scripts.
+  */
+  reason: string;
+}
+/**
+* Additional source module entries for Knip's source reachability graph.
+*
+* Default entries come from package exports, package binaries, package scripts,
+* and Knip-supported plugin entries. Packages without package.json#exports are
+* treated as application-style owners: Limina provides the full governed source
+* module set as the entry surface and skips unused-file coverage for that
+* package. Use this only for extra entry modules loaded by test runners, local
+* tools, or build steps that should not become package exports.
+*/
+interface SourceKnipEntryConfig {
+  /**
+  * Workspace-root-relative file or glob patterns that Knip should treat as
+  * additional entries for the keyed package.
+  */
+  files: string[];
+  /**
+  * Why these modules are legitimate entries even though they are not package
+  * exports, binaries, scripts, or plugin-discovered entries.
+  */
+  reason: string;
+}
+/**
+* Package-level Knip source analysis config interpreted by Limina.
+*/
+interface SourceKnipWorkspaceConfig {
+  /**
+  * Additional package-owned source modules Knip should treat as reachable
+  * roots. Limina disables Knip's implicit index/main/cli entry guessing by
+  * default; package manifest entries, scripts, plugin-discovered entries, and
+  * Limina virtual entries remain enabled.
+  */
+  entry?: SourceKnipEntryConfig[];
+  /**
+  * Declared workspace dependencies intentionally not visible through Knip's
+  * entry-reachable dependency graph.
+  */
+  ignoreDependencies?: SourceKnipIgnoredDependencyConfig[];
+  /**
+  * Package-owned source modules intentionally not visible through Knip's
+  * entry-reachable file graph.
+  */
+  ignoreFiles?: SourceKnipIgnoredFileConfig[];
+}
+/**
+* Knip-backed source analysis config interpreted by Limina.
+*/
+interface SourceKnipCheckConfig {
+  /**
+  * Package-specific Knip source analysis config keyed by workspace package
+  * name, such as "@example/app". Unknown package names fail source checks.
+  */
+  workspaces?: Record<string, SourceKnipWorkspaceConfig>;
+}
+/**
+* Explicit bare-import authority rule for imports not fully authorized by the
+* owning source package manifest.
+*/
+interface SourceImportAuthorityAllowRule {
+  /**
+  * Workspace-root-relative source file globs where this authorization applies.
+  */
+  files: string[];
+  /**
+  * Package names or package-name globs whose declarations may also be read
+  * from the workspace root package.json when this rule matches.
+  */
+  packages?: string[];
+  /**
+  * Full import specifiers or specifier globs authorized by this rule.
+  */
+  specifiers?: string[];
+  /**
+  * Optional source owner identity. Named owners use their package name;
+  * nameless owners use their workspace-root-relative package directory.
+  */
+  owner?: string;
+  /**
+  * Why this import may use the matched authority rule.
+  */
+  reason: string;
+}
+/**
+* Bare package import authority settings interpreted by source checks.
+*/
+interface SourceImportAuthorityConfig {
+  /**
+  * Explicit import authority rules. `packages` makes the workspace root
+  * package.json an additional declaration candidate; `specifiers` authorizes
+  * exact import specifier exceptions.
+  */
+  allow?: SourceImportAuthorityAllowRule[];
+}
+/**
+* Source-owned dependency usage check settings.
+*/
+interface SourceCheckConfig {
+  /**
+  * Knip-backed unused dependency and unused source module analysis.
+  *
+  * `true` or omitted uses Limina's generated default config, `false` skips
+  * these Knip-backed checks, and an object configures Limina's semantic Knip
+  * source rules by workspace package name.
+  *
+  * @default true
+  */
+  knip?: boolean | SourceKnipCheckConfig;
+  /**
+  * Bare package import authorization rules.
+  */
+  importAuthority?: SourceImportAuthorityConfig;
+}
+/**
+* Global source boundary used by proof checks.
+*/
+interface SourceBoundaryConfig {
+  /**
+  * Glob patterns for source files that Limina should govern.
+  *
+  * When omitted, Limina uses TypeScript/JSON source defaults and adds
+  * framework extensions from configured checkers, such as `.vue` or
+  * `.svelte`.
+  */
+  include?: string[];
+  /**
+  * Glob patterns or directory shorthands to omit from source governance.
+  *
+  * When omitted, Limina reads the workspace root `.gitignore` and combines it
+  * with the built-in excludes below.
+  *
+  * @default: [
+  *   "nx.json",
+  *   "project.json",
+  *   "tsconfig.json",
+  *   "**\/tsconfig.*.json",
+  *   "dist",
+  *   ".nx",
+  *   ".git",
+  *   ".tsbuild",
+  *   "coverage",
+  *   "node_modules",
+  * ]
+  */
+  exclude?: string[];
+}
+/**
+* Shared project facts used by graph, proof, and related checks.
+*/
+interface SharedLiminaConfig {
+  /**
+  * Checker capabilities shared by graph, proof, and tsc tasks.
+  */
+  checkers?: CheckerConfigMode;
+  /**
+  * Source import analysis behavior shared by graph, proof, and source checks.
+  */
+  imports?: ImportAnalysisConfig;
+  /**
+  * Global source file boundary used by proof checks.
+  */
+  source?: SourceBoundaryConfig;
+}
+/**
+* Declaration leaf boundary denied to projects with a matching Limina label.
+*/
+interface GraphRuleRefDenyEntry {
+  /**
+  * Target `tsconfig*.dts.json` path, relative to the inferred workspace root.
+  */
+  path: string;
+  /**
+  * Human-readable explanation shown when the rule fails.
+  */
+  reason: string;
+}
+/**
+* Declaration leaf boundary explicitly allowed for projects with a matching
+* Limina graph rule when static import analysis cannot prove the edge.
+*/
+interface GraphRuleRefAllowEntry {
+  /**
+  * Target `tsconfig*.dts.json` path, relative to the inferred workspace root.
+  */
+  path: string;
+  /**
+  * Human-readable explanation documenting why this extra reference is safe.
+  */
+  reason: string;
+}
+/**
+* Dependency denied to projects with a matching Limina label.
+*/
+interface GraphRuleDepDenyEntry {
+  /**
+  * Target package root, package.json imports specifier, or Node builtin name.
+  *
+  * Examples: `@acme/internal`, `zod`, `#internal/*`, `fs`, `node:fs`,
+  * or `node:*`.
+  */
+  name: string;
+  /**
+  * Human-readable explanation shown when the rule fails.
+  */
+  reason: string;
+}
+/**
+* Deny lists for a Limina graph label.
+*/
+interface GraphRuleDenyConfig {
+  /**
+  * Declaration leaf boundaries that matching projects must not reference or import.
+  */
+  refs?: GraphRuleRefDenyEntry[];
+  /**
+  * Packages, package imports, and Node builtins that matching projects must
+  * not reference or import.
+  */
+  deps?: GraphRuleDepDenyEntry[];
+}
+/**
+* Allow lists for a Limina graph label.
+*/
+interface GraphRuleAllowConfig {
+  /**
+  * Extra declaration leaf boundaries that matching projects may keep even
+  * when static import analysis cannot prove them.
+  */
+  refs?: GraphRuleRefAllowEntry[];
+}
+/**
+* Package-level graph governance rule keyed by a label declared in
+* `tsconfig*.dts.json`.
+*/
+interface GraphRule {
+  /**
+  * Allowed graph boundaries that static analysis cannot prove.
+  */
+  allow?: GraphRuleAllowConfig;
+  /**
+  * Denied graph boundaries and workspace package dependencies.
+  */
+  deny?: GraphRuleDenyConfig;
+}
+/**
+* TypeScript project graph policy.
+*/
+interface GraphConditionDomain {
+  /**
+  * Human-readable domain name used in graph check reports.
+  */
+  name: string;
+  /**
+  * Domain entry `tsconfig*.dts.json` path, relative to the inferred workspace root.
+  */
+  entry: string;
+  /**
+  * Bundler/package condition names expected for this declaration reference tree.
+  */
+  customConditions: string[];
+}
+interface GraphConfig {
+  /**
+  * Real declaration resolution domains whose project references should share
+  * the configured custom conditions.
+  */
+  conditionDomains?: GraphConditionDomain[];
+  /**
+  * Label-based package and build-boundary access rules.
+  *
+  * A `tsconfig*.dts.json` can opt into one or more rules by declaring
+  * `liminaOptions.graphRules`.
+  */
+  rules?: Record<string, GraphRule>;
+}
+/**
+* Explicit exception for a source file that is intentionally not covered by the
+* normal proof rules.
+*/
+interface ProofAllowlistEntry {
+  /**
+  * File path to allow, relative to the inferred workspace root.
+  */
+  file: string;
+  /**
+  * Why this file is safe to exclude from normal proof coverage.
+  */
+  reason: string;
+}
+/**
+* Typecheck coverage proof settings.
+*/
+interface ProofConfig {
+  /**
+  * Intentional file-level exceptions.
+  */
+  allowlist?: ProofAllowlistEntry[];
+}
+/**
+* Package check tools that can run against a built package output.
+*/
+type PackageCheckTool = "attw" | "boundary" | "publint";
+/**
+* CLI package check tool selection.
+*/
+type PackageCheckToolSelection = PackageCheckTool | "all";
+/**
+* Are The Types Wrong profile used for package type resolution checks.
+*/
+type PackageAttwProfile = "esm-only" | "node16" | "strict";
+/**
+* publint package check settings.
+*/
+type PackagePublintLevel = "error" | "suggestion" | "warning";
+interface PackagePublintCheckConfig {
+  /**
+  * Minimum publint message level to report.
+  */
+  level?: PackagePublintLevel;
+  /**
+  * Whether publint should run in strict mode.
+  *
+  * @default true
+  */
+  strict?: boolean;
+}
+/**
+* Are The Types Wrong package check settings.
+*/
+type PackageAttwLevel = "error" | "warn";
+type PackageAttwIgnoreRule = "cjs-only-exports-default" | "cjs-resolves-to-esm" | "fallback-condition" | "false-cjs" | "false-esm" | "false-export-default" | "internal-resolution-error" | "missing-export-equals" | "named-exports" | "no-resolution" | "unexpected-module-syntax" | "untyped-resolution" | (string & {});
+interface PackageAttwCheckConfig {
+  /**
+  * Exhaustive list of package entrypoints to check. The package root is ".".
+  */
+  entrypoints?: string[];
+  /**
+  * Whether ATTW should consider all published files as entrypoints when no
+  * other entrypoints are detected or configured.
+  */
+  entrypointsLegacy?: boolean;
+  /**
+  * Entrypoints to exclude from checking.
+  */
+  excludeEntrypoints?: (string | RegExp)[];
+  /**
+  * Problem rule names to ignore.
+  */
+  ignoreRules?: PackageAttwIgnoreRule[];
+  /**
+  * Entrypoints to check in addition to automatically discovered ones.
+  */
+  includeEntrypoints?: string[];
+  /**
+  * Whether ATTW findings fail the package check or are logged as warnings.
+  *
+  * @default "error"
+  */
+  level?: PackageAttwLevel;
+  /**
+  * Problem profile to enforce.
+  *
+  * `esm-only` ignores CJS resolution failures for pure ESM packages.
+  *
+  * @default "esm-only"
+  */
+  profile?: PackageAttwProfile;
+}
+/**
+* Built package import boundary settings.
+*/
+interface PackageBoundaryCheckConfig {
+  /**
+  * Runtime environment for each emitted file.
+  *
+  * Use a string when the whole package has one environment, or a function when
+  * different files have different environments.
+  */
+  environment?: RuntimeEnvironment | ((relativeFilePath: string) => RuntimeEnvironment);
+  /**
+  * External package imports that are intentionally allowed even when they are
+  * not listed in the built package manifest.
+  */
+  ignoredExternalPackages?: string[];
+}
+/**
+* One published package output entry.
+*/
+interface PackageEntry {
+  /**
+  * Package name used by CLI filters, reports, and cwd release matching.
+  */
+  name: string;
+  /**
+  * Built package directory to scan, relative to the inferred workspace root.
+  */
+  outDir: string;
+  /**
+  * Package check tools enabled for this entry.
+  *
+  * @default ["publint", "attw", "boundary"]
+  */
+  checks?: PackageCheckTool[];
+  /**
+  * publint settings for this package output.
+  */
+  publint?: boolean | PackagePublintCheckConfig;
+  /**
+  * Are The Types Wrong settings for this package output.
+  */
+  attw?: boolean | PackageAttwCheckConfig;
+  /**
+  * Built package import boundary settings.
+  */
+  boundary?: PackageBoundaryCheckConfig;
+}
+/**
+* Published package settings.
+*/
+interface PackageConfig {
+  /**
+  * Built package outputs to check.
+  */
+  entries?: PackageEntry[];
+}
+interface ReleaseContentHashConfigArgs {
+  /**
+  * Package currently being release-checked.
+  */
+  importerName: string;
+  /**
+  * Workspace dependency package being compared against npm.
+  */
+  dependencyName: string;
+}
+/**
+* Release dependency artifact content hash settings.
+*/
+interface ReleaseContentHashConfig {
+  /**
+  * npm dist-tag used as the online baseline for dependency package output.
+  *
+  * @default "latest"
+  */
+  baselineTag?: string | ((args: ReleaseContentHashConfigArgs) => string);
+  /**
+  * Use Limina's built-in dependency artifact ignore set as a fallback when
+  * `ignore` is omitted or returns `undefined`.
+  *
+  * @default false
+  */
+  builtinIgnore?: boolean;
+  /**
+  * Additional package-relative glob patterns ignored by dependency artifact
+  * content hashes.
+  */
+  ignore?: string[] | ((args: ReleaseContentHashConfigArgs) => string[] | undefined);
+}
+/**
+* Release check settings.
+*/
+interface ReleaseConfig {
+  /**
+  * Dependency artifact content hash comparison settings.
+  */
+  contentHash?: ReleaseContentHashConfig;
+}
+/**
+* Limina user config.
+*/
+interface LiminaConfig {
+  /**
+  * Shared project facts, such as checker entries and source boundary.
+  */
+  config?: SharedLiminaConfig;
+  /**
+  * Bounded execution settings for task, checker, package, and release work.
+  */
+  execution?: ExecutionConfig;
+  /**
+  * TypeScript project graph and architecture rules.
+  */
+  graph?: GraphConfig;
+  /**
+  * Rules for checking built package outputs before publishing.
+  */
+  package?: PackageConfig;
+  /**
+  * Named command pipelines runnable through `limina check <name>`.
+  */
+  pipelines?: Record<string, PipelineStep[]>;
+  /**
+  * Rules that prove source files are covered by graph or checker entries.
+  */
+  proof?: ProofConfig;
+  /**
+  * Rules for release dependency artifact comparisons.
+  */
+  release?: ReleaseConfig;
+  /**
+  * Rules for source-owned dependency usage checks.
+  */
+  source?: SourceCheckConfig;
+}
+/**
+* CLI command currently loading the config.
+*/
+type LiminaCommand = "check" | "graph" | "package" | "proof" | "release" | "source" | (string & {});
+/**
+* Environment passed to function-style configs.
+*/
+interface LiminaConfigEnv {
+  /**
+  * CLI command family, such as `check`, `graph`, or `package`.
+  */
+  command: LiminaCommand;
+  /**
+  * Mode passed through `--mode`.
+  *
+  * Defaults to `process.env.NODE_ENV`, then `default`.
+  */
+  mode: string;
+}
+type LiminaConfigFnObject = (env: LiminaConfigEnv) => LiminaConfig;
+type LiminaConfigFnPromise = (env: LiminaConfigEnv) => Promise<LiminaConfig>;
+type LiminaConfigFn = (env: LiminaConfigEnv) => LiminaConfig | Promise<LiminaConfig>;
+type LiminaConfigExport = LiminaConfig | Promise<LiminaConfig> | LiminaConfigFnObject | LiminaConfigFnPromise | LiminaConfigFn;
+/**
+* Type helper for limina.config.mjs.
+*
+* Accepts a direct config object, a Promise, or a function that receives the
+* current {@link LiminaConfigEnv}.
+*/
+declare function defineConfig(config: LiminaConfig): LiminaConfig;
+declare function defineConfig(config: Promise<LiminaConfig>): Promise<LiminaConfig>;
+declare function defineConfig(config: LiminaConfigFnObject): LiminaConfigFnObject;
+declare function defineConfig(config: LiminaConfigFnPromise): LiminaConfigFnPromise;
+declare function defineConfig(config: LiminaConfigFn): LiminaConfigFn;
 //#endregion
-export { type BuiltinCheckerPreset, type BuiltinTaskName, type CheckerConfig, type CheckerExecutionKind, type CheckerPreset, type GraphConditionDomain, type GraphConfig, type GraphRule, type GraphRuleAllowConfig, type GraphRuleDenyConfig, type GraphRuleDepDenyEntry, type GraphRuleRefAllowEntry, type GraphRuleRefDenyEntry, type LiminaCommand, type LiminaConfig, type LiminaConfigEnv, type LiminaConfigExport, type LiminaConfigFn, type LiminaConfigFnObject, type LiminaConfigFnPromise, type LiminaFlowFailureOptions, type LiminaFlowMessageOptions, type LiminaFlowOutputOptions, LiminaFlowReporter, type LiminaFlowReporterOptions, type LiminaFlowTask, type LoadConfigOptions, type PackageAttwCheckConfig, type PackageAttwIgnoreRule, type PackageAttwLevel, type PackageAttwProfile, type PackageBoundaryCheckConfig, type PackageCheckTool, type PackageCheckToolSelection, type PackageConfig, type PackageEntry, type PackagePublintCheckConfig, type PackagePublintLevel, type PipelineStep, type ProofAllowlistEntry, type ProofConfig, type ResolvedCheckerConfig, type ResolvedLiminaConfig, type RunCheckerBuildOptions, type RunCheckerBuildResult, type RunCheckerTypecheckOptions, type RunCheckerTypecheckResult, type RunGraphCheckOptions, type RunGraphSyncOptions, type RunGraphSyncResult, type RunInitOptions, type RunInitResult, type RunSourceCheckOptions, type RuntimeEnvironment, type SharedLiminaConfig, type SourceBoundaryConfig, type SourceCheckConfig, type SourceKnipCheckConfig, type SourceKnipEntryConfig, type SourceKnipIgnoredDependencyConfig, type SourceKnipIgnoredFileConfig, type SourceKnipWorkspaceConfig, type TypecheckRunner, type TypecheckTarget, type TypecheckTargetResult, createLiminaFlowReporter, defineConfig, getActiveCheckerExtensions, getActiveCheckers, isOrdinaryTypecheckConfigPath, loadConfig, runCheckerBuild, runCheckerTypecheck, runGraphCheck, runGraphSync, runInit, runSourceCheck, validateLiminaConfig };
+export { type AutoCheckerConfig, type BuildCheckerPreset, type BuiltinCheckerPreset, type BuiltinTaskName, type CheckerConfig, type CheckerConfigMode, type CheckerExecutionKind, type CheckerPreset, type GraphConditionDomain, type GraphConfig, type GraphRule, type GraphRuleAllowConfig, type GraphRuleDenyConfig, type GraphRuleDepDenyEntry, type GraphRuleRefAllowEntry, type GraphRuleRefDenyEntry, type ImportAnalysisConfig, type LiminaCommand, type LiminaConfig, type LiminaConfigEnv, type LiminaConfigExport, type LiminaConfigFn, type LiminaConfigFnObject, type LiminaConfigFnPromise, type PackageAttwCheckConfig, type PackageAttwIgnoreRule, type PackageAttwLevel, type PackageAttwProfile, type PackageBoundaryCheckConfig, type PackageCheckTool, type PackageCheckToolSelection, type PackageConfig, type PackageEntry, type PackagePublintCheckConfig, type PackagePublintLevel, type PipelineStep, type ProofAllowlistEntry, type ProofConfig, type ReleaseConfig, type ReleaseContentHashConfig, type ReleaseContentHashConfigArgs, type RuntimeEnvironment, type SharedLiminaConfig, type SourceBoundaryConfig, type SourceCheckConfig, type SourceImportAuthorityAllowRule, type SourceImportAuthorityConfig, type SourceKnipCheckConfig, type SourceKnipEntryConfig, type SourceKnipIgnoredDependencyConfig, type SourceKnipIgnoredFileConfig, type SourceKnipWorkspaceConfig, type VueImportParser, defineConfig };