@shirudo/ddd-kit 3.0.0-rc.13 → 3.0.0-rc.15

package/dist/index.d.ts

@@ -1,33 +1,18 @@
 import { $ as PendingEventLimitExceededErrorOptions, A as IdempotencyInFlightErrorOptions, B as InvalidEventStreamPageErrorOptions, C as FoldReturnedNoStateError, Ct as UnreplayableAggregateError, D as IdempotencyClaimLostErrorOptions, Dt as isWiringErrorLike, E as IdempotencyClaimLostError, Et as isInfrastructureErrorLike, F as InMemoryCapacityExceededError, G as KitWiringError, H as InvalidVersionError, I as InMemoryCapacityExceededErrorOptions, J as MissingFoldError, K as MisattributedEventError, L as InfrastructureError, M as IdempotencyKeyReuseErrorOptions, N as IdempotencyReconciliationRequiredError, O as IdempotencyCompletionWithoutClaimError, P as IdempotencyReconciliationRequiredErrorOptions, Q as PendingEventLimitExceededError, R as InvalidCommandMessageError, S as EventStreamPageReason, St as UnregisteredHandlerErrorOptions, T as HandBuiltEventError, Tt as isDomainErrorLike, U as KitErrorCode, V as InvalidIntegrationMessageError, W as KitErrorOptions, X as PendingEventBatchMismatchError, Y as MissingHandlerError, Z as PendingEventBatchMismatchErrorOptions, _ as DuplicateHandlerRegistrationError, _t as UnmanagedInstanceError, a as AggregateNotFoundErrorOptions, at as ReentrantEventRecordingError, b as ErrorMapperFailedErrorOptions, bt as UnregisteredChangesErrorOptions, c as ConcurrencyConflictErrorOptions, ct as ReplayRejectedErrorOptions, d as DirectStateMutationErrorOptions, dt as ReplayTargetMismatchReason, et as ProjectionGapError, f as DomainError, ft as SnapshotCorruptedError, g as DuplicateEventIdErrorOptions, gt as SnapshotVersionNotRestoredErrorOptions, h as DuplicateEventIdError, ht as SnapshotVersionNotRestoredError, i as AggregateNotFoundError, it as PrototypePollutionError, j as IdempotencyKeyReuseError, k as IdempotencyInFlightError, l as ConcurrencyConflictReason, lt as ReplayTargetMismatchError, m as DuplicateAggregateErrorOptions, mt as SnapshotSchemaMismatchErrorOptions, n as AggregateDeletedErrorOptions, nt as ProjectionOrderViolationError, o as CapabilityRegistryConflictError, ot as ReentrantEventRecordingErrorOptions, p as DuplicateAggregateError, pt as SnapshotSchemaMismatchError, q as MissingEntityIdError, r as AggregateIdentityMismatchOptions, rt as ProjectionReceiptViolationError, s as ConcurrencyConflictError, st as ReplayRejectedError, t as AggregateDeletedError, tt as ProjectionIdentityViolationError, u as DirectStateMutationError, ut as ReplayTargetMismatchErrorOptions, v as DuplicateHandlerRegistrationErrorOptions, vt as UnprojectableEventError, w as ForeignEventError, wt as UnreplayableAggregateErrorOptions, x as EventCollectionError, xt as UnregisteredHandlerError, y as ErrorMapperFailedError, yt as UnregisteredChangesError, z as InvalidEventStreamPageError } from "./chunks/kit-errors.js";
-import { $ as Version, A as IdempotentCommitRequest, At as DomainEventFactoryOptions, B as CommitRegistrationOptions, Bt as createStampedDomainEvent, C as IdempotencyClaim, Ct as AnyUnstampedDomainEvent, D as IdempotencyReconciliation, Dt as CreateUnstampedDomainEventOptions, E as IdempotencyOperationErrorContext, Et as CreateStampedDomainEventOptions, F as DeadLetterDeadline, Ft as UnstampedDomainEvent, G as TransactionalOptions, Gt as Command, H as WithCommitWorkResult, Ht as mergeMetadata, I as DeadlineStore, It as UnstampedDomainEventOf, J as OnceOptions, Jt as JsonObject, K as EventBus, Kt as CommandHandler, L as DueDeadline, Lt as copyMetadata, M as IdempotentExecution, Mt as EventIdFactory, N as WithIdempotentCommitDeps, Nt as EventMetadata, O as IdempotencyReconciliationDecision, Ot as DomainEvent, P as withIdempotentCommit, Pt as PendingDomainEvent, Q as ReplayableAggregate, R as AggregateCommitToken, Rt as createDomainEvent, S as isPositionAfter, St as AnyDomainEvent, T as IdempotencyLease, Tt as CreateDomainEventStampOptions, U as withCommit, Ut as ClockFactory, V as WithCommitDeps, Vt as defaultDomainEventFactory, W as TransactionScope, Wt as AggregateIdentity, X as Aggregate, Xt as JsonValue, Y as PublishOptions, Yt as JsonPrimitive, Z as AggregateSnapshot, _ as IdentityMap, _t as ExecutionContext, a as EventStoreAppendOptions, at as CommandMessageContent, b as ProjectionCheckpointStore, bt as EventCommitCandidate, c as StreamReadResult, ct as CommandOutboxMapper, d as RepositoryTracking, dt as routeEventsToCommandOutbox, et as sameVersion, f as UnitOfWorkIdentityMap, ft as DeadLetterRecord, g as AggregateClass, gt as OutboxWriter, h as PersistenceModel, ht as OutboxRecord, i as EventStore, it as CommandCommitOriginCandidate, j as IdempotentCommitResult, jt as DomainEventStamp, k as IdempotencyStore, kt as DomainEventFactory, l as AggregatePersistenceWrite, lt as CommandOutboxWriter, m as PersistenceLifecycle, mt as Outbox, n as ReplayableStreamPages, nt as Id, o as EventStreamReader, ot as CommandMessageRelationships, p as PersistenceChanges, pt as DispatchTrackingOutbox, q as EventHandler, qt as PublishedCommand, r as reconstituteAggregateFromStreamPages, rt as IdGenerator, s as ReadStreamOptions, st as CommandOutboxCommitCandidate, t as SnapshotStore, tt as toVersion, u as AggregateWriteIntent, ut as DurableCommandMessage, v as Projection, vt as CommitPosition, w as IdempotencyClaimHandle, wt as CreateDomainEventOptions, x as ProjectionPosition, xt as EventCommitCandidatePosition, y as ProjectionCheckpoint, yt as CommittedDomainEvent, z as CommitRegistration, zt as createDomainEventFactory } from "./chunks/snapshot-store.js";
+import { $ as PublishOptions, $t as JsonPrimitive, A as IdempotentCommitRequest, At as CreateEventOptions, B as CommitRegistrationOptions, Bt as UnstampedDomainEventOf, C as IdempotencyClaim, Ct as CommittedDomainEvent, D as IdempotencyReconciliation, Dt as AnyUnstampedDomainEvent, E as IdempotencyOperationErrorContext, Et as AnyDomainEvent, F as DeadLetterDeadline, Ft as DomainEventStamp, G as DomainEventStampProvider, Gt as defaultDomainEventFactory, H as WithCommitWorkResult, Ht as createDomainEvent, I as DeadlineStore, It as EventIdFactory, J as TransactionScope, Jt as AggregateIdentity, K as SharedDomainEventStampOptions, Kt as mergeMetadata, L as DueDeadline, Lt as EventMetadata, M as IdempotentExecution, Mt as DomainEvent, N as WithIdempotentCommitDeps, Nt as DomainEventFactory, O as IdempotencyReconciliationDecision, Ot as CreateDomainEventOptions, P as withIdempotentCommit, Pt as DomainEventFactoryOptions, Q as OnceOptions, Qt as JsonObject, R as AggregateCommitToken, Rt as PendingDomainEvent, S as isPositionAfter, St as CommitPosition, T as IdempotencyLease, Tt as EventCommitCandidatePosition, U as withCommit, Ut as createDomainEventFactory, V as WithCommitDeps, Vt as copyMetadata, W as DomainEventStampFactory, Wt as createStampedDomainEvent, X as EventBus, Xt as CommandHandler, Y as TransactionalOptions, Yt as Command, Z as EventHandler, Zt as PublishedCommand, _ as IdentityMap, _t as DispatchTrackingOutbox, a as EventStoreAppendOptions, at as toVersion, b as ProjectionCheckpointStore, bt as OutboxWriter, c as StreamReadResult, ct as CommandCommitOriginCandidate, d as RepositoryTracking, dt as CommandOutboxCommitCandidate, en as JsonValue, et as Aggregate, f as UnitOfWorkIdentityMap, ft as CommandOutboxMapper, g as AggregateClass, gt as DeadLetterRecord, h as PersistenceModel, ht as routeEventsToCommandOutbox, i as EventStore, it as sameVersion, j as IdempotentCommitResult, jt as CreateStampedDomainEventOptions, k as IdempotencyStore, kt as CreateDomainEventStampOptions, l as AggregatePersistenceWrite, lt as CommandMessageContent, m as PersistenceLifecycle, mt as DurableCommandMessage, n as ReplayableStreamPages, nt as ReplayableAggregate, o as EventStreamReader, ot as Id, p as PersistenceChanges, pt as CommandOutboxWriter, q as stampPendingEvents, qt as ClockFactory, r as reconstituteAggregateFromStreamPages, rt as Version, s as ReadStreamOptions, st as IdGenerator, t as SnapshotStore, tt as AggregateSnapshot, u as AggregateWriteIntent, ut as CommandMessageRelationships, v as Projection, vt as Outbox, w as IdempotencyClaimHandle, wt as EventCommitCandidate, x as ProjectionPosition, xt as ExecutionContext, y as ProjectionCheckpoint, yt as OutboxRecord, z as CommitRegistration, zt as UnstampedDomainEvent } from "./chunks/snapshot-store.js";
 import { Result } from "@shirudo/result";
 import { ValidationError } from "@shirudo/base-error";
 //#region src/application/cqrs/internal/bus-internals.d.ts
 /**
  * Keeps manual result typing available only for the deliberately untyped
  * default map. Concrete maps, typed or refined index maps, and `any` keep their
- * mapped result contract authoritative.
+ * mapped result contract authoritative. Under the `object` bound, only `any`
+ * satisfies `unknown extends TMap`; the usual `0 extends 1 & TMap` probe
+ * reduces to `never` there and misses `any`.
  */
-type UntypedMapDispatch<TMap extends Record<string, unknown>, TMessage> = 0 extends 1 & TMap ? never : string extends keyof TMap ? Record<string, unknown> extends TMap ? TMessage : never : never;
+type UntypedMapDispatch<TMap extends object, TMessage> = unknown extends TMap ? never : string extends keyof TMap ? Record<string, unknown> extends TMap ? TMessage : never : never;
 //#endregion
 //#region src/application/cqrs/command/command-bus.d.ts
-/**
- * Type map for command types to their return types.
- * Used to improve type inference in CommandBus.
- *
- * @example
- * ```typescript
- * type MyCommandMap = {
- *   CreateOrder: OrderId;
- *   CancelOrder: void;
- * };
- *
- * const bus = new CommandBus<MyCommandMap>();
- * const result = await bus.execute({ type: "CreateOrder", ... });
- * // result: Result<OrderId, string>  ← automatically inferred
- * ```
- */
-type CommandTypeMap = Record<string, unknown>;
 /**
  * Construction options for {@link CommandBus}.
  *
@@ -71,7 +56,7 @@ interface CommandBusOptions<E = string> {
  * // result: Result<unknown, string>
  * ```
  */
-interface ICommandBus<TMap extends CommandTypeMap = CommandTypeMap, E = string> {
+interface ICommandBus<TMap extends object = Record<string, unknown>, E = string> {
   /**
    * Executes a command by dispatching it to the registered handler.
    * When a type map is provided, the return type is inferred from the command type.
@@ -143,7 +128,7 @@ interface ICommandBus<TMap extends CommandTypeMap = CommandTypeMap, E = string>
  * const result = await bus.execute({ type: "CreateOrder", ... });
  * ```
  */
-declare class CommandBus<TMap extends CommandTypeMap = CommandTypeMap, E = string> implements ICommandBus<TMap, E> {
+declare class CommandBus<TMap extends object = Record<string, unknown>, E = string> implements ICommandBus<TMap, E> {
   private readonly handlers;
   private readonly mapExpectedError;
   constructor(options?: CommandBusOptions<E>);
@@ -248,23 +233,6 @@ interface Query {
 type QueryHandler<Q extends Query, R> = (query: Q) => Promise<R>;
 //#endregion
 //#region src/application/cqrs/query/query-bus.d.ts
-/**
- * Type map for query types to their return types.
- * Used to improve type inference in QueryBus.
- *
- * @example
- * ```typescript
- * type MyQueryMap = {
- *   GetOrder: Order | null;
- *   ListOrders: Order[];
- * };
- *
- * const bus = new QueryBus<MyQueryMap>();
- * const result = await bus.execute({ type: "GetOrder", orderId: "123" });
- * // result: Result<Order | null, string>  ← automatically inferred
- * ```
- */
-type QueryTypeMap = Record<string, unknown>;
 /**
  * Construction options for {@link QueryBus}.
  *
@@ -307,7 +275,7 @@ interface QueryBusOptions<E = string> {
  * // result: Result<unknown, string>
  * ```
  */
-interface IQueryBus<TMap extends QueryTypeMap = QueryTypeMap, E = string> {
+interface IQueryBus<TMap extends object = Record<string, unknown>, E = string> {
   /**
    * Executes a query by dispatching it to the registered handler.
    * When a type map is provided, the return type is inferred from the query type.
@@ -391,7 +359,7 @@ interface IQueryBus<TMap extends QueryTypeMap = QueryTypeMap, E = string> {
  * const result = await bus.execute({ type: "GetOrder", orderId: "123" });
  * ```
  */
-declare class QueryBus<TMap extends QueryTypeMap = QueryTypeMap, E = string> implements IQueryBus<TMap, E> {
+declare class QueryBus<TMap extends object = Record<string, unknown>, E = string> implements IQueryBus<TMap, E> {
   private readonly handlers;
   private readonly mapExpectedError;
   constructor(options?: QueryBusOptions<E>);
@@ -737,8 +705,8 @@ declare class DeadlineProcessor<TPayload = unknown> extends PollLoop {
   private readonly classifyFailure?;
   constructor(options: DeadlineProcessorOptions<TPayload>);
   /**
-   * One full delivery pass (the `run`/`drainOnce` shell lives on
-   * {@link PollLoop}): delivers due deadlines batch by batch until
+   * One full delivery pass (the `run`/`drainOnce` shell lives on the
+   * shared poll loop): delivers due deadlines batch by batch until
    * nothing is due or a cycle contained a failure.
    */
   protected pass(signal?: AbortSignal): Promise<"drained" | "stopped">;
@@ -1212,8 +1180,8 @@ declare class OutboxDispatcher<Evt extends AnyDomainEvent> extends PollLoop {
   private readonly trackingOutbox?;
   constructor(options: OutboxDispatcherOptions<Evt>);
   /**
-   * One full dispatch pass (the `run`/`drainOnce` shell lives on
-   * {@link PollLoop}): dispatches pending records batch by batch until
+   * One full dispatch pass (the `run`/`drainOnce` shell lives on the
+   * shared poll loop): dispatches pending records batch by batch until
    * the backlog is empty or a failure stops progress. A `"stopped"`
    * pass leaves the failed record pending (or dead-lettered by a
    * tracking outbox); the next cycle retries it.
@@ -1563,37 +1531,6 @@ declare class RollbackError extends InfrastructureError<"ROLLBACK_FAILED"> {
   constructor(cause: unknown, rollbackCause: unknown);
 }
 //#endregion
-//#region src/application/unit-of-work/stamp-pending-events.d.ts
-/** Minimal shell role accepted by {@link stampPendingEvents}. */
-type DomainEventStampFactory = Pick<DomainEventFactory, "createStamp">;
-/** Per-decision stamp provider for metadata that depends on the event. */
-type DomainEventStampProvider<TEvent extends AnyDomainEvent> = (event: UnstampedDomainEventOf<TEvent>, index: number) => DomainEventStamp;
-/**
- * Stamp options that every decision of one stamping shares: a stamp time
- * and metadata such as the correlation id of the request. An `eventId` is per
- * fact, so the factory creates it for each decision.
- */
-type SharedDomainEventStampOptions = Omit<CreateDomainEventStampOptions, "eventId">;
-/**
- * Records every still-unstamped event accepted by an aggregate.
- *
- * The function is a command that also returns the recorded batch, a
- * deliberate exception to command-query separation: the caller hands the
- * batch on to persistence and needs no second read of `pendingEvents`.
- *
- * Recording is atomic with respect to the aggregate's pending list: if stamp
- * creation or validation fails, every decision remains unstamped. A
- * successful second call returns the same event objects and does not read the
- * factory again, which keeps event identity stable across transaction retries.
- *
- * Pass a `DomainEventFactory` (only its `createStamp` role is required) for one
- * uniform stamping policy. Add `stampOptions` for metadata that every
- * decision of the batch shares, such as the correlation id of the request.
- * Pass a callback instead when metadata depends on the concrete decision.
- */
-declare function stampPendingEvents<TId extends Id<string>, TEvent extends AnyDomainEvent>(aggregate: Aggregate<TId, TEvent>, factory: DomainEventStampFactory, stampOptions?: SharedDomainEventStampOptions): ReadonlyArray<TEvent>;
-declare function stampPendingEvents<TId extends Id<string>, TEvent extends AnyDomainEvent>(aggregate: Aggregate<TId, TEvent>, createStamp: DomainEventStampProvider<TEvent>): ReadonlyArray<TEvent>;
-//#endregion
 //#region src/application/unit-of-work/unit-of-work.d.ts
 /**
  * What the application work callback receives: repositories already bound to
@@ -1624,6 +1561,11 @@ interface RunOptions {
    * `TransactionScope`. Use `AbortSignal.timeout(ms)` for a deadline.
    */
   readonly signal?: AbortSignal;
+  /**
+   * Stamp options that every event stamped in this run shares, for example
+   * the correlation id of the request.
+   */
+  readonly stampOptions?: SharedDomainEventStampOptions;
 }
 declare const repositoryDefinitionBrand: unique symbol;
 /** Adapter wiring accepted by {@link defineRepository}. */
@@ -1832,6 +1774,12 @@ interface UnitOfWorkDeps<Evt extends AnyDomainEvent, TCtx, TDefinitions extends
    * application phase. Default `30000`ms.
    */
   postCommitTimeoutMs?: number;
+  /**
+   * See `withCommit`: stamps every pending event that is still unstamped
+   * when `add`, `update`, or `remove` registers its aggregate. Defaults to
+   * `createDomainEventFactory()`.
+   */
+  eventStampFactory?: DomainEventStampFactory;
   repositories: CompatibleRepositoryDefinitions<Evt, TCtx, TDefinitions>;
 }
 /**
@@ -2388,8 +2336,8 @@ interface AggregateConfig<TState = unknown> extends EntityConfig<TState> {
  * tracking, the kit-internal post-commit acknowledgement capability,
  * the `markReconstituted` post-load marker, and the `createEvent` helper
  * that auto-injects `aggregateId` + `aggregateType` on every event the
- * aggregate emits. The application shell stamps the pending decisions
- * with `stampPendingEvents` before persistence.
+ * aggregate emits. The commit stamps the pending decisions when it
+ * registers the aggregate, before persistence.
  *
  * Consumers do NOT extend this class directly; extend
  * `StateStoredAggregate` for state-stored aggregates or
@@ -2599,15 +2547,22 @@ declare abstract class BaseAggregate<TState, TId extends Id<string>, TEvent exte
    * Creates the immutable business fact accepted by this aggregate without
    * reading a clock, generating an id, or attaching tracing metadata.
    *
-   * The application shell stamps pending events after the domain operation
-   * and before persistence. Payload schema version stays here, next to the
+   * The commit stamps pending events when it registers the aggregate,
+   * before persistence. Payload schema version stays here, next to the
    * concrete event producer, rather than in shell-owned stamp data.
    */
-  protected createEvent<E extends TEvent>(type: E["type"], payload: E["payload"], options?: Omit<CreateUnstampedDomainEventOptions, "aggregateId" | "aggregateType">): UnstampedDomainEventOf<E>;
+  protected createEvent<E extends TEvent>(type: E["type"], payload: E["payload"], options?: CreateEventOptions): UnstampedDomainEventOf<E>;
 }
 //#endregion
 //#region src/domain/aggregate/event-sourced-aggregate.d.ts
-type Fold<TState, TEvent> = (state: TState, event: TEvent) => TState;
+/**
+ * Folds one event of type `TEvent` into the state of an event-sourced
+ * aggregate and returns the next state. Each entry of
+ * `EventSourcedAggregate.folds` is a fold. The fold receives the event
+ * without its stamp: a live `apply` folds the event before the commit stamps
+ * it.
+ */
+type Fold<TState, TEvent extends AnyDomainEvent> = (state: TState, event: UnstampedDomainEventOf<TEvent>) => TState;
 /**
  * Base class for Event-Sourced Aggregate Roots (Vernon, IDDD Chapter 8).
  *
@@ -2797,9 +2752,9 @@ declare abstract class EventSourcedAggregate<TState, TId extends Id<string>, TEv
    * producing silently divergent state. When a time or identity changes a
    * business decision, pass it in the payload.
    */
-  protected abstract readonly folds: { [K in TEvent["type"]]: Fold<TState, UnstampedDomainEventOf<Extract<TEvent, {
+  protected abstract readonly folds: { [K in TEvent["type"]]: Fold<TState, Extract<TEvent, {
     type: K;
-  }>>>; };
+  }>>; };
 }
 /**
  * Reconstitutes an event-sourced aggregate from one page of history and
@@ -3004,7 +2959,7 @@ interface DeepOmitOptions {
  * path, so memoising the first path's result would be wrong. This is
  * inherently exponential for diamond-shaped sharing (a node reachable
  * via 2^n paths is cloned 2^n times); the walk aborts with a descriptive
- * error after {@link PATH_SENSITIVE_VISIT_BUDGET} node visits instead of
+ * error after a fixed budget of node visits instead of
  * hanging the process.
  *
  * **Prototype-pollution safety.** `__proto__` and `constructor` keys
@@ -3258,7 +3213,8 @@ declare abstract class ValueObject<T extends object> implements IValueObject<T>
 //#region src/domain/value-object/value-object-or-issues.d.ts
 /**
  * Builds an immutable value object while collecting **all** validation
- * violations into a single {@link ValidationError}, instead of failing on the
+ * violations into a single `ValidationError` of `@shirudo/base-error`,
+ * instead of failing on the
  * first one. This is the Result-first, multi-error counterpart to
  * `valueObjectOrError` (which returns a single string message).
  *
@@ -4210,7 +4166,7 @@ interface RetryPolicy {
   maxDelayMs?: number;
   /**
    * Classifier deciding whether an error is worth retrying. Default
-   * {@link someChainRetryable} (walks the cause chain for the loose
+   * `someChainRetryable` of `@shirudo/base-error` (walks the cause chain for the loose
    * `retryable === true` marker, so a `ConcurrencyConflictError` matches
    * even when an adapter wraps it, unless its reason is
    * `version_unchanged`, which names a defect a retry repeats). Override
@@ -4333,6 +4289,10 @@ declare class InMemorySnapshotStore<TState = unknown> implements SnapshotStore<T
 }
 //#endregion
 //#region src/persistence/snapshot-store/snapshot-model.d.ts
+/**
+ * The fields of an aggregate that a snapshot model reads.
+ * @inline
+ */
 interface SnapshotAggregate {
   readonly id: Id<string>;
   readonly version: Version;
@@ -4400,5 +4360,5 @@ declare function captureAggregateSnapshot<TAggregate extends SnapshotAggregate,
  */
 declare function reconstituteAggregateFromSnapshot<TAggregate extends SnapshotAggregate, TSnapshotState>(model: SnapshotModel<TAggregate, TSnapshotState>, id: TAggregate["id"], snapshot: AggregateSnapshot<unknown>): TAggregate;
 //#endregion
-export { type AbsentStreamPages, type Aggregate, type AggregateClass, type AggregateCommitToken, type AggregateConfig, AggregateDeletedError, type AggregateDeletedErrorOptions, type AggregateIdentity, type AggregateIdentityMismatchOptions, AggregateNotFoundError, type AggregateNotFoundErrorOptions, type AggregatePersistence, type AggregatePersistenceWrite, type AggregateSnapshot, AggregateTrackingError, type AggregateTrackingErrorOptions, type AggregateTrackingReason, type AggregateWriteIntent, type AggregateWriteRegistration, type AnyDomainEvent, type AnyUnstampedDomainEvent, type AppendOnlyWriteRegistration, CapabilityRegistryConflictError, type ClassifyConcurrencyConflictOptions, type ClockFactory, type Command, CommandBus, type CommandBusOptions, type CommandCommitOriginCandidate, type CommandHandler, type CommandMessageContent, type CommandMessageRelationships, type CommandOutboxCommitCandidate, type CommandOutboxMapper, type CommandOutboxWriter, CommitError, type CommitPosition, type CommitRegistration, type CommitRegistrationOptions, type CommittedDomainEvent, type CompatibleRepositoryDefinitions, ConcurrencyConflictError, type ConcurrencyConflictErrorOptions, type ConcurrencyConflictReason, type CreateDomainEventOptions, type CreateDomainEventStampOptions, type CreateStampedDomainEventOptions, type DeadLetterDeadline, type DeadLetterRecord, DeadlineProcessor, type DeadlineProcessorObservers, type DeadlineProcessorOptions, type DeadlineStore, type DeepOmitKey, type DeepOmitOptions, type DeepOmitPathSegment, type DeliveryFailureAssessment, type DeliveryFailureClassifier, type DeliveryFailureKind, DirectStateMutationError, type DirectStateMutationErrorOptions, type DispatchTrackingOutbox, DomainError, type DomainErrorClass, type DomainEvent, type DomainEventFactory, type DomainEventFactoryOptions, type DomainEventStamp, type DomainEventStampFactory, type DomainEventStampProvider, type DomainEventValidationCode, DomainEventValidationError, type DomainEventValidationField, type DueDeadline, DuplicateAggregateError, type DuplicateAggregateErrorOptions, DuplicateEventIdError, type DuplicateEventIdErrorOptions, DuplicateHandlerRegistrationError, type DuplicateHandlerRegistrationErrorOptions, type DurableCommandMessage, Entity, type EntityConfig, ErrorMapperFailedError, type ErrorMapperFailedErrorOptions, type EventBus, EventBusClosedError, type EventBusObservers, type EventBusOptions, EventCollectionError, type EventCommitCandidate, type EventCommitCandidatePosition, type EventHandler, type EventIdFactory, type EventMetadata, EventSourcedAggregate, type EventStore, type EventStoreAppendOptions, type EventStreamPageReason, type EventStreamReader, type ExecutionContext, type FlushStatementReason, FoldReturnedNoStateError, ForeignEventError, HandBuiltEventError, type HandlerFailureReport, type ICommandBus, type IEntity, type IQueryBus, type Id, type IdGenerator, type IdempotencyClaim, type IdempotencyClaimHandle, IdempotencyClaimLostError, type IdempotencyClaimLostErrorOptions, IdempotencyCompletionWithoutClaimError, IdempotencyInFlightError, type IdempotencyInFlightErrorOptions, IdempotencyKeyReuseError, type IdempotencyKeyReuseErrorOptions, type IdempotencyLease, type IdempotencyOperationErrorContext, type IdempotencyReconciliation, type IdempotencyReconciliationDecision, IdempotencyReconciliationRequiredError, type IdempotencyReconciliationRequiredErrorOptions, type IdempotencyStore, type IdempotentCommitRequest, type IdempotentCommitResult, type IdempotentExecution, type Identifiable, IdentityMap, InMemoryCapacityExceededError, type InMemoryCapacityExceededErrorOptions, InMemoryDeadlineStore, type InMemoryDeadlineStoreOptions, InMemoryEventStore, type InMemoryEventStoreOptions, InMemoryIdempotencyStore, type InMemoryIdempotencyStoreOptions, InMemoryOutbox, type InMemoryOutboxOptions, InMemoryProjectionCheckpointStore, type InMemoryProjectionCheckpointStoreOptions, InMemorySnapshotStore, type InMemorySnapshotStoreOptions, type InMemoryTransaction, type InMemoryTransactionParticipant, InMemoryTransactionScope, InProcessEventBus, InfrastructureError, type IntegrationMessage, type IntegrationMessageContent, type IntegrationMessageMapper, type IntegrationMessageRelationships, InvalidCommandMessageError, InvalidEventStreamPageError, type InvalidEventStreamPageErrorOptions, InvalidFlushStatementError, type InvalidFlushStatementErrorOptions, InvalidIntegrationMessageError, InvalidRepositoryAdapterError, type InvalidRepositoryAdapterErrorOptions, type InvalidRepositoryAdapterReason, InvalidRepositoryDefinitionError, InvalidVersionError, type JsonObject, type JsonPrimitive, type JsonValue, type KitErrorCode, type KitErrorOptions, type MatchedRows, MisattributedEventError, MissingEntityIdError, MissingFoldError, MissingHandlerError, NestedUnitOfWorkError, type OnceOptions, type Outbox, OutboxDispatcher, type OutboxDispatcherObservers, type OutboxDispatcherOptions, type OutboxRecord, type OutboxSink, type OutboxWriter, type PendingDomainEvent, PendingEventBatchMismatchError, type PendingEventBatchMismatchErrorOptions, PendingEventLimitExceededError, type PendingEventLimitExceededErrorOptions, type PersistenceChanges, type PersistenceLifecycle, type PersistenceModel, type PhysicalRemovalRegistration, type PinTargetVersionOptions, type PinnedTargetVersion, type ProjectOptions, type Projection, type ProjectionBatchResult, type ProjectionCheckpoint, type ProjectionCheckpointStore, type ProjectionEventHandler, type ProjectionFromHandlersOptions, ProjectionGapError, type ProjectionHandlers, ProjectionIdentityViolationError, ProjectionOrderViolationError, type ProjectionPosition, ProjectionReceiptViolationError, Projector, type ProjectorOptions, PrototypePollutionError, type PublishAbortedReport, type PublishChainState, type PublishChainStore, PublishDepthExceededError, type PublishOptions, type PublishedCommand, type Query, QueryBus, type QueryBusOptions, type QueryHandler, type ReachableStreamPages, type ReadStreamOptions, type ReadStreamPagesOptions, ReentrantEventRecordingError, type ReentrantEventRecordingErrorOptions, ReplayRejectedError, type ReplayRejectedErrorOptions, ReplayTargetMismatchError, type ReplayTargetMismatchErrorOptions, type ReplayTargetMismatchReason, type ReplayableAggregate, type ReplayableStreamPages, type RepositoriesOf, type Repository, type RepositoryDefinition, type RepositoryDefinitionOptions, RepositoryErrorMappingFailedError, type RepositoryErrorMappingFailedErrorOptions, type RepositoryTracking, type RetryPolicy, RetryingTransactionScope, RollbackError, type RunOptions, type SharedDomainEventStampOptions, SnapshotCorruptedError, type SnapshotModel, SnapshotSchemaMismatchError, type SnapshotSchemaMismatchErrorOptions, type SnapshotStore, SnapshotTimeValidationError, SnapshotVersionNotRestoredError, type SnapshotVersionNotRestoredErrorOptions, Specification, type SpecificationComposite, StateStoredAggregate, type StateValidator, type StreamPages, type StreamReadResult, type SubscriptionThresholdReport, TransactionClosedError, type TransactionScope, type TransactionalOptions, UnitOfWork, type UnitOfWorkContext, type UnitOfWorkDeps, type UnitOfWorkIdentityMap, UnmanagedInstanceError, UnprojectableEventError, type UnreachableStreamPages, UnregisteredChangesError, type UnregisteredChangesErrorOptions, UnregisteredHandlerError, type UnregisteredHandlerErrorOptions, UnreplayableAggregateError, type UnreplayableAggregateErrorOptions, type UnstampedDomainEvent, type UnstampedDomainEventOf, ValueObject, type ValueObjectOf, type Version, type VersionedFlushStatements, type VersionedWrite, type WithCommitDeps, type WithCommitWorkResult, type WithIdempotentCommitDeps, captureAggregateSnapshot, classifyConcurrencyConflict, copyMetadata, copyPlainState, createDomainEvent, createDomainEventFactory, createIntegrationMessage, createStampedDomainEvent, decodeIntegrationMessage, deepEqual, deepFreeze, deepOmit, defaultDomainEventFactory, defineRepository, defineSnapshotModel, domainErrorToResult, encodeIntegrationMessage, entityIds, eventBusSink, findEntityById, hasEntityId, ignoreProjectionEvent, integrationMessageToCommittedEvent, isDomainErrorLike, isInfrastructureErrorLike, isPositionAfter, isWiringErrorLike, mergeMetadata, outboxWriterAcceptingEventLoss, pinTargetVersion, projectionFromHandlers, readStreamPages, reconstituteAggregateFromHistory, reconstituteAggregateFromSnapshot, reconstituteAggregateFromStreamPages, removeEntityById, replaceEntityById, routeEventsToCommandOutbox, sameEntity, sameVersion, specification, stampPendingEvents, toVersion, updateEntityById, valueObject, valueObjectEquals, valueObjectEqualsExcept, valueObjectOrError, valueObjectOrIssues, versionedFlush, withCommit, withIdempotentCommit };
+export { type AbsentStreamPages, type Aggregate, type AggregateClass, type AggregateCommitToken, type AggregateConfig, AggregateDeletedError, type AggregateDeletedErrorOptions, type AggregateIdentity, type AggregateIdentityMismatchOptions, AggregateNotFoundError, type AggregateNotFoundErrorOptions, type AggregatePersistence, type AggregatePersistenceWrite, type AggregateSnapshot, AggregateTrackingError, type AggregateTrackingErrorOptions, type AggregateTrackingReason, type AggregateWriteIntent, type AggregateWriteRegistration, type AnyDomainEvent, type AnyUnstampedDomainEvent, type AppendOnlyWriteRegistration, CapabilityRegistryConflictError, type ClassifyConcurrencyConflictOptions, type ClockFactory, type Command, CommandBus, type CommandBusOptions, type CommandCommitOriginCandidate, type CommandHandler, type CommandMessageContent, type CommandMessageRelationships, type CommandOutboxCommitCandidate, type CommandOutboxMapper, type CommandOutboxWriter, CommitError, type CommitPosition, type CommitRegistration, type CommitRegistrationOptions, type CommittedDomainEvent, type CompatibleRepositoryDefinitions, ConcurrencyConflictError, type ConcurrencyConflictErrorOptions, type ConcurrencyConflictReason, type CreateDomainEventOptions, type CreateDomainEventStampOptions, type CreateEventOptions, type CreateStampedDomainEventOptions, type DeadLetterDeadline, type DeadLetterRecord, DeadlineProcessor, type DeadlineProcessorObservers, type DeadlineProcessorOptions, type DeadlineStore, type DeepOmitKey, type DeepOmitOptions, type DeepOmitPathSegment, type DeliveryFailureAssessment, type DeliveryFailureClassifier, type DeliveryFailureKind, DirectStateMutationError, type DirectStateMutationErrorOptions, type DispatchTrackingOutbox, DomainError, type DomainErrorClass, type DomainEvent, type DomainEventFactory, type DomainEventFactoryOptions, type DomainEventStamp, type DomainEventStampFactory, type DomainEventStampProvider, type DomainEventValidationCode, DomainEventValidationError, type DomainEventValidationField, type DueDeadline, DuplicateAggregateError, type DuplicateAggregateErrorOptions, DuplicateEventIdError, type DuplicateEventIdErrorOptions, DuplicateHandlerRegistrationError, type DuplicateHandlerRegistrationErrorOptions, type DurableCommandMessage, Entity, type EntityConfig, ErrorMapperFailedError, type ErrorMapperFailedErrorOptions, type EventBus, EventBusClosedError, type EventBusObservers, type EventBusOptions, EventCollectionError, type EventCommitCandidate, type EventCommitCandidatePosition, type EventHandler, type EventIdFactory, type EventMetadata, EventSourcedAggregate, type EventStore, type EventStoreAppendOptions, type EventStreamPageReason, type EventStreamReader, type ExecutionContext, type FlushStatementReason, type Fold, FoldReturnedNoStateError, ForeignEventError, HandBuiltEventError, type HandlerFailureReport, type ICommandBus, type IEntity, type IQueryBus, type Id, type IdGenerator, type IdempotencyClaim, type IdempotencyClaimHandle, IdempotencyClaimLostError, type IdempotencyClaimLostErrorOptions, IdempotencyCompletionWithoutClaimError, IdempotencyInFlightError, type IdempotencyInFlightErrorOptions, IdempotencyKeyReuseError, type IdempotencyKeyReuseErrorOptions, type IdempotencyLease, type IdempotencyOperationErrorContext, type IdempotencyReconciliation, type IdempotencyReconciliationDecision, IdempotencyReconciliationRequiredError, type IdempotencyReconciliationRequiredErrorOptions, type IdempotencyStore, type IdempotentCommitRequest, type IdempotentCommitResult, type IdempotentExecution, type Identifiable, IdentityMap, InMemoryCapacityExceededError, type InMemoryCapacityExceededErrorOptions, InMemoryDeadlineStore, type InMemoryDeadlineStoreOptions, InMemoryEventStore, type InMemoryEventStoreOptions, InMemoryIdempotencyStore, type InMemoryIdempotencyStoreOptions, InMemoryOutbox, type InMemoryOutboxOptions, InMemoryProjectionCheckpointStore, type InMemoryProjectionCheckpointStoreOptions, InMemorySnapshotStore, type InMemorySnapshotStoreOptions, type InMemoryTransaction, type InMemoryTransactionParticipant, InMemoryTransactionScope, InProcessEventBus, InfrastructureError, type IntegrationMessage, type IntegrationMessageContent, type IntegrationMessageMapper, type IntegrationMessageRelationships, InvalidCommandMessageError, InvalidEventStreamPageError, type InvalidEventStreamPageErrorOptions, InvalidFlushStatementError, type InvalidFlushStatementErrorOptions, InvalidIntegrationMessageError, InvalidRepositoryAdapterError, type InvalidRepositoryAdapterErrorOptions, type InvalidRepositoryAdapterReason, InvalidRepositoryDefinitionError, InvalidVersionError, type JsonObject, type JsonPrimitive, type JsonValue, type KitErrorCode, type KitErrorOptions, type MatchedRows, MisattributedEventError, MissingEntityIdError, MissingFoldError, MissingHandlerError, NestedUnitOfWorkError, type OnceOptions, type Outbox, OutboxDispatcher, type OutboxDispatcherObservers, type OutboxDispatcherOptions, type OutboxRecord, type OutboxSink, type OutboxWriter, type PendingDomainEvent, PendingEventBatchMismatchError, type PendingEventBatchMismatchErrorOptions, PendingEventLimitExceededError, type PendingEventLimitExceededErrorOptions, type PersistenceChanges, type PersistenceLifecycle, type PersistenceModel, type PhysicalRemovalRegistration, type PinTargetVersionOptions, type PinnedTargetVersion, type ProjectOptions, type Projection, type ProjectionBatchResult, type ProjectionCheckpoint, type ProjectionCheckpointStore, type ProjectionEventHandler, type ProjectionFromHandlersOptions, ProjectionGapError, type ProjectionHandlers, ProjectionIdentityViolationError, ProjectionOrderViolationError, type ProjectionPosition, ProjectionReceiptViolationError, Projector, type ProjectorOptions, PrototypePollutionError, type PublishAbortedReport, type PublishChainState, type PublishChainStore, PublishDepthExceededError, type PublishOptions, type PublishedCommand, type Query, QueryBus, type QueryBusOptions, type QueryHandler, type ReachableStreamPages, type ReadStreamOptions, type ReadStreamPagesOptions, ReentrantEventRecordingError, type ReentrantEventRecordingErrorOptions, ReplayRejectedError, type ReplayRejectedErrorOptions, ReplayTargetMismatchError, type ReplayTargetMismatchErrorOptions, type ReplayTargetMismatchReason, type ReplayableAggregate, type ReplayableStreamPages, type RepositoriesOf, type Repository, type RepositoryDefinition, type RepositoryDefinitionOptions, RepositoryErrorMappingFailedError, type RepositoryErrorMappingFailedErrorOptions, type RepositoryTracking, type RetryPolicy, RetryingTransactionScope, RollbackError, type RunOptions, type SharedDomainEventStampOptions, SnapshotCorruptedError, type SnapshotModel, SnapshotSchemaMismatchError, type SnapshotSchemaMismatchErrorOptions, type SnapshotStore, SnapshotTimeValidationError, SnapshotVersionNotRestoredError, type SnapshotVersionNotRestoredErrorOptions, Specification, type SpecificationComposite, StateStoredAggregate, type StateValidator, type StreamPages, type StreamReadResult, type SubscriptionThresholdReport, TransactionClosedError, type TransactionScope, type TransactionalOptions, UnitOfWork, type UnitOfWorkContext, type UnitOfWorkDeps, type UnitOfWorkIdentityMap, UnmanagedInstanceError, UnprojectableEventError, type UnreachableStreamPages, UnregisteredChangesError, type UnregisteredChangesErrorOptions, UnregisteredHandlerError, type UnregisteredHandlerErrorOptions, UnreplayableAggregateError, type UnreplayableAggregateErrorOptions, type UnstampedDomainEvent, type UnstampedDomainEventOf, ValueObject, type ValueObjectOf, type Version, type VersionedFlushStatements, type VersionedWrite, type WithCommitDeps, type WithCommitWorkResult, type WithIdempotentCommitDeps, captureAggregateSnapshot, classifyConcurrencyConflict, copyMetadata, copyPlainState, createDomainEvent, createDomainEventFactory, createIntegrationMessage, createStampedDomainEvent, decodeIntegrationMessage, deepEqual, deepFreeze, deepOmit, defaultDomainEventFactory, defineRepository, defineSnapshotModel, domainErrorToResult, encodeIntegrationMessage, entityIds, eventBusSink, findEntityById, hasEntityId, ignoreProjectionEvent, integrationMessageToCommittedEvent, isDomainErrorLike, isInfrastructureErrorLike, isPositionAfter, isWiringErrorLike, mergeMetadata, outboxWriterAcceptingEventLoss, pinTargetVersion, projectionFromHandlers, readStreamPages, reconstituteAggregateFromHistory, reconstituteAggregateFromSnapshot, reconstituteAggregateFromStreamPages, removeEntityById, replaceEntityById, routeEventsToCommandOutbox, sameEntity, sameVersion, specification, stampPendingEvents, toVersion, updateEntityById, valueObject, valueObjectEquals, valueObjectEqualsExcept, valueObjectOrError, valueObjectOrIssues, versionedFlush, withCommit, withIdempotentCommit };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -404,6 +404,42 @@ function captureObserverFunctions(context, observers, required) {
 	return Object.freeze(captured);
 }
 
+//#endregion
+//#region src/domain/aggregate/pending-event-recording.ts
+const { registry: capabilities$1, require } = createGlobalCapabilityRegistry(Symbol.for("@shirudo/ddd-kit/pending-event-recording-registry/v2"));
+/** Resolves the recording capability or throws `UnmanagedInstanceError`. */
+function requirePendingEventRecordingCapability(aggregate, operation) {
+	return require(aggregate, operation, "aggregate");
+}
+function registerPendingEventRecordingCapability(aggregate, capability) {
+	capabilities$1.set(aggregate, Object.freeze(capability));
+}
+
+//#endregion
+//#region src/application/unit-of-work/stamp-pending-events.ts
+function stampPendingEvents(aggregate, source, stampOptions) {
+	return recordWith(requirePendingEventRecordingCapability(aggregate, "stampPendingEvents"), source, stampOptions);
+}
+/**
+* Stamps the pending events that are still unstamped when the commit
+* registers an aggregate. An aggregate whose pending events all carry a
+* stamp stays untouched: an explicit {@link stampPendingEvents} call keeps
+* its stamps, and an instance without the recording capability passes when
+* it has nothing to stamp.
+*/
+function stampAtRegistration(aggregate, factory, stampOptions, operation) {
+	if (aggregate.pendingEvents.every(isStampedDomainEvent)) return;
+	recordWith(requirePendingEventRecordingCapability(aggregate, operation), factory, stampOptions);
+}
+function recordWith(capability, source, stampOptions) {
+	const shared = {
+		occurredAt: stampOptions?.occurredAt,
+		metadata: stampOptions?.metadata
+	};
+	const createStamp = typeof source === "function" ? source : () => source.createStamp(shared);
+	return capability.record((event, index) => createStamp(event, index));
+}
+
 //#endregion
 //#region src/application/cqrs/handler.ts
 /**
@@ -417,7 +453,7 @@ function registrationDiverged(record) {
 	return record.aggregate.version !== record.version || pending.length !== record.events.length || record.events.some((event, index) => event !== pending[index]);
 }
 /** One token registry per transactional callback attempt. */
-function createCommitTokenScope() {
+function createCommitTokenScope(stamp) {
 	const recordsByToken = /* @__PURE__ */ new WeakMap();
 	const tokensByAggregate = /* @__PURE__ */ new WeakMap();
 	let issuedTokenCount = 0;
@@ -436,8 +472,8 @@ function createCommitTokenScope() {
 		}
 		const eventLifecycle = requirePendingEventLifecycleCapability(aggregate, "withCommit registration");
 		const token = Object.freeze(Object.create(null));
+		stamp(aggregate, "withCommit registration");
 		const events = aggregate.pendingEvents;
-		for (const event of events) if (!isStampedDomainEvent(event)) throw new EventCollectionError(`withCommit: event "${event.type}" has not been stamped. Call stampPendingEvents(aggregate, createStamp) in the application shell before persistence or outbox collection.`, event.type);
 		const persistedVersion = eventLifecycle.persistedVersion();
 		tokensByAggregate.set(aggregate, token);
 		recordsByToken.set(token, {
@@ -609,17 +645,21 @@ async function withCommit(deps, fn) {
 }
 /**
 * {@link withCommit} with a check per attempt before the commit. The scope
-* receives `onAttemptStart` in its transactional options.
+* receives `onAttemptStart` in its transactional options. The callback also
+* receives the stamping step of the registration, so that a caller that
+* records the batch before it registers can stamp first.
 */
 async function withCheckedCommit(deps, fn, onAttemptStart) {
 	const postCommitTimeoutMs = deps.postCommitTimeoutMs ?? 3e4;
 	assertTimerDelay("withCommit", "postCommitTimeoutMs", postCommitTimeoutMs);
 	if (deps.signal?.aborted) throw abortReason(deps.signal, "withCommit aborted before opening a transaction");
+	const eventStampFactory = deps.eventStampFactory ?? defaultDomainEventFactory;
+	const stamp = (aggregate, operation) => stampAtRegistration(aggregate, eventStampFactory, deps.stampOptions, operation);
 	const { result, commitRecords, events } = await deps.scope.transactional(async (ctx) => {
-		const tokenScope = createCommitTokenScope();
+		const tokenScope = createCommitTokenScope(stamp);
 		let fnResult;
 		try {
-			fnResult = await fn(ctx, tokenScope.registration);
+			fnResult = await fn(ctx, tokenScope.registration, stamp);
 		} finally {
 			tokenScope.close();
 		}
@@ -631,24 +671,22 @@ async function withCheckedCommit(deps, fn, onAttemptStart) {
 				const registeredId = registered.aggregateId;
 				const registeredType = registered.aggregateType;
 				return record.events.map((event, index) => {
-					if (!isStampedDomainEvent(event)) throw new EventCollectionError(`withCommit: event "${event.type}" has not been stamped. Call stampPendingEvents(aggregate, createStamp) in the application shell before persistence or outbox collection.`, event.type);
-					const recordedEvent = event;
 					const commitSize = record.events.length;
-					const aggregateId = recordedEvent.aggregateId;
-					const aggregateType = recordedEvent.aggregateType;
+					const aggregateId = event.aggregateId;
+					const aggregateType = event.aggregateType;
 					const missing = [];
 					if (!aggregateId) missing.push("aggregateId");
 					if (!aggregateType) missing.push("aggregateType");
-					if (!aggregateId || !aggregateType) throw new EventCollectionError(`withCommit: event "${recordedEvent.type}" is missing ${missing.join(" and ")}. Use this.createEvent(type, payload) inside aggregate methods instead of createDomainEvent(...); createEvent auto-injects aggregateId and aggregateType. Outbox dispatchers and projection handlers rely on the envelope source.`, recordedEvent.type);
-					if (aggregateId !== registeredId || aggregateType !== registeredType) throw new EventCollectionError(`withCommit: event "${recordedEvent.type}" belongs to ${describeAggregateIdentity({
+					if (!aggregateId || !aggregateType) throw new EventCollectionError(`withCommit: event "${event.type}" is missing ${missing.join(" and ")}. Use this.createEvent(type, payload) inside aggregate methods instead of createDomainEvent(...); createEvent auto-injects aggregateId and aggregateType. Outbox dispatchers and projection handlers rely on the envelope source.`, event.type);
+					if (aggregateId !== registeredId || aggregateType !== registeredType) throw new EventCollectionError(`withCommit: event "${event.type}" belongs to ${describeAggregateIdentity({
 						aggregateType,
 						aggregateId
 					})} but was registered under ${describeAggregateIdentity({
 						aggregateType: registeredType,
 						aggregateId: registeredId
-					})}. The aggregate base classes attribute every event to the aggregate on every recording path; an instance from another package copy must stamp it the same way.`, recordedEvent.type);
+					})}. The aggregate base classes attribute every event to the aggregate on every recording path; an instance from another package copy must stamp it the same way.`, event.type);
 					return Object.freeze({
-						event: recordedEvent,
+						event,
 						source: Object.freeze({
 							aggregateId,
 							aggregateType
@@ -1280,8 +1318,8 @@ var DeadlineProcessor = class extends PollLoop {
 		assertTimerDelay("DeadlineProcessor", "storageTimeoutMs", this.storageTimeoutMs);
 	}
 	/**
-	* One full delivery pass (the `run`/`drainOnce` shell lives on
-	* {@link PollLoop}): delivers due deadlines batch by batch until
+	* One full delivery pass (the `run`/`drainOnce` shell lives on the
+	* shared poll loop): delivers due deadlines batch by batch until
 	* nothing is due or a cycle contained a failure.
 	*/
 	async pass(signal) {
@@ -2599,29 +2637,6 @@ function wiringErrorInCauseChain(error) {
 	return findInCauseChain(error, (link) => isWiringErrorLike(link) ? link : void 0);
 }
 
-//#endregion
-//#region src/domain/aggregate/pending-event-recording.ts
-const { registry: capabilities$1, require } = createGlobalCapabilityRegistry(Symbol.for("@shirudo/ddd-kit/pending-event-recording-registry/v2"));
-/** Resolves the recording capability or throws `UnmanagedInstanceError`. */
-function requirePendingEventRecordingCapability(aggregate, operation) {
-	return require(aggregate, operation, "aggregate");
-}
-function registerPendingEventRecordingCapability(aggregate, capability) {
-	capabilities$1.set(aggregate, Object.freeze(capability));
-}
-
-//#endregion
-//#region src/application/unit-of-work/stamp-pending-events.ts
-function stampPendingEvents(aggregate, source, stampOptions) {
-	const capability = requirePendingEventRecordingCapability(aggregate, "stampPendingEvents");
-	const shared = {
-		occurredAt: stampOptions?.occurredAt,
-		metadata: stampOptions?.metadata
-	};
-	const createStamp = typeof source === "function" ? source : () => source.createStamp(shared);
-	return capability.record((event, index) => createStamp(event, index));
-}
-
 //#endregion
 //#region src/application/unit-of-work/repository-facade.ts
 /**
@@ -3078,6 +3093,7 @@ function capabilityFor(baseline, operation) {
 */
 var Session = class {
 	commitRegistration;
+	stamp;
 	_registeredWrites = [];
 	_commitTokens = /* @__PURE__ */ new Set();
 	_identityMap = new IdentityMap();
@@ -3100,8 +3116,9 @@ var Session = class {
 	*/
 	_lateRegistrationsFailAttempt = false;
 	_registrationDuringFlush;
-	constructor(commitRegistration) {
+	constructor(commitRegistration, stamp) {
 		this.commitRegistration = commitRegistration;
+		this.stamp = stamp;
 	}
 	get identityMap() {
 		this.assertOpen("tracking.identityMap");
@@ -3224,6 +3241,7 @@ var Session = class {
 	}
 	/** Registers persistence intent and commit registration as one operation. */
 	registerWrite(entry, intent, definition) {
+		if (entry.registration === void 0) this.stamp(entry.aggregate, `repository.${intent}`);
 		const newlyRegistered = this.registerIntent(entry, intent);
 		try {
 			if (intent === "remove") this.registerRemovedCommit(entry.aggregate, definition, entry.expectedVersion);
@@ -3622,10 +3640,12 @@ var UnitOfWork = class {
 				onPersisted: this.deps.onPersisted,
 				onPersistError: this.deps.onPersistError,
 				postCommitTimeoutMs: this.deps.postCommitTimeoutMs,
-				signal: options?.signal
-			}, async (tx, registration) => {
+				signal: options?.signal,
+				eventStampFactory: this.deps.eventStampFactory,
+				stampOptions: options?.stampOptions
+			}, async (tx, registration, stamp) => {
 				session?.close();
-				const s = new Session(registration);
+				const s = new Session(registration, stamp);
 				session = s;
 				sessions.push(s);
 				const current = startAttempt();
@@ -4449,8 +4469,8 @@ function entityIds(entities) {
 * tracking, the kit-internal post-commit acknowledgement capability,
 * the `markReconstituted` post-load marker, and the `createEvent` helper
 * that auto-injects `aggregateId` + `aggregateType` on every event the
-* aggregate emits. The application shell stamps the pending decisions
-* with `stampPendingEvents` before persistence.
+* aggregate emits. The commit stamps the pending decisions when it
+* registers the aggregate, before persistence.
 *
 * Consumers do NOT extend this class directly; extend
 * `StateStoredAggregate` for state-stored aggregates or
@@ -4768,8 +4788,8 @@ var BaseAggregate = class extends Entity {
 	* Creates the immutable business fact accepted by this aggregate without
 	* reading a clock, generating an id, or attaching tracing metadata.
 	*
-	* The application shell stamps pending events after the domain operation
-	* and before persistence. Payload schema version stays here, next to the
+	* The commit stamps pending events when it registers the aggregate,
+	* before persistence. Payload schema version stays here, next to the
 	* concrete event producer, rather than in shell-owned stamp data.
 	*/
 	createEvent(type, payload, options) {
@@ -5232,7 +5252,8 @@ var NotSpecification = class extends Specification {
 //#region src/domain/value-object/value-object-or-issues.ts
 /**
 * Builds an immutable value object while collecting **all** validation
-* violations into a single {@link ValidationError}, instead of failing on the
+* violations into a single `ValidationError` of `@shirudo/base-error`,
+* instead of failing on the
 * first one. This is the Result-first, multi-error counterpart to
 * `valueObjectOrError` (which returns a single string message).
 *
@@ -6663,8 +6684,8 @@ var OutboxDispatcher = class extends PollLoop {
 		assertTimerDelay("OutboxDispatcher", "storageTimeoutMs", this.storageTimeoutMs);
 	}
 	/**
-	* One full dispatch pass (the `run`/`drainOnce` shell lives on
-	* {@link PollLoop}): dispatches pending records batch by batch until
+	* One full dispatch pass (the `run`/`drainOnce` shell lives on the
+	* shared poll loop): dispatches pending records batch by batch until
 	* the backlog is empty or a failure stops progress. A `"stopped"`
 	* pass leaves the failed record pending (or dead-lettered by a
 	* tracking outbox); the next cycle retries it.
@@ -6765,7 +6786,10 @@ var OutboxDispatcher = class extends PollLoop {
 function copyForStorage(event, index, stream) {
 	const subject = `InMemoryEventStore.append (stream ${describeAggregateIdentity(stream)}): events[${index}]`;
 	if (event === null || typeof event !== "object") throw new TypeError(`${subject} is not an event object`);
-	return copyFreezableState(event, subject);
+	const copy = copyFreezableState(event, subject);
+	const eventId = copy.eventId;
+	if (typeof eventId !== "string" || eventId === "") throw new TypeError(`${subject} has no eventId. Stamp the event before the append: the commit stamps it when a write registers its aggregate, and stampPendingEvents stamps it before that.`);
+	return copy;
 }
 function assertStreamPosition(name, value) {
 	if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) throw new RangeError(`InMemoryEventStore: ${name} must be a non-negative safe integer, got ${String(value)}`);