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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-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 HostileStateKeyError, 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 UnenrolledChangesErrorOptions, a as AggregateNotFoundErrorOptions, at as ReentrantEventRecordingErrorOptions, b as ErrorMapperFailedErrorOptions, bt as UnprojectableEventError, c as ConcurrencyConflictErrorOptions, ct as ReplayTargetMismatchError, d as DirectStateMutationErrorOptions, dt as SnapshotCorruptedError, et as ProjectionGapError, f as DomainError, ft as SnapshotSchemaMismatchError, g as DuplicateEventIdErrorOptions, gt as UnenrolledChangesError, h as DuplicateEventIdError, ht as SnapshotVersionNotRestoredErrorOptions, i as AggregateNotFoundError, it as ReentrantEventRecordingError, j as IdempotencyKeyReuseError, k as IdempotencyInFlightError, l as ConcurrencyConflictReason, lt as ReplayTargetMismatchErrorOptions, m as DuplicateAggregateErrorOptions, mt as SnapshotVersionNotRestoredError, n as AggregateDeletedErrorOptions, nt as ProjectionOrderViolationError, o as CapabilityRegistryConflictError, ot as ReplayRejectedError, p as DuplicateAggregateError, pt as SnapshotSchemaMismatchErrorOptions, q as MissingEntityIdError, r as AggregateIdentityMismatchOptions, rt as ProjectionReceiptViolationError, s as ConcurrencyConflictError, st as ReplayRejectedErrorOptions, t as AggregateDeletedError, tt as ProjectionIdentityViolationError, u as DirectStateMutationError, ut as ReplayTargetMismatchReason, v as DuplicateHandlerRegistrationErrorOptions, vt as UnmanagedInstanceError, w as ForeignEventError, wt as UnreplayableAggregateErrorOptions, x as EventHarvestError, xt as UnregisteredHandlerError, y as ErrorMapperFailedError, yt as UnmintedEventError, z as InvalidEventStreamPageError } from "./chunks/kit-errors.js";
-import { $ as EventHandler, $t as Command, A as IdempotencyClaimHandle, At as CreateDomainEventFromFactsOptions, B as withIdempotentCommit, Bt as PendingDomainEvent, C as IdentityMap, Ct as ExecutionContext, D as ProjectionPosition, Dt as EventCommitCandidatePosition, E as ProjectionCheckpointStore, Et as EventCommitCandidate, F as IdempotencyStore, Ft as DomainEventFactory, G as CommitEnrollment, Gt as createDomainEventFactory, H as DeadlineStore, Ht as UncommittedDomainEventOf, I as IdempotentCommitRequest, It as DomainEventFactoryOptions, J as WithCommitWorkResult, Jt as defaultDomainEventFactory, K as CommitEnrollmentOptions, Kt as createDomainEventFromFacts, L as IdempotentCommitResult, Lt as DomainEventStamp, M as IdempotencyOperationErrorContext, Mt as CreateDomainEventStampOptions, N as IdempotencyReconciliation, Nt as CreateUncommittedDomainEventOptions, O as isPositionAfter, Ot as AnyDomainEvent, P as IdempotencyReconciliationDecision, Pt as DomainEvent, Q as EventBus, Qt as AggregateIdentity, R as IdempotentExecution, Rt as EventIdFactory, S as AggregateClass, St as OutboxWriter, T as ProjectionCheckpoint, Tt as CommittedDomainEvent, U as DueDeadline, Ut as copyMetadata, V as DeadLetterDeadline, Vt as UncommittedDomainEvent, W as AggregateCommitToken, Wt as createDomainEvent, X as TransactionScope, Xt as recordDomainEvent, Y as withCommit, Yt as mergeMetadata, Z as TransactionalOptions, Zt as ClockFactory, _ as capturePersistenceBaseline, _t as routeEventsToCommandOutbox, a as EventStoreAppendOptions, at as Version, b as persistenceProjectionDrifted, bt as Outbox, c as StreamReadResult, ct as Id, d as RepositoryTracking, dt as CommandMessageContent, en as CommandHandler, et as OnceOptions, f as UnitOfWorkIdentityMap, ft as CommandMessageRelationships, g as PersistenceModel, gt as DurableCommandMessage, h as PersistenceLifecycle, ht as CommandOutboxWriter, i as EventStore, in as JsonValue, it as ReplayableAggregate, j as IdempotencyLease, jt as CreateDomainEventOptions, k as IdempotencyClaim, kt as AnyUncommittedDomainEvent, l as AggregatePersistenceWrite, lt as IdGenerator, m as PersistenceChanges, mt as CommandOutboxMapper, n as ReplayableStreamPages, nn as JsonObject, nt as Aggregate, o as EventStreamReader, ot as sameVersion, p as PersistenceBaseline, pt as CommandOutboxCommitCandidate, q as WithCommitDeps, qt as createUncommittedDomainEvent, r as reconstituteAggregateFromStreamPages, rn as JsonPrimitive, rt as AggregateSnapshot, s as ReadStreamOptions, st as toVersion, t as SnapshotStore, tn as PublishedCommand, tt as PublishOptions, u as AggregateWriteIntent, ut as CommandCommitOriginCandidate, v as derivePersistenceChanges, vt as DeadLetterRecord, w as Projection, wt as CommitPosition, x as recapturePersistenceBaseline, xt as OutboxRecord, y as insertPersistenceBaseline, yt as DispatchTrackingOutbox, z as WithIdempotentCommitDeps, zt as EventMetadata } from "./chunks/snapshot-store.js";
+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 PublishOptions, $t as JsonPrimitive, A as IdempotentCommitRequest, At as CreateStampedDomainEventOptions, 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 CreateUnstampedDomainEventOptions, 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
@@ -788,7 +788,7 @@ interface InMemoryIdempotencyStoreOptions {
  *
  * On its own, the store is the reference for the leased family: it cannot
  * see commits or rollbacks. Claims and staged outcomes carry bounded leases,
- * while every mutation compares the store-minted token. An expired pending
+ * while every mutation compares the store-issued token. An expired pending
  * claim may be replaced; an expired staged outcome cannot be guessed away and
  * instead returns `reconciliation-required`. Only an authoritative
  * `committed` / `not-committed` decision can settle it.
@@ -1532,10 +1532,10 @@ interface AggregateTrackingErrorOptions {
  * A `CommitError` is the **potentially transient** post-completion
  * failure (a commit-time serialization failure is the classic case), so
  * it is the one a retrying caller should consider re-running. The
- * deterministic post-completion failure, a harvest-guard violation (an
+ * deterministic post-completion failure, a collection-guard violation (an
  * event missing `aggregateId` / `aggregateType`, or an eventful persisted
  * aggregate that did not advance its version), is a programming bug and surfaces as
- * {@link EventHarvestError} instead, which does NOT extend
+ * {@link EventCollectionError} instead, which does NOT extend
  * `InfrastructureError`, so it stays out of retry paths by construction.
  */
 declare class CommitError extends InfrastructureError<"COMMIT_FAILED"> {
@@ -1563,37 +1563,6 @@ declare class RollbackError extends InfrastructureError<"ROLLBACK_FAILED"> {
   constructor(cause: unknown, rollbackCause: unknown);
 }
 //#endregion
-//#region src/application/unit-of-work/record-pending-events.d.ts
-/** Minimal shell role accepted by {@link recordPendingEvents}. */
-type DomainEventStampFactory = Pick<DomainEventFactory, "createStamp">;
-/** Per-decision stamp provider for metadata that depends on the event. */
-type DomainEventStampProvider<TEvent extends AnyDomainEvent> = (event: UncommittedDomainEventOf<TEvent>, index: number) => DomainEventStamp;
-/**
- * Stamp options that every decision of one recording shares: a recording time
- * and metadata such as the correlation id of the request. An `eventId` is per
- * fact, so the factory mints 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 unrecorded. 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 recording 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 recordPendingEvents<TId extends Id<string>, TEvent extends AnyDomainEvent>(aggregate: Aggregate<TId, TEvent>, factory: DomainEventStampFactory, stampOptions?: SharedDomainEventStampOptions): ReadonlyArray<TEvent>;
-declare function recordPendingEvents<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 +1593,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}. */
@@ -1635,7 +1609,7 @@ interface RepositoryDefinitionOptions<TCtx, TRepositoryPort extends object, TAgg
    * reach; the static factories stay the only door.
    */
   readonly aggregate: AggregateClass<TAggregate>;
-  /** Adapter-owned projection, baseline, and change-set policy. */
+  /** Adapter-owned capture, baseline, and change-set policy. */
   readonly persistence: PersistenceModel<TAggregate, TBaseline, TChangeSet>;
   /**
    * Creates the transaction-bound adapter for the port's non-lifecycle
@@ -1832,6 +1806,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>;
 }
 /**
@@ -1840,7 +1820,7 @@ interface UnitOfWorkDeps<Evt extends AnyDomainEvent, TCtx, TDefinitions extends
  * transaction and either persist completely or not at all.
  *
  * Built ON TOP of `withCommit` - the commit orchestration (event
- * harvest into the outbox inside the transaction, internal acknowledgement
+ * collection into the outbox inside the transaction, internal acknowledgement
  * after the commit, best-effort in-process publish last) is inherited,
  * not reimplemented. What this layer adds:
  *
@@ -1906,7 +1886,7 @@ declare class UnitOfWork<Evt extends AnyDomainEvent, TCtx, TDefinitions extends
    * Execute one unit of work: open the transaction, hand the callback
    * tx-bound repositories, commit on resolve, roll back on throw,
    * run the post-commit lifecycle (acknowledge, observe, publish) for every
-   * enrolled aggregate. Returns the callback's result.
+   * registered aggregate. Returns the callback's result.
    */
   run<R>(work: (context: UnitOfWorkContext<RepositoriesOf<TDefinitions>>) => Promise<R>, options?: RunOptions): Promise<R>;
   private buildRepositories;
@@ -2156,7 +2136,7 @@ declare abstract class Entity<TState, TId extends Id<string>> implements IEntity
    * `TState` publicly would expose the aggregate's live object graph and
    * let nested mutation bypass behavior, validation, versioning, and
    * dirty tracking. Concrete entities should expose business-meaningful queries or
-   * detached immutable DTOs (`deepFreeze(detachState(this.state))` for a
+   * immutable DTOs (`deepFreeze(copyPlainState(this.state))` for a
    * plain-data state). Snapshot projection belongs to the persistence
    * adapter, which captures the aggregate from outside through those
    * queries and DTOs rather than asking the entity to create its own
@@ -2189,7 +2169,7 @@ declare abstract class Entity<TState, TId extends Id<string>> implements IEntity
    * widens to the whole graph: NESTED objects are frozen in place too.
    *
    * @throws MissingEntityIdError when `id` is not a non-blank string.
-   * @throws HostileStateKeyError when a plain-object, null-prototype,
+   * @throws PrototypePollutionError when a plain-object, null-prototype,
    * or array state carries an own `"__proto__"` data key; validate and
    * strip untrusted input at the boundary.
    */
@@ -2205,23 +2185,11 @@ declare abstract class Entity<TState, TId extends Id<string>> implements IEntity
    * ownership transfer and is frozen in place; see the constructor.
    *
    * @param newState - The new state
-   * @throws HostileStateKeyError when the state carries an own
+   * @throws PrototypePollutionError when the state carries an own
    * `"__proto__"` data key; the previous state is kept.
    */
   protected setState(newState: TState): void;
 }
-/**
- * Shallow-freezes `value` when it's a non-null object or array, so that
- * direct property writes throw in strict mode. Returns the value as-is for
- * primitives. `Entity` picks this or {@link deepFreeze} per the
- * `deepFreezeState` config, so state read through the `state` getter
- * cannot be mutated from outside, without a deep clone on every read.
- *
- * Subclass code stores state through `setState`, which freezes by the
- * configured mode. The export remains for consumers using it as a
- * standalone utility.
- */
-declare function freezeShallow<T>(value: T): T;
 /**
  * Checks if two entities have the same ID.
  * Works with any object that has an 'id' property.
@@ -2303,7 +2271,7 @@ declare function removeEntityById<TId extends Id<string>, T extends Identifiable
 /**
  * Updates an entity with the given ID in the collection.
  * Returns a new array with the updated entity.
- * Structural sharing for adapter-owned persistence projections: returns
+ * Structural sharing for adapter-owned persistence captures: returns
  * the ORIGINAL array when nothing changed (no match, or the element kept
  * its reference), so a partial-write adapter can skip the untouched
  * collection; a new array only when an
@@ -2333,7 +2301,7 @@ declare function updateEntityById<TId extends Id<string>, T extends Identifiable
 /**
  * Replaces an entity with the given ID in the collection.
  * Returns a new array with the replaced entity.
- * Structural sharing for adapter-owned persistence projections: returns
+ * Structural sharing for adapter-owned persistence captures: returns
  * the ORIGINAL array when nothing changed (no match, or the element kept
  * its reference), so a partial-write adapter can skip the untouched
  * collection; a new array only when an
@@ -2400,8 +2368,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 records the pending decisions
- * with `recordPendingEvents` 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
@@ -2459,22 +2427,22 @@ declare abstract class BaseAggregate<TState, TId extends Id<string>, TEvent exte
   private readonly _maxPendingEvents;
   protected constructor(id: TId, initialState: TState, config?: AggregateConfig<TState>);
   /**
-   * Stamps every uncommitted decision in the pending list with identity
-   * and time from `createStamp`, passes an already recorded event through,
+   * Stamps every unstamped decision in the pending list with identity
+   * and time from `createStamp`, passes an already stamped event through,
    * and replaces the list atomically. Three guards run before the
-   * assignment: an event that no kit constructor minted is rejected
-   * ({@link UnmintedEventError}); a stamp provider that recorded a new
+   * assignment: an event that no kit constructor built is rejected
+   * ({@link HandBuiltEventError}); a stamp provider that recorded a new
    * decision on this aggregate mid-map is rejected
    * ({@link ReentrantEventRecordingError}); and two decisions that
    * received one eventId are rejected ({@link DuplicateEventIdError}).
-   * When a guard fires, every decision stays unrecorded.
+   * When a guard fires, every decision stays unstamped.
    */
   private recordPendingDecisions;
   private acknowledgePendingEvents;
   /**
    * Post-commit cleanup for the deleted disposition. The row is gone, so
    * there is no persisted version to advance: stamping the marker from the
-   * live instance would make a later legitimate re-enrollment of this
+   * live instance would make a later legitimate re-registration of this
    * instance trip the unique-cursor guard for a row that does not exist.
    */
   private discardPendingEventsAfterDeletion;
@@ -2536,12 +2504,12 @@ declare abstract class BaseAggregate<TState, TId extends Id<string>, TEvent exte
    */
   protected markReconstituted(version: Version): void;
   /**
-   * Appends a domain event to the pending list. The event must be minted
+   * Appends a domain event to the pending list. The event must be kit-built
    * by a kit constructor; a missing `aggregateId` or `aggregateType` is
    * stamped from this aggregate, and an aggregate identity that names another
    * aggregate throws {@link MisattributedEventError} before anything is
    * recorded. Each append is one fact. A decision appended twice becomes
-   * two facts with distinct ids. A recorded event that is already pending
+   * two facts with distinct ids. A stamped event that is already pending
    * throws {@link DuplicateEventIdError}, and a list at `maxPendingEvents`
    * throws {@link PendingEventLimitExceededError}, before anything is
    * recorded. Prefer the higher-level `StateStoredAggregate.setState()`
@@ -2556,7 +2524,7 @@ declare abstract class BaseAggregate<TState, TId extends Id<string>, TEvent exte
   protected addDomainEvent(event: PendingDomainEvent<TEvent>): void;
   /**
    * One identity per fact, checked before the change becomes observable:
-   * a recorded event whose `eventId` is already pending, or appears twice
+   * a stamped event whose `eventId` is already pending, or appears twice
    * in one batch, throws {@link DuplicateEventIdError}. A decision has no
    * `eventId` yet, so a stamp provider that reuses one is caught at
    * recording instead.
@@ -2571,7 +2539,7 @@ declare abstract class BaseAggregate<TState, TId extends Id<string>, TEvent exte
   protected assertPendingEventLimit(added: number): void;
   /**
    * Appends an event that the caller already passed through
-   * {@link stampNewEventIdentity}, {@link assertEventIdsNotPending} and
+   * {@link attributeNewEvent}, {@link assertEventIdsNotPending} and
    * {@link assertPendingEventLimit}. `setState()` and `apply()` run the
    * three before the state moves and append afterwards, so each gate
    * runs once per event.
@@ -2588,35 +2556,34 @@ declare abstract class BaseAggregate<TState, TId extends Id<string>, TEvent exte
    * present-but-foreign `aggregateId` / `aggregateType` is a wiring bug and
    * throws {@link MisattributedEventError}; missing fields are filled in
    * from the aggregate, so a recorded event always carries its full
-   * aggregate identity and can never fail the harvest or the replay guard
-   * later. The mint gate
-   * runs first, so an unminted event fails before anything else. The
+   * aggregate identity and can never fail the collection or the replay guard
+   * later. The kit-built check
+   * runs first, so a hand-built event fails before anything else. The
    * stamped copy is frozen like the original (payload and metadata are
    * shared, already deep-frozen by the constructors); a fully stamped
    * event is returned as is.
    */
-  protected stampNewEventIdentity<E extends PendingDomainEvent<TEvent>>(event: E): E;
+  protected attributeNewEvent<E extends PendingDomainEvent<TEvent>>(event: E): E;
   /**
-   * Mint gate for every recording path: only an event that a kit
-   * constructor produced passes. The kit marks two shapes: a recorded
-   * event carries the recorded brand (`createDomainEvent`,
-   * `createDomainEventFromFacts`) and a decision carries the uncommitted
-   * brand (`createUncommittedDomainEvent`, the aggregate `createEvent`
-   * helper). Either brand implies deeply frozen with defensively copied
+   * Kit-built check for every recording path: only an event that a kit
+   * constructor produced passes. The kit marks two shapes: a stamped
+   * event carries the stamped brand (`createDomainEvent`,
+   * `createStampedDomainEvent`) and a decision carries the unstamped
+   * brand (the aggregate `createEvent` helper). Either brand implies deeply frozen with defensively copied
    * payload and metadata, a guarantee no frozen-ness probe can establish
    * (a shallow-frozen literal with mutable nested data would fool it).
    * O(1): one brand check per shape.
    */
-  protected assertMintedEvent(event: PendingDomainEvent<TEvent>): void;
+  protected assertKitBuiltEvent(event: PendingDomainEvent<TEvent>): void;
   /**
    * Creates the immutable business fact accepted by this aggregate without
    * reading a clock, generating an id, or attaching tracing metadata.
    *
-   * The application shell records pending events after the domain operation
-   * and before persistence. Payload schema version stays here, next to the
-   * concrete event producer, rather than in shell-owned recording data.
+   * 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<CreateUncommittedDomainEventOptions, "aggregateId" | "aggregateType">): UncommittedDomainEventOf<E>;
+  protected createEvent<E extends TEvent>(type: E["type"], payload: E["payload"], options?: Omit<CreateUnstampedDomainEventOptions, "aggregateId" | "aggregateType">): UnstampedDomainEventOf<E>;
 }
 //#endregion
 //#region src/domain/aggregate/event-sourced-aggregate.d.ts
@@ -2699,7 +2666,7 @@ declare abstract class EventSourcedAggregate<TState, TId extends Id<string>, TEv
    * the read boundary (see the event-upcasting guide) so the folds
    * always receive the current event shape.
    */
-  protected validateEvent(_event: UncommittedDomainEventOf<TEvent>): void;
+  protected validateEvent(_event: UnstampedDomainEventOf<TEvent>): void;
   /**
    * Always throws {@link DirectStateMutationError}. An event-sourced
    * aggregate changes state only through `apply()`, where the fact is
@@ -2760,7 +2727,7 @@ declare abstract class EventSourcedAggregate<TState, TId extends Id<string>, TEv
    * stream corruption) after the all-or-nothing rollback. History
    * events without the optional aggregate identity fields pass unchecked (the
    * fields are optional on the event shape); NEW events are covered
-   * by the stricter `stampNewEventIdentity` on the apply path.
+   * by the stricter `attributeNewEvent` on the apply path.
    */
   private assertReplayedEventBelongsHere;
   private fold;
@@ -2801,16 +2768,16 @@ declare abstract class EventSourcedAggregate<TState, TId extends Id<string>, TEv
    * state as `null` or as a status field, never as `undefined`.
    *
    * A fold MUST derive state from `type` and `payload` only. The
-   * parameter is typed as the uncommitted shape because a live `apply()`
-   * folds the event BEFORE the shell records it: `eventId` and
-   * `occurredAt` do not exist yet. Replay folds recorded events
+   * parameter is typed as the unstamped shape because a live `apply()`
+   * folds the event BEFORE the shell stamps it: `eventId` and
+   * `occurredAt` do not exist yet. Replay folds stamped events
    * through the same map, so those fields ARE present at runtime
    * there. A fold that reads them through an escape hatch (`as any`,
    * plain JavaScript) sees `undefined` live and a value on replay,
    * 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, UncommittedDomainEventOf<Extract<TEvent, {
+  protected abstract readonly folds: { [K in TEvent["type"]]: Fold<TState, UnstampedDomainEventOf<Extract<TEvent, {
     type: K;
   }>>>; };
 }
@@ -2833,13 +2800,13 @@ declare function reconstituteAggregateFromHistory<TAggregate extends ReplayableA
  * The aggregate owns identity, valid domain state, behavior, its current
  * domain version, and pending domain events. It deliberately does not own a
  * database baseline or dirty-key bookkeeping. A repository adapter defines
- * its own persistence projection; the application shell retains that opaque
+ * its own persistence capture; the application shell retains that opaque
  * baseline and derives the adapter's change set at flush.
  */
 declare abstract class StateStoredAggregate<TState, TId extends Id<string>, TEvent extends AnyDomainEvent = never> extends BaseAggregate<TState, TId, TEvent> {
   /**
    * Replaces the state, advances the OCC version, and records the events
-   * of the change, in that order. State validation, the event mint gate,
+   * of the change, in that order. State validation, the kit-built check,
    * the aggregate identity check of the event, the pending event-id check,
    * and the pending event limit check run before the change becomes
    * observable, so a rejected decision records nothing and moves nothing.
@@ -2982,230 +2949,6 @@ declare abstract class Specification<T> {
  */
 declare function specification<T>(name: string, predicate: (candidate: T) => boolean): Specification<T>;
 //#endregion
-//#region src/domain/state-machine/contracts.d.ts
-/** Base shape for every input accepted by a domain state machine. */
-type DomainMachineInput = {
-  readonly type: string;
-};
-/** Recursively readonly view of data accepted by the domain state machine. */
-type DomainMachineReadonly<TValue> = TValue extends bigint | boolean | null | number | string | symbol | undefined ? TValue : TValue extends ((...args: never[]) => unknown) ? TValue : TValue extends readonly unknown[] ? { readonly [TKey in keyof TValue]: DomainMachineReadonly<TValue[TKey]>; } : TValue extends object ? { readonly [TKey in keyof TValue]: DomainMachineReadonly<TValue[TKey]>; } : TValue;
-/** Immutable state and context value suitable for persistence. */
-type DomainMachineSnapshot<TState extends string, TContext> = {
-  readonly state: TState;
-  readonly context: DomainMachineReadonly<TContext>;
-};
-/** Optional context replacement and requested external work from a reducer. */
-type DomainTransitionResult<TContext, TOutput> = {
-  readonly context?: TContext;
-  readonly outputs?: readonly TOutput[];
-};
-/** A guard either allows, generically rejects, or returns a domain-specific rejection. */
-type DomainTransitionGuardResult = boolean | DomainError;
-/** A guarded state change and its optional pure context reducer. */
-type DomainTransition<TState extends string, TContext, TInput extends DomainMachineInput, TOutput, TSource extends TState = TState> = {
-  readonly target: TState;
-  /**
-   * Must be synchronous, deterministic, and side-effect-free. Return a
-   * `DomainError` to provide a typed rejection that `can()` treats as false and
-   * `dispatch()` throws unchanged.
-   */
-  readonly guard?: (input: {
-    readonly state: TSource;
-    readonly context: DomainMachineReadonly<TContext>;
-    readonly input: DomainMachineReadonly<TInput>;
-  }) => DomainTransitionGuardResult;
-  /** Must be synchronous, deterministic, and side-effect-free. */
-  readonly reduce?: (input: {
-    readonly state: TSource;
-    readonly context: DomainMachineReadonly<TContext>;
-    readonly input: DomainMachineReadonly<TInput>;
-  }) => DomainTransitionResult<TContext, TOutput> | undefined;
-};
-/** Configuration for one named control state. */
-type DomainStateNode<TState extends string, TContext, TInput extends DomainMachineInput, TOutput, TName extends TState = TState> = {
-  readonly terminal?: boolean;
-  /** State-specific context invariant. Must be synchronous, deterministic, and side-effect-free. */
-  readonly validateContext?: (input: {
-    readonly state: TName;
-    readonly context: DomainMachineReadonly<TContext>;
-  }) => boolean;
-  readonly on?: { readonly [TType in TInput["type"]]?: DomainTransition<TState, TContext, Extract<TInput, {
-    readonly type: TType;
-  }>, TOutput, TName>; };
-};
-/** Complete, finite domain lifecycle definition. */
-type DomainMachineDefinition<TState extends string, TContext, TInput extends DomainMachineInput, TOutput = never> = {
-  readonly initial: TState;
-  readonly initialContext: () => TContext;
-  /** Must be synchronous, deterministic, and side-effect-free. */
-  readonly validateSnapshot?: (snapshot: DomainMachineSnapshot<TState, TContext>) => boolean;
-  readonly states: { readonly [TName in TState]: DomainStateNode<TState, TContext, TInput, TOutput, TName>; };
-};
-/** Result of a successful transition. */
-type DomainTransitionOutcome<TState extends string, TContext, TOutput> = {
-  readonly from: TState;
-  readonly to: TState;
-  readonly snapshot: DomainMachineSnapshot<TState, TContext>;
-  readonly outputs: readonly DomainMachineReadonly<TOutput>[];
-};
-//#endregion
-//#region src/domain/state-machine/analyzer.d.ts
-type DomainMachineDefinitionDiagnostic<TState extends string> = {
-  readonly code: "unreachable-state";
-  readonly state: TState;
-} | {
-  readonly code: "structural-dead-end";
-  readonly state: TState;
-} | {
-  readonly code: "no-terminal-path";
-  readonly state: TState;
-};
-type DomainMachineTransitionDescription<TState extends string, TInputType extends string> = {
-  readonly state: TState;
-  readonly inputType: TInputType;
-  readonly target: TState;
-  readonly guarded: boolean;
-};
-type DomainMachineDefinitionAnalysis<TState extends string, TInputType extends string> = {
-  readonly diagnostics: readonly DomainMachineDefinitionDiagnostic<TState>[];
-  readonly transitions: readonly DomainMachineTransitionDescription<TState, TInputType>[];
-  /** States reachable when every guard is assumed to allow its transition. */
-  readonly structurallyReachableStates: readonly TState[];
-  /** States with a graph path to a terminal state when every guard is assumed to allow it. */
-  readonly statesWithTerminalPath: readonly TState[];
-};
-/**
- * Inspects the declarative transition graph without executing definition callbacks.
- * Guarded edges are treated as possible edges, so diagnostics never claim more
- * runtime reachability than the static graph can prove.
- */
-declare function analyzeDomainMachineDefinition<TState extends string, TContext, TInput extends DomainMachineInput, TOutput>(definition: DomainMachineDefinition<TState, TContext, TInput, TOutput>): DomainMachineDefinitionAnalysis<TState, TInput["type"]>;
-//#endregion
-//#region src/domain/state-machine/definition.d.ts
-declare const preparedDefinitionBrand: unique symbol;
-/**
- * A machine definition that `prepareDomainMachineDefinition` has
- * validated, defensively copied, and deeply frozen. Assignable wherever
- * a plain `DomainMachineDefinition` is accepted; the reverse does NOT
- * hold (the brand is required), so an API that demands a prepared
- * definition rejects raw ones at compile time. The pure functions and
- * the `DomainStateMachine` constructor recognize prepared definitions
- * at runtime and skip their per-call validate-and-copy.
- */
-type PreparedDomainMachineDefinition<TState extends string, TContext, TInput extends DomainMachineInput, TOutput = never> = DomainMachineDefinition<TState, TContext, TInput, TOutput> & {
-  readonly [preparedDefinitionBrand]: true;
-};
-/**
- * Validates and stabilizes a machine definition ONCE, for repeated use
- * with the pure functions. Without it, `transitionDomainState` and
- * `canTransitionDomainState` re-validate and defensively re-copy the
- * WHOLE definition on every call (the documented safety of the raw
- * path); on a hot dispatch path that is avoidable O(definition) work.
- * The `DomainStateMachine` class does the equivalent once in its
- * constructor; this export brings the same amortization to pure-API
- * users:
- *
- * ```ts
- * const prepared = prepareDomainMachineDefinition(orderLifecycle);
- * // per dispatch: no re-validation, no definition copy
- * const outcome = transitionDomainState(prepared, snapshot, input);
- * ```
- *
- * The returned definition is a deeply frozen copy, isolated from later
- * mutation of the input object. Preparing an already-prepared
- * definition returns it unchanged.
- */
-declare function prepareDomainMachineDefinition<TState extends string, TContext, TInput extends DomainMachineInput, TOutput>(definition: DomainMachineDefinition<TState, TContext, TInput, TOutput>): PreparedDomainMachineDefinition<TState, TContext, TInput, TOutput>;
-//#endregion
-//#region src/domain/state-machine/errors.d.ts
-/** No transition is defined for the input in the current state. */
-declare class InvalidDomainTransitionError extends DomainError<"INVALID_DOMAIN_TRANSITION"> {
-  readonly state: string;
-  readonly inputType: string;
-  constructor(state: string, inputType: string);
-}
-/** A defined transition was rejected by its domain guard. */
-declare class DomainTransitionGuardRejectedError extends DomainError<"DOMAIN_TRANSITION_GUARD_REJECTED"> {
-  readonly state: string;
-  readonly inputType: string;
-  constructor(state: string, inputType: string);
-}
-/** The machine definition violates its runtime contract. */
-declare class InvalidDomainMachineDefinitionError extends KitWiringError<"INVALID_DOMAIN_MACHINE_DEFINITION"> {
-  constructor(message: string, cause?: unknown);
-}
-/** Context contains unsupported or unsafe runtime data. */
-declare class InvalidDomainMachineContextError extends KitWiringError<"INVALID_DOMAIN_MACHINE_CONTEXT"> {
-  constructor(message: string, cause?: unknown);
-}
-/** A supplied or produced snapshot is malformed or violates invariants. */
-declare class InvalidDomainMachineSnapshotError extends KitWiringError<"INVALID_DOMAIN_MACHINE_SNAPSHOT"> {
-  constructor(message: string, cause?: unknown);
-}
-/** An input is malformed or contains unsupported runtime data. */
-declare class InvalidDomainMachineInputError extends KitWiringError<"INVALID_DOMAIN_MACHINE_INPUT"> {
-  constructor(message: string, cause?: unknown);
-}
-/** A guard returned a value other than `boolean` or `DomainError`. */
-declare class InvalidDomainTransitionGuardResultError extends KitWiringError<"INVALID_DOMAIN_TRANSITION_GUARD_RESULT"> {
-  constructor(message: string, cause?: unknown);
-}
-/** A reducer returned a malformed result or unsupported output data. */
-declare class InvalidDomainTransitionResultError extends KitWiringError<"INVALID_DOMAIN_TRANSITION_RESULT"> {
-  constructor(message: string, cause?: unknown);
-}
-/** A callback attempted to evaluate the same stateful machine recursively. */
-declare class ReentrantDomainStateMachineEvaluationError extends KitWiringError<"REENTRANT_DOMAIN_STATE_MACHINE_EVALUATION"> {
-  constructor();
-}
-//#endregion
-//#region src/domain/state-machine/transition.d.ts
-/** Creates and validates a fresh initial snapshot from a machine definition. */
-declare function createInitialDomainMachineSnapshot<TState extends string, TContext, TInput extends DomainMachineInput, TOutput>(definition: DomainMachineDefinition<TState, TContext, TInput, TOutput>): DomainMachineSnapshot<TState, TContext>;
-/**
- * Checks whether an input currently has an allowed transition.
- *
- * Returns `false` for missing transitions, terminal states, rejected guards,
- * and inputs without an own string `type` property. Invalid payload data for a
- * matching transition and broken guard code still throw structured errors.
- */
-declare function canTransitionDomainState<TState extends string, TContext, TInput extends DomainMachineInput, TOutput>(definition: DomainMachineDefinition<TState, TContext, TInput, TOutput>, snapshot: DomainMachineSnapshot<TState, TContext>, input: TInput): boolean;
-/**
- * Applies one input without mutating the input definition or snapshot.
- *
- * @throws {@link InvalidDomainTransitionError} when no transition is defined.
- * @throws {@link DomainTransitionGuardRejectedError} when its guard rejects.
- * @throws A concrete `DomainError` returned by a rejecting guard.
- */
-declare function transitionDomainState<TState extends string, TContext, TInput extends DomainMachineInput, TOutput>(definition: DomainMachineDefinition<TState, TContext, TInput, TOutput>, snapshot: DomainMachineSnapshot<TState, TContext>, input: TInput): DomainTransitionOutcome<TState, TContext, TOutput>;
-//#endregion
-//#region src/domain/state-machine/domain-state-machine.d.ts
-/**
- * Stateful convenience wrapper around the pure domain transition functions.
- *
- * Persist {@link snapshot}, not the machine instance. Pass a restored snapshot
- * to the second constructor overload to validate and reconstitute a machine.
- */
-declare class DomainStateMachine<TState extends string, TContext, TInput extends DomainMachineInput, TOutput = never> {
-  #private;
-  private readonly definition;
-  constructor(definition: DomainMachineDefinition<TState, TContext, TInput, TOutput>);
-  constructor(definition: DomainMachineDefinition<TState, TContext, TInput, TOutput>, snapshot: DomainMachineSnapshot<TState, TContext> | undefined);
-  /** Returns a defensive, deeply frozen copy of the current snapshot. */
-  get snapshot(): DomainMachineSnapshot<TState, TContext>;
-  /** Current named control state. */
-  get state(): TState;
-  /** Current deeply readonly context. */
-  get context(): DomainMachineReadonly<TContext>;
-  /** Whether the current state permanently forbids outgoing transitions. */
-  isTerminal(): boolean;
-  /** Checks a transition without changing the current snapshot. */
-  can(input: TInput): boolean;
-  /** Applies an input and advances the current snapshot on success. */
-  dispatch(input: TInput): DomainTransitionOutcome<TState, TContext, TOutput>;
-  private evaluate;
-}
-//#endregion
 //#region src/internal/structural/deep-omit.d.ts
 type DeepOmitKey = string | symbol;
 type DeepOmitPathSegment = string | number | symbol;
@@ -3253,7 +2996,7 @@ interface DeepOmitOptions {
  * built via `Object.create(proto)` so the prototype is preserved, but the
  * constructor is NOT re-invoked, so class invariants enforced by the
  * constructor are not re-checked. `deepOmit` is therefore best used for
- * comparison/serialisation (`voEqualsExcept`, `deepEqualExcept`), not as
+ * comparison/serialisation (`valueObjectEqualsExcept`, `deepEqualExcept`), not as
  * a general-purpose clone for behaviour-carrying objects.
  *
  * @param value - The value to create a deep copy from
@@ -3262,58 +3005,35 @@ interface DeepOmitOptions {
  */
 declare function deepOmit<T>(value: T, options: DeepOmitOptions): T;
 //#endregion
-//#region src/internal/structural/deep-equal-except.d.ts
-type DeepEqualExceptOptions = DeepOmitOptions;
-/**
- * Performs a deep equality comparison between two values after omitting specified keys.
- *
- * This function first removes the specified keys from both values using `deepOmit`,
- * then performs a deep equality check using `deepEqual`.
- *
- * @param a - The first value to compare
- * @param b - The second value to compare
- * @param options - Options specifying which keys to omit before comparison
- * @returns `true` if the values are deeply equal after omitting specified keys, `false` otherwise
- *
- * @example
- * ```ts
- * const obj1 = { id: 1, name: "Alice", updatedAt: "2024-01-01" };
- * const obj2 = { id: 2, name: "Alice", updatedAt: "2024-01-02" };
- *
- * deepEqualExcept(obj1, obj2, { ignoreKeys: ["id", "updatedAt"] }); // true
- * ```
- */
-declare function deepEqualExcept(a: unknown, b: unknown, options: DeepEqualExceptOptions): boolean;
-//#endregion
 //#region src/domain/value-object/value-object.d.ts
-type VO<T> = Readonly<T>;
+type ValueObjectOf<T> = Readonly<T>;
 declare function deepFreeze<T>(obj: T): Readonly<T>;
 /**
  * Creates a deeply immutable value object from the given data.
  *
  * The input is first deep-cloned, then the clone is frozen, so calling
- * `vo(input)` never freezes the caller's own object graph as a
- * side-effect. Mutating the input afterwards does not bleed into the VO.
- * Symbol-keyed properties are preserved (matching `voEquals`). A kit
+ * `valueObject(input)` never freezes the caller's own object graph as a
+ * side-effect. Mutating the input afterwards does not bleed into the value object.
+ * Symbol-keyed properties are preserved (matching `valueObjectEquals`). A kit
  * `ValueObject` instance nested in the input is kept by reference and
  * frozen in place; it must keep all of its state in `props`. A value
  * object as the input itself is rejected.
  * Function values and every other custom class instance are rejected
  * (Value Objects are plain data, not behaviour-bearing object graphs). Inputs must be trusted and
  * Proxy-free: ECMAScript provides no portable way to identify a transparent
- * Proxy without potentially executing its traps, so `vo()` is not a sandbox
+ * Proxy without potentially executing its traps, so `valueObject()` is not a sandbox
  * for hostile in-process objects. Built-ins that cannot provide immutable,
- * value-based semantics are rejected instead of weakening the VO contract.
+ * value-based semantics are rejected instead of weakening the value object contract.
  *
  * @example
  * ```typescript
  * const nested = { lat: 52.5, lng: 13.4 };
- * const address = vo({ street: "Main St", coordinates: nested });
+ * const address = valueObject({ street: "Main St", coordinates: nested });
  * address.coordinates.lat = 99; // ❌ Cannot assign to read-only property
  * nested.lat = 0;               // ✅ caller's input still mutable
  * ```
  */
-declare function vo<T>(t: T): VO<T>;
+declare function valueObject<T>(t: T): ValueObjectOf<T>;
 /**
  * Compares two value objects for equality based on their values.
  * Uses deep equality comparison that handles:
@@ -3329,22 +3049,22 @@ declare function vo<T>(t: T): VO<T>;
  *
  * @example
  * ```typescript
- * const money1 = vo({ amount: 100, currency: "USD" });
- * const money2 = vo({ amount: 100, currency: "USD" });
- * voEquals(money1, money2); // true
+ * const money1 = valueObject({ amount: 100, currency: "USD" });
+ * const money2 = valueObject({ amount: 100, currency: "USD" });
+ * valueObjectEquals(money1, money2); // true
  *
- * const address1 = vo({
+ * const address1 = valueObject({
  *   street: "Main St",
  *   coordinates: { lat: 52.5, lng: 13.4 }
  * });
- * const address2 = vo({
+ * const address2 = valueObject({
  *   street: "Main St",
  *   coordinates: { lat: 52.5, lng: 13.4 }
  * });
- * voEquals(address1, address2); // true
+ * valueObjectEquals(address1, address2); // true
  * ```
  */
-declare function voEquals<T>(a: VO<T>, b: VO<T>): boolean;
+declare function valueObjectEquals<T>(a: ValueObjectOf<T>, b: ValueObjectOf<T>): boolean;
 /**
  * Compares two value objects for equality while ignoring specified keys.
  * Useful for comparing value objects that contain metadata or optional fields
@@ -3363,38 +3083,38 @@ declare function voEquals<T>(a: VO<T>, b: VO<T>): boolean;
  * @example
  * ```typescript
  * // Value object with metadata
- * const address1 = vo({
+ * const address1 = valueObject({
  *   street: "Main St",
  *   city: "Berlin",
  *   metadata: { createdAt: "2024-01-01", updatedAt: "2024-01-02" }
  * });
  *
- * const address2 = vo({
+ * const address2 = valueObject({
  *   street: "Main St",
  *   city: "Berlin",
  *   metadata: { createdAt: "2024-01-01", updatedAt: "2024-01-03" }
  * });
  *
  * // Compare ignoring metadata timestamps
- * voEqualsExcept(address1, address2, {
+ * valueObjectEqualsExcept(address1, address2, {
  *   ignoreKeys: ["updatedAt"],
  *   ignoreKeyPredicate: (key, path) => path.includes("metadata")
  * }); // true
  *
  * // Compare ignoring all metadata
- * voEqualsExcept(address1, address2, {
+ * valueObjectEqualsExcept(address1, address2, {
  *   ignoreKeyPredicate: (key, path) => path.includes("metadata")
  * }); // true
  * ```
  */
-declare function voEqualsExcept<T>(a: VO<T>, b: VO<T>, options: DeepEqualExceptOptions): boolean;
+declare function valueObjectEqualsExcept<T>(a: ValueObjectOf<T>, b: ValueObjectOf<T>, options: DeepOmitOptions): boolean;
 /**
  * Creates a value object with optional validation.
  * Returns a Result type instead of throwing an error.
  *
  * Note: the Result covers VALIDATION failures only. Non-data values and
  * built-ins without immutable value semantics still throw a
- * `TypeError` from `vo()`; they cannot occur in parsed JSON and signal
+ * `TypeError` from `valueObject()`; they cannot occur in parsed JSON and signal
  * a programming error, not a validation failure.
  *
  * @param t - The data to convert into a value object
@@ -3404,7 +3124,7 @@ declare function voEqualsExcept<T>(a: VO<T>, b: VO<T>, options: DeepEqualExceptO
  *
  * @example
  * ```typescript
- * const result = voWithValidation(
+ * const result = valueObjectOrError(
  *   { amount: 100, currency: "USD" },
  *   (m) => m.amount >= 0 && m.currency.length === 3,
  *   "Invalid money: amount must be non-negative and currency must be 3 characters"
@@ -3417,7 +3137,7 @@ declare function voEqualsExcept<T>(a: VO<T>, b: VO<T>, options: DeepEqualExceptO
  * }
  * ```
  */
-declare function voWithValidation<T>(t: T, validate: (value: T) => boolean, errorMessage?: string): Result<VO<T>, string>;
+declare function valueObjectOrError<T>(t: T, validate: (value: T) => boolean, errorMessage?: string): Result<ValueObjectOf<T>, string>;
 /**
  * Interface for Value Objects.
  * Value Objects are immutable and defined by their properties.
@@ -3515,16 +3235,16 @@ declare abstract class ValueObject<T extends object> implements IValueObject<T>
   toJSON(): Readonly<T>;
 }
 //#endregion
-//#region src/domain/value-object/vo-validated.d.ts
+//#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
  * first one. This is the Result-first, multi-error counterpart to
- * `voWithValidation` (which returns a single string message).
+ * `valueObjectOrError` (which returns a single string message).
  *
  * The `validate` callback receives a fresh `ValidationError` to push field
  * issues onto (via `addIssue` / `addIssues`) and the raw input. When no issue
- * was recorded the input is frozen into a `VO<T>` and returned as `Ok`;
+ * was recorded the input is frozen into a `ValueObjectOf<T>` and returned as `Ok`;
  * otherwise the populated `ValidationError` is returned as `Err`.
  *
  * `ValidationError` comes from `@shirudo/base-error`; import it from there to
@@ -3534,7 +3254,7 @@ declare abstract class ValueObject<T extends object> implements IValueObject<T>
  *
  * @example
  * ```ts
- * const result = voValidated(
+ * const result = valueObjectOrIssues(
  *   { email, age },
  *   (issues, m) => {
  *     if (!isEmail(m.email))
@@ -3547,38 +3267,9 @@ declare abstract class ValueObject<T extends object> implements IValueObject<T>
  * // result.isErr() → result.error.publicIssues() has both violations
  * ```
  */
-declare function voValidated<T>(t: T, validate: (issues: ValidationError, value: T) => void, message?: string): Result<VO<T>, ValidationError>;
+declare function valueObjectOrIssues<T>(t: T, validate: (issues: ValidationError, value: T) => void, message?: string): Result<ValueObjectOf<T>, ValidationError>;
 //#endregion
-//#region src/internal/structural/deep-equal.d.ts
-/**
- * Performs a deep equality check between two values.
- *
- * This function compares values recursively, handling:
- * - Primitives (with special handling for NaN)
- * - Arrays (nested arrays supported)
- * - Objects (plain objects and class instances)
- * - TypedArrays (Uint8Array, Int32Array, etc.)
- * - DataView
- * - Maps and Sets
- * - Dates and RegExp
- * - Wrapper objects (Boolean, Number, String)
- * - Circular references (detected and handled)
- *
- * @param a - The first value to compare
- * @param b - The second value to compare
- * @returns `true` if the values are deeply equal, `false` otherwise
- *
- * @example
- * ```ts
- * deepEqual([1, 2, 3], [1, 2, 3]); // true
- * deepEqual({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }); // true
- * deepEqual(NaN, NaN); // true
- * deepEqual([1, 2], [1, 2, 3]); // false
- * ```
- */
-declare function deepEqual(a: unknown, b: unknown): boolean;
-//#endregion
-//#region src/internal/structural/detach-state.d.ts
+//#region src/internal/structural/copy-plain-state.d.ts
 /**
  * Returns a copy of `state` that shares no object with the original.
  * Throws a `TypeError` that names the path when the graph carries a value
@@ -3587,7 +3278,7 @@ declare function deepEqual(a: unknown, b: unknown): boolean;
  * symbol-keyed, non-enumerable, or accessor property and an expando on a
  * built-in are dropped. A function or a symbol value throws a raw
  * `DataCloneError`. An Error, a Promise, a WeakMap, or a WeakSet cannot be
- * detached at all. A SharedArrayBuffer and a view over one keep sharing
+ * copied at all. A SharedArrayBuffer and a view over one keep sharing
  * their memory. A Proxy fails in the walk or in the clone; a failure in
  * the clone is rethrown as a `TypeError` with the cause. An error that a
  * Proxy trap throws in the walk passes unchanged, so a coded error of the
@@ -3616,12 +3307,41 @@ declare function deepEqual(a: unknown, b: unknown): boolean;
  * throws. A non-enumerable symbol key passes anywhere: it is metadata by
  * convention.
  *
- * The concrete entity uses it for a detached read DTO of a plain-data
+ * The concrete entity uses it for the plain state of a plain-data
  * state. The snapshot model uses it for the captured DTO and the restored
  * state. A state that carries a class-based child is mapped to plain data
  * first, in the entity or in the model.
  */
-declare function detachState<T>(state: T, subject?: string): T;
+declare function copyPlainState<T>(state: T, subject?: string): T;
+//#endregion
+//#region src/internal/structural/deep-equal.d.ts
+/**
+ * Performs a deep equality check between two values.
+ *
+ * This function compares values recursively, handling:
+ * - Primitives (with special handling for NaN)
+ * - Arrays (nested arrays supported)
+ * - Objects (plain objects and class instances)
+ * - TypedArrays (Uint8Array, Int32Array, etc.)
+ * - DataView
+ * - Maps and Sets
+ * - Dates and RegExp
+ * - Wrapper objects (Boolean, Number, String)
+ * - Circular references (detected and handled)
+ *
+ * @param a - The first value to compare
+ * @param b - The second value to compare
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @example
+ * ```ts
+ * deepEqual([1, 2, 3], [1, 2, 3]); // true
+ * deepEqual({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }); // true
+ * deepEqual(NaN, NaN); // true
+ * deepEqual([1, 2], [1, 2, 3]); // false
+ * ```
+ */
+declare function deepEqual(a: unknown, b: unknown): boolean;
 //#endregion
 //#region src/messaging/event-bus/errors.d.ts
 /**
@@ -3689,7 +3409,7 @@ interface PublishChainState {
  * ```ts
  * import { AsyncLocalStorage } from "node:async_hooks";
  *
- * const bus = new EventBusImpl<OrderEvent>({
+ * const bus = new InProcessEventBus<OrderEvent>({
  *   chainStore: new AsyncLocalStorage<PublishChainState>(),
  * });
  * ```
@@ -3767,7 +3487,7 @@ interface EventBusObservers {
    */
   readonly onSubscriptionThresholdExceeded: (report: SubscriptionThresholdReport) => void;
 }
-/** Construction options for {@link EventBusImpl}. */
+/** Construction options for {@link InProcessEventBus}. */
 interface EventBusOptions {
   /**
    * Subscriptions for one event type above which the bus reports through
@@ -3812,7 +3532,7 @@ interface EventBusOptions {
  *
  * @example
  * ```typescript
- * const bus = new EventBusImpl<OrderEvent>();
+ * const bus = new InProcessEventBus<OrderEvent>();
  *
  * bus.subscribe("OrderCreated", async (event) => {
  *   await sendEmail(event.payload.customerId);
@@ -3872,7 +3592,7 @@ interface EventBusOptions {
  * the signal.
  *
  */
-declare class EventBusImpl<Evt extends AnyDomainEvent> implements EventBus<Evt> {
+declare class InProcessEventBus<Evt extends AnyDomainEvent> implements EventBus<Evt> {
   private readonly handlers;
   private readonly catchAllHandlers;
   private readonly maxPublishDepth;
@@ -3963,7 +3683,7 @@ declare function encodeIntegrationMessage(message: IntegrationMessage): string;
  */
 declare function decodeIntegrationMessage(serialized: string): IntegrationMessage;
 /**
- * Composes a validated public message into a minted local projector input.
+ * Composes a validated public message into a kit-built local projector input.
  * Relationship headers become local event metadata. The public JSON schema is
  * retained; producer-private domain types are not reconstructed.
  */
@@ -4035,9 +3755,9 @@ interface InMemoryOutboxOptions {
  * another aggregate version. Without an `InMemoryTransactionScope`, it keeps
  * the first add of a rolled-back attempt. Dead-lettered and acknowledged
  * retries must match the complete original candidate receipt. Reusing an `eventId` for another source or commit position
- * throws {@link EventHarvestError} while the pending, dead-letter, or bounded
+ * throws {@link EventCollectionError} while the pending, dead-letter, or bounded
  * dispatched receipt still proves the collision. `add` also throws
- * {@link EventHarvestError} for a malformed candidate: a part that is not an
+ * {@link EventCollectionError} for a malformed candidate: a part that is not an
  * object, an `eventId` or `type` that is not an own string data property, a
  * source field that is not a string, or a position that is not a valid
  * commit position. Insertion order is preserved:
@@ -4052,7 +3772,7 @@ interface InMemoryOutboxOptions {
  * To link future eventful commits, the implementation also retains one
  * source cursor per qualified aggregate after dispatch. `endEventSources`
  * marks the cursor of a removed aggregate as ended, and a new event of that
- * source then throws {@link EventHarvestError}. Consequently a
+ * source then throws {@link EventCollectionError}. Consequently a
  * long-lived instance is bounded only when `maxRecords` and `maxSources` are
  * configured, plus `maxRetainedDispatchedEventIds`; use a durable adapter with
  * an explicit source-head lifecycle and an event-id unique key for unbounded
@@ -4084,10 +3804,10 @@ interface InMemoryOutboxOptions {
  *
  * @example
  * ```ts
- * import { InMemoryOutbox, EventBusImpl } from "@shirudo/ddd-kit";
+ * import { InMemoryOutbox, InProcessEventBus } from "@shirudo/ddd-kit";
  *
  * const outbox = new InMemoryOutbox<OrderEvent>();
- * const bus = new EventBusImpl<OrderEvent>();
+ * const bus = new InProcessEventBus<OrderEvent>();
  *
  * const uow = makeOrderUnitOfWork({ outbox, bus });
  * await uow.run(async ({ repositories }) => {
@@ -4518,7 +4238,7 @@ interface RetryPolicy {
  *
  * **Classification is by error, not by guesswork.** Only errors the
  * `isRetryable` predicate accepts are retried; everything else (a
- * `DomainError`, `EventHarvestError`, `UnenrolledChangesError`,
+ * `DomainError`, `EventCollectionError`, `UnregisteredChangesError`,
  * `DuplicateAggregateError`, a non-Error throw) surfaces immediately.
  * After `maxAttempts` the last error is rethrown unchanged, so a caller
  * can still match `ConcurrencyConflictError` and map it to HTTP 409.
@@ -4633,7 +4353,7 @@ interface SnapshotModel<TAggregate extends SnapshotAggregate, TSnapshotState> {
 /** Type-inference helper for declaring an adapter-owned snapshot model. */
 declare function defineSnapshotModel<TAggregate extends SnapshotAggregate, TSnapshotState>(model: SnapshotModel<TAggregate, TSnapshotState>): SnapshotModel<TAggregate, TSnapshotState>;
 /**
- * Captures a detached persistence envelope at an application-supplied time.
+ * Captures an independent persistence envelope at an application-supplied time.
  * The application decides when snapshotting is worthwhile; this function does
  * not read a clock or perform I/O. The envelope is deep-frozen, its `state`
  * and its `snapshotAt` included: a write into the captured state or a
@@ -4660,5 +4380,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 AnyUncommittedDomainEvent, 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, type CommitEnrollment, type CommitEnrollmentOptions, CommitError, type CommitPosition, type CommittedDomainEvent, type CompatibleRepositoryDefinitions, ConcurrencyConflictError, type ConcurrencyConflictErrorOptions, type ConcurrencyConflictReason, type CreateDomainEventFromFactsOptions, type CreateDomainEventOptions, type CreateDomainEventStampOptions, type CreateUncommittedDomainEventOptions, type DeadLetterDeadline, type DeadLetterRecord, DeadlineProcessor, type DeadlineProcessorObservers, type DeadlineProcessorOptions, type DeadlineStore, type DeepEqualExceptOptions, 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 DomainMachineDefinition, type DomainMachineDefinitionAnalysis, type DomainMachineDefinitionDiagnostic, type DomainMachineInput, type DomainMachineReadonly, type DomainMachineSnapshot, type DomainMachineTransitionDescription, DomainStateMachine, type DomainStateNode, type DomainTransition, DomainTransitionGuardRejectedError, type DomainTransitionGuardResult, type DomainTransitionOutcome, type DomainTransitionResult, type DueDeadline, DuplicateAggregateError, type DuplicateAggregateErrorOptions, DuplicateEventIdError, type DuplicateEventIdErrorOptions, DuplicateHandlerRegistrationError, type DuplicateHandlerRegistrationErrorOptions, type DurableCommandMessage, Entity, type EntityConfig, ErrorMapperFailedError, type ErrorMapperFailedErrorOptions, type EventBus, EventBusClosedError, EventBusImpl, type EventBusObservers, type EventBusOptions, type EventCommitCandidate, type EventCommitCandidatePosition, type EventHandler, EventHarvestError, type EventIdFactory, type EventMetadata, EventSourcedAggregate, type EventStore, type EventStoreAppendOptions, type EventStreamPageReason, type EventStreamReader, type ExecutionContext, type FlushStatementReason, FoldReturnedNoStateError, ForeignEventError, type HandlerFailureReport, HostileStateKeyError, type ICommandBus, type IEntity, type IQueryBus, type IValueObject, 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, InfrastructureError, type IntegrationMessage, type IntegrationMessageContent, type IntegrationMessageMapper, type IntegrationMessageRelationships, InvalidCommandMessageError, InvalidDomainMachineContextError, InvalidDomainMachineDefinitionError, InvalidDomainMachineInputError, InvalidDomainMachineSnapshotError, InvalidDomainTransitionError, InvalidDomainTransitionGuardResultError, InvalidDomainTransitionResultError, 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 PersistenceBaseline, type PersistenceChanges, type PersistenceLifecycle, type PersistenceModel, type PhysicalRemovalRegistration, type PinTargetVersionOptions, type PinnedTargetVersion, type PreparedDomainMachineDefinition, 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, type PublishAbortedReport, type PublishChainState, type PublishChainStore, PublishDepthExceededError, type PublishOptions, type PublishedCommand, type Query, QueryBus, type QueryBusOptions, type QueryHandler, type ReachableStreamPages, type ReadStreamOptions, type ReadStreamPagesOptions, ReentrantDomainStateMachineEvaluationError, 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, type UncommittedDomainEvent, type UncommittedDomainEventOf, UnenrolledChangesError, type UnenrolledChangesErrorOptions, UnitOfWork, type UnitOfWorkContext, type UnitOfWorkDeps, type UnitOfWorkIdentityMap, UnmanagedInstanceError, UnmintedEventError, UnprojectableEventError, type UnreachableStreamPages, UnregisteredHandlerError, type UnregisteredHandlerErrorOptions, UnreplayableAggregateError, type UnreplayableAggregateErrorOptions, type VO, ValueObject, type Version, type VersionedFlushStatements, type VersionedWrite, type WithCommitDeps, type WithCommitWorkResult, type WithIdempotentCommitDeps, analyzeDomainMachineDefinition, canTransitionDomainState, captureAggregateSnapshot, capturePersistenceBaseline, classifyConcurrencyConflict, copyMetadata, createDomainEvent, createDomainEventFactory, createDomainEventFromFacts, createInitialDomainMachineSnapshot, createIntegrationMessage, createUncommittedDomainEvent, decodeIntegrationMessage, deepEqual, deepEqualExcept, deepFreeze, deepOmit, defaultDomainEventFactory, defineRepository, defineSnapshotModel, derivePersistenceChanges, detachState, domainErrorToResult, encodeIntegrationMessage, entityIds, eventBusSink, findEntityById, freezeShallow, hasEntityId, ignoreProjectionEvent, insertPersistenceBaseline, integrationMessageToCommittedEvent, isDomainErrorLike, isInfrastructureErrorLike, isPositionAfter, isWiringErrorLike, mergeMetadata, outboxWriterAcceptingEventLoss, persistenceProjectionDrifted, pinTargetVersion, prepareDomainMachineDefinition, projectionFromHandlers, readStreamPages, recapturePersistenceBaseline, reconstituteAggregateFromHistory, reconstituteAggregateFromSnapshot, reconstituteAggregateFromStreamPages, recordDomainEvent, recordPendingEvents, removeEntityById, replaceEntityById, routeEventsToCommandOutbox, sameEntity, sameVersion, specification, toVersion, transitionDomainState, updateEntityById, versionedFlush, vo, voEquals, voEqualsExcept, voValidated, voWithValidation, 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 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 };
 //# sourceMappingURL=index.d.ts.map