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

package/dist/chunks/kit-errors.js

@@ -279,16 +279,16 @@ var FoldReturnedNoStateError = class extends KitWiringError {
 * and a handler.
 */
 var DirectStateMutationError = class extends KitWiringError {
-	aggregateId;
-	constructor(aggregateId) {
-		super("DIRECT_STATE_MUTATION", `Aggregate ${aggregateId} is event-sourced: its state changes only through apply(). Record the fact as an event and fold it in a handler instead of calling setState.`);
-		this.aggregateId = aggregateId;
+	identity;
+	constructor(options) {
+		super("DIRECT_STATE_MUTATION", `Aggregate ${describeAggregateIdentity(options.identity)} is event-sourced: its state changes only through apply(). Record the fact as an event and fold it in a handler instead of calling setState.`);
+		this.identity = detachAggregateIdentity(options.identity);
 	}
 };
 /**
 * 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
@@ -517,39 +517,68 @@ var InvalidVersionError = class extends KitWiringError {
 * discard a dirty instance and replay into a fresh one.
 */
 var UnreplayableAggregateError = class extends KitWiringError {
-	aggregateId;
-	constructor(aggregateId, reason) {
-		super("UNREPLAYABLE_AGGREGATE", `Cannot replay onto aggregate ${aggregateId}: ${reason}. Reconstitute on a fresh instance (no factory-recorded events, no unpersisted mutations).`);
-		this.aggregateId = aggregateId;
+	identity;
+	constructor(options) {
+		super("UNREPLAYABLE_AGGREGATE", `Cannot replay onto aggregate ${describeAggregateIdentity(options.identity)}: ${options.reason}. Reconstitute on a fresh instance (no factory-recorded events, no unpersisted mutations).`);
+		this.identity = detachAggregateIdentity(options.identity);
 	}
 };
-/** The address the event names; a missing field falls back to the receiving aggregate. */
-function describeEventAddress(options) {
+/**
+* Renders an aggregate identity for a kit message as `Type(id)`, the one
+* format every kit message uses, so a log search finds all of them. Kit
+* modules only; not part of the package entries.
+*/
+function describeAggregateIdentity(identity) {
+	return `${identity.aggregateType}(${identity.aggregateId})`;
+}
+/**
+* A frozen copy of the two aggregate identity fields. An error keeps its own
+* copy, so it neither shares the caller's object nor carries its other
+* properties into the log. Kit modules only; not part of the package
+* entries.
+*/
+function detachAggregateIdentity(identity) {
+	return Object.freeze({
+		aggregateType: identity.aggregateType,
+		aggregateId: identity.aggregateId
+	});
+}
+function detachPartialAggregateIdentity(identity) {
+	return Object.freeze({
+		...identity.aggregateType === void 0 ? {} : { aggregateType: identity.aggregateType },
+		...identity.aggregateId === void 0 ? {} : { aggregateId: identity.aggregateId }
+	});
+}
+/** The identity the event names; a missing field falls back to the receiving aggregate. */
+function describeEventIdentity(options) {
 	const { expected, actual } = options;
-	return `${actual.aggregateType ?? expected.aggregateType} ${actual.aggregateId ?? expected.aggregateId}`;
+	return describeAggregateIdentity({
+		aggregateType: actual.aggregateType ?? expected.aggregateType,
+		aggregateId: actual.aggregateId ?? expected.aggregateId
+	});
 }
 /**
 * 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.
 */
-var MisaddressedEventError = class extends KitWiringError {
-	/** Address of the aggregate that received the event. */
+var MisattributedEventError = class extends KitWiringError {
+	/** Identity of the aggregate that received the event. */
 	expected;
-	/** Address fields the event carries. */
+	/** Aggregate identity fields the event carries. */
 	actual;
 	eventType;
 	constructor(options) {
-		super("MISADDRESSED_EVENT", `New event "${options.eventType}" is addressed to ${describeEventAddress(options)} but was applied on ${options.expected.aggregateType} ${options.expected.aggregateId}: fix the call site (createEvent stamps the right address).`);
-		this.expected = options.expected;
-		this.actual = options.actual;
+		super("MISATTRIBUTED_EVENT", `New event "${options.eventType}" belongs to ${describeEventIdentity(options)} but was applied on ${describeAggregateIdentity(options.expected)}: fix the call site (createEvent stamps the right identity).`);
+		this.expected = detachAggregateIdentity(options.expected);
+		this.actual = detachPartialAggregateIdentity(options.actual);
 		this.eventType = options.eventType;
 	}
 };
@@ -562,14 +591,12 @@ var MisaddressedEventError = class extends KitWiringError {
 * channel would mask it as perpetual silent refolding.
 */
 var SnapshotVersionNotRestoredError = class extends KitWiringError {
-	aggregateType;
-	aggregateId;
+	identity;
 	snapshotVersion;
 	restoredVersion;
 	constructor(options) {
-		super("SNAPSHOT_VERSION_NOT_RESTORED", `SnapshotModel.reconstitute for ${options.aggregateType} ${options.aggregateId} returned an aggregate at version ${options.restoredVersion} for a snapshot at version ${options.snapshotVersion}. Reconstitution must restore the persisted version; call markReconstituted(version) inside the aggregate factory.`);
-		this.aggregateType = options.aggregateType;
-		this.aggregateId = options.aggregateId;
+		super("SNAPSHOT_VERSION_NOT_RESTORED", `SnapshotModel.reconstitute for ${describeAggregateIdentity(options.identity)} returned an aggregate at version ${options.restoredVersion} for a snapshot at version ${options.snapshotVersion}. Reconstitution must restore the persisted version; call markReconstituted(version) inside the aggregate factory.`);
+		this.identity = detachAggregateIdentity(options.identity);
 		this.snapshotVersion = options.snapshotVersion;
 		this.restoredVersion = options.restoredVersion;
 	}
@@ -626,8 +653,10 @@ var UnmintedEventError = class extends KitWiringError {
 * stamp providers free of domain decisions.
 */
 var ReentrantEventRecordingError = class extends KitWiringError {
-	constructor(aggregateId) {
-		super("REENTRANT_EVENT_RECORDING", `Pending events of aggregate ${aggregateId} changed while recordPendingEvents was stamping them. A stamp provider must not trigger new decisions on the aggregate being recorded; make every domain decision first, then record.`);
+	identity;
+	constructor(options) {
+		super("REENTRANT_EVENT_RECORDING", `Pending events of aggregate ${describeAggregateIdentity(options.identity)} changed while recordPendingEvents was stamping them. A stamp provider must not trigger new decisions on the aggregate being recorded; make every domain decision first, then record.`);
+		this.identity = detachAggregateIdentity(options.identity);
 	}
 };
 /**
@@ -642,10 +671,13 @@ var ReentrantEventRecordingError = class extends KitWiringError {
 * identity per fact.
 */
 var DuplicateEventIdError = class extends KitWiringError {
+	identity;
+	/** The event id two pending events would have shared. */
 	eventId;
-	constructor(aggregateId, eventId) {
-		super("DUPLICATE_EVENT_ID", `Two pending events of aggregate ${aggregateId} carry the same eventId "${eventId}". Each fact needs its own identity: append a recorded event once, and return a fresh stamp per decision from the stamp provider.`);
-		this.eventId = eventId;
+	constructor(options) {
+		super("DUPLICATE_EVENT_ID", `Two pending events of aggregate ${describeAggregateIdentity(options.identity)} carry the same eventId "${options.eventId}". Each fact needs its own event id: append a recorded event once, and return a fresh stamp per decision from the stamp provider.`);
+		this.identity = detachAggregateIdentity(options.identity);
+		this.eventId = options.eventId;
 	}
 };
 /**
@@ -658,15 +690,13 @@ var DuplicateEventIdError = class extends KitWiringError {
 * per decision.
 */
 var PendingEventLimitExceededError = class extends KitWiringError {
-	aggregateType;
-	aggregateId;
+	identity;
 	limit;
 	pending;
 	added;
 	constructor(options) {
-		super("PENDING_EVENT_LIMIT_EXCEEDED", `Aggregate ${options.aggregateType}(${options.aggregateId}) holds ${options.pending} pending event(s) and cannot record ${options.added} more: maxPendingEvents is ${options.limit}. A decision that emits this many facts points at a missing aggregate boundary.`);
-		this.aggregateType = options.aggregateType;
-		this.aggregateId = options.aggregateId;
+		super("PENDING_EVENT_LIMIT_EXCEEDED", `Aggregate ${describeAggregateIdentity(options.identity)} holds ${options.pending} pending event(s) and cannot record ${options.added} more: maxPendingEvents is ${options.limit}. A decision that emits this many facts points at a missing aggregate boundary.`);
+		this.identity = detachAggregateIdentity(options.identity);
 		this.limit = options.limit;
 		this.pending = options.pending;
 		this.added = options.added;
@@ -682,14 +712,14 @@ var PendingEventLimitExceededError = class extends KitWiringError {
 * orchestration: acknowledge exactly the batch that was enrolled, once.
 */
 var PendingEventBatchMismatchError = class extends KitWiringError {
-	aggregateId;
+	identity;
 	batchLength;
 	pendingLength;
-	constructor(aggregateId, batchLength, pendingLength) {
-		super("PENDING_EVENT_BATCH_MISMATCH", `The committed batch of ${batchLength} event(s) is no longer the pending prefix of aggregate ${aggregateId} (${pendingLength} pending). Acknowledge exactly the batch that was enrolled, once.`);
-		this.aggregateId = aggregateId;
-		this.batchLength = batchLength;
-		this.pendingLength = pendingLength;
+	constructor(options) {
+		super("PENDING_EVENT_BATCH_MISMATCH", `The committed batch of ${options.batchLength} event(s) is no longer the pending prefix of aggregate ${describeAggregateIdentity(options.identity)} (${options.pendingLength} pending). Acknowledge exactly the batch that was enrolled, once.`);
+		this.identity = detachAggregateIdentity(options.identity);
+		this.batchLength = options.batchLength;
+		this.pendingLength = options.pendingLength;
 	}
 };
 /**
@@ -699,89 +729,176 @@ var PendingEventBatchMismatchError = class extends KitWiringError {
 * 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}.
 */
 var ForeignEventError = class extends InfrastructureError {
-	/** Address of the aggregate that received the event. */
+	/** Identity of the aggregate that received the event. */
 	expected;
-	/** Address fields the event carries. */
+	/** Aggregate identity fields the event carries. */
 	actual;
 	eventType;
 	constructor(options) {
 		super({
 			code: "FOREIGN_EVENT",
-			message: `Persisted event "${options.eventType}" belongs to ${describeEventAddress(options)}, not to ${options.expected.aggregateType} ${options.expected.aggregateId}: the stream row addresses a different aggregate.`
+			message: `Persisted event "${options.eventType}" belongs to ${describeEventIdentity(options)}, not to ${describeAggregateIdentity(options.expected)}: the stream row belongs to a different aggregate.`
 		});
-		this.expected = options.expected;
-		this.actual = options.actual;
+		this.expected = detachAggregateIdentity(options.expected);
+		this.actual = detachPartialAggregateIdentity(options.actual);
 		this.eventType = options.eventType;
 	}
 };
+function describeReportedHead(head) {
+	if (typeof head === "number" && Number.isFinite(head)) return String(head);
+	return `${showReportedHead(head)} of type ${typeof head}`;
+}
+function showReportedHead(head) {
+	if (typeof head === "string") return JSON.stringify(head);
+	if (typeof head === "object" && head !== null) return Object.prototype.toString.call(head);
+	return String(head);
+}
+function eventStreamPageReasonMessage(stream, options) {
+	const target = `target version ${String(options.targetVersion)}`;
+	switch (options.reason) {
+		case "empty_page": return `The read of ${stream} returned an empty page after version ${options.fromVersion} toward ${target}. A page holds at least one event while events remain.`;
+		case "stream_vanished": return `readStream reported ${stream} absent after version ${options.fromVersion} while the replay had not reached ${target}. A stream is append-only, and only a physical removal deletes it; check for a removal that ran during the read.`;
+		case "page_past_target": return `The read of ${stream} returned ${String(options.eventCount)} events after version ${options.fromVersion}, more than the window (${options.fromVersion}, ${String(options.targetVersion)}] holds.`;
+		case "page_over_limit": return `The read of ${stream} returned ${String(options.eventCount)} events after version ${options.fromVersion}, more than the limit of ${String(options.limit)} it asked for.`;
+		case "head_regressed": return `readStream reported ${stream} at head ${String(options.lastVersion)} after version ${options.fromVersion}, below the head ${String(options.firstPageLastVersion)} of the first page. A stream is append-only, so its head never moves back.`;
+		case "invalid_head": return `readStream reported ${stream} with head ${describeReportedHead(options.lastVersion)} after version ${options.fromVersion}. The head of an existing stream is a safe integer of at least 1; report a stream without events as absent.`;
+	}
+}
 /**
-* 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.
+*
+* 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.
 *
-* 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.
+* 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.
 */
-var NonProgressingEventStreamPageError = class extends InfrastructureError {
-	aggregateType;
-	aggregateId;
+var InvalidEventStreamPageError = class extends InfrastructureError {
+	identity;
+	reason;
 	fromVersion;
 	targetVersion;
+	lastVersion;
+	firstPageLastVersion;
+	eventCount;
+	limit;
 	constructor(options) {
+		const stream = `${describeAggregateIdentity(options.identity)}`;
 		super({
-			code: "NON_PROGRESSING_EVENT_STREAM_PAGE",
-			message: `EventStore returned no events for ${options.aggregateType}(${options.aggregateId}) after version ${options.fromVersion}, before pinned target version ${options.targetVersion}. The page cannot advance; run the EventStore contract suite and fix the adapter's continuation window.`
+			code: "INVALID_EVENT_STREAM_PAGE",
+			message: eventStreamPageReasonMessage(stream, options)
 		});
-		this.aggregateType = options.aggregateType;
-		this.aggregateId = options.aggregateId;
+		this.identity = detachAggregateIdentity(options.identity);
+		this.reason = options.reason;
 		this.fromVersion = options.fromVersion;
 		this.targetVersion = options.targetVersion;
+		this.lastVersion = options.lastVersion;
+		this.firstPageLastVersion = options.firstPageLastVersion;
+		this.eventCount = options.eventCount;
+		this.limit = options.limit;
 	}
 };
+function replayTargetMismatchMessage(stream, options) {
+	switch (options.reason) {
+		case "target_not_at_cursor": return `Replay target for ${stream} stands at version ${options.actualVersion}, but the read continues after version ${options.fromVersion}. The reconstitution factory reports a version other than the read cursor.`;
+		case "pages_short_of_target": return `Replay of ${stream} ended at version ${options.actualVersion}, short of the pinned target version ${options.targetVersion}. The read stopped before the target version, the stream has a gap after version ${options.actualVersion}, or an upcaster merged stored events.`;
+	}
+}
 /**
-* 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.
 */
-var ReplayHeadMismatchError = class extends InfrastructureError {
-	aggregateType;
-	aggregateId;
+var ReplayTargetMismatchError = class extends InfrastructureError {
+	identity;
+	reason;
+	fromVersion;
 	targetVersion;
 	actualVersion;
 	constructor(options) {
+		const message = replayTargetMismatchMessage(`${describeAggregateIdentity(options.identity)}`, options);
 		super({
-			code: "REPLAY_HEAD_MISMATCH",
-			message: `Replay of ${options.aggregateType}(${options.aggregateId}) ended at version ${options.actualVersion}, not at the pinned stream head ${options.targetVersion}. The tail overlapped the restored version or a page lay outside the requested window; pass only the events after the restored version.`
+			code: "REPLAY_TARGET_MISMATCH",
+			message
 		});
-		this.aggregateType = options.aggregateType;
-		this.aggregateId = options.aggregateId;
+		this.identity = detachAggregateIdentity(options.identity);
+		this.reason = options.reason;
+		this.fromVersion = options.fromVersion;
 		this.targetVersion = options.targetVersion;
 		this.actualVersion = options.actualVersion;
 	}
 };
 /**
+* 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.
+*/
+var ReplayRejectedError = class extends InfrastructureError {
+	identity;
+	fromVersion;
+	toVersion;
+	constructor(options) {
+		const stream = `${describeAggregateIdentity(options.identity)}`;
+		const rejected = `${options.cause.code}: ${options.cause.message}`;
+		super({
+			code: "REPLAY_REJECTED",
+			message: options.fromVersion === options.toVersion ? `The replay target of ${stream} rejected an empty history at version ${options.fromVersion} with ${rejected}` : `The aggregate ${stream} rejected a stored event in the page (${options.fromVersion}, ${options.toVersion}] with ${rejected}`,
+			cause: options.cause
+		});
+		this.identity = detachAggregateIdentity(options.identity);
+		this.fromVersion = options.fromVersion;
+		this.toVersion = options.toVersion;
+	}
+};
+/**
 * 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
 * candidate would violate its event identity/source chain. Harvest failures
@@ -939,10 +1056,10 @@ var ErrorMapperFailedError = class extends KitWiringError {
 * change.
 */
 var UnenrolledChangesError = class extends KitWiringError {
-	aggregateId;
-	constructor(aggregateId, options = {}) {
-		super("UNENROLLED_CHANGES", `Aggregate ${aggregateId} was loaded and changed in this unit of work, ` + (options.appendOnly ? "but its repository is append-only and installs no update. An append-only aggregate must not change after add." : "but no update intent was registered. Call repository.update(aggregate) after the final domain decision so state and events flush together."));
-		this.aggregateId = aggregateId;
+	identity;
+	constructor(options) {
+		super("UNENROLLED_CHANGES", `Aggregate ${describeAggregateIdentity(options.identity)} was loaded and changed in this unit of work, ` + (options.appendOnly ? "but its repository is append-only and installs no update. An append-only aggregate must not change after add." : "but no update intent was registered. Call repository.update(aggregate) after the final domain decision so state and events flush together."));
+		this.identity = detachAggregateIdentity(options.identity);
 	}
 };
 /**
@@ -956,50 +1073,44 @@ var UnenrolledChangesError = class extends KitWiringError {
 * loud, not be absorbed by a generic infrastructure-error handler.
 */
 var AggregateDeletedError = class extends KitWiringError {
-	aggregateId;
-	constructor(aggregateId) {
-		super("AGGREGATE_DELETED", `Aggregate ${aggregateId} was removed in this unit of work and cannot be added, updated, tracked, or removed through another instance again. Removal is final within an operation. A repeated remove of the SAME instance is an accepted no-op; if the aggregate must remain, do not remove it.`);
-		this.aggregateId = aggregateId;
+	identity;
+	constructor(options) {
+		super("AGGREGATE_DELETED", `Aggregate ${describeAggregateIdentity(options.identity)} was removed in this unit of work and cannot be added, updated, tracked, or removed through another instance again. Removal is final within an operation. A repeated remove of the SAME instance is an accepted no-op; if the aggregate must remain, do not remove it.`);
+		this.identity = detachAggregateIdentity(options.identity);
 	}
 };
 var AggregateNotFoundError = class extends InfrastructureError {
-	aggregateType;
-	id;
+	identity;
 	constructor(options) {
 		super({
 			code: "AGGREGATE_NOT_FOUND",
-			message: `Aggregate not found: ${options.aggregateType}(${options.id})`,
+			message: `Aggregate not found: ${describeAggregateIdentity(options.identity)}`,
 			cause: options.cause
 		});
-		this.aggregateType = options.aggregateType;
-		this.id = options.id;
+		this.identity = detachAggregateIdentity(options.identity);
 	}
 };
 var DuplicateAggregateError = class extends InfrastructureError {
-	aggregateType;
-	aggregateId;
+	identity;
 	constructor(options) {
 		super({
 			code: "DUPLICATE_AGGREGATE",
-			message: `Duplicate aggregate: ${options.aggregateType}(${options.aggregateId}) already exists`,
+			message: `Duplicate aggregate: ${describeAggregateIdentity(options.identity)} already exists`,
 			cause: options.cause
 		});
-		this.aggregateType = options.aggregateType;
-		this.aggregateId = options.aggregateId;
+		this.identity = detachAggregateIdentity(options.identity);
 	}
 };
 var SnapshotSchemaMismatchError = class extends InfrastructureError {
-	aggregateType;
-	aggregateId;
+	identity;
 	expectedSchemaVersion;
 	actualSchemaVersion;
 	constructor(options) {
 		super({
 			code: "SNAPSHOT_SCHEMA_MISMATCH",
-			message: `Snapshot schema mismatch on ${options.aggregateType}(${options.aggregateId}): the snapshot model expects schema ${options.expectedSchemaVersion}, the stored snapshot carries ${options.actualSchemaVersion}. Override the model's migrate function to upgrade old snapshots, or discard the snapshot and refold from the full event stream.`
+			message: `Snapshot schema mismatch on ${describeAggregateIdentity(options.identity)}: the snapshot model expects schema ${options.expectedSchemaVersion}, the stored snapshot carries ${options.actualSchemaVersion}. Override the model's migrate function to upgrade old snapshots, or discard the snapshot and refold from the full event stream.`
 		});
-		this.aggregateType = options.aggregateType;
-		this.aggregateId = options.aggregateId;
+		this.identity = detachAggregateIdentity(options.identity);
 		this.expectedSchemaVersion = options.expectedSchemaVersion;
 		this.actualSchemaVersion = options.actualSchemaVersion;
 	}
@@ -1024,8 +1135,9 @@ var SnapshotSchemaMismatchError = class extends InfrastructureError {
 * but `version_unchanged`, which names a defect of the adapter.
 */
 var ConcurrencyConflictError = class extends InfrastructureError {
-	aggregateType;
-	aggregateId;
+	identity;
+	/** The write that failed, or `null` when the raising code does not know it. */
+	intent;
 	expectedVersion;
 	/** The stored version, or `null` when none exists to name. */
 	actualVersion;
@@ -1037,15 +1149,42 @@ var ConcurrencyConflictError = class extends InfrastructureError {
 			cause: options.cause,
 			retryable: options.reason !== "version_unchanged"
 		});
-		this.aggregateType = options.aggregateType;
-		this.aggregateId = options.aggregateId;
+		this.identity = detachAggregateIdentity(options.identity);
+		this.intent = options.intent ?? null;
 		this.expectedVersion = options.expectedVersion;
 		this.actualVersion = options.actualVersion ?? null;
 		this.reason = options.reason;
 	}
 };
+/**
+* Sets the write intent on a conflict that its raising code could not name,
+* and renders the message again. The conflict keeps its class, its fields,
+* its cause, and its throw site.
+*/
+function attributeConflictIntent(conflict, intent) {
+	if (conflict.intent === intent) return;
+	Reflect.set(conflict, "intent", intent);
+	rewriteErrorMessage(conflict, concurrencyConflictMessage({
+		identity: conflict.identity,
+		intent,
+		expectedVersion: conflict.expectedVersion,
+		reason: conflict.reason,
+		actualVersion: conflict.actualVersion
+	}));
+}
+/**
+* Replaces the message of an error, and the message in the first line of its
+* stack where the engine lets the kit write it.
+*/
+function rewriteErrorMessage(error, message) {
+	const header = `${error.name}: ${error.message}`;
+	const stack = Reflect.get(error, "stack");
+	Reflect.set(error, "message", message);
+	if (typeof stack === "string" && stack.startsWith(header)) Reflect.set(error, "stack", `${error.name}: ${message}${stack.slice(header.length)}`);
+}
 function concurrencyConflictMessage(options) {
-	const site = `${options.aggregateType}(${options.aggregateId})`;
+	const aggregate = describeAggregateIdentity(options.identity);
+	const site = options.intent == null ? aggregate : `${options.intent} of ${aggregate}`;
 	switch (options.reason) {
 		case "stale_version": return `Concurrency conflict on ${site}: expected version ${options.expectedVersion}, stored version ${options.actualVersion}.`;
 		case "version_unchanged": return `Concurrency conflict on ${site}: the write matched nothing, although the stored version is ${options.actualVersion}. Its statement carries a condition beyond the version, or its version read answered from a transaction snapshot. Drop the extra condition, or read the version with a locking read, for example SELECT ... FOR SHARE.`;
@@ -1161,5 +1300,5 @@ var IdempotencyCompletionWithoutClaimError = class extends KitWiringError {
 };
 
 //#endregion
-export { NonProgressingEventStreamPageError as A, SnapshotSchemaMismatchError as B, InvalidIntegrationMessageError as C, MissingEntityIdError as D, MisaddressedEventError as E, ProjectionOrderViolationError as F, UnprojectableEventError as G, UnenrolledChangesError as H, ProjectionReceiptViolationError as I, assertNoHostileOwnProtoKey as J, UnregisteredHandlerError as K, ReentrantEventRecordingError as L, PendingEventLimitExceededError as M, ProjectionGapError as N, MissingFoldError as O, ProjectionIdentityViolationError as P, ReplayHeadMismatchError as R, InvalidCommandMessageError as S, KitWiringError as T, UnmanagedInstanceError as U, SnapshotVersionNotRestoredError as V, UnmintedEventError as W, isInfrastructureErrorLike as X, isDomainErrorLike as Y, isWiringErrorLike as Z, IdempotencyInFlightError as _, DirectStateMutationError as a, InMemoryCapacityExceededError as b, DuplicateEventIdError as c, EventHarvestError as d, FoldReturnedNoStateError as f, IdempotencyCompletionWithoutClaimError as g, IdempotencyClaimLostError as h, ConcurrencyConflictError as i, PendingEventBatchMismatchError as j, MissingHandlerError as k, DuplicateHandlerRegistrationError as l, HostileStateKeyError as m, AggregateNotFoundError as n, DomainError as o, ForeignEventError as p, UnreplayableAggregateError as q, CapabilityRegistryConflictError as r, DuplicateAggregateError as s, AggregateDeletedError as t, ErrorMapperFailedError as u, IdempotencyKeyReuseError as v, InvalidVersionError as w, InfrastructureError as x, IdempotencyReconciliationRequiredError as y, SnapshotCorruptedError as z };
+export { isDomainErrorLike as $, MissingHandlerError as A, SnapshotCorruptedError as B, InvalidEventStreamPageError as C, MisattributedEventError as D, KitWiringError as E, ProjectionOrderViolationError as F, UnmintedEventError as G, SnapshotVersionNotRestoredError as H, ProjectionReceiptViolationError as I, UnreplayableAggregateError as J, UnprojectableEventError as K, ReentrantEventRecordingError as L, PendingEventLimitExceededError as M, ProjectionGapError as N, MissingEntityIdError as O, ProjectionIdentityViolationError as P, detachAggregateIdentity as Q, ReplayRejectedError as R, InvalidCommandMessageError as S, InvalidVersionError as T, UnenrolledChangesError as U, SnapshotSchemaMismatchError as V, UnmanagedInstanceError as W, attributeConflictIntent as X, assertNoHostileOwnProtoKey as Y, describeAggregateIdentity as Z, IdempotencyInFlightError as _, DirectStateMutationError as a, InMemoryCapacityExceededError as b, DuplicateEventIdError as c, EventHarvestError as d, isInfrastructureErrorLike as et, FoldReturnedNoStateError as f, IdempotencyCompletionWithoutClaimError as g, IdempotencyClaimLostError as h, ConcurrencyConflictError as i, PendingEventBatchMismatchError as j, MissingFoldError as k, DuplicateHandlerRegistrationError as l, HostileStateKeyError as m, AggregateNotFoundError as n, rewriteErrorMessage as nt, DomainError as o, ForeignEventError as p, UnregisteredHandlerError as q, CapabilityRegistryConflictError as r, DuplicateAggregateError as s, AggregateDeletedError as t, isWiringErrorLike as tt, ErrorMapperFailedError as u, IdempotencyKeyReuseError as v, InvalidIntegrationMessageError as w, InfrastructureError as x, IdempotencyReconciliationRequiredError as y, ReplayTargetMismatchError as z };
 //# sourceMappingURL=kit-errors.js.map