limina 0.0.1

package/config.d.ts

@@ -0,0 +1,483 @@
+//#region src/config.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`, or `vue-tsc`.
+  *
+  * 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;
+  /**
+  * 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:check" | "package:check" | "proof:check" | "source:check";
+type BuiltinCheckerPreset = "svelte-check" | "tsc" | "vue-tsc";
+type CheckerPreset = BuiltinCheckerPreset | (string & {});
+type CheckerExecutionKind = "build" | "typecheck";
+/**
+* Checker capability for one source module family.
+*/
+interface CheckerConfig {
+  /**
+  * Built-in checker preset, such as `tsc`, `vue-tsc`, or `svelte-check`.
+  */
+  preset: CheckerPreset;
+  /**
+  * Checker entry project used by both build and typecheck execution modes.
+  */
+  entry: string;
+  /**
+  * Source file suffixes covered by this checker.
+  *
+  * Built-in presets may omit this and use their default suffixes.
+  */
+  extensions?: string[];
+}
+interface ResolvedCheckerConfig {
+  entry: string;
+  extensions: string[];
+  name: string;
+  preset: CheckerPreset;
+}
+/**
+* Source boundary that must be covered by checker entries or allowlist proof.
+*/
+interface SourceBoundaryConfig {
+  /**
+  * Glob patterns for source files that need proof coverage.
+  *
+  * When omitted, Limina derives the source boundary from configured checker
+  * extensions and then applies `exclude`.
+  */
+  include?: string[];
+  /**
+  * Glob patterns or directory shorthands to omit from proof coverage.
+  *
+  * @default: [
+  *   "node_modules",
+  *   "dist",
+  *   ".git",
+  *   ".tsbuild",
+  *   "coverage",
+  *   "**\/tsconfig*.json",
+  *   "**\/package.json",
+  *   ".prettierrc.json",
+  *   ".markdownlint.json",
+  *   "vercel.json",
+  * ]
+  */
+  exclude?: string[];
+}
+/**
+* Shared project facts used by graph, paths, proof, and related checks.
+*/
+interface SharedLiminaConfig {
+  /**
+  * Checker capabilities shared by graph, proof, paths, and tsc tasks.
+  */
+  checkers?: Record<string, CheckerConfig>;
+  /**
+  * Source file boundary used by coverage proof.
+  */
+  source?: SourceBoundaryConfig;
+}
+/**
+* Options for generated TypeScript `paths` compatibility files.
+*/
+interface PathsConfig {
+  /**
+  * Directory names treated as build artifacts when mapping package exports
+  * back to source files.
+  */
+  artifactDirectories?: string[];
+  /**
+  * Export condition priority when resolving package exports.
+  *
+  * Put more specific conditions earlier when your package exports use several
+  * entries such as `types`, `import`, `node`, or `default`.
+  */
+  conditionPriority?: string[];
+  /**
+  * File name used for generated path mapping configs.
+  *
+  * @default "tsconfig.dts.paths.generated.json"
+  */
+  generatedFileName?: string;
+  /**
+  * Header marker written into generated files.
+  *
+  * Limina uses this to know which files it is allowed to refresh.
+  */
+  generatedFileMarker?: string;
+  /**
+  * Source extensions tried when replacing artifact exports with source files.
+  */
+  sourceExtensions?: string[];
+}
+/**
+* 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;
+}
+/**
+* Workspace package dependency denied to projects with a matching Limina label.
+*/
+interface GraphRuleDepDenyEntry {
+  /**
+  * Target workspace package name.
+  *
+  * @deprecated Use `workspaceDeps` for new configs.
+  */
+  name: string;
+  /**
+  * Human-readable explanation shown when the rule fails.
+  */
+  reason: string;
+}
+/**
+* Workspace package dependency denied to projects with a matching Limina label.
+*/
+interface GraphRuleWorkspaceDepDenyEntry {
+  /**
+  * Target workspace package name.
+  */
+  name: string;
+  /**
+  * Human-readable explanation shown when the rule fails.
+  */
+  reason: string;
+}
+/**
+* Node builtin denied to source files with a matching Limina label.
+*/
+interface GraphRuleNodeBuiltinDenyEntry {
+  /**
+  * Target Node builtin name, such as `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[];
+  /**
+  * Workspace packages that matching projects must not reference or import.
+  *
+  * @deprecated Use `workspaceDeps` for new configs.
+  */
+  deps?: GraphRuleDepDenyEntry[];
+  /**
+  * Node builtins that matching projects must not import.
+  */
+  nodeBuiltins?: GraphRuleNodeBuiltinDenyEntry[];
+  /**
+  * Workspace packages that matching projects must not reference or import.
+  */
+  workspaceDeps?: GraphRuleWorkspaceDepDenyEntry[];
+}
+/**
+* Package-level graph governance rule keyed by a label declared in
+* `tsconfig*.dts.json`.
+*/
+interface GraphRule {
+  /**
+  * Denied graph boundaries and workspace package dependencies.
+  */
+  deny?: GraphRuleDenyConfig;
+}
+/**
+* TypeScript project graph policy.
+*/
+interface GraphConfig {
+  /**
+  * Label-based package and build-boundary access rules.
+  *
+  * A `tsconfig*.dts.json` can opt into one rule by declaring
+  * `"limina": "<label>"`.
+  */
+  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.
+*/
+interface PackagePublintCheckConfig {
+  /**
+  * Whether publint should run in strict mode.
+  *
+  * @default true
+  */
+  strict?: boolean;
+}
+/**
+* Are The Types Wrong package check settings.
+*/
+interface PackageAttwCheckConfig {
+  /**
+  * 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 to check.
+*/
+interface PackageCheckTarget {
+  /**
+  * Built package directory to scan, relative to the inferred workspace root.
+  */
+  outDir: string;
+  /**
+  * Package check tools enabled for this target.
+  *
+  * @default ["publint", "attw", "boundary"]
+  */
+  checks?: PackageCheckTool[];
+  /**
+  * publint settings for this package output.
+  */
+  publint?: PackagePublintCheckConfig;
+  /**
+  * Are The Types Wrong settings for this package output.
+  */
+  attw?: PackageAttwCheckConfig;
+  /**
+  * Built package import boundary settings.
+  */
+  boundary?: PackageBoundaryCheckConfig;
+  /**
+  * Friendly target name used by CLI filters and reports.
+  *
+  * Defaults to the `outDir` path.
+  */
+  name?: string;
+}
+/**
+* Published package check settings.
+*/
+interface PackageChecksConfig {
+  /**
+  * Built package outputs to check.
+  */
+  targets?: PackageCheckTarget[];
+}
+/**
+* Limina user config.
+*/
+interface LiminaConfig {
+  /**
+  * Shared project facts, such as checker entries and source boundary.
+  */
+  config?: SharedLiminaConfig;
+  /**
+  * TypeScript project graph and architecture rules.
+  */
+  graph?: GraphConfig;
+  /**
+  * Rules for checking built package outputs before publishing.
+  */
+  packageChecks?: PackageChecksConfig;
+  /**
+  * Options for generating TypeScript source `paths` compatibility files.
+  */
+  paths?: PathsConfig;
+  /**
+  * 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;
+}
+/**
+* CLI command currently loading the config.
+*/
+type LiminaCommand = "check" | "graph" | "package" | "paths" | "proof" | "source" | (string & {});
+/**
+* Environment passed to function-style configs.
+*/
+interface LiminaConfigEnv {
+  /**
+  * CLI command family, such as `check`, `graph`, or `paths`.
+  */
+  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;
+interface ResolvedLiminaConfig extends LiminaConfig {
+  /**
+  * Absolute path to the loaded config file.
+  */
+  configPath: string;
+  /**
+  * Absolute workspace root inferred from `cwd` and its parent directories.
+  */
+  rootDir: string;
+}
+/**
+* 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;
+declare function validateLiminaConfig(config: LiminaConfig): void;
+declare function getActiveCheckers(config: LiminaConfig): ResolvedCheckerConfig[];
+declare function getActiveCheckerExtensions(config: LiminaConfig): string[];
+interface LoadConfigOptions {
+  /**
+  * Command family to expose to function-style configs.
+  */
+  command?: LiminaCommand;
+  /**
+  * Config file path, resolved from `cwd`. When omitted, Limina searches for
+  * the nearest `limina.config.mjs` from `cwd` upward to the inferred pnpm
+  * workspace root.
+  *
+  * @default nearest "limina.config.mjs" in `cwd` or workspace parents
+  */
+  configPath?: string;
+  /**
+  * Directory used to resolve `configPath`.
+  *
+  * @default process.cwd()
+  */
+  cwd?: string;
+  /**
+  * Mode exposed to function-style configs.
+  *
+  * @default process.env.NODE_ENV ?? "default"
+  */
+  mode?: string;
+}
+declare function loadConfig(options?: LoadConfigOptions): Promise<ResolvedLiminaConfig>;
+//#endregion
+export { BuiltinCheckerPreset, BuiltinTaskName, CheckerConfig, CheckerExecutionKind, CheckerPreset, GraphConfig, GraphRule, GraphRuleDenyConfig, GraphRuleDepDenyEntry, GraphRuleNodeBuiltinDenyEntry, GraphRuleRefDenyEntry, GraphRuleWorkspaceDepDenyEntry, LiminaCommand, LiminaConfig, LiminaConfigEnv, LiminaConfigExport, LiminaConfigFn, LiminaConfigFnObject, LiminaConfigFnPromise, LoadConfigOptions, PackageAttwCheckConfig, PackageAttwProfile, PackageBoundaryCheckConfig, PackageCheckTarget, PackageCheckTool, PackageCheckToolSelection, PackageChecksConfig, PackagePublintCheckConfig, PathsConfig, PipelineStep, ProofAllowlistEntry, ProofConfig, ResolvedCheckerConfig, ResolvedLiminaConfig, RuntimeEnvironment, SharedLiminaConfig, SourceBoundaryConfig, defineConfig, getActiveCheckerExtensions, getActiveCheckers, loadConfig, validateLiminaConfig };

package/config.js

@@ -0,0 +1,4 @@
+import "./chunks/dep-lkQg1P9Q.js";
+import { a as validateLiminaConfig, i as loadConfig, n as getActiveCheckerExtensions, r as getActiveCheckers, t as defineConfig } from "./chunks/dep-jgc7X0zw.js";
+
+export { defineConfig, getActiveCheckerExtensions, getActiveCheckers, loadConfig, validateLiminaConfig };

package/index.d.ts

@@ -0,0 +1,144 @@
+import { BuiltinCheckerPreset, BuiltinTaskName, CheckerConfig, CheckerExecutionKind, CheckerPreset, GraphConfig, GraphRule, GraphRuleDenyConfig, GraphRuleDepDenyEntry, GraphRuleNodeBuiltinDenyEntry, GraphRuleRefDenyEntry, GraphRuleWorkspaceDepDenyEntry, LiminaCommand, LiminaConfig, LiminaConfigEnv, LiminaConfigExport, LiminaConfigFn, LiminaConfigFnObject, LiminaConfigFnPromise, LoadConfigOptions, PackageAttwCheckConfig, PackageAttwProfile, PackageBoundaryCheckConfig, PackageCheckTarget, PackageCheckTool, PackageCheckToolSelection, PackageChecksConfig, PackagePublintCheckConfig, PathsConfig, PipelineStep, ProofAllowlistEntry, ProofConfig, ResolvedCheckerConfig, ResolvedLiminaConfig, RuntimeEnvironment, SharedLiminaConfig, SourceBoundaryConfig, 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;
+//#endregion
+//#region src/commands/source.d.ts
+interface RunSourceCheckOptions {
+  clearScreen?: boolean;
+  flow?: LiminaFlowReporter;
+  flowDepth?: number;
+}
+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 RunCheckerTypecheckOptions {
+  clearScreen?: boolean;
+  config: ResolvedLiminaConfig;
+  concurrency?: number;
+  cwd?: string;
+  flow?: LiminaFlowReporter;
+  flowDepth?: number;
+  checkerPackageResolver?: CheckerPackageResolver;
+  runner?: TypecheckRunner;
+  tscCommand?: string;
+}
+interface RunCheckerTypecheckResult {
+  passed: boolean;
+  projectRootDir: string;
+  results: TypecheckTargetResult[];
+  rootConfigPaths: string[];
+  targetProjectPaths: string[];
+}
+declare function runCheckerTypecheck(options: RunCheckerTypecheckOptions): Promise<RunCheckerTypecheckResult>;
+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[];
+}
+declare function runCheckerBuild(options: RunCheckerBuildOptions): Promise<RunCheckerBuildResult>;
+//#endregion
+//#region src/tsconfig.d.ts
+interface CollectTypecheckTargetProjectPathsOptions {
+  rootConfigPath: string;
+  rootDir: string;
+}
+interface CollectTypecheckTargetProjectPathsResult {
+  problems: string[];
+  projectPaths: string[];
+  targetProjectPaths: string[];
+}
+declare function isOrdinaryTypecheckConfigPath(configPath: string): boolean;
+declare function collectTypecheckTargetProjectPaths(options: CollectTypecheckTargetProjectPathsOptions): CollectTypecheckTargetProjectPathsResult;
+//#endregion
+export { type BuiltinCheckerPreset, type BuiltinTaskName, type CheckerConfig, type CheckerExecutionKind, type CheckerPreset, type CollectTypecheckTargetProjectPathsOptions, type CollectTypecheckTargetProjectPathsResult, type GraphConfig, type GraphRule, type GraphRuleDenyConfig, type GraphRuleDepDenyEntry, type GraphRuleNodeBuiltinDenyEntry, type GraphRuleRefDenyEntry, type GraphRuleWorkspaceDepDenyEntry, 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 PackageAttwProfile, type PackageBoundaryCheckConfig, type PackageCheckTarget, type PackageCheckTool, type PackageCheckToolSelection, type PackageChecksConfig, type PackagePublintCheckConfig, type PathsConfig, type PipelineStep, type ProofAllowlistEntry, type ProofConfig, type ResolvedCheckerConfig, type ResolvedLiminaConfig, type RunCheckerBuildOptions, type RunCheckerBuildResult, type RunCheckerTypecheckOptions, type RunCheckerTypecheckResult, type RunSourceCheckOptions, type RuntimeEnvironment, type SharedLiminaConfig, type SourceBoundaryConfig, type TypecheckRunner, type TypecheckTarget, type TypecheckTargetResult, collectTypecheckTargetProjectPaths, createLiminaFlowReporter, defineConfig, getActiveCheckerExtensions, getActiveCheckers, isOrdinaryTypecheckConfigPath, loadConfig, runCheckerBuild, runCheckerTypecheck, runSourceCheck, validateLiminaConfig };

package/index.js

@@ -0,0 +1,5 @@
+import "./chunks/dep-lkQg1P9Q.js";
+import { a as validateLiminaConfig, i as loadConfig, n as getActiveCheckerExtensions, r as getActiveCheckers, t as defineConfig } from "./chunks/dep-jgc7X0zw.js";
+import { G as isOrdinaryTypecheckConfigPath, R as collectTypecheckTargetProjectPaths, a as runSourceCheck, i as runCheckerTypecheck, n as createLiminaFlowReporter, r as runCheckerBuild, t as LiminaFlowReporter } from "./chunks/dep-DoSHsBSP.js";
+
+export { LiminaFlowReporter, collectTypecheckTargetProjectPaths, createLiminaFlowReporter, defineConfig, getActiveCheckerExtensions, getActiveCheckers, isOrdinaryTypecheckConfigPath, loadConfig, runCheckerBuild, runCheckerTypecheck, runSourceCheck, validateLiminaConfig };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "limina",
+  "version": "0.0.1",
+  "type": "module",
+  "license": "MIT",
+  "author": "Senao Xi",
+  "description": "Configurable monorepo architecture and TypeScript graph governance CLI",
+  "keywords": [
+    "monorepo",
+    "typescript",
+    "project-references",
+    "workspace",
+    "architecture"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "bin": {
+    "limina": "./bin/limina.js"
+  },
+  "dependencies": {
+    "@arethetypeswrong/core": "^0.18.2",
+    "@clack/prompts": "^1.4.0",
+    "@docs-islands/logger": "0.0.5",
+    "@publint/pack": "^0.1.4",
+    "cac": "^6.7.14",
+    "es-module-lexer": "^2.0.0",
+    "publint": "^0.3.17",
+    "tinyglobby": "^0.2.15",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "svelte-check": "^4.4.7",
+    "typescript": "~5.9.3",
+    "vue-tsc": "~3.2.4"
+  },
+  "peerDependenciesMeta": {
+    "svelte-check": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    },
+    "vue-tsc": {
+      "optional": true
+    }
+  },
+  "types": "./index.d.ts",
+  "exports": {
+    ".": "./index.js",
+    "./config": "./config.js",
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false
+}