archstone 1.2.1 → 1.3.0-rc.2

package/dist/core/index.d.ts

@@ -1,2 +1,2 @@
-import { Either, Optional, UniqueEntityId, ValueObject, WatchedList, left, right } from "../shared/chunk-t21213sm.js";
-export { right, left, WatchedList, ValueObject, UniqueEntityId, Optional, Either };
+import { DomainEvent, DomainEvents, Either, EventHandler, Optional, UniqueEntityId, ValueObject, WatchedList, left, right } from "../shared/chunk-rgs8z093.js";
+export { right, left, WatchedList, ValueObject, UniqueEntityId, Optional, EventHandler, Either, DomainEvents, DomainEvent };

package/dist/core/index.js

@@ -1,2 +1,2 @@
 // @bun
-import{d as a,e as b,f as c,g as d,h as e}from"../shared/chunk-r63mxet1.js";export{b as right,a as left,e as WatchedList,d as ValueObject,c as UniqueEntityId};
+import{c as a,d as b,e as c,f as d,g as e,h as f}from"../shared/chunk-8hx7pxm3.js";export{b as right,a as left,f as WatchedList,e as ValueObject,d as UniqueEntityId,c as DomainEvents};

package/dist/domain/application/index.d.ts

@@ -1,3 +1,2 @@
-import { Creatable, Deletable, Findable, Repository, Saveable, UseCase, UseCaseError } from "../../shared/chunk-txbqwwkc.js";
-import "../../shared/chunk-t21213sm.js";
+import { Creatable, Deletable, Findable, Repository, Saveable, UseCase, UseCaseError } from "../../shared/chunk-rgs8z093.js";
 export { UseCaseError, UseCase, Saveable, Repository, Findable, Deletable, Creatable };

package/dist/domain/enterprise/index.d.ts

@@ -1,3 +1,2 @@
-import { AggregateRoot, DomainEvent, DomainEvents, Entity, EventHandler } from "../../shared/chunk-axgwjkjg.js";
-import "../../shared/chunk-t21213sm.js";
+import { AggregateRoot, DomainEvent, DomainEvents, Entity, EventHandler } from "../../shared/chunk-rgs8z093.js";
 export { EventHandler, Entity, DomainEvents, DomainEvent, AggregateRoot };

package/dist/domain/enterprise/index.js

@@ -1,2 +1,2 @@
 // @bun
-import{a,b,c}from"../../shared/chunk-jw0ckhsy.js";import"../../shared/chunk-r63mxet1.js";export{b as Entity,a as DomainEvents,c as AggregateRoot};
+import{a as b,b as c}from"../../shared/chunk-s2r7zghq.js";import{e as a}from"../../shared/chunk-8hx7pxm3.js";export{b as Entity,a as DomainEvents,c as AggregateRoot};

package/dist/domain/index.d.ts

@@ -1,5 +1,2 @@
-import "../shared/chunk-em5cewpk.js";
-import { Creatable, Deletable, Findable, Repository, Saveable, UseCase, UseCaseError } from "../shared/chunk-txbqwwkc.js";
-import { AggregateRoot, DomainEvent, DomainEvents, Entity, EventHandler } from "../shared/chunk-axgwjkjg.js";
-import "../shared/chunk-t21213sm.js";
+import { AggregateRoot, Creatable, Deletable, DomainEvent, DomainEvents, Entity, EventHandler, Findable, Repository, Saveable, UseCase, UseCaseError } from "../shared/chunk-rgs8z093.js";
 export { UseCaseError, UseCase, Saveable, Repository, Findable, EventHandler, Entity, DomainEvents, DomainEvent, Deletable, Creatable, AggregateRoot };

package/dist/domain/index.js

@@ -1,2 +1,2 @@
 // @bun
-import"../shared/chunk-x296z7h1.js";import"../shared/chunk-wsjyhnpq.js";import{a,b,c}from"../shared/chunk-jw0ckhsy.js";import"../shared/chunk-r63mxet1.js";export{b as Entity,a as DomainEvents,c as AggregateRoot};
+import"../shared/chunk-x296z7h1.js";import"../shared/chunk-wsjyhnpq.js";import{a as b,b as c}from"../shared/chunk-s2r7zghq.js";import{e as a}from"../shared/chunk-8hx7pxm3.js";export{b as Entity,a as DomainEvents,c as AggregateRoot};

package/dist/index.d.ts

@@ -1,5 +1,2 @@
-import "./shared/chunk-em5cewpk.js";
-import { Creatable, Deletable, Findable, Repository, Saveable, UseCase, UseCaseError } from "./shared/chunk-txbqwwkc.js";
-import { AggregateRoot, DomainEvent, DomainEvents, Entity, EventHandler } from "./shared/chunk-axgwjkjg.js";
-import { Either, Optional, UniqueEntityId, ValueObject, WatchedList, left, right } from "./shared/chunk-t21213sm.js";
+import { AggregateRoot, Creatable, Deletable, DomainEvent, DomainEvents, Either, Entity, EventHandler, Findable, Optional, Repository, Saveable, UniqueEntityId, UseCase, UseCaseError, ValueObject, WatchedList, left, right } from "./shared/chunk-rgs8z093.js";
 export { right, left, WatchedList, ValueObject, UseCaseError, UseCase, UniqueEntityId, Saveable, Repository, Optional, Findable, EventHandler, Entity, Either, DomainEvents, DomainEvent, Deletable, Creatable, AggregateRoot };

package/dist/index.js

@@ -1,2 +1,2 @@
 // @bun
-import"./shared/chunk-x296z7h1.js";import"./shared/chunk-wsjyhnpq.js";import{a,b,c}from"./shared/chunk-jw0ckhsy.js";import{d as f,e as m,f as p,g as t,h as x}from"./shared/chunk-r63mxet1.js";export{m as right,f as left,x as WatchedList,t as ValueObject,p as UniqueEntityId,b as Entity,a as DomainEvents,c as AggregateRoot};
+import"./shared/chunk-x296z7h1.js";import"./shared/chunk-wsjyhnpq.js";import{a as b,b as c}from"./shared/chunk-s2r7zghq.js";import{c as f,d as m,e as p,f as t,g as x,h as a}from"./shared/chunk-8hx7pxm3.js";export{m as right,f as left,a as WatchedList,x as ValueObject,t as UniqueEntityId,b as Entity,p as DomainEvents,c as AggregateRoot};

package/dist/shared/chunk-8hx7pxm3.js

@@ -0,0 +1,2 @@
+// @bun
+class H{value;constructor(x){this.value=x}isRight(){return!1}isLeft(){return!0}}class V{value;constructor(x){this.value=x}isRight(){return!0}isLeft(){return!1}}var B=(x)=>new H(x),F=(x)=>new V(x);class W{handlersMap=new Map;markedAggregates=new Set;markAggregateForDispatch(x){if(!this.findMarkedAggregateByID(x.id))this.markedAggregates.add(x)}dispatchEventsForAggregate(x){let E=this.findMarkedAggregateByID(x);if(E)this.dispatchAggregateEvents(E),E.clearEvents(),this.removeAggregateFromMarkedDispatchList(E)}register(x,E){if(!this.handlersMap.has(E))this.handlersMap.set(E,[]);this.handlersMap.get(E)?.push(x)}clearHandlers(){this.handlersMap.clear()}clearMarkedAggregates(){this.markedAggregates.clear()}dispatchAggregateEvents(x){for(let E of x.domainEvents)this.dispatch(E)}removeAggregateFromMarkedDispatchList(x){this.markedAggregates.delete(x)}findMarkedAggregateByID(x){return[...this.markedAggregates].find((E)=>E.id.equals(x))}dispatch(x){let E=this.handlersMap.get(x.constructor.name)??[];for(let O of E)O(x)}}var G=new W;var{randomUUIDv7:J}=globalThis.Bun;class f{value;constructor(x){this.value=x??J()}toValue(){return this.value}toString(){return this.value}equals(x){return x.toValue()===this.value}}class z{props;constructor(x){this.props=x}equals(x){return JSON.stringify(this.props)===JSON.stringify(x.props)}}class A{currentItems;initial;new;removed;constructor(x){this.currentItems=x??[],this.initial=x??[],this.new=[],this.removed=[]}getItems(){return this.currentItems}getNewItems(){return this.new}getRemovedItems(){return this.removed}exists(x){return this.isCurrentItem(x)}add(x){if(this.isRemovedItem(x))this.removeFromRemoved(x);if(!(this.isNewItem(x)||this.wasAddedInitially(x)))this.new.push(x);if(!this.isCurrentItem(x))this.currentItems.push(x)}remove(x){if(this.removeFromCurrent(x),this.isNewItem(x)){this.removeFromNew(x);return}if(!this.isRemovedItem(x))this.removed.push(x)}update(x){this.new=x.filter((E)=>!this.getItems().some((O)=>this.compareItems(E,O))),this.removed=this.getItems().filter((E)=>!x.some((O)=>this.compareItems(E,O))),this.currentItems=x}isCurrentItem(x){return this.currentItems.some((E)=>this.compareItems(x,E))}isNewItem(x){return this.new.some((E)=>this.compareItems(x,E))}isRemovedItem(x){return this.removed.some((E)=>this.compareItems(x,E))}removeFromNew(x){this.new=this.new.filter((E)=>!this.compareItems(E,x))}removeFromCurrent(x){this.currentItems=this.currentItems.filter((E)=>!this.compareItems(x,E))}removeFromRemoved(x){this.removed=this.removed.filter((E)=>!this.compareItems(x,E))}wasAddedInitially(x){return this.initial.some((E)=>this.compareItems(x,E))}}export{B as c,F as d,G as e,f,z as g,A as h};

package/dist/shared/chunk-rgs8z093.d.ts

@@ -0,0 +1,637 @@
+/**
+* Contract for entities that can be created.
+*
+* @template T - The entity type
+*/
+interface Creatable<T> {
+	/**
+	* Persists a new entity for the first time.
+	*
+	* @param entity - The entity to create
+	*/
+	create(entity: T): Promise<void>;
+}
+/**
+* Contract for entities that can be deleted.
+*
+* @template T - The entity type
+*/
+interface Deletable<T> {
+	/**
+	* Deletes an entity from the repository.
+	*
+	* @param entity - The entity to delete
+	*/
+	delete(entity: T): Promise<void>;
+}
+/**
+* Contract for entities that can be retrieved by their unique identifier.
+*
+* @template T - The entity type
+*/
+interface Findable<T> {
+	/**
+	* Finds an entity by its unique identifier.
+	*
+	* @param id - The unique identifier of the entity
+	* @returns The entity if found, `null` otherwise
+	*/
+	findById(id: string): Promise<T | null>;
+}
+/**
+* Contract for entities that can be persisted.
+*
+* @template T - The entity type
+*/
+interface Saveable<T> {
+	/**
+	* Persists an existing entity.
+	*
+	* @param entity - The entity to save
+	*/
+	save(entity: T): Promise<void>;
+}
+/**
+* Full CRUD repository contract, composing all segregated interfaces.
+*
+* Use this when the repository needs to support all operations. For more
+* constrained repositories, prefer composing only the interfaces you need.
+*
+* @template T - The entity type
+*
+* @example
+* ```ts
+* // full CRUD
+* interface UserRepository extends Repository<User> {
+*   findByEmail(email: string): Promise<User | null>
+* }
+*
+* // read-only
+* interface ReportRepository extends Findable<Report> {
+*   findByPeriod(start: Date, end: Date): Promise<Report[]>
+* }
+*
+* // append-only
+* interface AuditRepository extends Creatable<AuditLog> {}
+* ```
+*/
+interface Repository<T> extends Findable<T>, Saveable<T>, Creatable<T>, Deletable<T> {}
+/**
+* Base contract for all use case errors.
+*
+* Implement this interface to define semantic, domain-aware errors
+* that can be returned as the left side of an {@link Either}.
+*
+* @example
+* ```ts
+* class UserNotFoundError implements UseCaseError {
+*   message = "User not found."
+* }
+*
+* type FindUserResult = Either<UserNotFoundError, User>
+* ```
+*/
+interface UseCaseError {
+	message: string;
+}
+/**
+* Represents the left side of an {@link Either} — conventionally used for
+* failure or error values.
+*
+* @template L - The type of the failure value
+* @template R - The type of the success value
+*/
+declare class Left<
+	L,
+	R
+> {
+	readonly value: L;
+	constructor(value: L);
+	isRight(): this is Right<L, R>;
+	isLeft(): this is Left<L, R>;
+}
+/**
+* Represents the right side of an {@link Either} — conventionally used for
+* success values.
+*
+* @template L - The type of the failure value
+* @template R - The type of the success value
+*/
+declare class Right<
+	L,
+	R
+> {
+	readonly value: R;
+	constructor(value: R);
+	isRight(): this is Right<L, R>;
+	isLeft(): this is Left<L, R>;
+}
+/**
+* A discriminated union that represents a value of one of two possible types.
+*
+* Commonly used as a type-safe alternative to throwing exceptions — the left
+* side carries an error, and the right side carries a success value.
+*
+* Use the {@link left} and {@link right} helper functions to construct values,
+* and `isLeft()` / `isRight()` to narrow the type.
+*
+* @template L - The type of the failure value
+* @template R - The type of the success value
+*
+* @example
+* ```ts
+* type FindUserResult = Either<NotFoundError, User>
+*
+* function findUser(id: string): FindUserResult {
+*   const user = db.find(id)
+*   if (!user) return left(new NotFoundError("User", id))
+*   return right(user)
+* }
+*
+* const result = findUser("123")
+*
+* if (result.isLeft()) {
+*   console.error(result.value) // NotFoundError
+* } else {
+*   console.log(result.value)   // User
+* }
+* ```
+*/
+type Either<
+	L,
+	R
+> = Left<L, R> | Right<L, R>;
+/**
+* Constructs a {@link Left} value, representing a failure.
+*
+* @param value - The error or failure value
+*/
+declare const left: <
+	L,
+	R
+>(value: L) => Either<L, R>;
+/**
+* Constructs a {@link Right} value, representing a success.
+*
+* @param value - The success value
+*/
+declare const right: <
+	L,
+	R
+>(value: R) => Either<L, R>;
+/**
+* Base contract for all domain events.
+*
+* A domain event represents something meaningful that happened in the domain.
+* Events are raised by aggregate roots and dispatched after successful persistence,
+* enabling decoupled side effects such as notifications, projections, and integrations.
+*
+* @example
+* ```ts
+* class UserCreatedEvent implements DomainEvent {
+*   occurredAt = new Date()
+*
+*   constructor(private readonly user: User) {}
+*
+*   getAggregateId(): UniqueEntityId {
+*     return this.user.id
+*   }
+* }
+* ```
+*/
+interface DomainEvent {
+	/**
+	* Returns the identifier of the aggregate root that raised this event.
+	*/
+	getAggregateId(): UniqueEntityId;
+	/**
+	* The date and time when the event occurred.
+	*/
+	occurredAt: Date;
+}
+/**
+* Base class for all domain entities.
+*
+* An entity is an object defined by its identity rather than its attributes.
+* Two entities are considered equal if they share the same `id`, regardless
+* of their other properties.
+*
+* All entities must implement a static `create` factory method to encapsulate
+* construction logic and keep the constructor protected.
+*
+* @template Props - The shape of the entity's properties
+*
+* @example
+* ```ts
+* interface UserProps {
+*   id: UniqueEntityId
+*   name: string
+*   email: string
+*   createdAt: Date
+* }
+*
+* class User extends Entity<UserProps> {
+*   get name() { return this.props.name }
+*   get email() { return this.props.email }
+*
+*   static create(props: Optional<UserProps, "id" | "createdAt">): User {
+*     return new User(
+*       { ...props, createdAt: props.createdAt ?? new Date() },
+*       props.id ?? new UniqueEntityId(),
+*     )
+*   }
+* }
+* ```
+*/
+declare abstract class Entity<Props> {
+	private readonly _id;
+	protected props: Props;
+	get id(): UniqueEntityId;
+	protected constructor(props: Props, id?: UniqueEntityId);
+	/**
+	* Compares this entity with another by identity.
+	*
+	* @param entity - The entity to compare against
+	* @returns `true` if both entities share the same `id`
+	*/
+	equals(entity: Entity<unknown>): boolean;
+}
+/**
+* Base class for all aggregate roots in the domain.
+*
+* An aggregate root is the entry point to an aggregate — a cluster of domain
+* objects that are treated as a single unit. It is responsible for enforcing
+* invariants and coordinating domain events within its boundary.
+*
+* Domain events are collected internally and dispatched after the aggregate
+* is persisted, ensuring side effects only occur after a successful transaction.
+*
+* @template Props - The shape of the aggregate's properties
+*
+* @example
+* ```ts
+* class User extends AggregateRoot<UserProps> {
+*   static create(props: Optional<UserProps, "id" | "createdAt">): User {
+*     const user = new User(
+*       { ...props, createdAt: props.createdAt ?? new Date() },
+*       props.id ?? new UniqueEntityId(),
+*     )
+*
+*     user.addDomainEvent(new UserCreatedEvent(user))
+*
+*     return user
+*   }
+* }
+* ```
+*/
+declare abstract class AggregateRoot<Props> extends Entity<Props> {
+	private readonly _domainEvents;
+	/**
+	* Returns all domain events that have been raised by this aggregate
+	* and are pending dispatch.
+	*/
+	get domainEvents(): DomainEvent[];
+	/**
+	* Registers a domain event to be dispatched after the aggregate is persisted.
+	* Automatically marks this aggregate for dispatch in the {@link DomainEvents} registry.
+	*
+	* @param domainEvent - The domain event to register
+	*/
+	protected addDomainEvent(domainEvent: DomainEvent): void;
+	/**
+	* Clears all pending domain events from this aggregate.
+	* Should be called by the infrastructure layer after events are dispatched.
+	*/
+	clearEvents(): void;
+}
+/**
+* Callback function invoked when a domain event is dispatched.
+*/
+type DomainEventCallback = (event: DomainEvent) => void;
+/**
+* Central registry and dispatcher for domain events.
+*
+* Aggregates register themselves for dispatch after raising events.
+* The infrastructure layer is responsible for calling {@link dispatchEventsForAggregate}
+* after successfully persisting an aggregate, ensuring events are only
+* dispatched after a successful transaction.
+*
+* @example
+* ```ts
+* // register a handler
+* DomainEvents.register(
+*   (event) => sendWelcomeEmail(event as UserCreatedEvent),
+*   UserCreatedEvent.name,
+* )
+*
+* // dispatch after persistence
+* await userRepository.create(user)
+* DomainEvents.dispatchEventsForAggregate(user.id)
+* ```
+*/
+declare class DomainEventsImplementation {
+	private readonly handlersMap;
+	private readonly markedAggregates;
+	/**
+	* Marks an aggregate root to have its events dispatched.
+	* Called automatically by {@link AggregateRoot.addDomainEvent}.
+	*
+	* @param aggregate - The aggregate to mark for dispatch
+	*/
+	markAggregateForDispatch(aggregate: AggregateRoot<unknown>): void;
+	/**
+	* Dispatches all pending events for the aggregate with the given id,
+	* clears its events, and removes it from the dispatch list.
+	*
+	* Should be called by the infrastructure layer after persisting the aggregate.
+	*
+	* @param id - The identifier of the aggregate to dispatch events for
+	*/
+	dispatchEventsForAggregate(id: UniqueEntityId): void;
+	/**
+	* Registers an event handler for a given event class name.
+	*
+	* @param callback - The function to invoke when the event is dispatched
+	* @param eventClassName - The name of the event class to listen for
+	*/
+	register(callback: DomainEventCallback, eventClassName: string): void;
+	/**
+	* Removes all registered event handlers.
+	* Useful for test isolation.
+	*/
+	clearHandlers(): void;
+	/**
+	* Removes all aggregates from the dispatch list.
+	* Useful for test isolation.
+	*/
+	clearMarkedAggregates(): void;
+	private dispatchAggregateEvents;
+	private removeAggregateFromMarkedDispatchList;
+	private findMarkedAggregateByID;
+	private dispatch;
+}
+/**
+* Singleton instance of the domain events registry.
+* Use this to register handlers and dispatch events across the application.
+*/
+declare const DomainEvents: DomainEventsImplementation;
+/**
+* Base contract for all event handlers.
+*
+* An event handler is responsible for subscribing to domain events
+* and executing side effects in response — such as sending emails,
+* updating read models, or triggering external integrations.
+*
+* All handlers must implement {@link setupSubscriptions} to register
+* their callbacks in the {@link DomainEvents} registry.
+*
+* @example
+* ```ts
+* class OnUserCreated implements EventHandler {
+*   constructor(private readonly mailer: Mailer) {}
+*
+*   setupSubscriptions(): void {
+*     DomainEvents.register(
+*       (event) => this.sendWelcomeEmail(event as UserCreatedEvent),
+*       UserCreatedEvent.name,
+*     )
+*   }
+*
+*   private async sendWelcomeEmail(event: UserCreatedEvent): Promise<void> {
+*     await this.mailer.send(event.user.email)
+*   }
+* }
+* ```
+*/
+interface EventHandler {
+	/**
+	* Registers all event subscriptions for this handler.
+	* Should be called once during application bootstrap.
+	*/
+	setupSubscriptions(): void;
+}
+/**
+* Make some property optional on type
+*
+* @example
+* ```typescript
+* type Post {
+*  id: string;
+*  name: string;
+*  email: string;
+* }
+*
+* Optional<Post, 'id' | 'email'>
+* ```
+*/
+type Optional<
+	T,
+	K extends keyof T
+> = Pick<Partial<T>, K> & Omit<T, K>;
+/**
+* Represents a unique identifier for a domain entity.
+*
+* Wraps a UUID v7 string, which is time-sortable and ideal for database
+* indexing. A new identifier is generated automatically if no value is provided.
+*
+* @example
+* ```ts
+* // auto-generated
+* const id = new UniqueEntityId()
+*
+* // from existing value (e.g. reconstructing from database)
+* const id = new UniqueEntityId("0195d810-5b3e-7000-8e3e-1a2b3c4d5e6f")
+* ```
+*/
+declare class UniqueEntityId {
+	private readonly value;
+	constructor(value?: string);
+	/**
+	* Returns the identifier as a primitive string.
+	* Useful for serialization and database persistence.
+	*/
+	toValue(): string;
+	/**
+	* Returns the string representation of the identifier.
+	*/
+	toString(): string;
+	/**
+	* Compares this identifier with another by value equality.
+	*
+	* @param id - The identifier to compare against
+	* @returns `true` if both identifiers have the same value
+	*/
+	equals(id: UniqueEntityId): boolean;
+}
+/**
+* Base class for all value objects in the domain.
+*
+* A value object is an object defined entirely by its attributes — it has no
+* identity. Two value objects are considered equal if all their properties
+* are deeply equal, regardless of reference.
+*
+* Value objects should be immutable. Avoid mutating `props` directly;
+* instead, create a new instance with the updated values.
+*
+* All value objects must implement a static `create` factory method to
+* encapsulate construction and validation logic, keeping the constructor
+* protected from external instantiation.
+*
+* @template Props - The shape of the value object's properties
+*
+* @example
+* ```ts
+* interface EmailProps {
+*   value: string
+* }
+*
+* class Email extends ValueObject<EmailProps> {
+*   get value() { return this.props.value }
+*
+*   static create(email: string): Email {
+*     if (!email.includes("@")) {
+*       throw new ValidationError("Invalid email address.")
+*     }
+*
+*     return new Email({ value: email })
+*   }
+* }
+* ```
+*/
+declare abstract class ValueObject<Props> {
+	protected props: Props;
+	protected constructor(props: Props);
+	/**
+	* Compares this value object with another by deep equality of their properties.
+	*
+	* @param other - The value object to compare against
+	* @returns `true` if both value objects have deeply equal properties
+	*/
+	equals(other: ValueObject<Props>): boolean;
+}
+/**
+* Tracks additions and removals of items in a collection, enabling
+* efficient persistence of only what changed.
+*
+* Commonly used inside aggregate roots to manage one-to-many relationships
+* without rewriting the entire collection on every save — only new and
+* removed items are persisted.
+*
+* Subclasses must implement {@link compareItems} to define equality between items.
+*
+* @template T - The type of items in the list
+*
+* @example
+* ```ts
+* class TagList extends WatchedList<Tag> {
+*   compareItems(a: Tag, b: Tag): boolean {
+*     return a.id.equals(b.id)
+*   }
+*
+*   static create(tags: Tag[]): TagList {
+*     return new TagList(tags)
+*   }
+* }
+*
+* const tags = TagList.create([existingTag])
+*
+* tags.add(newTag)      // tracked as new
+* tags.remove(oldTag)   // tracked as removed
+*
+* tags.getNewItems()     // [newTag]
+* tags.getRemovedItems() // [oldTag]
+* ```
+*/
+declare abstract class WatchedList<T> {
+	protected currentItems: T[];
+	protected initial: T[];
+	protected new: T[];
+	protected removed: T[];
+	constructor(initialItems?: T[]);
+	/**
+	* Returns all current items in the list.
+	*/
+	getItems(): T[];
+	/**
+	* Returns items that were added since the list was created.
+	*/
+	getNewItems(): T[];
+	/**
+	* Returns items that were removed since the list was created.
+	*/
+	getRemovedItems(): T[];
+	/**
+	* Returns whether the given item exists in the current list.
+	*
+	* @param item - The item to check
+	*/
+	exists(item: T): boolean;
+	/**
+	* Adds an item to the list, tracking it as new if it wasn't in the initial set.
+	* If the item was previously removed, it is restored.
+	*
+	* @param item - The item to add
+	*/
+	add(item: T): void;
+	/**
+	* Removes an item from the list, tracking it as removed if it was in the initial set.
+	*
+	* @param item - The item to remove
+	*/
+	remove(item: T): void;
+	/**
+	* Replaces the entire list with a new set of items, automatically
+	* computing what was added and what was removed.
+	*
+	* @param items - The new set of items
+	*/
+	update(items: T[]): void;
+	private isCurrentItem;
+	private isNewItem;
+	private isRemovedItem;
+	private removeFromNew;
+	private removeFromCurrent;
+	private removeFromRemoved;
+	private wasAddedInitially;
+}
+/**
+* Represents the expected output shape of any use case.
+* Always an {@link Either} — left for errors, right for success.
+*/
+type UseCaseOutput = Either<UseCaseError | never, unknown | null>;
+/**
+* Base contract for all application use cases.
+*
+* A use case orchestrates domain logic for a single application operation.
+* It receives a typed input, interacts with the domain, and returns an
+* {@link Either} — never throwing exceptions directly.
+*
+* The left side carries a {@link UseCaseError} on failure.
+* The right side carries the success value.
+*
+* @template Input - The shape of the data required to execute the use case
+* @template Output - The expected {@link Either} output, constrained to {@link UseCaseOutput}
+*
+* @example
+* ```ts
+* type Input = { userId: string }
+* type Output = Either<UserNotFoundError, User>
+*
+* class GetUserUseCase implements UseCase<Input, Output> {
+*   constructor(private userRepository: UserRepository) {}
+*
+*   async execute({ userId }: Input): Promise<Output> {
+*     const user = await this.userRepository.findById(userId)
+*     if (!user) return left(new UserNotFoundError(userId))
+*     return right(user)
+*   }
+* }
+* ```
+*/
+interface UseCase<
+	Input,
+	Output extends UseCaseOutput
+> {
+	execute(input: Input): Promise<Output>;
+}
+export { Either, left, right, DomainEvent, Creatable, Deletable, Findable, Saveable, Repository, UseCaseError, UseCase, Entity, AggregateRoot, DomainEvents, EventHandler, Optional, UniqueEntityId, ValueObject, WatchedList };

package/dist/shared/chunk-s2r7zghq.js

@@ -0,0 +1,2 @@
+// @bun
+import{e as D,f as H}from"./chunk-8hx7pxm3.js";class A{_id;props;get id(){return this._id}constructor(x,f){this._id=f??new H,this.props=x}equals(x){if(x===this)return!0;return x.id.equals(this._id)}}class R extends A{_domainEvents=new Set;get domainEvents(){return Array.from(this._domainEvents)}addDomainEvent(x){this._domainEvents.add(x),D.markAggregateForDispatch(this)}clearEvents(){this._domainEvents.clear()}}export{A as a,R as b};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "archstone",
   "description": "TypeScript architecture foundation for backend services based on Domain-Driven Design and Clean Architecture",
-  "version": "1.2.1",
+  "version": "1.3.0-rc.2",
   "type": "module",
   "private": false,
   "files": [
@@ -76,6 +76,7 @@
     "test": "bun test",
     "check": "ultracite check",
     "fix": "ultracite fix",
+    "release": "bun publish --access public",
     "prepublishOnly": "bun run build",
     "prepare": "bunx husky"
   },

package/dist/shared/chunk-axgwjkjg.d.ts

@@ -1,233 +0,0 @@
-import { UniqueEntityId } from "./chunk-t21213sm.js";
-/**
-* Base contract for all domain events.
-*
-* A domain event represents something meaningful that happened in the domain.
-* Events are raised by aggregate roots and dispatched after successful persistence,
-* enabling decoupled side effects such as notifications, projections, and integrations.
-*
-* @example
-* ```ts
-* class UserCreatedEvent implements DomainEvent {
-*   occurredAt = new Date()
-*
-*   constructor(private readonly user: User) {}
-*
-*   getAggregateId(): UniqueEntityId {
-*     return this.user.id
-*   }
-* }
-* ```
-*/
-interface DomainEvent {
-	/**
-	* Returns the identifier of the aggregate root that raised this event.
-	*/
-	getAggregateId(): UniqueEntityId;
-	/**
-	* The date and time when the event occurred.
-	*/
-	occurredAt: Date;
-}
-/**
-* Callback function invoked when a domain event is dispatched.
-*/
-type DomainEventCallback = (event: DomainEvent) => void;
-/**
-* Central registry and dispatcher for domain events.
-*
-* Aggregates register themselves for dispatch after raising events.
-* The infrastructure layer is responsible for calling {@link dispatchEventsForAggregate}
-* after successfully persisting an aggregate, ensuring events are only
-* dispatched after a successful transaction.
-*
-* @example
-* ```ts
-* // register a handler
-* DomainEvents.register(
-*   (event) => sendWelcomeEmail(event as UserCreatedEvent),
-*   UserCreatedEvent.name,
-* )
-*
-* // dispatch after persistence
-* await userRepository.create(user)
-* DomainEvents.dispatchEventsForAggregate(user.id)
-* ```
-*/
-declare class DomainEventsImplementation {
-	private readonly handlersMap;
-	private readonly markedAggregates;
-	/**
-	* Marks an aggregate root to have its events dispatched.
-	* Called automatically by {@link AggregateRoot.addDomainEvent}.
-	*
-	* @param aggregate - The aggregate to mark for dispatch
-	*/
-	markAggregateForDispatch(aggregate: AggregateRoot<unknown>): void;
-	/**
-	* Dispatches all pending events for the aggregate with the given id,
-	* clears its events, and removes it from the dispatch list.
-	*
-	* Should be called by the infrastructure layer after persisting the aggregate.
-	*
-	* @param id - The identifier of the aggregate to dispatch events for
-	*/
-	dispatchEventsForAggregate(id: UniqueEntityId): void;
-	/**
-	* Registers an event handler for a given event class name.
-	*
-	* @param callback - The function to invoke when the event is dispatched
-	* @param eventClassName - The name of the event class to listen for
-	*/
-	register(callback: DomainEventCallback, eventClassName: string): void;
-	/**
-	* Removes all registered event handlers.
-	* Useful for test isolation.
-	*/
-	clearHandlers(): void;
-	/**
-	* Removes all aggregates from the dispatch list.
-	* Useful for test isolation.
-	*/
-	clearMarkedAggregates(): void;
-	private dispatchAggregateEvents;
-	private removeAggregateFromMarkedDispatchList;
-	private findMarkedAggregateByID;
-	private dispatch;
-}
-/**
-* Singleton instance of the domain events registry.
-* Use this to register handlers and dispatch events across the application.
-*/
-declare const DomainEvents: DomainEventsImplementation;
-/**
-* Base contract for all event handlers.
-*
-* An event handler is responsible for subscribing to domain events
-* and executing side effects in response — such as sending emails,
-* updating read models, or triggering external integrations.
-*
-* All handlers must implement {@link setupSubscriptions} to register
-* their callbacks in the {@link DomainEvents} registry.
-*
-* @example
-* ```ts
-* class OnUserCreated implements EventHandler {
-*   constructor(private readonly mailer: Mailer) {}
-*
-*   setupSubscriptions(): void {
-*     DomainEvents.register(
-*       (event) => this.sendWelcomeEmail(event as UserCreatedEvent),
-*       UserCreatedEvent.name,
-*     )
-*   }
-*
-*   private async sendWelcomeEmail(event: UserCreatedEvent): Promise<void> {
-*     await this.mailer.send(event.user.email)
-*   }
-* }
-* ```
-*/
-interface EventHandler {
-	/**
-	* Registers all event subscriptions for this handler.
-	* Should be called once during application bootstrap.
-	*/
-	setupSubscriptions(): void;
-}
-/**
-* Base class for all domain entities.
-*
-* An entity is an object defined by its identity rather than its attributes.
-* Two entities are considered equal if they share the same `id`, regardless
-* of their other properties.
-*
-* All entities must implement a static `create` factory method to encapsulate
-* construction logic and keep the constructor protected.
-*
-* @template Props - The shape of the entity's properties
-*
-* @example
-* ```ts
-* interface UserProps {
-*   id: UniqueEntityId
-*   name: string
-*   email: string
-*   createdAt: Date
-* }
-*
-* class User extends Entity<UserProps> {
-*   get name() { return this.props.name }
-*   get email() { return this.props.email }
-*
-*   static create(props: Optional<UserProps, "id" | "createdAt">): User {
-*     return new User(
-*       { ...props, createdAt: props.createdAt ?? new Date() },
-*       props.id ?? new UniqueEntityId(),
-*     )
-*   }
-* }
-* ```
-*/
-declare abstract class Entity<Props> {
-	private readonly _id;
-	protected props: Props;
-	get id(): UniqueEntityId;
-	protected constructor(props: Props, id?: UniqueEntityId);
-	/**
-	* Compares this entity with another by identity.
-	*
-	* @param entity - The entity to compare against
-	* @returns `true` if both entities share the same `id`
-	*/
-	equals(entity: Entity<unknown>): boolean;
-}
-/**
-* Base class for all aggregate roots in the domain.
-*
-* An aggregate root is the entry point to an aggregate — a cluster of domain
-* objects that are treated as a single unit. It is responsible for enforcing
-* invariants and coordinating domain events within its boundary.
-*
-* Domain events are collected internally and dispatched after the aggregate
-* is persisted, ensuring side effects only occur after a successful transaction.
-*
-* @template Props - The shape of the aggregate's properties
-*
-* @example
-* ```ts
-* class User extends AggregateRoot<UserProps> {
-*   static create(props: Optional<UserProps, "id" | "createdAt">): User {
-*     const user = new User(
-*       { ...props, createdAt: props.createdAt ?? new Date() },
-*       props.id ?? new UniqueEntityId(),
-*     )
-*
-*     user.addDomainEvent(new UserCreatedEvent(user))
-*
-*     return user
-*   }
-* }
-* ```
-*/
-declare abstract class AggregateRoot<Props> extends Entity<Props> {
-	private readonly _domainEvents;
-	/**
-	* Returns all domain events that have been raised by this aggregate
-	* and are pending dispatch.
-	*/
-	get domainEvents(): DomainEvent[];
-	/**
-	* Registers a domain event to be dispatched after the aggregate is persisted.
-	* Automatically marks this aggregate for dispatch in the {@link DomainEvents} registry.
-	*
-	* @param domainEvent - The domain event to register
-	*/
-	protected addDomainEvent(domainEvent: DomainEvent): void;
-	/**
-	* Clears all pending domain events from this aggregate.
-	* Should be called by the infrastructure layer after events are dispatched.
-	*/
-	clearEvents(): void;
-}
-export { DomainEvent, DomainEvents, EventHandler, Entity, AggregateRoot };

package/dist/shared/chunk-jw0ckhsy.js

@@ -1,2 +0,0 @@
-// @bun
-import{f as j}from"./chunk-r63mxet1.js";class R{handlersMap=new Map;markedAggregates=new Set;markAggregateForDispatch(x){if(!this.findMarkedAggregateByID(x.id))this.markedAggregates.add(x)}dispatchEventsForAggregate(x){let f=this.findMarkedAggregateByID(x);if(f)this.dispatchAggregateEvents(f),f.clearEvents(),this.removeAggregateFromMarkedDispatchList(f)}register(x,f){if(!this.handlersMap.has(f))this.handlersMap.set(f,[]);this.handlersMap.get(f)?.push(x)}clearHandlers(){this.handlersMap.clear()}clearMarkedAggregates(){this.markedAggregates.clear()}dispatchAggregateEvents(x){for(let f of x.domainEvents)this.dispatch(f)}removeAggregateFromMarkedDispatchList(x){this.markedAggregates.delete(x)}findMarkedAggregateByID(x){return[...this.markedAggregates].find((f)=>f.id.equals(x))}dispatch(x){let f=this.handlersMap.get(x.constructor.name)??[];for(let B of f)B(x)}}var H=new R;class A{_id;props;get id(){return this._id}constructor(x,f){this._id=f??new j,this.props=x}equals(x){if(x===this)return!0;return x.id.equals(this._id)}}class z extends A{_domainEvents=new Set;get domainEvents(){return Array.from(this._domainEvents)}addDomainEvent(x){this._domainEvents.add(x),H.markAggregateForDispatch(this)}clearEvents(){this._domainEvents.clear()}}export{H as a,A as b,z as c};

package/dist/shared/chunk-r63mxet1.js

@@ -1,2 +0,0 @@
-// @bun
-class V{value;constructor(x){this.value=x}isRight(){return!1}isLeft(){return!0}}class W{value;constructor(x){this.value=x}isRight(){return!0}isLeft(){return!1}}var F=(x)=>new V(x),G=(x)=>new W(x);var{randomUUIDv7:H}=globalThis.Bun;class z{value;constructor(x){this.value=x??H()}toValue(){return this.value}toString(){return this.value}equals(x){return x.toValue()===this.value}}class A{props;constructor(x){this.props=x}equals(x){return JSON.stringify(this.props)===JSON.stringify(x.props)}}class B{currentItems;initial;new;removed;constructor(x){this.currentItems=x??[],this.initial=x??[],this.new=[],this.removed=[]}getItems(){return this.currentItems}getNewItems(){return this.new}getRemovedItems(){return this.removed}exists(x){return this.isCurrentItem(x)}add(x){if(this.isRemovedItem(x))this.removeFromRemoved(x);if(!(this.isNewItem(x)||this.wasAddedInitially(x)))this.new.push(x);if(!this.isCurrentItem(x))this.currentItems.push(x)}remove(x){if(this.removeFromCurrent(x),this.isNewItem(x)){this.removeFromNew(x);return}if(!this.isRemovedItem(x))this.removed.push(x)}update(x){this.new=x.filter((E)=>!this.getItems().some((O)=>this.compareItems(E,O))),this.removed=this.getItems().filter((E)=>!x.some((O)=>this.compareItems(E,O))),this.currentItems=x}isCurrentItem(x){return this.currentItems.some((E)=>this.compareItems(x,E))}isNewItem(x){return this.new.some((E)=>this.compareItems(x,E))}isRemovedItem(x){return this.removed.some((E)=>this.compareItems(x,E))}removeFromNew(x){this.new=this.new.filter((E)=>!this.compareItems(E,x))}removeFromCurrent(x){this.currentItems=this.currentItems.filter((E)=>!this.compareItems(x,E))}removeFromRemoved(x){this.removed=this.removed.filter((E)=>!this.compareItems(x,E))}wasAddedInitially(x){return this.initial.some((E)=>this.compareItems(x,E))}}export{F as d,G as e,z as f,A as g,B as h};

package/dist/shared/chunk-t21213sm.d.ts

@@ -1,270 +0,0 @@
-/**
-* Represents the left side of an {@link Either} — conventionally used for
-* failure or error values.
-*
-* @template L - The type of the failure value
-* @template R - The type of the success value
-*/
-declare class Left<
-	L,
-	R
-> {
-	readonly value: L;
-	constructor(value: L);
-	isRight(): this is Right<L, R>;
-	isLeft(): this is Left<L, R>;
-}
-/**
-* Represents the right side of an {@link Either} — conventionally used for
-* success values.
-*
-* @template L - The type of the failure value
-* @template R - The type of the success value
-*/
-declare class Right<
-	L,
-	R
-> {
-	readonly value: R;
-	constructor(value: R);
-	isRight(): this is Right<L, R>;
-	isLeft(): this is Left<L, R>;
-}
-/**
-* A discriminated union that represents a value of one of two possible types.
-*
-* Commonly used as a type-safe alternative to throwing exceptions — the left
-* side carries an error, and the right side carries a success value.
-*
-* Use the {@link left} and {@link right} helper functions to construct values,
-* and `isLeft()` / `isRight()` to narrow the type.
-*
-* @template L - The type of the failure value
-* @template R - The type of the success value
-*
-* @example
-* ```ts
-* type FindUserResult = Either<NotFoundError, User>
-*
-* function findUser(id: string): FindUserResult {
-*   const user = db.find(id)
-*   if (!user) return left(new NotFoundError("User", id))
-*   return right(user)
-* }
-*
-* const result = findUser("123")
-*
-* if (result.isLeft()) {
-*   console.error(result.value) // NotFoundError
-* } else {
-*   console.log(result.value)   // User
-* }
-* ```
-*/
-type Either<
-	L,
-	R
-> = Left<L, R> | Right<L, R>;
-/**
-* Constructs a {@link Left} value, representing a failure.
-*
-* @param value - The error or failure value
-*/
-declare const left: <
-	L,
-	R
->(value: L) => Either<L, R>;
-/**
-* Constructs a {@link Right} value, representing a success.
-*
-* @param value - The success value
-*/
-declare const right: <
-	L,
-	R
->(value: R) => Either<L, R>;
-/**
-* Make some property optional on type
-*
-* @example
-* ```typescript
-* type Post {
-*  id: string;
-*  name: string;
-*  email: string;
-* }
-*
-* Optional<Post, 'id' | 'email'>
-* ```
-*/
-type Optional<
-	T,
-	K extends keyof T
-> = Pick<Partial<T>, K> & Omit<T, K>;
-/**
-* Represents a unique identifier for a domain entity.
-*
-* Wraps a UUID v7 string, which is time-sortable and ideal for database
-* indexing. A new identifier is generated automatically if no value is provided.
-*
-* @example
-* ```ts
-* // auto-generated
-* const id = new UniqueEntityId()
-*
-* // from existing value (e.g. reconstructing from database)
-* const id = new UniqueEntityId("0195d810-5b3e-7000-8e3e-1a2b3c4d5e6f")
-* ```
-*/
-declare class UniqueEntityId {
-	private readonly value;
-	constructor(value?: string);
-	/**
-	* Returns the identifier as a primitive string.
-	* Useful for serialization and database persistence.
-	*/
-	toValue(): string;
-	/**
-	* Returns the string representation of the identifier.
-	*/
-	toString(): string;
-	/**
-	* Compares this identifier with another by value equality.
-	*
-	* @param id - The identifier to compare against
-	* @returns `true` if both identifiers have the same value
-	*/
-	equals(id: UniqueEntityId): boolean;
-}
-/**
-* Base class for all value objects in the domain.
-*
-* A value object is an object defined entirely by its attributes — it has no
-* identity. Two value objects are considered equal if all their properties
-* are deeply equal, regardless of reference.
-*
-* Value objects should be immutable. Avoid mutating `props` directly;
-* instead, create a new instance with the updated values.
-*
-* All value objects must implement a static `create` factory method to
-* encapsulate construction and validation logic, keeping the constructor
-* protected from external instantiation.
-*
-* @template Props - The shape of the value object's properties
-*
-* @example
-* ```ts
-* interface EmailProps {
-*   value: string
-* }
-*
-* class Email extends ValueObject<EmailProps> {
-*   get value() { return this.props.value }
-*
-*   static create(email: string): Email {
-*     if (!email.includes("@")) {
-*       throw new ValidationError("Invalid email address.")
-*     }
-*
-*     return new Email({ value: email })
-*   }
-* }
-* ```
-*/
-declare abstract class ValueObject<Props> {
-	protected props: Props;
-	protected constructor(props: Props);
-	/**
-	* Compares this value object with another by deep equality of their properties.
-	*
-	* @param other - The value object to compare against
-	* @returns `true` if both value objects have deeply equal properties
-	*/
-	equals(other: ValueObject<Props>): boolean;
-}
-/**
-* Tracks additions and removals of items in a collection, enabling
-* efficient persistence of only what changed.
-*
-* Commonly used inside aggregate roots to manage one-to-many relationships
-* without rewriting the entire collection on every save — only new and
-* removed items are persisted.
-*
-* Subclasses must implement {@link compareItems} to define equality between items.
-*
-* @template T - The type of items in the list
-*
-* @example
-* ```ts
-* class TagList extends WatchedList<Tag> {
-*   compareItems(a: Tag, b: Tag): boolean {
-*     return a.id.equals(b.id)
-*   }
-*
-*   static create(tags: Tag[]): TagList {
-*     return new TagList(tags)
-*   }
-* }
-*
-* const tags = TagList.create([existingTag])
-*
-* tags.add(newTag)      // tracked as new
-* tags.remove(oldTag)   // tracked as removed
-*
-* tags.getNewItems()     // [newTag]
-* tags.getRemovedItems() // [oldTag]
-* ```
-*/
-declare abstract class WatchedList<T> {
-	protected currentItems: T[];
-	protected initial: T[];
-	protected new: T[];
-	protected removed: T[];
-	constructor(initialItems?: T[]);
-	/**
-	* Returns all current items in the list.
-	*/
-	getItems(): T[];
-	/**
-	* Returns items that were added since the list was created.
-	*/
-	getNewItems(): T[];
-	/**
-	* Returns items that were removed since the list was created.
-	*/
-	getRemovedItems(): T[];
-	/**
-	* Returns whether the given item exists in the current list.
-	*
-	* @param item - The item to check
-	*/
-	exists(item: T): boolean;
-	/**
-	* Adds an item to the list, tracking it as new if it wasn't in the initial set.
-	* If the item was previously removed, it is restored.
-	*
-	* @param item - The item to add
-	*/
-	add(item: T): void;
-	/**
-	* Removes an item from the list, tracking it as removed if it was in the initial set.
-	*
-	* @param item - The item to remove
-	*/
-	remove(item: T): void;
-	/**
-	* Replaces the entire list with a new set of items, automatically
-	* computing what was added and what was removed.
-	*
-	* @param items - The new set of items
-	*/
-	update(items: T[]): void;
-	private isCurrentItem;
-	private isNewItem;
-	private isRemovedItem;
-	private removeFromNew;
-	private removeFromCurrent;
-	private removeFromRemoved;
-	private wasAddedInitially;
-}
-export { Either, left, right, Optional, UniqueEntityId, ValueObject, WatchedList };

package/dist/shared/chunk-txbqwwkc.d.ts

@@ -1,138 +0,0 @@
-import { Either } from "./chunk-t21213sm.js";
-/**
-* Contract for entities that can be created.
-*
-* @template T - The entity type
-*/
-interface Creatable<T> {
-	/**
-	* Persists a new entity for the first time.
-	*
-	* @param entity - The entity to create
-	*/
-	create(entity: T): Promise<void>;
-}
-/**
-* Contract for entities that can be deleted.
-*
-* @template T - The entity type
-*/
-interface Deletable<T> {
-	/**
-	* Deletes an entity from the repository.
-	*
-	* @param entity - The entity to delete
-	*/
-	delete(entity: T): Promise<void>;
-}
-/**
-* Contract for entities that can be retrieved by their unique identifier.
-*
-* @template T - The entity type
-*/
-interface Findable<T> {
-	/**
-	* Finds an entity by its unique identifier.
-	*
-	* @param id - The unique identifier of the entity
-	* @returns The entity if found, `null` otherwise
-	*/
-	findById(id: string): Promise<T | null>;
-}
-/**
-* Contract for entities that can be persisted.
-*
-* @template T - The entity type
-*/
-interface Saveable<T> {
-	/**
-	* Persists an existing entity.
-	*
-	* @param entity - The entity to save
-	*/
-	save(entity: T): Promise<void>;
-}
-/**
-* Full CRUD repository contract, composing all segregated interfaces.
-*
-* Use this when the repository needs to support all operations. For more
-* constrained repositories, prefer composing only the interfaces you need.
-*
-* @template T - The entity type
-*
-* @example
-* ```ts
-* // full CRUD
-* interface UserRepository extends Repository<User> {
-*   findByEmail(email: string): Promise<User | null>
-* }
-*
-* // read-only
-* interface ReportRepository extends Findable<Report> {
-*   findByPeriod(start: Date, end: Date): Promise<Report[]>
-* }
-*
-* // append-only
-* interface AuditRepository extends Creatable<AuditLog> {}
-* ```
-*/
-interface Repository<T> extends Findable<T>, Saveable<T>, Creatable<T>, Deletable<T> {}
-/**
-* Base contract for all use case errors.
-*
-* Implement this interface to define semantic, domain-aware errors
-* that can be returned as the left side of an {@link Either}.
-*
-* @example
-* ```ts
-* class UserNotFoundError implements UseCaseError {
-*   message = "User not found."
-* }
-*
-* type FindUserResult = Either<UserNotFoundError, User>
-* ```
-*/
-interface UseCaseError {
-	message: string;
-}
-/**
-* Represents the expected output shape of any use case.
-* Always an {@link Either} — left for errors, right for success.
-*/
-type UseCaseOutput = Either<UseCaseError | never, unknown | null>;
-/**
-* Base contract for all application use cases.
-*
-* A use case orchestrates domain logic for a single application operation.
-* It receives a typed input, interacts with the domain, and returns an
-* {@link Either} — never throwing exceptions directly.
-*
-* The left side carries a {@link UseCaseError} on failure.
-* The right side carries the success value.
-*
-* @template Input - The shape of the data required to execute the use case
-* @template Output - The expected {@link Either} output, constrained to {@link UseCaseOutput}
-*
-* @example
-* ```ts
-* type Input = { userId: string }
-* type Output = Either<UserNotFoundError, User>
-*
-* class GetUserUseCase implements UseCase<Input, Output> {
-*   constructor(private userRepository: UserRepository) {}
-*
-*   async execute({ userId }: Input): Promise<Output> {
-*     const user = await this.userRepository.findById(userId)
-*     if (!user) return left(new UserNotFoundError(userId))
-*     return right(user)
-*   }
-* }
-* ```
-*/
-interface UseCase<
-	Input,
-	Output extends UseCaseOutput
-> {
-	execute(input: Input): Promise<Output>;
-}
-export { Creatable, Deletable, Findable, Saveable, Repository, UseCaseError, UseCase };