@shirudo/ddd-kit 3.0.0-rc.10 → 3.0.0-rc.11

package/dist/chunks/kit-errors.d.ts

@@ -201,6 +201,14 @@ declare class FoldReturnedNoStateError extends KitWiringError<"FOLD_RETURNED_NO_
   readonly eventType: string;
   constructor(eventType: string);
 }
+/** Constructor options for {@link DirectStateMutationError}. */
+interface DirectStateMutationErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+}
 /**
  * Thrown by `EventSourcedAggregate.setState`: on an event-sourced aggregate
  * the state changes only through `apply()`, where the fact is recorded and
@@ -210,13 +218,13 @@ declare class FoldReturnedNoStateError extends KitWiringError<"FOLD_RETURNED_NO_
  * and a handler.
  */
 declare class DirectStateMutationError extends KitWiringError<"DIRECT_STATE_MUTATION"> {
-  readonly aggregateId: string;
-  constructor(aggregateId: string);
+  readonly identity: DirectStateMutationErrorOptions["identity"];
+  constructor(options: DirectStateMutationErrorOptions);
 }
 /**
  * Thrown by `Projector.project` when an event cannot be projected
  * safely because its cursor is missing or malformed, or its aggregate
- * address is absent. Applying such an event would break idempotency, so
+ * identity is absent. Applying such an event would break idempotency, so
  * the batch fails. Events written by `withCommit` carry the complete
  * cursor automatically; other sources compose a gap-proof committed-event
  * envelope. A well-formed cursor that does not continue the stored chain
@@ -357,6 +365,16 @@ declare class InvalidVersionError extends KitWiringError<"INVALID_VERSION"> {
   /** Why the value was rejected, for example "is not a safe integer". */
   reason: string);
 }
+/** Constructor options for {@link UnreplayableAggregateError}. */
+interface UnreplayableAggregateErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+  /** Why the aggregate cannot take a replay, with the safe remedy. */
+  readonly reason: string;
+}
 /**
  * Thrown by `EventSourcedAggregate.replayHistory` when the replay target
  * carries unflushed `pendingEvents`. Replaying persisted facts onto that
@@ -377,16 +395,17 @@ declare class InvalidVersionError extends KitWiringError<"INVALID_VERSION"> {
  * discard a dirty instance and replay into a fresh one.
  */
 declare class UnreplayableAggregateError extends KitWiringError<"UNREPLAYABLE_AGGREGATE"> {
-  readonly aggregateId: string;
-  constructor(aggregateId: string, reason: string);
+  readonly identity: UnreplayableAggregateErrorOptions["identity"];
+  constructor(options: UnreplayableAggregateErrorOptions);
 }
 /**
- * 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.
+ * Constructor options for {@link MisattributedEventError} and
+ * {@link ForeignEventError}: the identity of the aggregate that received the
+ * event, and the aggregate identity fields the event carries. A missing
+ * field on the event matches by default, so `actual` names only what the
+ * event states.
  */
-interface AggregateAddressMismatchOptions {
+interface AggregateIdentityMismatchOptions {
   readonly expected: {
     readonly aggregateType: string;
     readonly aggregateId: string;
@@ -401,26 +420,29 @@ interface AggregateAddressMismatchOptions {
  * Thrown by `EventSourcedAggregate.apply()` when a NEW event carries an
  * `aggregateId` or `aggregateType` naming a different aggregate: a
  * deterministic programming bug at the call site (a hand-built or
- * copied event addressed elsewhere), caught before the event can be
- * recorded and poison the own stream. Events with MISSING address
- * fields do not trip this: `apply()` stamps them from the aggregate,
+ * copied event that belongs elsewhere), caught before the event can be
+ * recorded and poison the own stream. Events with MISSING aggregate
+ * identity fields do not trip this: `apply()` stamps them from the aggregate,
  * the same guarantee `createEvent` gives. A wiring error, distinct
  * from {@link ForeignEventError} on purpose: a wrong new event is a
  * bug in today's code, a wrong PERSISTED row is corrupted or miswired
  * infrastructure, and handlers for one must not absorb the other.
  */
-declare class MisaddressedEventError extends KitWiringError<"MISADDRESSED_EVENT"> {
-  /** Address of the aggregate that received the event. */
-  readonly expected: AggregateAddressMismatchOptions["expected"];
-  /** Address fields the event carries. */
-  readonly actual: AggregateAddressMismatchOptions["actual"];
+declare class MisattributedEventError extends KitWiringError<"MISATTRIBUTED_EVENT"> {
+  /** Identity of the aggregate that received the event. */
+  readonly expected: AggregateIdentityMismatchOptions["expected"];
+  /** Aggregate identity fields the event carries. */
+  readonly actual: AggregateIdentityMismatchOptions["actual"];
   readonly eventType: string;
-  constructor(options: AggregateAddressMismatchOptions);
+  constructor(options: AggregateIdentityMismatchOptions);
 }
 /** Constructor options for {@link SnapshotVersionNotRestoredError}. */
 interface SnapshotVersionNotRestoredErrorOptions {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
   /** The version the snapshot carries. */
   readonly snapshotVersion: number;
   /** The version the factory's aggregate reports. */
@@ -435,8 +457,7 @@ interface SnapshotVersionNotRestoredErrorOptions {
  * channel would mask it as perpetual silent refolding.
  */
 declare class SnapshotVersionNotRestoredError extends KitWiringError<"SNAPSHOT_VERSION_NOT_RESTORED"> {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  readonly identity: SnapshotVersionNotRestoredErrorOptions["identity"];
   readonly snapshotVersion: number;
   readonly restoredVersion: number;
   constructor(options: SnapshotVersionNotRestoredErrorOptions);
@@ -474,6 +495,14 @@ declare class SnapshotCorruptedError extends InfrastructureError<"SNAPSHOT_CORRU
 declare class UnmintedEventError extends KitWiringError<"UNMINTED_EVENT"> {
   constructor(eventType: string);
 }
+/** Constructor options for {@link ReentrantEventRecordingError}. */
+interface ReentrantEventRecordingErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+}
 /**
  * Thrown by `recordPendingEvents` when the aggregate's pending-event list
  * changes while its events are being stamped: a stamp provider that
@@ -485,7 +514,18 @@ declare class UnmintedEventError extends KitWiringError<"UNMINTED_EVENT"> {
  * stamp providers free of domain decisions.
  */
 declare class ReentrantEventRecordingError extends KitWiringError<"REENTRANT_EVENT_RECORDING"> {
-  constructor(aggregateId: string);
+  readonly identity: ReentrantEventRecordingErrorOptions["identity"];
+  constructor(options: ReentrantEventRecordingErrorOptions);
+}
+/** Constructor options for {@link DuplicateEventIdError}. */
+interface DuplicateEventIdErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+  /** The event id two pending events would have shared. */
+  readonly eventId: string;
 }
 /**
  * Thrown when two facts of one aggregate would carry the same `eventId`.
@@ -499,16 +539,18 @@ declare class ReentrantEventRecordingError extends KitWiringError<"REENTRANT_EVE
  * identity per fact.
  */
 declare class DuplicateEventIdError extends KitWiringError<"DUPLICATE_EVENT_ID"> {
-  /** The identity two pending events would have shared. */
+  readonly identity: DuplicateEventIdErrorOptions["identity"];
+  /** The event id two pending events would have shared. */
   readonly eventId: string;
-  constructor(aggregateId: string,
-  /** The identity two pending events would have shared. */
-  eventId: string);
+  constructor(options: DuplicateEventIdErrorOptions);
 }
 /** Constructor options for {@link PendingEventLimitExceededError}. */
 interface PendingEventLimitExceededErrorOptions {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
   /** The configured `maxPendingEvents`. */
   readonly limit: number;
   /** Events pending before the rejected recording. */
@@ -526,13 +568,24 @@ interface PendingEventLimitExceededErrorOptions {
  * per decision.
  */
 declare class PendingEventLimitExceededError extends KitWiringError<"PENDING_EVENT_LIMIT_EXCEEDED"> {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  readonly identity: PendingEventLimitExceededErrorOptions["identity"];
   readonly limit: number;
   readonly pending: number;
   readonly added: number;
   constructor(options: PendingEventLimitExceededErrorOptions);
 }
+/** Constructor options for {@link PendingEventBatchMismatchError}. */
+interface PendingEventBatchMismatchErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+  /** Events in the committed batch. */
+  readonly batchLength: number;
+  /** Events pending on the aggregate. */
+  readonly pendingLength: number;
+}
 /**
  * Thrown by the post-commit acknowledgement of an aggregate when the
  * committed batch is not the prefix of its pending events any more. The
@@ -543,10 +596,10 @@ declare class PendingEventLimitExceededError extends KitWiringError<"PENDING_EVE
  * orchestration: acknowledge exactly the batch that was enrolled, once.
  */
 declare class PendingEventBatchMismatchError extends KitWiringError<"PENDING_EVENT_BATCH_MISMATCH"> {
-  readonly aggregateId: string;
+  readonly identity: PendingEventBatchMismatchErrorOptions["identity"];
   readonly batchLength: number;
   readonly pendingLength: number;
-  constructor(aggregateId: string, batchLength: number, pendingLength: number);
+  constructor(options: PendingEventBatchMismatchErrorOptions);
 }
 /**
  * Thrown by persisted-event consumers (including `replayHistory` and
@@ -555,79 +608,177 @@ declare class PendingEventBatchMismatchError extends KitWiringError<"PENDING_EVE
  * the persisted row belongs to someone else (a miswired stream read,
  * ids colliding across aggregate types, a corrupted store). An
  * `InfrastructureError`, NOT a `DomainError` (same posture as
- * {@link SnapshotSchemaMismatchError}): a wrong address is data
+ * {@link SnapshotSchemaMismatchError}): a wrong aggregate identity is data
  * corruption or wiring, never an expected business rejection, so it
  * must not be absorbed by generic domain error handling or presented
  * as a 4xx. It therefore PROPAGATES as a throw through the replay
  * methods' `Result` contract (which reserves `Err` for `DomainError`),
  * after the usual all-or-nothing rollback. History events without the
- * optional address fields pass unchecked (the fields are optional on
+ * optional aggregate identity fields pass unchecked (the fields are optional on
  * the event shape); new events are covered by
- * {@link MisaddressedEventError}.
+ * {@link MisattributedEventError}.
  */
 declare class ForeignEventError extends InfrastructureError<"FOREIGN_EVENT"> {
-  /** Address of the aggregate that received the event. */
-  readonly expected: AggregateAddressMismatchOptions["expected"];
-  /** Address fields the event carries. */
-  readonly actual: AggregateAddressMismatchOptions["actual"];
+  /** Identity of the aggregate that received the event. */
+  readonly expected: AggregateIdentityMismatchOptions["expected"];
+  /** Aggregate identity fields the event carries. */
+  readonly actual: AggregateIdentityMismatchOptions["actual"];
   readonly eventType: string;
-  constructor(options: AggregateAddressMismatchOptions);
-}
-/** Constructor options for {@link NonProgressingEventStreamPageError}. */
-interface NonProgressingEventStreamPageErrorOptions {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
-  /** Exclusive continuation cursor supplied to `EventStore.readStream`. */
+  constructor(options: AggregateIdentityMismatchOptions);
+}
+/** How a page of a stream read breaks the `readStream` contract. */
+type EventStreamPageReason = "empty_page" | "stream_vanished" | "page_past_target" | "page_over_limit" | "head_regressed" | "invalid_head";
+/** Constructor options for {@link InvalidEventStreamPageError}. */
+interface InvalidEventStreamPageErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+  /** How the page breaks the contract; see {@link EventStreamPageReason}. */
+  readonly reason: EventStreamPageReason;
+  /** The exclusive cursor the page followed. */
   readonly fromVersion: number;
-  /** Pinned inclusive stream version the replay still has to reach. */
-  readonly targetVersion: number;
+  /**
+   * The pinned inclusive target version. Absent for `invalid_head` on the
+   * first page: that page pins no target.
+   */
+  readonly targetVersion?: number;
+  /**
+   * The stream head the page reported, as the adapter returned it. Present
+   * for `head_regressed` and `invalid_head`.
+   */
+  readonly lastVersion?: unknown;
+  /** The stream head the first page reported. Present for `head_regressed`. */
+  readonly firstPageLastVersion?: number;
+  /**
+   * The number of events on the page. Present for `page_past_target` and
+   * `page_over_limit`.
+   */
+  readonly eventCount?: number;
+  /** The page limit the read asked for. Present for `page_over_limit`. */
+  readonly limit?: number;
 }
 /**
- * Thrown by a paged EventStore consumer when `readStream` returns no events
- * even though its continuation cursor has not reached the pinned target.
- * Such a page cannot advance and violates the EventStore port contract; a
- * replay loop that merely continued would spin forever.
+ * Thrown when a page of a stream read breaks the `readStream` contract.
+ * `readStreamPages` checks every page it reads, and
+ * `reconstituteAggregateFromStreamPages` checks every page an adapter that
+ * pages on its own hands over. Both throw this error for the same defect.
  *
- * This is a non-retryable infrastructure error: the persistence adapter
- * deterministically contradicted its port contract, so retrying the same read
- * is not a recovery policy. Run `createEventStoreContractTests` against the
- * adapter and fix its windowing/continuation implementation.
+ * The `reason` names the defect. `empty_page`: the page holds no event,
+ * but events remain before the target version. `stream_vanished`: a
+ * continuation page reports the stream absent. `page_past_target`: the
+ * page holds more events than its window has left. `page_over_limit`: the
+ * page holds more events than the `limit` of the read. `head_regressed`: a
+ * continuation page reports a head below the head of the first page.
+ * `invalid_head`: a page of an existing stream reports a head that is not
+ * a safe integer of at least 1, for example `0` for a stream without
+ * events, or a string from a driver that returns big integers as text.
+ *
+ * No case is retryable. Fix the adapter: run `createEventStoreContractTests`
+ * against an EventStore adapter, and `createReplayableStreamPagesContractTests`
+ * against an adapter that pages on its own. Two causes lie outside the
+ * adapter. A stream is append-only, and only a physical removal deletes it
+ * (the repository guide, "Domain deletion versus physical removal"), so a
+ * removal that runs during the read gives `stream_vanished`. An upcaster
+ * that splits one stored event into several gives `page_past_target` at
+ * the replay, because the replay counts one version per event.
  */
-declare class NonProgressingEventStreamPageError extends InfrastructureError<"NON_PROGRESSING_EVENT_STREAM_PAGE"> {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+declare class InvalidEventStreamPageError extends InfrastructureError<"INVALID_EVENT_STREAM_PAGE"> {
+  readonly identity: InvalidEventStreamPageErrorOptions["identity"];
+  readonly reason: EventStreamPageReason;
   readonly fromVersion: number;
+  readonly targetVersion: number | undefined;
+  readonly lastVersion: unknown;
+  readonly firstPageLastVersion: number | undefined;
+  readonly eventCount: number | undefined;
+  readonly limit: number | undefined;
+  constructor(options: InvalidEventStreamPageErrorOptions);
+}
+/** The check a {@link ReplayTargetMismatchError} reports. */
+type ReplayTargetMismatchReason = "target_not_at_cursor" | "pages_short_of_target";
+/** Constructor options for {@link ReplayTargetMismatchError}. */
+interface ReplayTargetMismatchErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+  /** The check that failed; see {@link ReplayTargetMismatchReason}. */
+  readonly reason: ReplayTargetMismatchReason;
+  /** The cursor the read started at; the replay target must start here. */
+  readonly fromVersion: number;
+  /**
+   * Pinned inclusive target the replay had to reach: the stream head, or
+   * `toVersion` on a point-in-time read.
+   */
   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. */
+  /** Version the aggregate held when the check ran. */
   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.
+ * Thrown by `reconstituteAggregateFromStreamPages`, or by a load recipe
+ * that replays on its own, when the replay target does not line up with the
+ * read. Events carry no stream position, so the aggregate cannot detect a
+ * tail that overlaps or misses the version it was reconstituted at. Only
+ * the caller, which pinned the target version, can compare. A single page
+ * that breaks its window is an {@link InvalidEventStreamPageError} instead.
  *
- * 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.
+ * The `reason` names the check that failed. `target_not_at_cursor`: the
+ * replay target stands at a version other than the `fromVersion` the read
+ * used, found before any page is replayed; a reconstitution factory reports
+ * the wrong version. `pages_short_of_target`: the pages ended before the
+ * target version. The read stopped early, the stream has a gap, or an
+ * upcaster merged several stored events into one. For an EventStore
+ * adapter, run `createEventStoreContractTests` and
+ * `createEsRepositoryContractTests` against it and fix its windowing. None
+ * of the cases is retryable. A snapshot beyond its stream does not reach
+ * the replay: `readStreamPages` reports that window as unreachable first,
+ * and an adapter that pages on its own must do the same.
  */
-declare class ReplayHeadMismatchError extends InfrastructureError<"REPLAY_HEAD_MISMATCH"> {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+declare class ReplayTargetMismatchError extends InfrastructureError<"REPLAY_TARGET_MISMATCH"> {
+  readonly identity: ReplayTargetMismatchErrorOptions["identity"];
+  readonly reason: ReplayTargetMismatchReason;
+  readonly fromVersion: number;
   readonly targetVersion: number;
   readonly actualVersion: number;
-  constructor(options: ReplayHeadMismatchErrorOptions);
+  constructor(options: ReplayTargetMismatchErrorOptions);
+}
+/** Constructor options for {@link ReplayRejectedError}. */
+interface ReplayRejectedErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+  /**
+   * The version the aggregate held before the rejected page. With
+   * `toVersion`, it bounds the window `(fromVersion, toVersion]` of the
+   * rejected page, not the window of the read.
+   */
+  readonly fromVersion: number;
+  /** The last stream position of the rejected page (inclusive). */
+  readonly toVersion: number;
+  /** The error the aggregate raised for a stored event of the page. */
+  readonly cause: DomainError;
+}
+/**
+ * The `Err` of `reconstituteAggregateFromStreamPages`: the aggregate
+ * rejected a stored event while it replayed a page of the stream.
+ *
+ * The window `(fromVersion, toVersion]` locates the rejected page, and
+ * `cause` holds the `DomainError` of the aggregate. A stored stream that
+ * the domain cannot replay is a defect of the stored data, not a request
+ * the caller can correct. So this is an `InfrastructureError`, and it is
+ * not retryable. An empty window means that the replay target rejected an
+ * empty history before the first page.
+ */
+declare class ReplayRejectedError extends InfrastructureError<"REPLAY_REJECTED"> {
+  readonly identity: ReplayRejectedErrorOptions["identity"];
+  readonly fromVersion: number;
+  readonly toVersion: number;
+  readonly cause: DomainError;
+  constructor(options: ReplayRejectedErrorOptions);
 }
 /**
  * Thrown when an event harvested from an aggregate cannot be safely composed
@@ -767,6 +918,16 @@ declare class ErrorMapperFailedError extends KitWiringError<"ERROR_MAPPER_FAILED
   readonly mapperCause: unknown;
   constructor(options: ErrorMapperFailedErrorOptions);
 }
+/** Constructor options for {@link UnenrolledChangesError}. */
+interface UnenrolledChangesErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+  /** Whether the repository of the aggregate is append-only. */
+  readonly appendOnly?: boolean;
+}
 /**
  * Thrown at the end of a `UnitOfWork.run` when an aggregate that was
  * loaded into the identity map changed but no `update` intent was registered.
@@ -791,10 +952,16 @@ declare class ErrorMapperFailedError extends KitWiringError<"ERROR_MAPPER_FAILED
  * change.
  */
 declare class UnenrolledChangesError extends KitWiringError<"UNENROLLED_CHANGES"> {
-  readonly aggregateId: string;
-  constructor(aggregateId: string, options?: {
-    readonly appendOnly?: boolean;
-  });
+  readonly identity: UnenrolledChangesErrorOptions["identity"];
+  constructor(options: UnenrolledChangesErrorOptions);
+}
+/** Constructor options for {@link AggregateDeletedError}. */
+interface AggregateDeletedErrorOptions {
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
 }
 /**
  * Thrown when an aggregate removed within the current unit of work is added,
@@ -807,8 +974,8 @@ declare class UnenrolledChangesError extends KitWiringError<"UNENROLLED_CHANGES"
  * loud, not be absorbed by a generic infrastructure-error handler.
  */
 declare class AggregateDeletedError extends KitWiringError<"AGGREGATE_DELETED"> {
-  readonly aggregateId: string;
-  constructor(aggregateId: string);
+  readonly identity: AggregateDeletedErrorOptions["identity"];
+  constructor(options: AggregateDeletedErrorOptions);
 }
 /**
  * Thrown by `AggregatePersistence.getById()` when an aggregate with the
@@ -824,14 +991,16 @@ declare class AggregateDeletedError extends KitWiringError<"AGGREGATE_DELETED">
  * Not retryable: retrying won't make the row appear.
  */
 interface AggregateNotFoundErrorOptions {
-  readonly aggregateType: string;
-  readonly id: string;
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
   /** Optional lower-level error to preserve in the cause chain. */
   readonly cause?: unknown;
 }
 declare class AggregateNotFoundError extends InfrastructureError<"AGGREGATE_NOT_FOUND"> {
-  readonly aggregateType: string;
-  readonly id: string;
+  readonly identity: AggregateNotFoundErrorOptions["identity"];
   constructor(options: AggregateNotFoundErrorOptions);
 }
 /**
@@ -854,14 +1023,16 @@ declare class AggregateNotFoundError extends InfrastructureError<"AGGREGATE_NOT_
  * request as already-applied.
  */
 interface DuplicateAggregateErrorOptions {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
   /** Optional driver-level error to preserve in the cause chain. */
   readonly cause?: unknown;
 }
 declare class DuplicateAggregateError extends InfrastructureError<"DUPLICATE_AGGREGATE"> {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  readonly identity: DuplicateAggregateErrorOptions["identity"];
   constructor(options: DuplicateAggregateErrorOptions);
 }
 /**
@@ -880,14 +1051,16 @@ declare class DuplicateAggregateError extends InfrastructureError<"DUPLICATE_AGG
  * truth.
  */
 interface SnapshotSchemaMismatchErrorOptions {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
   readonly expectedSchemaVersion: number;
   readonly actualSchemaVersion: number;
 }
 declare class SnapshotSchemaMismatchError extends InfrastructureError<"SNAPSHOT_SCHEMA_MISMATCH"> {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  readonly identity: SnapshotSchemaMismatchErrorOptions["identity"];
   readonly expectedSchemaVersion: number;
   readonly actualSchemaVersion: number;
   constructor(options: SnapshotSchemaMismatchErrorOptions);
@@ -926,8 +1099,13 @@ type ConcurrencyConflictReason =
 /** The version read failed. The failure travels as the cause. */
 "version_unknown";
 type ConcurrencyConflictErrorOptions = {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  /** The aggregate the error names. */
+  readonly identity: {
+    readonly aggregateType: string;
+    readonly aggregateId: string;
+  };
+  /** The write that failed, or `null` when the raising code does not know it. */
+  readonly intent?: "add" | "update" | "remove" | null;
   readonly expectedVersion: number;
   /** Optional driver-level error to preserve in the cause chain. */
   readonly cause?: unknown;
@@ -960,8 +1138,9 @@ type ConcurrencyConflictErrorOptions = {
  * but `version_unchanged`, which names a defect of the adapter.
  */
 declare class ConcurrencyConflictError extends InfrastructureError<"CONCURRENCY_CONFLICT"> {
-  readonly aggregateType: string;
-  readonly aggregateId: string;
+  readonly identity: ConcurrencyConflictErrorOptions["identity"];
+  /** The write that failed, or `null` when the raising code does not know it. */
+  readonly intent: NonNullable<ConcurrencyConflictErrorOptions["intent"]> | null;
   readonly expectedVersion: number;
   /** The stored version, or `null` when none exists to name. */
   readonly actualVersion: number | null;
@@ -1075,7 +1254,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" | "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_FLUSH_STATEMENT" | "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";
+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_AGGREGATE_IDENTITY_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_EVENT_STREAM_PAGE" | "INVALID_FLUSH_STATEMENT" | "INVALID_INTEGRATION_MESSAGE" | "INVALID_MONEY" | "INVALID_REPOSITORY_ADAPTER" | "INVALID_REPOSITORY_DEFINITION" | "INVALID_VERSION" | "MISATTRIBUTED_EVENT" | "MISSING_ENTITY_ID" | "MISSING_FOLD" | "MISSING_HANDLER" | "MONEY_CURRENCY_MISMATCH" | "MONEY_PRECISION_LOSS" | "MONEY_SCALE_MISMATCH" | "NESTED_UNIT_OF_WORK" | "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_REJECTED" | "REPLAY_TARGET_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 { ReentrantEventRecordingError as $, IdempotencyReconciliationRequiredErrorOptions as A, MisaddressedEventError as B, IdempotencyClaimLostErrorOptions as C, IdempotencyKeyReuseError as D, IdempotencyInFlightErrorOptions as E, InvalidIntegrationMessageError as F, NonProgressingEventStreamPageErrorOptions as G, MissingFoldError as H, InvalidVersionError as I, PendingEventLimitExceededErrorOptions as J, PendingEventBatchMismatchError as K, KitErrorCode as L, InMemoryCapacityExceededErrorOptions as M, InfrastructureError as N, IdempotencyKeyReuseErrorOptions as O, InvalidCommandMessageError as P, ProjectionReceiptViolationError as Q, KitErrorOptions as R, IdempotencyClaimLostError as S, IdempotencyInFlightError as T, MissingHandlerError as U, MissingEntityIdError as V, NonProgressingEventStreamPageError as W, ProjectionIdentityViolationError as X, ProjectionGapError as Y, ProjectionOrderViolationError as Z, ErrorMapperFailedErrorOptions as _, CapabilityRegistryConflictError as a, SnapshotVersionNotRestoredError as at, ForeignEventError as b, ConcurrencyConflictReason as c, UnmanagedInstanceError as ct, DuplicateAggregateError as d, UnregisteredHandlerError as dt, ReplayHeadMismatchError as et, DuplicateAggregateErrorOptions as f, UnregisteredHandlerErrorOptions as ft, ErrorMapperFailedError as g, isWiringErrorLike as gt, DuplicateHandlerRegistrationErrorOptions as h, isInfrastructureErrorLike as ht, AggregateNotFoundErrorOptions as i, SnapshotSchemaMismatchErrorOptions as it, InMemoryCapacityExceededError as j, IdempotencyReconciliationRequiredError as k, DirectStateMutationError as l, UnmintedEventError as lt, DuplicateHandlerRegistrationError as m, isDomainErrorLike as mt, AggregateDeletedError as n, SnapshotCorruptedError as nt, ConcurrencyConflictError as o, SnapshotVersionNotRestoredErrorOptions as ot, DuplicateEventIdError as p, UnreplayableAggregateError as pt, PendingEventLimitExceededError as q, AggregateNotFoundError as r, SnapshotSchemaMismatchError as rt, ConcurrencyConflictErrorOptions as s, UnenrolledChangesError as st, AggregateAddressMismatchOptions as t, ReplayHeadMismatchErrorOptions as tt, DomainError as u, UnprojectableEventError as ut, EventHarvestError as v, IdempotencyCompletionWithoutClaimError as w, HostileStateKeyError as x, FoldReturnedNoStateError as y, KitWiringError as z };
+export { PendingEventLimitExceededErrorOptions as $, IdempotencyInFlightErrorOptions as A, InvalidEventStreamPageErrorOptions as B, FoldReturnedNoStateError as C, UnreplayableAggregateError as Ct, IdempotencyClaimLostErrorOptions as D, isWiringErrorLike as Dt, IdempotencyClaimLostError as E, isInfrastructureErrorLike as Et, InMemoryCapacityExceededError as F, KitWiringError as G, InvalidVersionError as H, InMemoryCapacityExceededErrorOptions as I, MissingFoldError as J, MisattributedEventError as K, InfrastructureError as L, IdempotencyKeyReuseErrorOptions as M, IdempotencyReconciliationRequiredError as N, IdempotencyCompletionWithoutClaimError as O, IdempotencyReconciliationRequiredErrorOptions as P, PendingEventLimitExceededError as Q, InvalidCommandMessageError as R, EventStreamPageReason as S, UnregisteredHandlerErrorOptions as St, HostileStateKeyError as T, isDomainErrorLike as Tt, KitErrorCode as U, InvalidIntegrationMessageError as V, KitErrorOptions as W, PendingEventBatchMismatchError as X, MissingHandlerError as Y, PendingEventBatchMismatchErrorOptions as Z, DuplicateHandlerRegistrationError as _, UnenrolledChangesErrorOptions as _t, AggregateNotFoundErrorOptions as a, ReentrantEventRecordingErrorOptions as at, ErrorMapperFailedErrorOptions as b, UnprojectableEventError as bt, ConcurrencyConflictErrorOptions as c, ReplayTargetMismatchError as ct, DirectStateMutationErrorOptions as d, SnapshotCorruptedError as dt, ProjectionGapError as et, DomainError as f, SnapshotSchemaMismatchError as ft, DuplicateEventIdErrorOptions as g, UnenrolledChangesError as gt, DuplicateEventIdError as h, SnapshotVersionNotRestoredErrorOptions as ht, AggregateNotFoundError as i, ReentrantEventRecordingError as it, IdempotencyKeyReuseError as j, IdempotencyInFlightError as k, ConcurrencyConflictReason as l, ReplayTargetMismatchErrorOptions as lt, DuplicateAggregateErrorOptions as m, SnapshotVersionNotRestoredError as mt, AggregateDeletedErrorOptions as n, ProjectionOrderViolationError as nt, CapabilityRegistryConflictError as o, ReplayRejectedError as ot, DuplicateAggregateError as p, SnapshotSchemaMismatchErrorOptions as pt, MissingEntityIdError as q, AggregateIdentityMismatchOptions as r, ProjectionReceiptViolationError as rt, ConcurrencyConflictError as s, ReplayRejectedErrorOptions as st, AggregateDeletedError as t, ProjectionIdentityViolationError as tt, DirectStateMutationError as u, ReplayTargetMismatchReason as ut, DuplicateHandlerRegistrationErrorOptions as v, UnmanagedInstanceError as vt, ForeignEventError as w, UnreplayableAggregateErrorOptions as wt, EventHarvestError as x, UnregisteredHandlerError as xt, ErrorMapperFailedError as y, UnmintedEventError as yt, InvalidEventStreamPageError as z };
 //# sourceMappingURL=kit-errors.d.ts.map