@alveolus/arch 0.0.0-stage → 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,599 @@
+import { Project } from "ts-morph";
+//#region src/architecture/allowed-packages.d.ts
+type PackageDependencies = Readonly<Record<string, true | readonly string[]>>;
+export declare class AllowedPackages {
+  private readonly packages;
+  constructor(packages?: PackageDependencies);
+  has(packageName: string): boolean;
+  forbiddenNames(packageName: string, names: readonly string[]): readonly string[];
+  allowedNames(packageName: string): readonly string[];
+  with(other: AllowedPackages): AllowedPackages;
+}
+//#endregion
+//#region src/conventions/core-api.d.ts
+declare const coreKinds: readonly ["AggregateRoot", "Entity", "ValueObject", "Identifier", "DomainEvent", "DomainError", "DomainService", "Port", "CommandRepository", "QueryRepository", "CommandHandler", "QueryHandler", "EventTranslator", "EventPublisher", "Outbox", "UnitOfWork"];
+type CoreKind = (typeof coreKinds)[number];
+declare const coreMarkers: readonly ["OpenHostService", "AntiCorruptionLayer"];
+type CoreMarker = (typeof coreMarkers)[number];
+//#endregion
+//#region src/conventions/layers.d.ts
+declare const layers: readonly ["domain", "application", "published-language", "driven", "driving"];
+type Layer = (typeof layers)[number];
+//#endregion
+//#region src/conventions/building-blocks.d.ts
+interface PlaceSpec {
+  readonly layer: Layer;
+  readonly folder?: string;
+  readonly suffix?: string;
+}
+//#endregion
+//#region src/model/classes/named-type.d.ts
+interface NamedType {
+  readonly name: string;
+  readonly packageName: string | undefined;
+}
+//#endregion
+//#region src/model/classes/class-type.d.ts
+declare class ClassType {
+  readonly name: string;
+  readonly declaredIn: string | undefined;
+  readonly lineage: readonly NamedType[];
+  constructor(name: string, declaredIn: string | undefined, lineage: readonly NamedType[]);
+  get key(): string;
+  get isInstalled(): boolean;
+}
+//#endregion
+//#region src/model/classes/heritage.d.ts
+interface TypeArgument {
+  readonly parameter: string;
+  readonly line: number;
+  readonly types: readonly ClassType[];
+}
+interface Heritage {
+  readonly isByName: boolean;
+  readonly typeArguments: readonly TypeArgument[];
+}
+//#endregion
+//#region src/model/classes/return-shape.d.ts
+interface ReturnShape {
+  readonly alias: NamedType | undefined;
+  readonly union: readonly NamedType[];
+}
+//#endregion
+//#region src/model/classes/member.d.ts
+type MemberKind = "field" | "constructor parameter" | "method" | "getter" | "setter";
+type Visibility = "public" | "protected" | "private";
+interface MemberProps {
+  readonly name: string;
+  readonly line: number;
+  readonly kind: MemberKind;
+  readonly visibility: Visibility;
+  readonly isStatic: boolean;
+  readonly isParameterProperty: boolean;
+  readonly isCallable: boolean;
+  readonly valueTypes: readonly ClassType[];
+  readonly parameterTypes: readonly ClassType[];
+  readonly returns: ReturnShape | undefined;
+}
+declare class Member {
+  readonly name: string;
+  readonly line: number;
+  readonly kind: MemberKind;
+  readonly visibility: Visibility;
+  readonly isStatic: boolean;
+  readonly isParameterProperty: boolean;
+  readonly isCallable: boolean;
+  readonly valueTypes: readonly ClassType[];
+  readonly parameterTypes: readonly ClassType[];
+  readonly returns: ReturnShape | undefined;
+  constructor(props: MemberProps);
+  get isPublicInstance(): boolean;
+  get isField(): boolean;
+}
+//#endregion
+//#region src/model/classes/class-declaration.d.ts
+interface ClassDeclarationProps {
+  readonly name: string;
+  readonly line: number;
+  readonly isAbstract: boolean;
+  readonly type: ClassType;
+  readonly heritage: Heritage | undefined;
+  readonly implemented: readonly NamedType[];
+  readonly members: readonly Member[];
+}
+declare class ClassDeclaration {
+  readonly name: string;
+  readonly line: number;
+  readonly isAbstract: boolean;
+  readonly type: ClassType;
+  readonly heritage: Heritage | undefined;
+  readonly implemented: readonly NamedType[];
+  readonly members: readonly Member[];
+  constructor(props: ClassDeclarationProps);
+  get heldMembers(): Member[];
+  get publicSurface(): Member[];
+  get typeArguments(): readonly TypeArgument[];
+  get extendsByName(): boolean;
+  get isStaticOnly(): boolean;
+  private isDeclared;
+}
+//#endregion
+//#region src/model/dependencies/dependency.d.ts
+type DependencyForm = "import" | "re-export" | "inline type" | "dynamic import" | "require" | "global";
+type TargetVisibility = "analysed" | "ignored" | "unresolved";
+type DependencyTarget = {
+  readonly kind: "file";
+  readonly path: string;
+  readonly visibility: TargetVisibility;
+} | {
+  readonly kind: "package";
+  readonly name: string;
+};
+declare class Dependency {
+  readonly line: number;
+  readonly form: DependencyForm;
+  readonly specifier: string;
+  readonly names: readonly string[];
+  readonly target: DependencyTarget;
+  constructor(line: number, form: DependencyForm, specifier: string, names: readonly string[], target: DependencyTarget);
+  get label(): string;
+  isOnPackage(name: string): boolean;
+}
+//#endregion
+//#region src/model/dependencies/global-use.d.ts
+type GlobalOrigin = "ecmascript" | "host";
+type GlobalEffect = "clock" | "randomness";
+declare class GlobalUse {
+  readonly line: number;
+  readonly name: string;
+  readonly origin: GlobalOrigin;
+  readonly effect: GlobalEffect | undefined;
+  constructor(line: number, name: string, origin: GlobalOrigin, effect: GlobalEffect | undefined);
+}
+//#endregion
+//#region src/model/statements/disable-comment.d.ts
+declare class DisableComment {
+  readonly line: number;
+  readonly text: string;
+  constructor(line: number, text: string);
+  get target(): number;
+}
+//#endregion
+//#region src/model/statements/throw.d.ts
+type ThrowForm = "throw" | "Promise.reject";
+declare class Throw {
+  readonly line: number;
+  readonly form: ThrowForm;
+  constructor(line: number, form: ThrowForm);
+}
+//#endregion
+//#region src/model/statements/top-level-statement.d.ts
+type StatementKind = "function" | "enum" | "namespace" | "mutable variable" | "computed constant" | "class expression" | "statement";
+declare class TopLevelStatement {
+  readonly kind: StatementKind;
+  readonly name: string;
+  readonly line: number;
+  constructor(kind: StatementKind, name: string, line: number);
+}
+//#endregion
+//#region src/model/source-file.d.ts
+interface SourceFileProps {
+  readonly path: string;
+  readonly text: string;
+  readonly dependencies: readonly Dependency[];
+  readonly classes: readonly ClassDeclaration[];
+  readonly statements: readonly TopLevelStatement[];
+  readonly throws: readonly Throw[];
+  readonly globals: readonly GlobalUse[];
+  readonly disables: readonly DisableComment[];
+}
+declare class SourceFile {
+  readonly path: string;
+  readonly dependencies: readonly Dependency[];
+  readonly classes: readonly ClassDeclaration[];
+  readonly statements: readonly TopLevelStatement[];
+  readonly throws: readonly Throw[];
+  readonly globals: readonly GlobalUse[];
+  readonly disables: readonly DisableComment[];
+  private readonly lines;
+  constructor(props: SourceFileProps);
+  lineText(line: number): string;
+  disableAbove(line: number): DisableComment | undefined;
+  classNamed(name: string): ClassDeclaration | undefined;
+}
+//#endregion
+//#region src/model/project.d.ts
+declare class Project$1 {
+  readonly directory: string;
+  readonly files: readonly SourceFile[];
+  private readonly filesByPath;
+  constructor(directory: string, files: readonly SourceFile[]);
+  file(path: string): SourceFile | undefined;
+  classOf(type: ClassType): ClassDeclaration | undefined;
+  relativePath(path: string): string;
+}
+//#endregion
+//#region src/architecture/core-api.d.ts
+declare class CoreApi {
+  get packageName(): string;
+  kindsOf(type: ClassType): CoreKind[];
+  markersOf(implemented: readonly NamedType[]): CoreMarker[];
+  isResult(shape: ReturnShape): boolean;
+  isDomainSymbol(name: string): boolean;
+  isPublishedLanguageSymbol(name: string): boolean;
+  private isKind;
+  private isMarker;
+  private isCore;
+}
+//#endregion
+//#region src/architecture/paths/location.d.ts
+type Area = "context" | "shared-kernel" | "root" | "outside";
+type Unseen = "ignored" | "unresolved";
+interface LocationProps {
+  readonly area: Area;
+  readonly context?: string;
+  readonly layer?: Layer;
+  readonly folder?: string;
+  readonly foldersInLayer?: readonly string[];
+  readonly fileName: string;
+  readonly isCompositionRoot?: boolean;
+  readonly unseen?: Unseen;
+}
+declare class Location {
+  readonly area: Area;
+  readonly context: string | undefined;
+  readonly layer: Layer | undefined;
+  readonly folder: string | undefined;
+  readonly foldersInLayer: readonly string[];
+  readonly fileName: string;
+  readonly isCompositionRoot: boolean;
+  readonly unseen: Unseen | undefined;
+  constructor(props: LocationProps);
+  get isInBoundedContext(): boolean;
+  get isInSharedKernel(): boolean;
+  get isAtRoot(): boolean;
+  get isOutside(): boolean;
+  get isInLayer(): boolean;
+  isSameContextAs(other: Location): boolean;
+  isOtherBoundedContextThan(other: Location): boolean;
+}
+//#endregion
+//#region src/architecture/paths/place.d.ts
+declare class Place {
+  readonly layer: Layer;
+  readonly folder: string | undefined;
+  readonly suffix: string | undefined;
+  constructor(spec: PlaceSpec);
+  fits(location: Location): boolean;
+}
+//#endregion
+//#region src/architecture/building-blocks.d.ts
+interface MarkedPlace {
+  readonly marker: CoreMarker;
+  readonly place: Place;
+}
+declare class BuildingBlocks {
+  private readonly core;
+  constructor(core: CoreApi);
+  placeOf(declaration: ClassDeclaration): Place | undefined;
+  markedPlacesOf(declaration: ClassDeclaration): MarkedPlace[];
+  foldersOf(layer: "domain" | "application"): readonly string[];
+}
+//#endregion
+//#region src/architecture/context-map.d.ts
+type Upstreams = Readonly<Record<string, readonly string[]>>;
+declare class ContextMap {
+  private readonly upstreams;
+  constructor(upstreams: Upstreams);
+  static ofEdges(edges: readonly {
+    readonly from: string;
+    readonly to: string;
+  }[]): ContextMap;
+  get contexts(): string[];
+  allows(from: string, to: string): boolean;
+  cycle(): string[] | undefined;
+  cycleThrough(from: string, to: string): boolean;
+  private cycleFrom;
+  private reaches;
+}
+//#endregion
+//#region src/architecture/layers.d.ts
+declare class Layers {
+  isLayer(name: string): name is Layer;
+  importableFrom(layer: Exclude<Layer, "domain">): readonly Layer[];
+}
+//#endregion
+//#region src/architecture/settings.d.ts
+interface ContextFolder {
+  readonly name: string;
+  readonly dir: string;
+  readonly isSharedKernel: boolean;
+}
+type ExtraFolders = Readonly<Partial<Record<"domain" | "application", readonly string[]>>>;
+interface Settings {
+  readonly rootDir: string;
+  readonly contextFolders: readonly ContextFolder[];
+  readonly compositionRoot: string;
+  readonly extraFolders: ExtraFolders;
+  readonly contextMap: ContextMap | undefined;
+  readonly domainDependencies: AllowedPackages;
+  readonly applicationDependencies: AllowedPackages;
+}
+//#endregion
+//#region src/architecture/paths/layer-shape.d.ts
+type ShapeIssue = {
+  readonly kind: "directlyInLayer" | "tooDeep";
+  readonly layer: "domain" | "application";
+  readonly example: string;
+} | {
+  readonly kind: "unknownFolder";
+  readonly layer: "domain" | "application";
+  readonly folder: string;
+  readonly folders: readonly string[];
+} | {
+  readonly kind: "nestedPublishedLanguage" | "drivenWithoutTechnology" | "drivenTooDeep" | "drivingWithoutTechnology";
+};
+//#endregion
+//#region src/architecture/architecture.d.ts
+type FileTarget$1 = Extract<DependencyTarget, {
+  kind: "file";
+}>;
+export declare class Architecture {
+  readonly project: Project$1;
+  private readonly settings;
+  readonly core: CoreApi;
+  readonly layers: Layers;
+  readonly blocks: BuildingBlocks;
+  private readonly shape;
+  private readonly layout;
+  private readonly locations;
+  constructor(project: Project$1, settings: Settings);
+  get files(): readonly SourceFile[];
+  get domainDependencies(): AllowedPackages;
+  get applicationDependencies(): AllowedPackages;
+  get contextMap(): ContextMap | undefined;
+  locationOf(file: SourceFile): Location;
+  locationOfTarget(target: FileTarget$1): Location;
+  shapeIssueOf(location: Location): ShapeIssue | undefined;
+  relativePath(path: string): string;
+  kindsOf(subject: ClassType | ClassDeclaration): CoreKind[];
+  kindOf(subject: ClassType | ClassDeclaration): CoreKind | undefined;
+  is(subject: ClassType | ClassDeclaration, kind: CoreKind): boolean;
+  isBuildingBlock(subject: ClassType | ClassDeclaration): boolean;
+  implementsMarker(declaration: ClassDeclaration, marker: CoreMarker): boolean;
+  returnsResult(member: Member): boolean;
+  classOf(type: ClassType): ClassDeclaration | undefined;
+  private locate;
+  private typeOf;
+}
+//#endregion
+//#region src/rules/framework/finding.d.ts
+type FindingData = Readonly<Record<string, string | number>>;
+interface Finding<MessageId extends string = string> {
+  readonly file: SourceFile;
+  readonly line: number;
+  readonly symbol: string;
+  readonly messageId: MessageId;
+  readonly data: FindingData;
+}
+//#endregion
+//#region src/rules/framework/wording.d.ts
+type FileTarget = Extract<DependencyTarget, {
+  kind: "file";
+}>;
+declare class Wording {
+  target(target: FileTarget, architecture: Architecture): string;
+  location(location: Location): string;
+  place(place: Place): string;
+}
+//#endregion
+//#region src/rules/framework/rule.d.ts
+interface RuleMeta<Id extends string, MessageId extends string> {
+  readonly id: Id;
+  readonly description: string;
+  readonly messages: Readonly<Record<MessageId, string>>;
+}
+export declare abstract class Rule<Id extends string = string, MessageId extends string = string> {
+  abstract readonly meta: RuleMeta<Id, MessageId>;
+  protected readonly wording: Wording;
+  abstract check(architecture: Architecture): Finding<MessageId>[];
+  protected finding(file: SourceFile, line: number, symbol: string, messageId: MessageId, data?: FindingData): Finding<MessageId>;
+}
+//#endregion
+//#region src/rules/tooling/no-loose-disable.rule.d.ts
+type MessageId = "noRule" | "unknownRule" | "noReason" | "unused";
+declare class NoLooseDisableRule extends Rule<"tooling/no-loose-disable", MessageId> {
+  private readonly knownRules;
+  readonly meta: RuleMeta<"tooling/no-loose-disable", MessageId>;
+  constructor(knownRules: readonly string[]);
+  check(architecture: Architecture): Finding<MessageId>[];
+  unused(file: SourceFile, comment: DisableComment): Finding<MessageId>;
+  private malformed;
+}
+//#endregion
+//#region src/rules/registry.d.ts
+declare const ruleIds: readonly ["strategic/no-cross-context-import", "strategic/no-leaky-host-service", "strategic/no-unmapped-context", "strategic/no-fat-shared-kernel", "layers/no-impure-domain", "layers/no-outward-import", "layers/no-portless-adapter", "layers/no-driving-shortcut", "tactical/no-aggregate-reference", "tactical/no-public-field", "tactical/no-foreign-command-dependency", "tactical/no-foreign-query-dependency", "tactical/no-stateful-service", "tactical/no-thrown-failure", "tactical/no-misplaced-class", "tactical/no-loose-code", "tooling/no-loose-disable"];
+type RuleId = (typeof ruleIds)[number];
+export declare class RuleRegistry {
+  readonly rules: readonly Rule<RuleId>[];
+  get looseDisable(): NoLooseDisableRule;
+  get ids(): RuleId[];
+}
+//#endregion
+//#region src/check/violation.d.ts
+type Severity = "error" | "warn" | "info";
+interface Violation {
+  readonly rule: RuleId;
+  readonly severity: Severity;
+  readonly file: string;
+  readonly line: number;
+  readonly symbol: string;
+  readonly message: string;
+  readonly fingerprint: string;
+}
+//#endregion
+//#region src/check/baseline.d.ts
+export declare class Baseline {
+  private readonly entries;
+  static readonly fileName = "alveolus.baseline.json";
+  private constructor();
+  static of(violations: readonly Violation[]): Baseline;
+  static load(path: string): Promise<Baseline>;
+  get size(): number;
+  get outdatedEntries(): number;
+  newViolations(violations: readonly Violation[]): Violation[];
+  staleEntries(violations: readonly Violation[]): number;
+  private match;
+  save(path: string): Promise<void>;
+  private keyOf;
+}
+//#endregion
+//#region src/importer/importer.d.ts
+interface ImportScope {
+  readonly projectDir: string;
+  readonly rootDir: string;
+  isIgnored(path: string): boolean;
+}
+export declare abstract class Importer {
+  abstract read(scope: ImportScope): Project$1;
+  abstract resolves(packageName: string, scope: ImportScope): boolean;
+}
+//#endregion
+//#region src/importer/ts-morph/ts-morph-importer.d.ts
+export declare class TsMorphImporter extends Importer {
+  private readonly sources;
+  private readonly classes;
+  private readonly statements;
+  private readonly disables;
+  private readonly throws;
+  constructor(sources: Project);
+  static fromTsConfig(tsConfigFilePath: string): TsMorphImporter;
+  resolves(packageName: string, scope: ImportScope): boolean;
+  read(scope: ImportScope): Project$1;
+  private readFile;
+  private globalUsesOf;
+  private isInside;
+}
+//#endregion
+//#region src/check/checker.d.ts
+interface CheckSettings extends ImportScope, Settings {
+  severityOf(rule: RuleId): Severity | "off";
+}
+interface Suppressed {
+  readonly violation: Violation;
+  readonly reason: string;
+}
+interface CheckOutcome {
+  readonly files: number;
+  readonly violations: Violation[];
+  readonly suppressed: Suppressed[];
+}
+export declare class Checker {
+  private readonly importer;
+  private readonly rules;
+  private readonly fingerprint;
+  constructor(importer: Importer, rules: readonly Rule<RuleId>[]);
+  check(settings: CheckSettings): CheckOutcome;
+  run(rule: Rule<RuleId>, architecture: Architecture): Violation[];
+  private collect;
+  private collectUnusedDisables;
+  private violationOf;
+  private messageOf;
+  private fill;
+  private compare;
+}
+//#endregion
+//#region src/check/report.d.ts
+interface ReportInput {
+  readonly files: number;
+  readonly violations: readonly Violation[];
+  readonly suppressed: readonly Suppressed[];
+  readonly baselined: number;
+  readonly stale: number;
+}
+export declare class Report {
+  private readonly input;
+  private readonly colors;
+  constructor(input: ReportInput, colored?: boolean);
+  text(): string;
+  json(): string;
+  sarif(rules: readonly RuleMeta<string, string>[]): string;
+  private byFile;
+  private block;
+  private severity;
+  private summary;
+  private counts;
+}
+//#endregion
+//#region src/cli/cli.d.ts
+interface Output {
+  write(text: string): unknown;
+}
+export declare class Cli {
+  private readonly stdout;
+  private readonly stderr;
+  private readonly cwd;
+  private readonly colored;
+  private exitCode;
+  constructor(stdout: Output, stderr: Output, cwd: string, colored?: boolean);
+  run(args: readonly string[]): Promise<number>;
+  private program;
+  private withOptions;
+  private check;
+  private render;
+  private warnOutdated;
+  private baseline;
+  private analyze;
+  private fail;
+}
+//#endregion
+//#region src/config/alveolus-config.d.ts
+type RuleSetting = "error" | "warn" | "info" | "off";
+interface LayoutConfig {
+  readonly extraFolders?: Readonly<Partial<Record<"domain" | "application", readonly string[]>>>;
+}
+interface AlveolusConfig {
+  readonly root: string;
+  readonly tsconfig?: string;
+  readonly boundedContexts: Readonly<Record<string, string>>;
+  readonly sharedKernel?: string;
+  readonly contextMap?: Upstreams;
+  readonly compositionRoot?: string;
+  readonly domainDependencies?: PackageDependencies;
+  readonly applicationDependencies?: PackageDependencies;
+  readonly ignore?: readonly string[];
+  readonly layout?: LayoutConfig;
+  readonly rules?: Readonly<Partial<Record<RuleId, RuleSetting>>>;
+}
+//#endregion
+//#region src/config/config.d.ts
+export declare class Config implements CheckSettings {
+  readonly projectDir: string;
+  readonly rootDir: string;
+  readonly tsConfigPath: string;
+  readonly compositionRoot: string;
+  readonly domainDependencies: AllowedPackages;
+  readonly applicationDependencies: AllowedPackages;
+  readonly contextFolders: readonly ContextFolder[];
+  readonly extraFolders: ExtraFolders;
+  readonly contextMap: ContextMap | undefined;
+  private readonly ignored;
+  private readonly rules;
+  constructor(config: AlveolusConfig, projectDir: string);
+  private validContextMap;
+  isIgnored(path: string): boolean;
+  severityOf(rule: RuleId): Severity | "off";
+}
+//#endregion
+//#region src/config/config-loader.d.ts
+export declare class ConfigLoader {
+  static readonly fileName = "alveolus.config.ts";
+  load(projectDir: string, configFile?: string): Promise<Config>;
+  private validate;
+}
+//#endregion
+//#region src/config/define-config.d.ts
+export declare function defineConfig(config: AlveolusConfig): AlveolusConfig;
+//#endregion
+export type { AlveolusConfig, CheckSettings, Finding, FindingData, ImportScope, PackageDependencies, RuleId, RuleMeta, RuleSetting, Settings, Violation };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":["Project","FileTarget","Project","Project","MorphProject","Project"],"sources":["../src/architecture/allowed-packages.ts","../src/conventions/core-api.ts","../src/conventions/layers.ts","../src/conventions/building-blocks.ts","../src/model/classes/named-type.ts","../src/model/classes/class-type.ts","../src/model/classes/heritage.ts","../src/model/classes/return-shape.ts","../src/model/classes/member.ts","../src/model/classes/class-declaration.ts","../src/model/dependencies/dependency.ts","../src/model/dependencies/global-use.ts","../src/model/statements/disable-comment.ts","../src/model/statements/throw.ts","../src/model/statements/top-level-statement.ts","../src/model/source-file.ts","../src/model/project.ts","../src/architecture/core-api.ts","../src/architecture/paths/location.ts","../src/architecture/paths/place.ts","../src/architecture/building-blocks.ts","../src/architecture/context-map.ts","../src/architecture/layers.ts","../src/architecture/settings.ts","../src/architecture/paths/layer-shape.ts","../src/architecture/architecture.ts","../src/rules/framework/finding.ts","../src/rules/framework/wording.ts","../src/rules/framework/rule.ts","../src/rules/tooling/no-loose-disable.rule.ts","../src/rules/registry.ts","../src/check/violation.ts","../src/check/baseline.ts","../src/importer/importer.ts","../src/importer/ts-morph/ts-morph-importer.ts","../src/check/checker.ts","../src/check/report.ts","../src/cli/cli.ts","../src/config/alveolus-config.ts","../src/config/config.ts","../src/config/config-loader.ts","../src/config/define-config.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,9 @@
+import { a as Config, c as RuleRegistry, d as AllowedPackages, f as Baseline, i as ConfigLoader, l as Rule, n as TsMorphImporter, o as Report, r as Importer, s as Checker, t as Cli, u as Architecture } from "./cli-CwPCGjDg.mjs";
+//#region src/config/define-config.ts
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+export { AllowedPackages, Architecture, Baseline, Checker, Cli, Config, ConfigLoader, Importer, Report, Rule, RuleRegistry, TsMorphImporter, defineConfig };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/config/define-config.ts"],"sourcesContent":["import type { AlveolusConfig } from \"./alveolus-config.ts\";\n\nexport function defineConfig(config: AlveolusConfig): AlveolusConfig {\n\treturn config;\n}\n"],"mappings":";;AAEA,SAAgB,aAAa,QAAwC;CACpE,OAAO;AACR"}

package/package.json

@@ -1,6 +1,55 @@
 {
+  "bin": {
+    "alveolus": "./dist/bin.mjs"
+  },
+  "dependencies": {
+    "commander": "^15.0.0",
+    "jiti": "^2.7.0",
+    "picocolors": "^1.1.1",
+    "ts-morph": "^28.0.0",
+    "zod": "^4.6.5"
+  },
+  "description": "Architecture checks that keep a Domain-Driven Design project from drifting",
+  "devDependencies": {
+    "@alveolus/core": "0.1.0"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./bin": "./dist/bin.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://alveolus.dev/",
+  "keywords": [
+    "ddd",
+    "domain-driven-design",
+    "typescript",
+    "architecture",
+    "architecture-testing",
+    "linter",
+    "bounded-context",
+    "hexagonal-architecture",
+    "clean-architecture",
+    "dependency-rules",
+    "cli"
+  ],
+  "license": "MIT",
   "name": "@alveolus/arch",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "repository": {
+    "directory": "packages/arch",
+    "type": "git",
+    "url": "git+https://github.com/alveolusjs/alveolus.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "version": "0.1.0",
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json"
+  }
 }