@arts-n-crafts/ts 3.19.0 → 5.0.0-rc.2

package/packages/v5/dist/adapters/outbound/capabilities/index.d.cts

@@ -0,0 +1,77 @@
+import { GatewayFailure, StoredEvent, OutboxEnvelope, Notification } from '../shapes/index.cjs';
+import { D as DomainEvent, S as StreamKey } from '../../../DomainEvent-CSzUMw46.cjs';
+import { I as Intent } from '../../../Intent-B6l0bHZU.cjs';
+import '../../../core/shapes/index.cjs';
+import '../../../Message-c9XdBoh4.cjs';
+import '../../../Rejection-D9PlzquK.cjs';
+
+interface AdvanceCheckpoint<TResult = Promise<void | GatewayFailure>> {
+    advanceCheckpoint(position: number): TResult;
+}
+
+interface AppendToEventStore<TDomainEvent extends DomainEvent, TReturn = Promise<void>> {
+    append(events: TDomainEvent[], expectedPosition?: number): TReturn;
+}
+
+interface LoadCheckpoint<TResult = Promise<number | GatewayFailure>> {
+    loadCheckpoint(): TResult;
+}
+
+interface LoadDomainEvents<TEvent extends DomainEvent, TResult = Promise<TEvent[]>> {
+    load(concerns: readonly StreamKey[]): TResult;
+}
+
+interface LoadEventsFrom<TEvent extends DomainEvent, TResult = Promise<StoredEvent<TEvent>[] | GatewayFailure>> {
+    loadFrom(globalPosition: number, limit?: number): TResult;
+}
+
+interface LoadPendingIntents<TIntent extends Intent, TResult = Promise<OutboxEnvelope<TIntent>[] | GatewayFailure>> {
+    loadPending(limit?: number): TResult;
+}
+
+interface LoadProjection<TState, TResult = Promise<TState | GatewayFailure>> {
+    load(): TResult;
+}
+
+interface MarkIntentDispatched<TResult = Promise<void | GatewayFailure>> {
+    markDispatched(intentId: string): TResult;
+}
+
+interface MarkIntentFailed<TResult = Promise<void | GatewayFailure>> {
+    markFailed(intentId: string, reason: string): TResult;
+}
+
+interface SaveProjection<TState, TResult = Promise<void | GatewayFailure>> {
+    save(state: TState): TResult;
+}
+
+/**
+ * Describes the fault to simulate on an adapter that implements `SimulatesFaults`.
+ *
+ * Built-in modes:
+ * - `offline` — the gateway is unreachable, operations fail immediately
+ * - `timeout` — the gateway is reachable but operations hang or take too long
+ *
+ * The type accepts any string to allow custom fault modes in user-land,
+ * while preserving autocomplete for the built-in modes.
+ */
+type FaultSimulationMode = "offline" | "timeout" | (string & {});
+/**
+ * Capability for adapters that support fault simulation.
+ *
+ * Has a way to simulate faults for testing purposes, such as
+ * an offline gateway or a timeout. Useful for testing resilience
+ * and failure handling in use cases without real infrastructure.
+ */
+interface SimulateFaults {
+    simulate(fault: FaultSimulationMode): void;
+    restore(): void;
+    get isSimulating(): boolean;
+    get activeFault(): FaultSimulationMode | undefined;
+}
+
+interface StageNotifications<TNotification extends Notification, TResult = Promise<void>> {
+    stage(notifications: TNotification[]): TResult;
+}
+
+export type { AdvanceCheckpoint, AppendToEventStore, FaultSimulationMode, LoadCheckpoint, LoadDomainEvents, LoadEventsFrom, LoadPendingIntents, LoadProjection, MarkIntentDispatched, MarkIntentFailed, SaveProjection, SimulateFaults, StageNotifications };

package/packages/v5/dist/adapters/outbound/capabilities/index.d.ts

@@ -0,0 +1,77 @@
+import { GatewayFailure, StoredEvent, OutboxEnvelope, Notification } from '../shapes/index.js';
+import { D as DomainEvent, S as StreamKey } from '../../../DomainEvent-w1jyCjai.js';
+import { I as Intent } from '../../../Intent-BLNY6RoG.js';
+import '../../../core/shapes/index.js';
+import '../../../Message-c9XdBoh4.js';
+import '../../../Rejection-D9PlzquK.js';
+
+interface AdvanceCheckpoint<TResult = Promise<void | GatewayFailure>> {
+    advanceCheckpoint(position: number): TResult;
+}
+
+interface AppendToEventStore<TDomainEvent extends DomainEvent, TReturn = Promise<void>> {
+    append(events: TDomainEvent[], expectedPosition?: number): TReturn;
+}
+
+interface LoadCheckpoint<TResult = Promise<number | GatewayFailure>> {
+    loadCheckpoint(): TResult;
+}
+
+interface LoadDomainEvents<TEvent extends DomainEvent, TResult = Promise<TEvent[]>> {
+    load(concerns: readonly StreamKey[]): TResult;
+}
+
+interface LoadEventsFrom<TEvent extends DomainEvent, TResult = Promise<StoredEvent<TEvent>[] | GatewayFailure>> {
+    loadFrom(globalPosition: number, limit?: number): TResult;
+}
+
+interface LoadPendingIntents<TIntent extends Intent, TResult = Promise<OutboxEnvelope<TIntent>[] | GatewayFailure>> {
+    loadPending(limit?: number): TResult;
+}
+
+interface LoadProjection<TState, TResult = Promise<TState | GatewayFailure>> {
+    load(): TResult;
+}
+
+interface MarkIntentDispatched<TResult = Promise<void | GatewayFailure>> {
+    markDispatched(intentId: string): TResult;
+}
+
+interface MarkIntentFailed<TResult = Promise<void | GatewayFailure>> {
+    markFailed(intentId: string, reason: string): TResult;
+}
+
+interface SaveProjection<TState, TResult = Promise<void | GatewayFailure>> {
+    save(state: TState): TResult;
+}
+
+/**
+ * Describes the fault to simulate on an adapter that implements `SimulatesFaults`.
+ *
+ * Built-in modes:
+ * - `offline` — the gateway is unreachable, operations fail immediately
+ * - `timeout` — the gateway is reachable but operations hang or take too long
+ *
+ * The type accepts any string to allow custom fault modes in user-land,
+ * while preserving autocomplete for the built-in modes.
+ */
+type FaultSimulationMode = "offline" | "timeout" | (string & {});
+/**
+ * Capability for adapters that support fault simulation.
+ *
+ * Has a way to simulate faults for testing purposes, such as
+ * an offline gateway or a timeout. Useful for testing resilience
+ * and failure handling in use cases without real infrastructure.
+ */
+interface SimulateFaults {
+    simulate(fault: FaultSimulationMode): void;
+    restore(): void;
+    get isSimulating(): boolean;
+    get activeFault(): FaultSimulationMode | undefined;
+}
+
+interface StageNotifications<TNotification extends Notification, TResult = Promise<void>> {
+    stage(notifications: TNotification[]): TResult;
+}
+
+export type { AdvanceCheckpoint, AppendToEventStore, FaultSimulationMode, LoadCheckpoint, LoadDomainEvents, LoadEventsFrom, LoadPendingIntents, LoadProjection, MarkIntentDispatched, MarkIntentFailed, SaveProjection, SimulateFaults, StageNotifications };

package/packages/v5/dist/adapters/outbound/capabilities/index.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/packages/v5/dist/adapters/outbound/capabilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/packages/v5/dist/adapters/outbound/shapes/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/packages/v5/dist/adapters/outbound/shapes/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/packages/v5/dist/adapters/outbound/shapes/index.d.cts

@@ -0,0 +1,68 @@
+import { Failure } from '../../../core/shapes/index.cjs';
+import { M as Message } from '../../../Message-c9XdBoh4.cjs';
+import { R as Rejection } from '../../../Rejection-D9PlzquK.cjs';
+import { I as Intent } from '../../../Intent-B6l0bHZU.cjs';
+import { D as DomainEvent } from '../../../DomainEvent-CSzUMw46.cjs';
+export { S as StreamKey } from '../../../DomainEvent-CSzUMw46.cjs';
+
+/**
+ * A specialisation of `Failure` for I/O related infrastructure failures.
+ *
+ * A `GatewayFailure` is returned as `Err` when an outbound adapter cannot
+ * reach its underlying infrastructure — for example, when the event store
+ * is offline, a database times out, or an external service is unavailable.
+ *
+ * It is never the result of a business rule violation. Use `Rejection` for
+ * those cases.
+ *
+ * The `gateway` field identifies which infrastructure component failed,
+ * enabling the adapter to map it to an appropriate response — typically
+ * HTTP 503.
+ *
+ * @example
+ * const failure: GatewayFailure = {
+ *   kind: 'failure',
+ *   code: 'GATEWAY_FAILURE',
+ *   gateway: 'EventStore',
+ *   reason: 'Connection refused',
+ *   cause: originalError,
+ * };
+ */
+type GatewayFailure<TCode = string> = Failure<TCode> & {
+    readonly code: "GATEWAY_FAILURE";
+    readonly gateway: string;
+};
+
+/**
+ * StoredEvent wraps a DomainEvent for persistence in the event store based on its concerns.
+ * This table must be immutable, append-only.
+ */
+type StoredEvent<TEvent extends DomainEvent> = {
+    /** Global position in the store */
+    readonly globalPosition: number;
+    /** Write-time, distinct from event.timestamp */
+    readonly insertedAt: number;
+    /** The actual domain event. */
+    readonly event: TEvent;
+    /** Concerns (streamkeys) of the event, hoisted */
+    readonly concerns: TEvent["concerns"];
+};
+
+interface Notification<TType = string, TPayload = unknown, TCode = string, TDetails = Rejection<TCode> | Failure<TCode>> extends Message<TType, TPayload> {
+    readonly kind: "failure" | "rejection";
+    readonly details: TDetails;
+    readonly commandType: string;
+    readonly commandId: string;
+}
+
+type OutboxEnvelope<TEntry extends Intent | Notification> = {
+    status: "pending" | "dispatched" | "failed";
+    readonly stagedAt: number;
+    attemptCount: number;
+    dispatchedAt?: number;
+    failedAt?: number;
+    lastError?: string;
+    readonly entry: TEntry;
+};
+
+export type { GatewayFailure, Notification, OutboxEnvelope, StoredEvent };

package/packages/v5/dist/adapters/outbound/shapes/index.d.ts

@@ -0,0 +1,68 @@
+import { Failure } from '../../../core/shapes/index.js';
+import { M as Message } from '../../../Message-c9XdBoh4.js';
+import { R as Rejection } from '../../../Rejection-D9PlzquK.js';
+import { I as Intent } from '../../../Intent-BLNY6RoG.js';
+import { D as DomainEvent } from '../../../DomainEvent-w1jyCjai.js';
+export { S as StreamKey } from '../../../DomainEvent-w1jyCjai.js';
+
+/**
+ * A specialisation of `Failure` for I/O related infrastructure failures.
+ *
+ * A `GatewayFailure` is returned as `Err` when an outbound adapter cannot
+ * reach its underlying infrastructure — for example, when the event store
+ * is offline, a database times out, or an external service is unavailable.
+ *
+ * It is never the result of a business rule violation. Use `Rejection` for
+ * those cases.
+ *
+ * The `gateway` field identifies which infrastructure component failed,
+ * enabling the adapter to map it to an appropriate response — typically
+ * HTTP 503.
+ *
+ * @example
+ * const failure: GatewayFailure = {
+ *   kind: 'failure',
+ *   code: 'GATEWAY_FAILURE',
+ *   gateway: 'EventStore',
+ *   reason: 'Connection refused',
+ *   cause: originalError,
+ * };
+ */
+type GatewayFailure<TCode = string> = Failure<TCode> & {
+    readonly code: "GATEWAY_FAILURE";
+    readonly gateway: string;
+};
+
+/**
+ * StoredEvent wraps a DomainEvent for persistence in the event store based on its concerns.
+ * This table must be immutable, append-only.
+ */
+type StoredEvent<TEvent extends DomainEvent> = {
+    /** Global position in the store */
+    readonly globalPosition: number;
+    /** Write-time, distinct from event.timestamp */
+    readonly insertedAt: number;
+    /** The actual domain event. */
+    readonly event: TEvent;
+    /** Concerns (streamkeys) of the event, hoisted */
+    readonly concerns: TEvent["concerns"];
+};
+
+interface Notification<TType = string, TPayload = unknown, TCode = string, TDetails = Rejection<TCode> | Failure<TCode>> extends Message<TType, TPayload> {
+    readonly kind: "failure" | "rejection";
+    readonly details: TDetails;
+    readonly commandType: string;
+    readonly commandId: string;
+}
+
+type OutboxEnvelope<TEntry extends Intent | Notification> = {
+    status: "pending" | "dispatched" | "failed";
+    readonly stagedAt: number;
+    attemptCount: number;
+    dispatchedAt?: number;
+    failedAt?: number;
+    lastError?: string;
+    readonly entry: TEntry;
+};
+
+export type { GatewayFailure, Notification, OutboxEnvelope, StoredEvent };

package/packages/v5/dist/adapters/outbound/shapes/index.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/packages/v5/dist/adapters/outbound/shapes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/packages/v5/dist/core/capabilities/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/packages/v5/dist/core/capabilities/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/packages/v5/dist/core/capabilities/index.d.cts

@@ -0,0 +1,33 @@
+import { I as Intent } from '../../Intent-B6l0bHZU.cjs';
+import { D as DomainEvent } from '../../DomainEvent-CSzUMw46.cjs';
+import '../../Message-c9XdBoh4.cjs';
+
+/**
+ * Encapsulates a single business rule as a named, testable, composable predicate.
+ *
+ * An EvaluateCandidate answers one question about a candidate: does it satisfy
+ * this rule? It keeps business rules explicit, reusable across use cases,
+ * and independently testable without going through a decider.
+ *
+ * @example
+ * const membershipIsInitial: EvaluateCandidate<MembershipState> = {
+ *   isSatisfiedBy: (candidate) => candidate.status === 'initial',
+ * };
+ *
+ * if (!membershipIsInitial.isSatisfiedBy(state)) {
+ *   return { accepted: false, rejection: { code: 'MEMBERSHIP_ALREADY_EXISTS', reason: '...' } };
+ * }
+ */
+interface EvaluateCandidate<TCandidate> {
+    isSatisfiedBy(candidate: TCandidate): boolean;
+}
+
+interface StageIntents<TIntent extends Intent, TResult = Promise<void>> {
+    stage(intents: TIntent[]): TResult;
+}
+
+interface StoreDomainEvents<TDomainEvent extends DomainEvent, TReturn = Promise<void>> {
+    store(events: TDomainEvent[]): TReturn;
+}
+
+export type { EvaluateCandidate, StageIntents, StoreDomainEvents };

package/packages/v5/dist/core/capabilities/index.d.ts

@@ -0,0 +1,33 @@
+import { I as Intent } from '../../Intent-BLNY6RoG.js';
+import { D as DomainEvent } from '../../DomainEvent-w1jyCjai.js';
+import '../../Message-c9XdBoh4.js';
+
+/**
+ * Encapsulates a single business rule as a named, testable, composable predicate.
+ *
+ * An EvaluateCandidate answers one question about a candidate: does it satisfy
+ * this rule? It keeps business rules explicit, reusable across use cases,
+ * and independently testable without going through a decider.
+ *
+ * @example
+ * const membershipIsInitial: EvaluateCandidate<MembershipState> = {
+ *   isSatisfiedBy: (candidate) => candidate.status === 'initial',
+ * };
+ *
+ * if (!membershipIsInitial.isSatisfiedBy(state)) {
+ *   return { accepted: false, rejection: { code: 'MEMBERSHIP_ALREADY_EXISTS', reason: '...' } };
+ * }
+ */
+interface EvaluateCandidate<TCandidate> {
+    isSatisfiedBy(candidate: TCandidate): boolean;
+}
+
+interface StageIntents<TIntent extends Intent, TResult = Promise<void>> {
+    stage(intents: TIntent[]): TResult;
+}
+
+interface StoreDomainEvents<TDomainEvent extends DomainEvent, TReturn = Promise<void>> {
+    store(events: TDomainEvent[]): TReturn;
+}
+
+export type { EvaluateCandidate, StageIntents, StoreDomainEvents };

package/packages/v5/dist/core/capabilities/index.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/packages/v5/dist/core/capabilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/packages/v5/dist/core/shapes/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/packages/v5/dist/core/shapes/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/packages/v5/dist/core/shapes/index.d.cts

@@ -0,0 +1,27 @@
+export { D as DomainEvent } from '../../DomainEvent-CSzUMw46.cjs';
+export { I as Intent } from '../../Intent-B6l0bHZU.cjs';
+export { M as Message, a as Metadata, W as WithIdentifier } from '../../Message-c9XdBoh4.cjs';
+export { R as Rejection } from '../../Rejection-D9PlzquK.cjs';
+
+/**
+ * A generic failure value object representing something that went wrong
+ * outside of the domain's control.
+ *
+ * `Failure` is a sans-I/O building block — it carries no infrastructure
+ * concerns. Adapters specialise it into concrete failure types such as
+ * `GatewayFailure` for I/O related failures.
+ *
+ * Failures are modelled as `Err` values via neverthrow, not as thrown
+ * exceptions. A `Failure` is always unexpected — if the domain explicitly
+ * said no, that is a `Rejection`, not a `Failure`.
+ */
+interface Failure<TCode = string> {
+    /** Tag that distinguishes a `Failure` from a `Rejection` at runtime. */
+    readonly kind: "failure";
+    /** Specific failure subtype, e.g. `"GATEWAY_FAILURE"`. */
+    readonly code: TCode;
+    readonly reason: string;
+    readonly cause?: unknown;
+}
+
+export type { Failure };

package/packages/v5/dist/core/shapes/index.d.ts

@@ -0,0 +1,27 @@
+export { D as DomainEvent } from '../../DomainEvent-w1jyCjai.js';
+export { I as Intent } from '../../Intent-BLNY6RoG.js';
+export { M as Message, a as Metadata, W as WithIdentifier } from '../../Message-c9XdBoh4.js';
+export { R as Rejection } from '../../Rejection-D9PlzquK.js';
+
+/**
+ * A generic failure value object representing something that went wrong
+ * outside of the domain's control.
+ *
+ * `Failure` is a sans-I/O building block — it carries no infrastructure
+ * concerns. Adapters specialise it into concrete failure types such as
+ * `GatewayFailure` for I/O related failures.
+ *
+ * Failures are modelled as `Err` values via neverthrow, not as thrown
+ * exceptions. A `Failure` is always unexpected — if the domain explicitly
+ * said no, that is a `Rejection`, not a `Failure`.
+ */
+interface Failure<TCode = string> {
+    /** Tag that distinguishes a `Failure` from a `Rejection` at runtime. */
+    readonly kind: "failure";
+    /** Specific failure subtype, e.g. `"GATEWAY_FAILURE"`. */
+    readonly code: TCode;
+    readonly reason: string;
+    readonly cause?: unknown;
+}
+
+export type { Failure };

package/packages/v5/dist/core/shapes/index.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/packages/v5/dist/core/shapes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/packages/v5/dist/useCases/command/capabilities/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/packages/v5/dist/useCases/command/capabilities/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/packages/v5/dist/useCases/command/capabilities/index.d.cts

@@ -0,0 +1,27 @@
+import { D as DomainEvent } from '../../../DomainEvent-CSzUMw46.cjs';
+import { I as Intent } from '../../../Intent-B6l0bHZU.cjs';
+import { Decision, Command } from '../shapes/index.cjs';
+import '../../../Message-c9XdBoh4.cjs';
+import '../../../Rejection-D9PlzquK.cjs';
+
+interface Decide<TCommand, TState, TEvent extends DomainEvent, TIntent extends Intent = never> {
+    decide(command: TCommand, currentState: TState): Decision<TEvent, TIntent>;
+}
+
+interface Evolve<TState, TEvent extends DomainEvent> {
+    evolve(currentState: TState, event: TEvent): TState;
+}
+
+interface HandleCommand<TCommand extends Command, TResult = Promise<void>> {
+    handle(input: TCommand): TResult;
+}
+
+interface InitializeState<TState> {
+    initialize(id: string): TState;
+}
+
+interface LoadDecisionState<TState, TReturn = Promise<TState>> {
+    load(id: string, ...otherIds: string[]): TReturn;
+}
+
+export type { Decide, Evolve, HandleCommand, InitializeState, LoadDecisionState };

package/packages/v5/dist/useCases/command/capabilities/index.d.ts

@@ -0,0 +1,27 @@
+import { D as DomainEvent } from '../../../DomainEvent-w1jyCjai.js';
+import { I as Intent } from '../../../Intent-BLNY6RoG.js';
+import { Decision, Command } from '../shapes/index.js';
+import '../../../Message-c9XdBoh4.js';
+import '../../../Rejection-D9PlzquK.js';
+
+interface Decide<TCommand, TState, TEvent extends DomainEvent, TIntent extends Intent = never> {
+    decide(command: TCommand, currentState: TState): Decision<TEvent, TIntent>;
+}
+
+interface Evolve<TState, TEvent extends DomainEvent> {
+    evolve(currentState: TState, event: TEvent): TState;
+}
+
+interface HandleCommand<TCommand extends Command, TResult = Promise<void>> {
+    handle(input: TCommand): TResult;
+}
+
+interface InitializeState<TState> {
+    initialize(id: string): TState;
+}
+
+interface LoadDecisionState<TState, TReturn = Promise<TState>> {
+    load(id: string, ...otherIds: string[]): TReturn;
+}
+
+export type { Decide, Evolve, HandleCommand, InitializeState, LoadDecisionState };

package/packages/v5/dist/useCases/command/capabilities/index.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/packages/v5/dist/useCases/command/capabilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/packages/v5/dist/useCases/command/shapes/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/packages/v5/dist/useCases/command/shapes/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/packages/v5/dist/useCases/command/shapes/index.d.cts

@@ -0,0 +1,78 @@
+import { M as Message } from '../../../Message-c9XdBoh4.cjs';
+import { D as DomainEvent } from '../../../DomainEvent-CSzUMw46.cjs';
+import { I as Intent } from '../../../Intent-B6l0bHZU.cjs';
+import { R as Rejection } from '../../../Rejection-D9PlzquK.cjs';
+
+/**
+ * Represents a successful decision made by a decider.
+ *
+ * An accepted decision is the result of a command passing all business rules.
+ * It carries one or more domain events to be appended to the event stream,
+ * and zero or more intents to be staged in the outbox.
+ *
+ * An accepted decision does NOT mean the command has been fully processed —
+ * it means the domain has decided what should happen. Infrastructure concerns
+ * (persisting events, dispatching intents) are handled by the use case handler.
+ */
+type Accepted<TEvent extends DomainEvent, TIntent extends Intent = never> = {
+    readonly accepted: true;
+    readonly events: [TEvent, ...TEvent[]];
+    readonly intents: TIntent[];
+};
+/**
+ * Represents a rejection decision made by a decider.
+ *
+ * A rejection is a first-class business outcome — not an exception or an error.
+ * It means the command was valid and understood, but one or more business rules
+ * prevented it from being accepted. The domain explicitly said no.
+ *
+ * Rejections are never appended to the event stream. They may be recorded in
+ * an audit log by the use case handler, and can be published as an integration
+ * event if other bounded contexts need to know the command did not get through.
+ */
+type Rejected<TRejection extends Rejection> = {
+    readonly accepted: false;
+    readonly rejection: TRejection;
+};
+/**
+ * The return type of a decider's decide() function.
+ *
+ * A Decision is a discriminated union on `accepted`, enabling exhaustive
+ * pattern matching at the use case handler and adapter level.
+ *
+ * Both `Accepted` and `Rejected` are expected business outcomes and are
+ * returned as `Ok` from the use case. Only infrastructure failures such as
+ * a unavailable event store are modelled as `Err` via `GatewayFailure`.
+ *
+ * @example
+ * // Use case handler
+ * const decision = decider.decide(command, state);
+ *
+ * if (!decision.accepted) {
+ *   await auditLog.record(command, decision.rejection);
+ * }
+ *
+ * return okAsync(decision);
+ *
+ * @example
+ * // Adapter
+ * const result = await useCase.execute(command);
+ *
+ * result.match(
+ *   (decision) => {
+ *     if (!decision.accepted) {
+ *       const status = rejectionCodeToStatus[decision.rejection.code];
+ *       return reply.status(status).send({ error: decision.rejection.reason });
+ *     }
+ *     return reply.status(200).send({ events: decision.events });
+ *   },
+ *   (error) => reply.status(503).send({ error: 'Service unavailable' }) // GatewayFailure
+ * );
+ */
+type Decision<TEvent extends DomainEvent, TIntent extends Intent = never, TRejection extends Rejection = never> = Accepted<TEvent, TIntent> | Rejected<TRejection>;
+
+interface Command<TType = string, TPayload = unknown> extends Message<TType, TPayload> {
+    readonly kind: "command";
+}
+
+export type { Accepted, Command, Decision, Rejected };