@shirudo/ddd-kit 3.0.0-rc.4 → 3.0.0-rc.5

package/README.md

@@ -23,22 +23,6 @@ clear boundaries around persistence and side effects.
 ![npm version](https://img.shields.io/npm/v/@shirudo/ddd-kit)
 ![license](https://img.shields.io/npm/l/@shirudo/ddd-kit)
 
-## When This Helps
-
-Use this kit when your TypeScript code has domain rules that deserve more than
-DTOs and service functions:
-
-- an order can only be confirmed once
-- a booking must stay inside an allowed date range
-- money must never lose precision at a JSON boundary
-- optimistic concurrency conflicts must be handled deliberately
-- domain events must be persisted and dispatched reliably
-- repository adapters must prove they enforce the same contract
-
-The library is intentionally boring at the edges. It does not ship an ORM, a
-message broker, decorators, a dependency-injection container, or a web
-framework. Those choices belong to the application.
-
 ## Installation
 
 ```bash
@@ -55,7 +39,7 @@ Cloudflare Workers, Vercel Edge, Deno, and Bun.
 
 ```ts
 import {
-  AggregateRoot,
+  StateStoredAggregate,
   DomainError,
   type DomainEvent,
   type Id,
@@ -85,7 +69,7 @@ class OrderAlreadyConfirmedError extends DomainError<
   }
 }
 
-class Order extends AggregateRoot<OrderState, OrderId, OrderEvent> {
+class Order extends StateStoredAggregate<OrderState, OrderId, OrderEvent> {
   protected readonly aggregateType = "Order";
 
   private constructor(id: OrderId, state: OrderState) {
@@ -105,7 +89,7 @@ class Order extends AggregateRoot<OrderState, OrderId, OrderEvent> {
       throw new OrderAlreadyConfirmedError(this.id);
     }
 
-    this.commit(
+    this.setState(
       { status: "confirmed" },
       this.createEvent("OrderConfirmed", { orderId: this.id }),
     );
@@ -125,7 +109,7 @@ That example is deliberately small, but it shows the core shape:
 
 - The aggregate owns the rule.
 - The domain throws an error when an invariant is broken.
-- `commit(...)` changes the state and records the event together.
+- `setState(...)` changes the state and records the event together.
 - `createEvent(...)` captures the immutable domain decision and aggregate source.
 - The application shell adds event identity, recording time, and trace metadata.
 - Persistence stays outside the aggregate.

package/dist/chunks/{errors.d.ts → kit-errors.d.ts}

@@ -1,6 +1,5 @@
 import { StructuredError } from "@shirudo/base-error";
-
-//#region src/core/errors.d.ts
+//#region src/errors/kit-errors.d.ts
 /**
  * **The kit's error identity model (since v3).** Every kit error is a
  * structured error carrying exactly ONE identifier: `code`, a stable
@@ -89,7 +88,7 @@ declare abstract class KitWiringError<TCode extends string> extends StructuredEr
  * Library-internal concrete subclasses: {@link AggregateNotFoundError},
  * {@link ConcurrencyConflictError}, {@link DuplicateAggregateError},
  * plus the unit-of-work lifecycle wrappers `CommitError` and
- * `RollbackError` (in `src/app/unit-of-work.ts`).
+ * `RollbackError` (in `src/application/unit-of-work/errors.ts`).
  */
 declare abstract class InfrastructureError<TCode extends string = string> extends StructuredError<TCode, "INFRASTRUCTURE"> {
   protected constructor(options: KitErrorOptions<TCode>);
@@ -136,18 +135,15 @@ declare class InMemoryCapacityExceededError extends InfrastructureError<"IN_MEMO
   constructor(options: InMemoryCapacityExceededErrorOptions);
 }
 /**
- * Thrown when event dispatch reaches a type with no own handler registration.
- * This covers `EventSourcedAggregate.apply()` and the exhaustive
- * `projectionFromHandlers` helper: the declared event union and its handler map
- * disagree at runtime, which is a programming / configuration bug rather than
- * a domain or infrastructure failure.
+ * Thrown when a projection built with `projectionFromHandlers` receives an
+ * event type with no own handler entry: the declared event union and the
+ * handler map disagree at runtime, which is a programming / configuration
+ * bug rather than a domain or infrastructure failure.
  *
  * Deliberately **not** on `DomainError` or `InfrastructureError`:
  * a generic `catch (e instanceof DomainError)` handler at the App
  * layer must not mask a forgotten handler; this should crash loud and
- * fail the calling Use Case so the bug surfaces in development. The
- * replay through `loadFromHistory` also lets it propagate uncaught instead
- * of wrapping it in `Result.Err`.
+ * fail the calling Use Case so the bug surfaces in development.
  *
  * Use `isBaseError(e)` from `@shirudo/base-error` to detect
  * "any structured error from the kit or any other BaseError-using
@@ -157,6 +153,43 @@ declare class MissingHandlerError extends KitWiringError<"MISSING_HANDLER"> {
   readonly eventType: string;
   constructor(eventType: string, cause?: unknown);
 }
+/**
+ * Thrown by an event-sourced aggregate when `apply()` or replay reaches an
+ * event type with no own entry in the `folds` map: the declared event union
+ * and the map disagree at runtime. Same posture as
+ * {@link MissingHandlerError}: a deterministic bug, never a domain
+ * rejection, so it propagates through `replayHistory` instead of riding its
+ * `Result`.
+ */
+declare class MissingFoldError extends KitWiringError<"MISSING_FOLD"> {
+  readonly eventType: string;
+  constructor(eventType: string, cause?: unknown);
+}
+/**
+ * Thrown by an event-sourced aggregate when a fold returns `undefined`
+ * for an event, which is almost always a fold without a `return` statement.
+ * Storing that result would set the aggregate state to `undefined`, record
+ * the fact anyway on the apply path, and leave every later fold working on
+ * nothing. Same posture as {@link MissingFoldError}: a deterministic bug
+ * in the folds map, never a domain rejection, so it propagates through
+ * `replayHistory` instead of riding its `Result`.
+ */
+declare class FoldReturnedNoStateError extends KitWiringError<"FOLD_RETURNED_NO_STATE"> {
+  readonly eventType: string;
+  constructor(eventType: string);
+}
+/**
+ * Thrown by `EventSourcedAggregate.setState`: on an event-sourced aggregate
+ * the state changes only through `apply()`, where the fact is recorded and
+ * the version advances with it. A direct state write would leave the
+ * instance ahead of its stream with nothing to replay. A wiring error: a
+ * deterministic bug in the aggregate's own code, the remedy is an event
+ * and a handler.
+ */
+declare class DirectStateMutationError extends KitWiringError<"DIRECT_STATE_MUTATION"> {
+  readonly aggregateId: string;
+  constructor(aggregateId: string);
+}
 /**
  * Thrown by `Projector.project` when an event cannot be projected
  * safely because its cursor is missing or malformed, or its aggregate
@@ -246,16 +279,19 @@ declare class InvalidCommandMessageError extends InfrastructureError<"INVALID_CO
   constructor(path: string, reason: string, cause?: unknown);
 }
 /**
- * Thrown by `Entity` (constructor and `setState`) and by the event
- * metadata helpers (`createDomainEvent`'s `options.metadata`,
- * `mergeMetadata`, `copyMetadata`) when the value carries an own
- * `"__proto__"` data key:
+ * Thrown by `Entity` (constructor and `setState`), by the event-sourced
+ * fold (`apply` and replay), by the event constructors for the payload,
+ * and by the event metadata helpers (`createDomainEvent`'s
+ * `options.metadata`, `mergeMetadata`, `copyMetadata`) when the value
+ * carries an own `"__proto__"` data key:
  * the shape `JSON.parse` produces for hostile DB rows or request bodies
  * handed to reconstitute factories. Such a key can never be legitimate
  * domain state; accepting it would hand a prototype-pollution payload to
  * every downstream consumer that copies the state through `[[Set]]`
  * (`Object.assign`, for-in assignment loops), and dropping it would be
- * silent data mutation.
+ * silent data mutation. The check looks at the root object only; nested
+ * objects are not walked, and a class instance is an ownership transfer
+ * that passes.
  *
  * Deliberately **not** a `DomainError` or `InfrastructureError` (same
  * posture as {@link MissingHandlerError}): untrusted input reaching the
@@ -269,7 +305,37 @@ declare class HostileStateKeyError extends KitWiringError<"HOSTILE_STATE_KEY"> {
   constructor(key: string, subject?: string);
 }
 /**
- * Thrown by `EventSourcedAggregate.loadFromHistory` when the replay target
+ * Thrown by the `Entity` constructor when the id is not a non-blank
+ * string. That covers `null`, `undefined`, a blank string, and a
+ * non-string value that reached the constructor through a cast. An
+ * entity without a usable identity cannot be tracked, compared, or
+ * persisted, so the construction fails before any state is stored. A
+ * wiring error: a deterministic bug at the call site, never a domain
+ * rejection.
+ */
+declare class MissingEntityIdError extends KitWiringError<"MISSING_ENTITY_ID"> {
+  constructor(
+  /** The rejected value, for the message only; never a usable id. */
+  received: unknown);
+}
+/**
+ * Thrown when a number that is not a valid aggregate version reaches the
+ * kit: `toVersion`, `markReconstituted`, `setVersion`, and the post-commit
+ * acknowledgement all reject it. A version is a safe integer of at least
+ * zero, and a restore never moves below the current version. A wiring
+ * error: an adapter passed a corrupt row value or a wrong number, and
+ * the optimistic-concurrency cursor must not carry it. Not retryable.
+ */
+declare class InvalidVersionError extends KitWiringError<"INVALID_VERSION"> {
+  readonly value: unknown;
+  /** Why the value was rejected, for example "is not a safe integer". */
+  readonly reason: string;
+  constructor(value: unknown,
+  /** Why the value was rejected, for example "is not a safe integer". */
+  reason: string);
+}
+/**
+ * Thrown by `EventSourcedAggregate.replayHistory` when the replay target
  * carries unflushed `pendingEvents`. Replaying persisted facts onto that
  * instance would advance the version underneath decisions made against an
  * older state and could later claim history the stream does not carry.
@@ -291,6 +357,23 @@ declare class UnreplayableAggregateError extends KitWiringError<"UNREPLAYABLE_AG
   readonly aggregateId: string;
   constructor(aggregateId: string, reason: string);
 }
+/**
+ * Constructor options for {@link MisaddressedEventError} and
+ * {@link ForeignEventError}: the address of the aggregate that received the
+ * event, and the address fields the event carries. A missing field on the
+ * event matches by default, so `actual` names only what the event states.
+ */
+interface AggregateAddressMismatchOptions {
+  readonly expected: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+  readonly actual: {
+    readonly aggregateType?: string;
+    readonly aggregateId?: string;
+  };
+  readonly eventType: string;
+}
 /**
  * Thrown by `EventSourcedAggregate.apply()` when a NEW event carries an
  * `aggregateId` or `aggregateType` naming a different aggregate: a
@@ -304,12 +387,36 @@ declare class UnreplayableAggregateError extends KitWiringError<"UNREPLAYABLE_AG
  * infrastructure, and handlers for one must not absorb the other.
  */
 declare class MisaddressedEventError extends KitWiringError<"MISADDRESSED_EVENT"> {
-  readonly expectedAggregateId: string;
-  readonly expectedAggregateType: string;
+  /** Address of the aggregate that received the event. */
+  readonly expected: AggregateAddressMismatchOptions["expected"];
+  /** Address fields the event carries. */
+  readonly actual: AggregateAddressMismatchOptions["actual"];
   readonly eventType: string;
-  readonly actualAggregateId?: string | undefined;
-  readonly actualAggregateType?: string | undefined;
-  constructor(expectedAggregateId: string, expectedAggregateType: string, eventType: string, actualAggregateId?: string | undefined, actualAggregateType?: string | undefined);
+  constructor(options: AggregateAddressMismatchOptions);
+}
+/** Constructor options for {@link SnapshotVersionNotRestoredError}. */
+interface SnapshotVersionNotRestoredErrorOptions {
+  readonly aggregateType: string;
+  readonly aggregateId: string;
+  /** The version the snapshot carries. */
+  readonly snapshotVersion: number;
+  /** The version the factory's aggregate reports. */
+  readonly restoredVersion: number;
+}
+/**
+ * Thrown by `reconstituteAggregateFromSnapshot` when the `reconstitute`
+ * factory returns an aggregate at a version other than the snapshot
+ * version. The factory ignored the version parameter, usually a forgotten
+ * `markReconstituted(version)`. A wiring error in the snapshot model,
+ * never snapshot corruption: routing it into the discard-and-refold
+ * channel would mask it as perpetual silent refolding.
+ */
+declare class SnapshotVersionNotRestoredError extends KitWiringError<"SNAPSHOT_VERSION_NOT_RESTORED"> {
+  readonly aggregateType: string;
+  readonly aggregateId: string;
+  readonly snapshotVersion: number;
+  readonly restoredVersion: number;
+  constructor(options: SnapshotVersionNotRestoredErrorOptions);
 }
 /**
  * The structural-integrity rejection for a stored snapshot. A consumer's
@@ -326,17 +433,20 @@ declare class SnapshotCorruptedError extends InfrastructureError<"SNAPSHOT_CORRU
 }
 /**
  * Thrown when an event reaches the aggregate's recording paths
- * (`apply`, `commit`, `addDomainEvent`) without having been minted by
+ * (`apply`, `setState`, `addDomainEvent`) without having been minted by
  * the kit's constructors: `createDomainEvent`,
- * `createDomainEventFromFacts`, `createUncommittedDomainEvent`, or aggregate
- * event helpers
- * deep-freeze the event and defensively copy payload and metadata,
- * and register the result in an internal, unforgeable mint marker.
- * Anything else (a hand-rolled literal, a shallow-frozen copy with
- * mutable nested data) is rejected: a mutable event recorded next to
- * a state change can silently diverge from it afterwards. A wiring
- * error: deterministic bug at the call site, the remedy is minting
- * through the constructors.
+ * `createDomainEventFromFacts`, `createUncommittedDomainEvent`, or the
+ * aggregate `createEvent` helper. Those constructors deep-freeze the
+ * event, defensively copy payload and metadata, and mark the result as
+ * minted. The mark has two tiers: a
+ * module-private one for events of this loaded copy of the kit, and a
+ * cooperative `Symbol.for` brand that a second loaded copy stamps and
+ * recognizes. Anything else (a hand-rolled literal, a shallow-frozen
+ * copy with mutable nested data) is rejected: a mutable event recorded
+ * next to a state change can silently diverge from it afterwards. A
+ * wiring error: deterministic bug at the call site, the remedy is
+ * minting through the constructors. The gate catches accidents, not
+ * adversaries: code in the same process can fake the brand.
  */
 declare class UnmintedEventError extends KitWiringError<"UNMINTED_EVENT"> {
   constructor(eventType: string);
@@ -355,20 +465,68 @@ declare class ReentrantEventRecordingError extends KitWiringError<"REENTRANT_EVE
   constructor(aggregateId: string);
 }
 /**
- * Thrown by `recordPendingEvents` when two events in one aggregate's pending
- * batch carry the same `eventId`: a stamp provider that returns one reused
- * stamp (or repeats an explicit id) would otherwise mint two distinct facts
+ * Thrown when two facts of one aggregate would carry the same `eventId`.
+ * Two causes, two sites: the aggregate rejects a recorded event that is
+ * already pending at the append, before the state moves; and
+ * `recordPendingEvents` rejects a stamp provider that returns one reused
+ * stamp (or repeats an explicit id). Either would mint two distinct facts
  * sharing one identity, and downstream idempotent consumers keyed on
- * `eventId` silently drop one of them. A wiring error: deterministic bug in
- * the stamp provider, the remedy is one fresh identity per decision.
+ * `eventId` silently drop one of them. A wiring error: deterministic bug at
+ * the append site or in the stamp provider, the remedy is one fresh
+ * identity per fact.
  */
 declare class DuplicateEventIdError extends KitWiringError<"DUPLICATE_EVENT_ID"> {
   /** The identity two pending events would have shared. */
   readonly eventId: string;
-  constructor(aggregateId: string, /** The identity two pending events would have shared. */eventId: string);
+  constructor(aggregateId: string,
+  /** The identity two pending events would have shared. */
+  eventId: string);
+}
+/** Constructor options for {@link PendingEventLimitExceededError}. */
+interface PendingEventLimitExceededErrorOptions {
+  readonly aggregateType: string;
+  readonly aggregateId: string;
+  /** The configured `maxPendingEvents`. */
+  readonly limit: number;
+  /** Events pending before the rejected recording. */
+  readonly pending: number;
+  /** Events the rejected recording would have added. */
+  readonly added: number;
+}
+/**
+ * Thrown when a recording would grow the pending list of an aggregate past
+ * `AggregateConfig.maxPendingEvents`. The check runs before the state
+ * moves, so the rejected decision records nothing and moves nothing. The
+ * limit is a modelling signal, not a runtime budget: a decision that emits
+ * hundreds of facts points at a missing aggregate boundary, and a retry
+ * repeats it. A wiring error: split the aggregate, or emit fewer facts
+ * per decision.
+ */
+declare class PendingEventLimitExceededError extends KitWiringError<"PENDING_EVENT_LIMIT_EXCEEDED"> {
+  readonly aggregateType: string;
+  readonly aggregateId: string;
+  readonly limit: number;
+  readonly pending: number;
+  readonly added: number;
+  constructor(options: PendingEventLimitExceededErrorOptions);
+}
+/**
+ * Thrown by the post-commit acknowledgement of an aggregate when the
+ * committed batch is not the prefix of its pending events any more. The
+ * batch is longer than the pending list, or an event in it is not the
+ * pending event at the same position. Acknowledging such a batch would
+ * drop decisions the commit never persisted or keep events it did. The
+ * pending list stays untouched. A wiring error in application commit
+ * orchestration: acknowledge exactly the batch that was enrolled, once.
+ */
+declare class PendingEventBatchMismatchError extends KitWiringError<"PENDING_EVENT_BATCH_MISMATCH"> {
+  readonly aggregateId: string;
+  readonly batchLength: number;
+  readonly pendingLength: number;
+  constructor(aggregateId: string, batchLength: number, pendingLength: number);
 }
 /**
- * Thrown by persisted-event consumers (including `loadFromHistory` and
+ * Thrown by persisted-event consumers (including `replayHistory` and
  * `Projector`) when an event carries an
  * `aggregateId` or `aggregateType` that names a different aggregate:
  * the persisted row belongs to someone else (a miswired stream read,
@@ -385,12 +543,12 @@ declare class DuplicateEventIdError extends KitWiringError<"DUPLICATE_EVENT_ID">
  * {@link MisaddressedEventError}.
  */
 declare class ForeignEventError extends InfrastructureError<"FOREIGN_EVENT"> {
-  readonly expectedAggregateId: string;
-  readonly expectedAggregateType: string;
+  /** Address of the aggregate that received the event. */
+  readonly expected: AggregateAddressMismatchOptions["expected"];
+  /** Address fields the event carries. */
+  readonly actual: AggregateAddressMismatchOptions["actual"];
   readonly eventType: string;
-  readonly actualAggregateId?: string | undefined;
-  readonly actualAggregateType?: string | undefined;
-  constructor(expectedAggregateId: string, expectedAggregateType: string, eventType: string, actualAggregateId?: string | undefined, actualAggregateType?: string | undefined);
+  constructor(options: AggregateAddressMismatchOptions);
 }
 /** Constructor options for {@link NonProgressingEventStreamPageError}. */
 interface NonProgressingEventStreamPageErrorOptions {
@@ -419,6 +577,35 @@ declare class NonProgressingEventStreamPageError extends InfrastructureError<"NO
   readonly targetVersion: number;
   constructor(options: NonProgressingEventStreamPageErrorOptions);
 }
+/** Constructor options for {@link ReplayHeadMismatchError}. */
+interface ReplayHeadMismatchErrorOptions {
+  readonly aggregateType: string;
+  readonly aggregateId: string;
+  /** Pinned inclusive stream head the replay had to reach. */
+  readonly targetVersion: number;
+  /** Version the aggregate holds after the replay. */
+  readonly actualVersion: number;
+}
+/**
+ * Thrown by a load recipe when the replayed aggregate does not end at the
+ * pinned stream head. Events carry no stream position, so the aggregate
+ * cannot detect a tail that overlaps the restored version or a page that
+ * lies outside the requested window; only the caller, which pinned the
+ * head, can compare. A snapshot catch-up passes only the events after the
+ * restored version, and the final version must equal the head.
+ *
+ * This is a non-retryable infrastructure error: the persistence adapter
+ * contradicted its port contract. Run `createEventStoreContractTests` and
+ * `createEsRepositoryContractTests` against the adapter and fix its
+ * windowing.
+ */
+declare class ReplayHeadMismatchError extends InfrastructureError<"REPLAY_HEAD_MISMATCH"> {
+  readonly aggregateType: string;
+  readonly aggregateId: string;
+  readonly targetVersion: number;
+  readonly actualVersion: number;
+  constructor(options: ReplayHeadMismatchErrorOptions);
+}
 /**
  * Thrown when an event harvested from an aggregate cannot be safely composed
  * into a commit envelope, or when an outbox can prove that accepting a
@@ -441,7 +628,44 @@ declare class NonProgressingEventStreamPageError extends InfrastructureError<"NO
 declare class EventHarvestError extends KitWiringError<"EVENT_HARVEST_FAILED"> {
   /** The `type` of the offending event, for programmatic routing. */
   readonly eventType?: string | undefined;
-  constructor(message: string, /** The `type` of the offending event, for programmatic routing. */eventType?: string | undefined);
+  constructor(message: string,
+  /** The `type` of the offending event, for programmatic routing. */
+  eventType?: string | undefined);
+}
+/**
+ * Thrown at bootstrap when the global key of a kit capability registry
+ * already holds a value that is not a registry: another module claimed
+ * the key. The kit neither shares that value nor overwrites it, because a
+ * silent replacement would break whichever module owned the key first. A
+ * wiring error in the host process; the remedy is one owner per key.
+ */
+declare class CapabilityRegistryConflictError extends KitWiringError<"CAPABILITY_REGISTRY_CONFLICT"> {
+  readonly key: symbol;
+  constructor(key: symbol);
+}
+/**
+ * Thrown when a kit operation receives an instance that this package did
+ * not construct: a structural lookalike, a repository DTO, or an instance
+ * from an incompatible copy of the package. Such an instance carries none
+ * of the kit-managed capabilities the operation needs. A wiring error:
+ * extend the kit's base classes and run one compatible package copy.
+ */
+declare class UnmanagedInstanceError extends KitWiringError<"UNMANAGED_INSTANCE"> {
+  /** The kit operation that rejected the instance. */
+  readonly operation: string;
+  /** What was rejected: "aggregate", "entity", "the persistence baseline". */
+  readonly subject: string;
+  /** The rejected instance's id, when it has one. */
+  readonly instanceId?: unknown | undefined;
+  constructor(
+  /** The kit operation that rejected the instance. */
+  operation: string,
+  /** What was rejected: "aggregate", "entity", "the persistence baseline". */
+  subject: string,
+  /** The rejected instance's id, when it has one. */
+  instanceId?: unknown | undefined,
+  /** One extra sentence about the registry state, when it explains the rejection. */
+  detail?: string);
 }
 /** Constructor options for {@link UnregisteredHandlerError}. */
 interface UnregisteredHandlerErrorOptions {
@@ -779,7 +1003,7 @@ declare class IdempotencyCompletionWithoutClaimError extends KitWiringError<"IDE
  * base-error `matchError` cases that cover kit and consumer codes
  * together, without importing anything from base-error.
  */
-type KitErrorCode = "AGGREGATE_DELETED" | "AGGREGATE_NOT_FOUND" | "AGGREGATE_TRACKING" | "COMMIT_FAILED" | "CONCURRENCY_CONFLICT" | "DOMAIN_TRANSITION_GUARD_REJECTED" | "DUPLICATE_AGGREGATE" | "DUPLICATE_EVENT_ID" | "DUPLICATE_HANDLER_REGISTRATION" | "ERROR_MAPPER_FAILED" | "EVENT_ADDRESS_INVALID" | "EVENT_HARVEST_FAILED" | "EVENT_ID_INVALID" | "EVENT_ID_REQUIRED" | "EVENT_OCCURRED_AT_INVALID" | "EVENT_OCCURRED_AT_REQUIRED" | "EVENT_SCHEMA_VERSION_INVALID" | "EVENT_TYPE_INVALID" | "FOREIGN_EVENT" | "HOSTILE_STATE_KEY" | "IDEMPOTENCY_CLAIM_LOST" | "IDEMPOTENCY_COMPLETED_WITHOUT_CLAIM" | "IDEMPOTENCY_IN_FLIGHT" | "IDEMPOTENCY_KEY_REUSE" | "IDEMPOTENCY_RECONCILIATION_REQUIRED" | "IN_MEMORY_CAPACITY_EXCEEDED" | "INVALID_DOMAIN_MACHINE_CONTEXT" | "INVALID_DOMAIN_MACHINE_DEFINITION" | "INVALID_DOMAIN_MACHINE_INPUT" | "INVALID_DOMAIN_MACHINE_SNAPSHOT" | "INVALID_DOMAIN_TRANSITION" | "INVALID_DOMAIN_TRANSITION_GUARD_RESULT" | "INVALID_DOMAIN_TRANSITION_RESULT" | "INVALID_COMMAND_MESSAGE" | "INVALID_INTEGRATION_MESSAGE" | "INVALID_MONEY" | "INVALID_REPOSITORY_ADAPTER" | "INVALID_REPOSITORY_DEFINITION" | "MISADDRESSED_EVENT" | "MISSING_HANDLER" | "MONEY_CURRENCY_MISMATCH" | "MONEY_PRECISION_LOSS" | "MONEY_SCALE_MISMATCH" | "NESTED_UNIT_OF_WORK" | "NON_PROGRESSING_EVENT_STREAM_PAGE" | "PROJECTION_GAP" | "PROJECTION_IDENTITY_VIOLATION" | "PROJECTION_ORDER_VIOLATION" | "PROJECTION_RECEIPT_VIOLATION" | "REENTRANT_DOMAIN_STATE_MACHINE_EVALUATION" | "REENTRANT_EVENT_RECORDING" | "REPOSITORY_ERROR_MAPPING_FAILED" | "ROLLBACK_FAILED" | "SNAPSHOT_CORRUPTED" | "SNAPSHOT_SCHEMA_MISMATCH" | "SNAPSHOT_TIME_INVALID" | "TRANSACTION_CLOSED" | "UNENROLLED_CHANGES" | "UNKNOWN_CURRENCY" | "UNMINTED_EVENT" | "UNPROJECTABLE_EVENT" | "UNREGISTERED_HANDLER" | "UNREPLAYABLE_AGGREGATE";
+type KitErrorCode = "AGGREGATE_DELETED" | "AGGREGATE_NOT_FOUND" | "AGGREGATE_TRACKING" | "CAPABILITY_REGISTRY_CONFLICT" | "COMMIT_FAILED" | "CONCURRENCY_CONFLICT" | "DIRECT_STATE_MUTATION" | "DOMAIN_TRANSITION_GUARD_REJECTED" | "DUPLICATE_AGGREGATE" | "DUPLICATE_EVENT_ID" | "DUPLICATE_HANDLER_REGISTRATION" | "ERROR_MAPPER_FAILED" | "EVENT_ADDRESS_INVALID" | "EVENT_BUS_CLOSED" | "EVENT_HARVEST_FAILED" | "EVENT_ID_INVALID" | "EVENT_ID_REQUIRED" | "EVENT_OCCURRED_AT_INVALID" | "EVENT_OCCURRED_AT_REQUIRED" | "EVENT_SCHEMA_VERSION_INVALID" | "EVENT_TYPE_INVALID" | "FOLD_RETURNED_NO_STATE" | "FOREIGN_EVENT" | "HOSTILE_STATE_KEY" | "IDEMPOTENCY_CLAIM_LOST" | "IDEMPOTENCY_COMPLETED_WITHOUT_CLAIM" | "IDEMPOTENCY_IN_FLIGHT" | "IDEMPOTENCY_KEY_REUSE" | "IDEMPOTENCY_RECONCILIATION_REQUIRED" | "IN_MEMORY_CAPACITY_EXCEEDED" | "INVALID_DOMAIN_MACHINE_CONTEXT" | "INVALID_DOMAIN_MACHINE_DEFINITION" | "INVALID_DOMAIN_MACHINE_INPUT" | "INVALID_DOMAIN_MACHINE_SNAPSHOT" | "INVALID_DOMAIN_TRANSITION" | "INVALID_DOMAIN_TRANSITION_GUARD_RESULT" | "INVALID_DOMAIN_TRANSITION_RESULT" | "INVALID_COMMAND_MESSAGE" | "INVALID_INTEGRATION_MESSAGE" | "INVALID_MONEY" | "INVALID_REPOSITORY_ADAPTER" | "INVALID_REPOSITORY_DEFINITION" | "INVALID_VERSION" | "MISADDRESSED_EVENT" | "MISSING_ENTITY_ID" | "MISSING_FOLD" | "MISSING_HANDLER" | "MONEY_CURRENCY_MISMATCH" | "MONEY_PRECISION_LOSS" | "MONEY_SCALE_MISMATCH" | "NESTED_UNIT_OF_WORK" | "NON_PROGRESSING_EVENT_STREAM_PAGE" | "PENDING_EVENT_BATCH_MISMATCH" | "PENDING_EVENT_LIMIT_EXCEEDED" | "PROJECTION_GAP" | "PROJECTION_IDENTITY_VIOLATION" | "PROJECTION_ORDER_VIOLATION" | "PROJECTION_RECEIPT_VIOLATION" | "PUBLISH_DEPTH_EXCEEDED" | "REENTRANT_DOMAIN_STATE_MACHINE_EVALUATION" | "REENTRANT_EVENT_RECORDING" | "REPLAY_HEAD_MISMATCH" | "REPOSITORY_ERROR_MAPPING_FAILED" | "ROLLBACK_FAILED" | "SNAPSHOT_CORRUPTED" | "SNAPSHOT_SCHEMA_MISMATCH" | "SNAPSHOT_TIME_INVALID" | "SNAPSHOT_VERSION_NOT_RESTORED" | "TRANSACTION_CLOSED" | "UNENROLLED_CHANGES" | "UNKNOWN_CURRENCY" | "UNMANAGED_INSTANCE" | "UNMINTED_EVENT" | "UNPROJECTABLE_EVENT" | "UNREGISTERED_HANDLER" | "UNREPLAYABLE_AGGREGATE";
 //#endregion
-export { isInfrastructureErrorLike as $, InvalidIntegrationMessageError as A, ProjectionOrderViolationError as B, IdempotencyKeyReuseErrorOptions as C, InMemoryCapacityExceededErrorOptions as D, InMemoryCapacityExceededError as E, MissingHandlerError as F, SnapshotSchemaMismatchErrorOptions as G, ReentrantEventRecordingError as H, NonProgressingEventStreamPageError as I, UnprojectableEventError as J, UnenrolledChangesError as K, NonProgressingEventStreamPageErrorOptions as L, KitErrorOptions as M, KitWiringError as N, InfrastructureError as O, MisaddressedEventError as P, isDomainErrorLike as Q, ProjectionGapError as R, IdempotencyKeyReuseError as S, IdempotencyReconciliationRequiredErrorOptions as T, SnapshotCorruptedError as U, ProjectionReceiptViolationError as V, SnapshotSchemaMismatchError as W, UnregisteredHandlerErrorOptions as X, UnregisteredHandlerError as Y, UnreplayableAggregateError as Z, IdempotencyClaimLostError as _, ConcurrencyConflictErrorOptions as a, IdempotencyInFlightError as b, DuplicateAggregateErrorOptions as c, DuplicateHandlerRegistrationErrorOptions as d, ErrorMapperFailedError as f, HostileStateKeyError as g, ForeignEventError as h, ConcurrencyConflictError as i, KitErrorCode as j, InvalidCommandMessageError as k, DuplicateEventIdError as l, EventHarvestError as m, AggregateNotFoundError as n, DomainError as o, ErrorMapperFailedErrorOptions as p, UnmintedEventError as q, AggregateNotFoundErrorOptions as r, DuplicateAggregateError as s, AggregateDeletedError as t, DuplicateHandlerRegistrationError as u, IdempotencyClaimLostErrorOptions as v, IdempotencyReconciliationRequiredError as w, IdempotencyInFlightErrorOptions as x, IdempotencyCompletionWithoutClaimError as y, ProjectionIdentityViolationError as z };
-//# sourceMappingURL=errors.d.ts.map
+export { ReplayHeadMismatchError as $, InMemoryCapacityExceededError as A, MissingEntityIdError as B, IdempotencyCompletionWithoutClaimError as C, IdempotencyKeyReuseErrorOptions as D, IdempotencyKeyReuseError as E, InvalidVersionError as F, PendingEventBatchMismatchError as G, MissingHandlerError as H, KitErrorCode as I, ProjectionGapError as J, PendingEventLimitExceededError as K, KitErrorOptions as L, InfrastructureError as M, InvalidCommandMessageError as N, IdempotencyReconciliationRequiredError as O, InvalidIntegrationMessageError as P, ReentrantEventRecordingError as Q, KitWiringError as R, IdempotencyClaimLostErrorOptions as S, IdempotencyInFlightErrorOptions as T, NonProgressingEventStreamPageError as U, MissingFoldError as V, NonProgressingEventStreamPageErrorOptions as W, ProjectionOrderViolationError as X, ProjectionIdentityViolationError as Y, ProjectionReceiptViolationError as Z, EventHarvestError as _, CapabilityRegistryConflictError as a, SnapshotVersionNotRestoredErrorOptions as at, HostileStateKeyError as b, DirectStateMutationError as c, UnmintedEventError as ct, DuplicateAggregateErrorOptions as d, UnregisteredHandlerErrorOptions as dt, ReplayHeadMismatchErrorOptions as et, DuplicateEventIdError as f, UnreplayableAggregateError as ft, ErrorMapperFailedErrorOptions as g, ErrorMapperFailedError as h, AggregateNotFoundErrorOptions as i, SnapshotVersionNotRestoredError as it, InMemoryCapacityExceededErrorOptions as j, IdempotencyReconciliationRequiredErrorOptions as k, DomainError as l, UnprojectableEventError as lt, DuplicateHandlerRegistrationErrorOptions as m, isInfrastructureErrorLike as mt, AggregateDeletedError as n, SnapshotSchemaMismatchError as nt, ConcurrencyConflictError as o, UnenrolledChangesError as ot, DuplicateHandlerRegistrationError as p, isDomainErrorLike as pt, PendingEventLimitExceededErrorOptions as q, AggregateNotFoundError as r, SnapshotSchemaMismatchErrorOptions as rt, ConcurrencyConflictErrorOptions as s, UnmanagedInstanceError as st, AggregateAddressMismatchOptions as t, SnapshotCorruptedError as tt, DuplicateAggregateError as u, UnregisteredHandlerError as ut, FoldReturnedNoStateError as v, IdempotencyInFlightError as w, IdempotencyClaimLostError as x, ForeignEventError as y, MisaddressedEventError as z };
+//# sourceMappingURL=kit-errors.d.ts.map