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

package/dist/chunks/{errors.js → kit-errors.js}

@@ -1,6 +1,6 @@
 import { StructuredError } from "@shirudo/base-error";
 
-//#region src/core/errors.ts
+//#region src/errors/kit-errors.ts
 /**
 * Abstract base for **domain-invariant violations**. Domain methods
 * (aggregates, entity validation hooks, value-object constructors)
@@ -72,7 +72,7 @@ var KitWiringError = class extends StructuredError {
 * 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`).
 */
 var InfrastructureError = class extends StructuredError {
 	constructor(options) {
@@ -128,18 +128,15 @@ var InMemoryCapacityExceededError = class extends InfrastructureError {
 	}
 };
 /**
-* 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
@@ -153,6 +150,52 @@ var MissingHandlerError = class extends KitWiringError {
 	}
 };
 /**
+* 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`.
+*/
+var MissingFoldError = class extends KitWiringError {
+	eventType;
+	constructor(eventType, cause) {
+		super("MISSING_FOLD", `Missing fold for event type: ${eventType}`, cause);
+		this.eventType = eventType;
+	}
+};
+/**
+* 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`.
+*/
+var FoldReturnedNoStateError = class extends KitWiringError {
+	eventType;
+	constructor(eventType) {
+		super("FOLD_RETURNED_NO_STATE", `The fold for event type "${eventType}" returned no state. A fold must return the next state; check for a missing return statement.`);
+		this.eventType = eventType;
+	}
+};
+/**
+* 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.
+*/
+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;
+	}
+};
+/**
 * 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
@@ -297,16 +340,19 @@ var InvalidCommandMessageError = class extends InfrastructureError {
 	}
 };
 /**
-* 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
@@ -323,7 +369,46 @@ var HostileStateKeyError = class extends KitWiringError {
 	}
 };
 /**
-* 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.
+*/
+var MissingEntityIdError = class extends KitWiringError {
+	constructor(received) {
+		super("MISSING_ENTITY_ID", `Entity ID must be a non-blank string; received ${describeRejectedId(received)}.`);
+	}
+};
+function describeRejectedId(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (typeof value === "object") return Array.isArray(value) ? "array" : "object";
+	if (typeof value === "function") return "function";
+	return `${typeof value} ${String(value)}`;
+}
+/**
+* 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.
+*/
+var InvalidVersionError = class extends KitWiringError {
+	value;
+	reason;
+	constructor(value, reason) {
+		super("INVALID_VERSION", `Version ${String(value)} ${reason}. A version is a safe integer of at least zero; create one with toVersion(n) from the stored row value.`);
+		this.value = value;
+		this.reason = reason;
+	}
+};
+/**
+* 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.
@@ -348,6 +433,11 @@ var UnreplayableAggregateError = class extends KitWiringError {
 		this.aggregateId = aggregateId;
 	}
 };
+/** The address the event names; a missing field falls back to the receiving aggregate. */
+function describeEventAddress(options) {
+	const { expected, actual } = options;
+	return `${actual.aggregateType ?? expected.aggregateType} ${actual.aggregateId ?? expected.aggregateId}`;
+}
 /**
 * Thrown by `EventSourcedAggregate.apply()` when a NEW event carries an
 * `aggregateId` or `aggregateType` naming a different aggregate: a
@@ -361,18 +451,37 @@ var UnreplayableAggregateError = class extends KitWiringError {
 * infrastructure, and handlers for one must not absorb the other.
 */
 var MisaddressedEventError = class extends KitWiringError {
-	expectedAggregateId;
-	expectedAggregateType;
+	/** Address of the aggregate that received the event. */
+	expected;
+	/** Address fields the event carries. */
+	actual;
 	eventType;
-	actualAggregateId;
-	actualAggregateType;
-	constructor(expectedAggregateId, expectedAggregateType, eventType, actualAggregateId, actualAggregateType) {
-		super("MISADDRESSED_EVENT", `New event "${eventType}" is addressed to ${actualAggregateType ?? expectedAggregateType} ${actualAggregateId ?? expectedAggregateId} but was applied on ${expectedAggregateType} ${expectedAggregateId}: fix the call site (createEvent stamps the right address).`);
-		this.expectedAggregateId = expectedAggregateId;
-		this.expectedAggregateType = expectedAggregateType;
-		this.eventType = eventType;
-		this.actualAggregateId = actualAggregateId;
-		this.actualAggregateType = actualAggregateType;
+	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;
+		this.eventType = options.eventType;
+	}
+};
+/**
+* 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.
+*/
+var SnapshotVersionNotRestoredError = class extends KitWiringError {
+	aggregateType;
+	aggregateId;
+	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;
+		this.snapshotVersion = options.snapshotVersion;
+		this.restoredVersion = options.restoredVersion;
 	}
 };
 /**
@@ -396,17 +505,20 @@ var SnapshotCorruptedError = class extends InfrastructureError {
 };
 /**
 * 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.
 */
 var UnmintedEventError = class extends KitWiringError {
 	constructor(eventType) {
@@ -429,22 +541,69 @@ var ReentrantEventRecordingError = class extends KitWiringError {
 	}
 };
 /**
-* 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.
 */
 var DuplicateEventIdError = class extends KitWiringError {
 	eventId;
 	constructor(aggregateId, eventId) {
-		super("DUPLICATE_EVENT_ID", `Two pending events of aggregate ${aggregateId} carry the same eventId "${eventId}". Each decision needs its own identity; return a fresh stamp per event from the stamp provider.`);
+		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;
 	}
 };
 /**
-* Thrown by persisted-event consumers (including `loadFromHistory` and
+* 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.
+*/
+var PendingEventLimitExceededError = class extends KitWiringError {
+	aggregateType;
+	aggregateId;
+	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;
+		this.limit = options.limit;
+		this.pending = options.pending;
+		this.added = options.added;
+	}
+};
+/**
+* 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.
+*/
+var PendingEventBatchMismatchError = class extends KitWiringError {
+	aggregateId;
+	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;
+	}
+};
+/**
+* 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,
@@ -461,21 +620,19 @@ var DuplicateEventIdError = class extends KitWiringError {
 * {@link MisaddressedEventError}.
 */
 var ForeignEventError = class extends InfrastructureError {
-	expectedAggregateId;
-	expectedAggregateType;
+	/** Address of the aggregate that received the event. */
+	expected;
+	/** Address fields the event carries. */
+	actual;
 	eventType;
-	actualAggregateId;
-	actualAggregateType;
-	constructor(expectedAggregateId, expectedAggregateType, eventType, actualAggregateId, actualAggregateType) {
+	constructor(options) {
 		super({
 			code: "FOREIGN_EVENT",
-			message: `Persisted event "${eventType}" belongs to ${actualAggregateType ?? expectedAggregateType} ${actualAggregateId ?? expectedAggregateId}, not to ${expectedAggregateType} ${expectedAggregateId}: the stream row addresses a different aggregate.`
+			message: `Persisted event "${options.eventType}" belongs to ${describeEventAddress(options)}, not to ${options.expected.aggregateType} ${options.expected.aggregateId}: the stream row addresses a different aggregate.`
 		});
-		this.expectedAggregateId = expectedAggregateId;
-		this.expectedAggregateType = expectedAggregateType;
-		this.eventType = eventType;
-		this.actualAggregateId = actualAggregateId;
-		this.actualAggregateType = actualAggregateType;
+		this.expected = options.expected;
+		this.actual = options.actual;
+		this.eventType = options.eventType;
 	}
 };
 /**
@@ -506,6 +663,35 @@ var NonProgressingEventStreamPageError = class extends InfrastructureError {
 	}
 };
 /**
+* 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.
+*/
+var ReplayHeadMismatchError = class extends InfrastructureError {
+	aggregateType;
+	aggregateId;
+	targetVersion;
+	actualVersion;
+	constructor(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.`
+		});
+		this.aggregateType = options.aggregateType;
+		this.aggregateId = options.aggregateId;
+		this.targetVersion = options.targetVersion;
+		this.actualVersion = options.actualVersion;
+	}
+};
+/**
 * 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
@@ -532,6 +718,38 @@ var EventHarvestError = class extends KitWiringError {
 	}
 };
 /**
+* 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.
+*/
+var CapabilityRegistryConflictError = class extends KitWiringError {
+	key;
+	constructor(key) {
+		super("CAPABILITY_REGISTRY_CONFLICT", `The global key ${String(key)} holds a value that is not a capability registry of this package. Another module claimed the key; the kit refuses to share or overwrite it.`);
+		this.key = key;
+	}
+};
+/**
+* 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.
+*/
+var UnmanagedInstanceError = class extends KitWiringError {
+	operation;
+	subject;
+	instanceId;
+	constructor(operation, subject, instanceId, detail) {
+		super("UNMANAGED_INSTANCE", `${operation} requires an instance constructed by this package; ${instanceId === void 0 ? subject : `${subject} ${String(instanceId)}`} carries no kit-managed capability. Construct it through this package and run one compatible package copy; a structural lookalike or an instance from another copy cannot be managed.` + (detail === void 0 ? "" : ` ${detail}`));
+		this.operation = operation;
+		this.subject = subject;
+		this.instanceId = instanceId;
+	}
+};
+/**
 * Shared guard for the loud-rejection contract on own `__proto__` data
 * keys (the shape `JSON.parse` produces for hostile rows, bodies, or
 * envelopes): used by `Entity` state copies and the event metadata
@@ -818,5 +1036,5 @@ var IdempotencyCompletionWithoutClaimError = class extends KitWiringError {
 };
 
 //#endregion
-export { SnapshotCorruptedError as A, MissingHandlerError as C, ProjectionOrderViolationError as D, ProjectionIdentityViolationError as E, UnregisteredHandlerError as F, UnreplayableAggregateError as I, assertNoHostileOwnProtoKey as L, UnenrolledChangesError as M, UnmintedEventError as N, ProjectionReceiptViolationError as O, UnprojectableEventError as P, isDomainErrorLike as R, MisaddressedEventError as S, ProjectionGapError as T, InMemoryCapacityExceededError as _, DuplicateAggregateError as a, InvalidIntegrationMessageError as b, ErrorMapperFailedError as c, HostileStateKeyError as d, IdempotencyClaimLostError as f, IdempotencyReconciliationRequiredError as g, IdempotencyKeyReuseError as h, DomainError as i, SnapshotSchemaMismatchError as j, ReentrantEventRecordingError as k, EventHarvestError as l, IdempotencyInFlightError as m, AggregateNotFoundError as n, DuplicateEventIdError as o, IdempotencyCompletionWithoutClaimError as p, ConcurrencyConflictError as r, DuplicateHandlerRegistrationError as s, AggregateDeletedError as t, ForeignEventError as u, InfrastructureError as v, NonProgressingEventStreamPageError as w, KitWiringError as x, InvalidCommandMessageError as y, isInfrastructureErrorLike as z };
-//# sourceMappingURL=errors.js.map
+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, 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 };
+//# sourceMappingURL=kit-errors.js.map