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

package/README.md

@@ -111,7 +111,7 @@ That example is deliberately small, but it shows the core shape:
 - The domain throws an error when an invariant is broken.
 - `setState(...)` changes the state and records the event together.
 - `createEvent(...)` captures the immutable domain decision and aggregate source.
-- The application shell adds event identity, recording time, and trace metadata.
+- The application shell adds event identity, stamp time, and trace metadata.
 - Persistence stays outside the aggregate.
 
 In production, a repository and `withCommit` or `UnitOfWork` persist the state,
@@ -122,12 +122,13 @@ aggregate as persisted after the transaction commits.
 
 **Domain modeling**
 
-- value objects via `vo()` and `ValueObject<T>`
-- exact Money helpers in `@shirudo/ddd-kit/money`
+- value objects via `valueObject()` and `ValueObject<T>`
+- exact Money helpers in `@shirudo/ddd-kit/money` (experimental)
 - child entities with branded identity
 - state-stored and event-sourced aggregate roots
 - domain events with metadata, schema version, and commit stamps
-- a domain state machine for named lifecycle states
+- a domain state machine for named lifecycle states in
+  `@shirudo/ddd-kit/state-machine` (experimental)
 
 **Application boundaries**
 
@@ -136,7 +137,7 @@ aggregate as persisted after the transaction commits.
   runtimes
 - a clear error split: domain code throws, command/query boundaries return
   `Result`
-- `voValidated` for collecting field-level validation issues
+- `valueObjectOrIssues` for collecting field-level validation issues
 - optional HTTP/RFC 9457 presentation helpers
 
 **Persistence and delivery**
@@ -144,8 +145,8 @@ aggregate as persisted after the transaction commits.
 - repository interfaces for id-based and filtered access
 - a per-operation Identity Map contract
 - optimistic concurrency errors and duplicate-insert errors
-- `withCommit` for transaction, outbox, event harvest, and post-commit cleanup
-- `UnitOfWork` for repository registration and enrollment
+- `withCommit` for transaction, outbox, event collection, and post-commit cleanup
+- `UnitOfWork` for repository registration and registration
 - outbox dispatcher, projection, event-store, and snapshot ports
 - contract tests for repository and outbox adapters
 
@@ -185,7 +186,7 @@ first adapter or aggregate.
 | Repository contracts and Identity Map | [Repository](./docs/guide/repository.md) |
 | Transaction-scoped repositories | [Unit of Work](./docs/guide/unit-of-work.md) |
 | Duplicate-safe commands and inbox handling | [Command Idempotency](./docs/guide/idempotency.md) |
-| Reliable event harvest and delivery | [Outbox & Transactions](./docs/guide/outbox.md) |
+| Reliable event collection and delivery | [Outbox & Transactions](./docs/guide/outbox.md) |
 | Read models and projectors | [Projections](./docs/guide/projections.md) |
 | Event schema changes | [Event Upcasting](./docs/guide/event-upcasting.md) |
 | Optimistic concurrency | [Concurrency](./docs/guide/concurrency.md) |
@@ -213,6 +214,10 @@ packages side by side until those API-based tools support TypeScript 7.
 Tests and package builds run through Vite+ (`pnpm test`, `pnpm build`). Biome
 remains the repository's lint and format policy.
 
+A change of the public API follows the [stability policy](./STABILITY.md):
+breaking changes only in a major version, a deprecation before a removal, and
+a pull request description that says whether a change is breaking.
+
 Bug reports, questions, and pull requests are welcome on
 [GitHub](https://github.com/shi-rudo/ddd-kit-ts). Please open pull requests
 against `main`.

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

@@ -331,7 +331,7 @@ declare class InvalidCommandMessageError extends InfrastructureError<"INVALID_CO
  * input at the application edge; model genuinely arbitrary keys with a
  * `Map`, not a plain object.
  */
-declare class HostileStateKeyError extends KitWiringError<"HOSTILE_STATE_KEY"> {
+declare class PrototypePollutionError extends KitWiringError<"PROTOTYPE_POLLUTION"> {
   readonly key: string;
   constructor(key: string, subject?: string);
 }
@@ -477,22 +477,21 @@ declare class SnapshotCorruptedError extends InfrastructureError<"SNAPSHOT_CORRU
 }
 /**
  * Thrown when an event reaches the aggregate's recording paths
- * (`apply`, `setState`, `addDomainEvent`) without having been minted by
- * the kit's constructors: `createDomainEvent`,
- * `createDomainEventFromFacts`, `createUncommittedDomainEvent`, or the
- * aggregate `createEvent` helper. Those constructors deep-freeze the
+ * (`apply`, `setState`, `addDomainEvent`) without having been built by
+ * the kit's constructors: `createDomainEvent`, `createStampedDomainEvent`, or
+ * the aggregate `createEvent` helper. Those constructors deep-freeze the
  * event, defensively copy payload and metadata, and mark the result as
- * minted. The mark has two tiers: a
+ * kit-built. The mark has two tiers: a
  * module-private one for events of this loaded copy of the kit, and a
- * cooperative `Symbol.for` brand that a second loaded copy stamps and
+ * cooperative `Symbol.for` brand that a second loaded copy applies and
  * recognizes. Anything else (a hand-rolled literal, a shallow-frozen
  * copy with mutable nested data) is rejected: a mutable event recorded
  * next to a state change can silently diverge from it afterwards. A
  * wiring error: deterministic bug at the call site, the remedy is
- * minting through the constructors. The gate catches accidents, not
+ * building through the constructors. The gate catches accidents, not
  * adversaries: code in the same process can fake the brand.
  */
-declare class UnmintedEventError extends KitWiringError<"UNMINTED_EVENT"> {
+declare class HandBuiltEventError extends KitWiringError<"HAND_BUILT_EVENT"> {
   constructor(eventType: string);
 }
 /** Constructor options for {@link ReentrantEventRecordingError}. */
@@ -504,12 +503,12 @@ interface ReentrantEventRecordingErrorOptions {
   };
 }
 /**
- * Thrown by `recordPendingEvents` when the aggregate's pending-event list
+ * Thrown by `stampPendingEvents` when the aggregate's pending-event list
  * changes while its events are being stamped: a stamp provider that
  * directly or transitively triggers a new decision on the same aggregate
  * would otherwise have that decision silently discarded when recording
  * replaces the pending list. Recording is atomic: when this guard fires,
- * every decision (including the re-entrant one) remains unrecorded. A
+ * every decision (including the re-entrant one) remains unstamped. A
  * wiring error: deterministic bug at the call site, the remedy is keeping
  * stamp providers free of domain decisions.
  */
@@ -529,10 +528,10 @@ interface DuplicateEventIdErrorOptions {
 }
 /**
  * Thrown when two facts of one aggregate would carry the same `eventId`.
- * Two causes, two sites: the aggregate rejects a recorded event that is
+ * Two causes, two sites: the aggregate rejects a stamped event that is
  * already pending at the append, before the state moves; and
- * `recordPendingEvents` rejects a stamp provider that returns one reused
- * stamp (or repeats an explicit id). Either would mint two distinct facts
+ * `stampPendingEvents` rejects a stamp provider that returns one reused
+ * stamp (or repeats an explicit id). Either would create two distinct facts
  * sharing one identity, and downstream idempotent consumers keyed on
  * `eventId` silently drop one of them. A wiring error: deterministic bug at
  * the append site or in the stamp provider, the remedy is one fresh
@@ -593,7 +592,7 @@ interface PendingEventBatchMismatchErrorOptions {
  * pending event at the same position. Acknowledging such a batch would
  * drop decisions the commit never persisted or keep events it did. The
  * pending list stays untouched. A wiring error in application commit
- * orchestration: acknowledge exactly the batch that was enrolled, once.
+ * orchestration: acknowledge exactly the batch that was registered, once.
  */
 declare class PendingEventBatchMismatchError extends KitWiringError<"PENDING_EVENT_BATCH_MISMATCH"> {
   readonly identity: PendingEventBatchMismatchErrorOptions["identity"];
@@ -781,9 +780,9 @@ declare class ReplayRejectedError extends InfrastructureError<"REPLAY_REJECTED">
   constructor(options: ReplayRejectedErrorOptions);
 }
 /**
- * Thrown when an event harvested from an aggregate cannot be safely composed
+ * Thrown when an event collected from an aggregate cannot be safely composed
  * into a commit envelope, or when an outbox can prove that accepting a
- * candidate would violate its event identity/source chain. Harvest failures
+ * candidate would violate its event identity/source chain. Collect failures
  * include missing `aggregateId` / `aggregateType` (downstream routing would
  * break), or an
  * eventful persisted aggregate did not advance its version (two commits
@@ -799,7 +798,7 @@ declare class ReplayRejectedError extends InfrastructureError<"REPLAY_REJECTED">
  * `UnitOfWork.run` passes it through unchanged instead of wrapping it in
  * `CommitError`.
  */
-declare class EventHarvestError extends KitWiringError<"EVENT_HARVEST_FAILED"> {
+declare class EventCollectionError extends KitWiringError<"EVENT_COLLECTION_FAILED"> {
   /** The `type` of the offending event, for programmatic routing. */
   readonly eventType?: string | undefined;
   constructor(message: string,
@@ -918,8 +917,8 @@ declare class ErrorMapperFailedError extends KitWiringError<"ERROR_MAPPER_FAILED
   readonly mapperCause: unknown;
   constructor(options: ErrorMapperFailedErrorOptions);
 }
-/** Constructor options for {@link UnenrolledChangesError}. */
-interface UnenrolledChangesErrorOptions {
+/** Constructor options for {@link UnregisteredChangesError}. */
+interface UnregisteredChangesErrorOptions {
   /** The aggregate the error names. */
   readonly identity: {
     readonly aggregateType: string;
@@ -951,9 +950,9 @@ interface UnenrolledChangesErrorOptions {
  * message names the rule instead: a loaded append-only aggregate must not
  * change.
  */
-declare class UnenrolledChangesError extends KitWiringError<"UNENROLLED_CHANGES"> {
-  readonly identity: UnenrolledChangesErrorOptions["identity"];
-  constructor(options: UnenrolledChangesErrorOptions);
+declare class UnregisteredChangesError extends KitWiringError<"UNREGISTERED_CHANGES"> {
+  readonly identity: UnregisteredChangesErrorOptions["identity"];
+  constructor(options: UnregisteredChangesErrorOptions);
 }
 /** Constructor options for {@link AggregateDeletedError}. */
 interface AggregateDeletedErrorOptions {
@@ -1128,7 +1127,7 @@ type ConcurrencyConflictErrorOptions = {
  * **Retry means a FRESH unit of work** (a new `UnitOfWork.run()` /
  * `withCommit` invocation): reload, re-apply, and register `update` again. Do NOT catch this
  * inside the same `run()` callback and continue: the failed aggregate
- * is already enrolled (its events would be committed for a write that
+ * is already registered (its events would be committed for a write that
  * never happened) and the identity map still serves the same stale
  * instance to any in-place "reload".
  *
@@ -1254,7 +1253,7 @@ declare class IdempotencyCompletionWithoutClaimError extends KitWiringError<"IDE
  * base-error `matchError` cases that cover kit and consumer codes
  * together, without importing anything from base-error.
  */
-type KitErrorCode = "AGGREGATE_DELETED" | "AGGREGATE_NOT_FOUND" | "AGGREGATE_TRACKING" | "CAPABILITY_REGISTRY_CONFLICT" | "COMMIT_FAILED" | "CONCURRENCY_CONFLICT" | "DIRECT_STATE_MUTATION" | "DOMAIN_TRANSITION_GUARD_REJECTED" | "DUPLICATE_AGGREGATE" | "DUPLICATE_EVENT_ID" | "DUPLICATE_HANDLER_REGISTRATION" | "ERROR_MAPPER_FAILED" | "EVENT_AGGREGATE_IDENTITY_INVALID" | "EVENT_BUS_CLOSED" | "EVENT_HARVEST_FAILED" | "EVENT_ID_INVALID" | "EVENT_ID_REQUIRED" | "EVENT_OCCURRED_AT_INVALID" | "EVENT_OCCURRED_AT_REQUIRED" | "EVENT_SCHEMA_VERSION_INVALID" | "EVENT_TYPE_INVALID" | "FOLD_RETURNED_NO_STATE" | "FOREIGN_EVENT" | "HOSTILE_STATE_KEY" | "IDEMPOTENCY_CLAIM_LOST" | "IDEMPOTENCY_COMPLETED_WITHOUT_CLAIM" | "IDEMPOTENCY_IN_FLIGHT" | "IDEMPOTENCY_KEY_REUSE" | "IDEMPOTENCY_RECONCILIATION_REQUIRED" | "IN_MEMORY_CAPACITY_EXCEEDED" | "INVALID_DOMAIN_MACHINE_CONTEXT" | "INVALID_DOMAIN_MACHINE_DEFINITION" | "INVALID_DOMAIN_MACHINE_INPUT" | "INVALID_DOMAIN_MACHINE_SNAPSHOT" | "INVALID_DOMAIN_TRANSITION" | "INVALID_DOMAIN_TRANSITION_GUARD_RESULT" | "INVALID_DOMAIN_TRANSITION_RESULT" | "INVALID_COMMAND_MESSAGE" | "INVALID_EVENT_STREAM_PAGE" | "INVALID_FLUSH_STATEMENT" | "INVALID_INTEGRATION_MESSAGE" | "INVALID_MONEY" | "INVALID_REPOSITORY_ADAPTER" | "INVALID_REPOSITORY_DEFINITION" | "INVALID_VERSION" | "MISATTRIBUTED_EVENT" | "MISSING_ENTITY_ID" | "MISSING_FOLD" | "MISSING_HANDLER" | "MONEY_CURRENCY_MISMATCH" | "MONEY_PRECISION_LOSS" | "MONEY_SCALE_MISMATCH" | "NESTED_UNIT_OF_WORK" | "PENDING_EVENT_BATCH_MISMATCH" | "PENDING_EVENT_LIMIT_EXCEEDED" | "PROJECTION_GAP" | "PROJECTION_IDENTITY_VIOLATION" | "PROJECTION_ORDER_VIOLATION" | "PROJECTION_RECEIPT_VIOLATION" | "PUBLISH_DEPTH_EXCEEDED" | "REENTRANT_DOMAIN_STATE_MACHINE_EVALUATION" | "REENTRANT_EVENT_RECORDING" | "REPLAY_REJECTED" | "REPLAY_TARGET_MISMATCH" | "REPOSITORY_ERROR_MAPPING_FAILED" | "ROLLBACK_FAILED" | "SNAPSHOT_CORRUPTED" | "SNAPSHOT_SCHEMA_MISMATCH" | "SNAPSHOT_TIME_INVALID" | "SNAPSHOT_VERSION_NOT_RESTORED" | "TRANSACTION_CLOSED" | "UNENROLLED_CHANGES" | "UNKNOWN_CURRENCY" | "UNMANAGED_INSTANCE" | "UNMINTED_EVENT" | "UNPROJECTABLE_EVENT" | "UNREGISTERED_HANDLER" | "UNREPLAYABLE_AGGREGATE";
+type KitErrorCode = "AGGREGATE_DELETED" | "AGGREGATE_NOT_FOUND" | "AGGREGATE_TRACKING" | "CAPABILITY_REGISTRY_CONFLICT" | "COMMIT_FAILED" | "CONCURRENCY_CONFLICT" | "DIRECT_STATE_MUTATION" | "DOMAIN_TRANSITION_GUARD_REJECTED" | "DUPLICATE_AGGREGATE" | "DUPLICATE_EVENT_ID" | "DUPLICATE_HANDLER_REGISTRATION" | "ERROR_MAPPER_FAILED" | "EVENT_AGGREGATE_IDENTITY_INVALID" | "EVENT_BUS_CLOSED" | "EVENT_COLLECTION_FAILED" | "EVENT_ID_INVALID" | "EVENT_ID_REQUIRED" | "EVENT_OCCURRED_AT_INVALID" | "EVENT_OCCURRED_AT_REQUIRED" | "EVENT_SCHEMA_VERSION_INVALID" | "EVENT_TYPE_INVALID" | "FOLD_RETURNED_NO_STATE" | "FOREIGN_EVENT" | "PROTOTYPE_POLLUTION" | "IDEMPOTENCY_CLAIM_LOST" | "IDEMPOTENCY_COMPLETED_WITHOUT_CLAIM" | "IDEMPOTENCY_IN_FLIGHT" | "IDEMPOTENCY_KEY_REUSE" | "IDEMPOTENCY_RECONCILIATION_REQUIRED" | "IN_MEMORY_CAPACITY_EXCEEDED" | "INVALID_DOMAIN_MACHINE_CONTEXT" | "INVALID_DOMAIN_MACHINE_DEFINITION" | "INVALID_DOMAIN_MACHINE_INPUT" | "INVALID_DOMAIN_MACHINE_SNAPSHOT" | "INVALID_DOMAIN_TRANSITION" | "INVALID_DOMAIN_TRANSITION_GUARD_RESULT" | "INVALID_DOMAIN_TRANSITION_RESULT" | "INVALID_COMMAND_MESSAGE" | "INVALID_EVENT_STREAM_PAGE" | "INVALID_FLUSH_STATEMENT" | "INVALID_INTEGRATION_MESSAGE" | "INVALID_MONEY" | "INVALID_REPOSITORY_ADAPTER" | "INVALID_REPOSITORY_DEFINITION" | "INVALID_VERSION" | "MISATTRIBUTED_EVENT" | "MISSING_ENTITY_ID" | "MISSING_FOLD" | "MISSING_HANDLER" | "MONEY_CURRENCY_MISMATCH" | "MONEY_PRECISION_LOSS" | "MONEY_SCALE_MISMATCH" | "NESTED_UNIT_OF_WORK" | "PENDING_EVENT_BATCH_MISMATCH" | "PENDING_EVENT_LIMIT_EXCEEDED" | "PROJECTION_GAP" | "PROJECTION_IDENTITY_VIOLATION" | "PROJECTION_ORDER_VIOLATION" | "PROJECTION_RECEIPT_VIOLATION" | "PUBLISH_DEPTH_EXCEEDED" | "REENTRANT_DOMAIN_STATE_MACHINE_EVALUATION" | "REENTRANT_EVENT_RECORDING" | "REPLAY_REJECTED" | "REPLAY_TARGET_MISMATCH" | "REPOSITORY_ERROR_MAPPING_FAILED" | "ROLLBACK_FAILED" | "SNAPSHOT_CORRUPTED" | "SNAPSHOT_SCHEMA_MISMATCH" | "SNAPSHOT_TIME_INVALID" | "SNAPSHOT_VERSION_NOT_RESTORED" | "TRANSACTION_CLOSED" | "UNREGISTERED_CHANGES" | "UNKNOWN_CURRENCY" | "UNMANAGED_INSTANCE" | "HAND_BUILT_EVENT" | "UNPROJECTABLE_EVENT" | "UNREGISTERED_HANDLER" | "UNREPLAYABLE_AGGREGATE";
 //#endregion
-export { PendingEventLimitExceededErrorOptions as $, IdempotencyInFlightErrorOptions as A, InvalidEventStreamPageErrorOptions as B, FoldReturnedNoStateError as C, UnreplayableAggregateError as Ct, IdempotencyClaimLostErrorOptions as D, isWiringErrorLike as Dt, IdempotencyClaimLostError as E, isInfrastructureErrorLike as Et, InMemoryCapacityExceededError as F, KitWiringError as G, InvalidVersionError as H, InMemoryCapacityExceededErrorOptions as I, MissingFoldError as J, MisattributedEventError as K, InfrastructureError as L, IdempotencyKeyReuseErrorOptions as M, IdempotencyReconciliationRequiredError as N, IdempotencyCompletionWithoutClaimError as O, IdempotencyReconciliationRequiredErrorOptions as P, PendingEventLimitExceededError as Q, InvalidCommandMessageError as R, EventStreamPageReason as S, UnregisteredHandlerErrorOptions as St, HostileStateKeyError as T, isDomainErrorLike as Tt, KitErrorCode as U, InvalidIntegrationMessageError as V, KitErrorOptions as W, PendingEventBatchMismatchError as X, MissingHandlerError as Y, PendingEventBatchMismatchErrorOptions as Z, DuplicateHandlerRegistrationError as _, UnenrolledChangesErrorOptions as _t, AggregateNotFoundErrorOptions as a, ReentrantEventRecordingErrorOptions as at, ErrorMapperFailedErrorOptions as b, UnprojectableEventError as bt, ConcurrencyConflictErrorOptions as c, ReplayTargetMismatchError as ct, DirectStateMutationErrorOptions as d, SnapshotCorruptedError as dt, ProjectionGapError as et, DomainError as f, SnapshotSchemaMismatchError as ft, DuplicateEventIdErrorOptions as g, UnenrolledChangesError as gt, DuplicateEventIdError as h, SnapshotVersionNotRestoredErrorOptions as ht, AggregateNotFoundError as i, ReentrantEventRecordingError as it, IdempotencyKeyReuseError as j, IdempotencyInFlightError as k, ConcurrencyConflictReason as l, ReplayTargetMismatchErrorOptions as lt, DuplicateAggregateErrorOptions as m, SnapshotVersionNotRestoredError as mt, AggregateDeletedErrorOptions as n, ProjectionOrderViolationError as nt, CapabilityRegistryConflictError as o, ReplayRejectedError as ot, DuplicateAggregateError as p, SnapshotSchemaMismatchErrorOptions as pt, MissingEntityIdError as q, AggregateIdentityMismatchOptions as r, ProjectionReceiptViolationError as rt, ConcurrencyConflictError as s, ReplayRejectedErrorOptions as st, AggregateDeletedError as t, ProjectionIdentityViolationError as tt, DirectStateMutationError as u, ReplayTargetMismatchReason as ut, DuplicateHandlerRegistrationErrorOptions as v, UnmanagedInstanceError as vt, ForeignEventError as w, UnreplayableAggregateErrorOptions as wt, EventHarvestError as x, UnregisteredHandlerError as xt, ErrorMapperFailedError as y, UnmintedEventError as yt, InvalidEventStreamPageError as z };
+export { PendingEventLimitExceededErrorOptions as $, IdempotencyInFlightErrorOptions as A, InvalidEventStreamPageErrorOptions as B, FoldReturnedNoStateError as C, UnreplayableAggregateError as Ct, IdempotencyClaimLostErrorOptions as D, isWiringErrorLike as Dt, IdempotencyClaimLostError as E, isInfrastructureErrorLike as Et, InMemoryCapacityExceededError as F, KitWiringError as G, InvalidVersionError as H, InMemoryCapacityExceededErrorOptions as I, MissingFoldError as J, MisattributedEventError as K, InfrastructureError as L, IdempotencyKeyReuseErrorOptions as M, IdempotencyReconciliationRequiredError as N, IdempotencyCompletionWithoutClaimError as O, IdempotencyReconciliationRequiredErrorOptions as P, PendingEventLimitExceededError as Q, InvalidCommandMessageError as R, EventStreamPageReason as S, UnregisteredHandlerErrorOptions as St, HandBuiltEventError as T, isDomainErrorLike as Tt, KitErrorCode as U, InvalidIntegrationMessageError as V, KitErrorOptions as W, PendingEventBatchMismatchError as X, MissingHandlerError as Y, PendingEventBatchMismatchErrorOptions as Z, DuplicateHandlerRegistrationError as _, UnmanagedInstanceError as _t, AggregateNotFoundErrorOptions as a, ReentrantEventRecordingError as at, ErrorMapperFailedErrorOptions as b, UnregisteredChangesErrorOptions as bt, ConcurrencyConflictErrorOptions as c, ReplayRejectedErrorOptions as ct, DirectStateMutationErrorOptions as d, ReplayTargetMismatchReason as dt, ProjectionGapError as et, DomainError as f, SnapshotCorruptedError as ft, DuplicateEventIdErrorOptions as g, SnapshotVersionNotRestoredErrorOptions as gt, DuplicateEventIdError as h, SnapshotVersionNotRestoredError as ht, AggregateNotFoundError as i, PrototypePollutionError as it, IdempotencyKeyReuseError as j, IdempotencyInFlightError as k, ConcurrencyConflictReason as l, ReplayTargetMismatchError as lt, DuplicateAggregateErrorOptions as m, SnapshotSchemaMismatchErrorOptions as mt, AggregateDeletedErrorOptions as n, ProjectionOrderViolationError as nt, CapabilityRegistryConflictError as o, ReentrantEventRecordingErrorOptions as ot, DuplicateAggregateError as p, SnapshotSchemaMismatchError as pt, MissingEntityIdError as q, AggregateIdentityMismatchOptions as r, ProjectionReceiptViolationError as rt, ConcurrencyConflictError as s, ReplayRejectedError as st, AggregateDeletedError as t, ProjectionIdentityViolationError as tt, DirectStateMutationError as u, ReplayTargetMismatchErrorOptions as ut, DuplicateHandlerRegistrationErrorOptions as v, UnprojectableEventError as vt, ForeignEventError as w, UnreplayableAggregateErrorOptions as wt, EventCollectionError as x, UnregisteredHandlerError as xt, ErrorMapperFailedError as y, UnregisteredChangesError as yt, InvalidEventStreamPageError as z };
 //# sourceMappingURL=kit-errors.d.ts.map

package/dist/chunks/kit-errors.js

@@ -282,7 +282,7 @@ var DirectStateMutationError = class extends KitWiringError {
 	identity;
 	constructor(options) {
 		super("DIRECT_STATE_MUTATION", `Aggregate ${describeAggregateIdentity(options.identity)} is event-sourced: its state changes only through apply(). Record the fact as an event and fold it in a handler instead of calling setState.`);
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 	}
 };
 /**
@@ -451,10 +451,10 @@ var InvalidCommandMessageError = class extends InfrastructureError {
 * input at the application edge; model genuinely arbitrary keys with a
 * `Map`, not a plain object.
 */
-var HostileStateKeyError = class extends KitWiringError {
+var PrototypePollutionError = class extends KitWiringError {
 	key;
 	constructor(key, subject = "Entity state") {
-		super("HOSTILE_STATE_KEY", `${subject} carries a hostile own "${key}" key, which can never be legitimate domain data. Validate and strip untrusted input at the boundary, or model arbitrary keys with a Map.`);
+		super("PROTOTYPE_POLLUTION", `${subject} carries an own "${key}" key, a prototype-pollution payload that can never be legitimate domain data. Validate and strip untrusted input at the boundary, or model arbitrary keys with a Map.`);
 		this.key = key;
 	}
 };
@@ -520,7 +520,7 @@ var UnreplayableAggregateError = class extends KitWiringError {
 	identity;
 	constructor(options) {
 		super("UNREPLAYABLE_AGGREGATE", `Cannot replay onto aggregate ${describeAggregateIdentity(options.identity)}: ${options.reason}. Reconstitute on a fresh instance (no factory-recorded events, no unpersisted mutations).`);
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 	}
 };
 /**
@@ -537,13 +537,13 @@ function describeAggregateIdentity(identity) {
 * properties into the log. Kit modules only; not part of the package
 * entries.
 */
-function detachAggregateIdentity(identity) {
+function copyAggregateIdentity(identity) {
 	return Object.freeze({
 		aggregateType: identity.aggregateType,
 		aggregateId: identity.aggregateId
 	});
 }
-function detachPartialAggregateIdentity(identity) {
+function copyPartialAggregateIdentity(identity) {
 	return Object.freeze({
 		...identity.aggregateType === void 0 ? {} : { aggregateType: identity.aggregateType },
 		...identity.aggregateId === void 0 ? {} : { aggregateId: identity.aggregateId }
@@ -577,8 +577,8 @@ var MisattributedEventError = class extends KitWiringError {
 	eventType;
 	constructor(options) {
 		super("MISATTRIBUTED_EVENT", `New event "${options.eventType}" belongs to ${describeEventIdentity(options)} but was applied on ${describeAggregateIdentity(options.expected)}: fix the call site (createEvent stamps the right identity).`);
-		this.expected = detachAggregateIdentity(options.expected);
-		this.actual = detachPartialAggregateIdentity(options.actual);
+		this.expected = copyAggregateIdentity(options.expected);
+		this.actual = copyPartialAggregateIdentity(options.actual);
 		this.eventType = options.eventType;
 	}
 };
@@ -596,7 +596,7 @@ var SnapshotVersionNotRestoredError = class extends KitWiringError {
 	restoredVersion;
 	constructor(options) {
 		super("SNAPSHOT_VERSION_NOT_RESTORED", `SnapshotModel.reconstitute for ${describeAggregateIdentity(options.identity)} returned an aggregate at version ${options.restoredVersion} for a snapshot at version ${options.snapshotVersion}. Reconstitution must restore the persisted version; call markReconstituted(version) inside the aggregate factory.`);
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 		this.snapshotVersion = options.snapshotVersion;
 		this.restoredVersion = options.restoredVersion;
 	}
@@ -622,49 +622,48 @@ var SnapshotCorruptedError = class extends InfrastructureError {
 };
 /**
 * Thrown when an event reaches the aggregate's recording paths
-* (`apply`, `setState`, `addDomainEvent`) without having been minted by
-* the kit's constructors: `createDomainEvent`,
-* `createDomainEventFromFacts`, `createUncommittedDomainEvent`, or the
-* aggregate `createEvent` helper. Those constructors deep-freeze the
+* (`apply`, `setState`, `addDomainEvent`) without having been built by
+* the kit's constructors: `createDomainEvent`, `createStampedDomainEvent`, or
+* the aggregate `createEvent` helper. Those constructors deep-freeze the
 * event, defensively copy payload and metadata, and mark the result as
-* minted. The mark has two tiers: a
+* kit-built. The mark has two tiers: a
 * module-private one for events of this loaded copy of the kit, and a
-* cooperative `Symbol.for` brand that a second loaded copy stamps and
+* cooperative `Symbol.for` brand that a second loaded copy applies and
 * recognizes. Anything else (a hand-rolled literal, a shallow-frozen
 * copy with mutable nested data) is rejected: a mutable event recorded
 * next to a state change can silently diverge from it afterwards. A
 * wiring error: deterministic bug at the call site, the remedy is
-* minting through the constructors. The gate catches accidents, not
+* building through the constructors. The gate catches accidents, not
 * adversaries: code in the same process can fake the brand.
 */
-var UnmintedEventError = class extends KitWiringError {
+var HandBuiltEventError = class extends KitWiringError {
 	constructor(eventType) {
-		super("UNMINTED_EVENT", `Event "${eventType}" was not minted by a domain-event constructor or aggregate createEvent(...) helper. Those constructors deep-freeze the event and defensively copy payload and metadata; a mutable event could diverge from the state change it records.`);
+		super("HAND_BUILT_EVENT", `Event "${eventType}" was not built by a domain-event constructor or aggregate createEvent(...) helper. Those constructors deep-freeze the event and defensively copy payload and metadata; a mutable event could diverge from the state change it records.`);
 	}
 };
 /**
-* Thrown by `recordPendingEvents` when the aggregate's pending-event list
+* Thrown by `stampPendingEvents` when the aggregate's pending-event list
 * changes while its events are being stamped: a stamp provider that
 * directly or transitively triggers a new decision on the same aggregate
 * would otherwise have that decision silently discarded when recording
 * replaces the pending list. Recording is atomic: when this guard fires,
-* every decision (including the re-entrant one) remains unrecorded. A
+* every decision (including the re-entrant one) remains unstamped. A
 * wiring error: deterministic bug at the call site, the remedy is keeping
 * stamp providers free of domain decisions.
 */
 var ReentrantEventRecordingError = class extends KitWiringError {
 	identity;
 	constructor(options) {
-		super("REENTRANT_EVENT_RECORDING", `Pending events of aggregate ${describeAggregateIdentity(options.identity)} changed while recordPendingEvents was stamping them. A stamp provider must not trigger new decisions on the aggregate being recorded; make every domain decision first, then record.`);
-		this.identity = detachAggregateIdentity(options.identity);
+		super("REENTRANT_EVENT_RECORDING", `Pending events of aggregate ${describeAggregateIdentity(options.identity)} changed while stampPendingEvents was stamping them. A stamp provider must not trigger new decisions on the aggregate being recorded; make every domain decision first, then stamp.`);
+		this.identity = copyAggregateIdentity(options.identity);
 	}
 };
 /**
 * Thrown when two facts of one aggregate would carry the same `eventId`.
-* Two causes, two sites: the aggregate rejects a recorded event that is
+* Two causes, two sites: the aggregate rejects a stamped event that is
 * already pending at the append, before the state moves; and
-* `recordPendingEvents` rejects a stamp provider that returns one reused
-* stamp (or repeats an explicit id). Either would mint two distinct facts
+* `stampPendingEvents` rejects a stamp provider that returns one reused
+* stamp (or repeats an explicit id). Either would create two distinct facts
 * sharing one identity, and downstream idempotent consumers keyed on
 * `eventId` silently drop one of them. A wiring error: deterministic bug at
 * the append site or in the stamp provider, the remedy is one fresh
@@ -675,8 +674,8 @@ var DuplicateEventIdError = class extends KitWiringError {
 	/** The event id two pending events would have shared. */
 	eventId;
 	constructor(options) {
-		super("DUPLICATE_EVENT_ID", `Two pending events of aggregate ${describeAggregateIdentity(options.identity)} carry the same eventId "${options.eventId}". Each fact needs its own event id: append a recorded event once, and return a fresh stamp per decision from the stamp provider.`);
-		this.identity = detachAggregateIdentity(options.identity);
+		super("DUPLICATE_EVENT_ID", `Two pending events of aggregate ${describeAggregateIdentity(options.identity)} carry the same eventId "${options.eventId}". Each fact needs its own event id: append a stamped event once, and return a fresh stamp per decision from the stamp provider.`);
+		this.identity = copyAggregateIdentity(options.identity);
 		this.eventId = options.eventId;
 	}
 };
@@ -696,7 +695,7 @@ var PendingEventLimitExceededError = class extends KitWiringError {
 	added;
 	constructor(options) {
 		super("PENDING_EVENT_LIMIT_EXCEEDED", `Aggregate ${describeAggregateIdentity(options.identity)} holds ${options.pending} pending event(s) and cannot record ${options.added} more: maxPendingEvents is ${options.limit}. A decision that emits this many facts points at a missing aggregate boundary.`);
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 		this.limit = options.limit;
 		this.pending = options.pending;
 		this.added = options.added;
@@ -709,15 +708,15 @@ var PendingEventLimitExceededError = class extends KitWiringError {
 * pending event at the same position. Acknowledging such a batch would
 * drop decisions the commit never persisted or keep events it did. The
 * pending list stays untouched. A wiring error in application commit
-* orchestration: acknowledge exactly the batch that was enrolled, once.
+* orchestration: acknowledge exactly the batch that was registered, once.
 */
 var PendingEventBatchMismatchError = class extends KitWiringError {
 	identity;
 	batchLength;
 	pendingLength;
 	constructor(options) {
-		super("PENDING_EVENT_BATCH_MISMATCH", `The committed batch of ${options.batchLength} event(s) is no longer the pending prefix of aggregate ${describeAggregateIdentity(options.identity)} (${options.pendingLength} pending). Acknowledge exactly the batch that was enrolled, once.`);
-		this.identity = detachAggregateIdentity(options.identity);
+		super("PENDING_EVENT_BATCH_MISMATCH", `The committed batch of ${options.batchLength} event(s) is no longer the pending prefix of aggregate ${describeAggregateIdentity(options.identity)} (${options.pendingLength} pending). Acknowledge exactly the batch that was registered, once.`);
+		this.identity = copyAggregateIdentity(options.identity);
 		this.batchLength = options.batchLength;
 		this.pendingLength = options.pendingLength;
 	}
@@ -750,8 +749,8 @@ var ForeignEventError = class extends InfrastructureError {
 			code: "FOREIGN_EVENT",
 			message: `Persisted event "${options.eventType}" belongs to ${describeEventIdentity(options)}, not to ${describeAggregateIdentity(options.expected)}: the stream row belongs to a different aggregate.`
 		});
-		this.expected = detachAggregateIdentity(options.expected);
-		this.actual = detachPartialAggregateIdentity(options.actual);
+		this.expected = copyAggregateIdentity(options.expected);
+		this.actual = copyPartialAggregateIdentity(options.actual);
 		this.eventType = options.eventType;
 	}
 };
@@ -815,7 +814,7 @@ var InvalidEventStreamPageError = class extends InfrastructureError {
 			code: "INVALID_EVENT_STREAM_PAGE",
 			message: eventStreamPageReasonMessage(stream, options)
 		});
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 		this.reason = options.reason;
 		this.fromVersion = options.fromVersion;
 		this.targetVersion = options.targetVersion;
@@ -863,7 +862,7 @@ var ReplayTargetMismatchError = class extends InfrastructureError {
 			code: "REPLAY_TARGET_MISMATCH",
 			message
 		});
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 		this.reason = options.reason;
 		this.fromVersion = options.fromVersion;
 		this.targetVersion = options.targetVersion;
@@ -893,15 +892,15 @@ var ReplayRejectedError = class extends InfrastructureError {
 			message: options.fromVersion === options.toVersion ? `The replay target of ${stream} rejected an empty history at version ${options.fromVersion} with ${rejected}` : `The aggregate ${stream} rejected a stored event in the page (${options.fromVersion}, ${options.toVersion}] with ${rejected}`,
 			cause: options.cause
 		});
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 		this.fromVersion = options.fromVersion;
 		this.toVersion = options.toVersion;
 	}
 };
 /**
-* Thrown when an event harvested from an aggregate cannot be safely composed
+* Thrown when an event collected from an aggregate cannot be safely composed
 * into a commit envelope, or when an outbox can prove that accepting a
-* candidate would violate its event identity/source chain. Harvest failures
+* candidate would violate its event identity/source chain. Collect failures
 * include missing `aggregateId` / `aggregateType` (downstream routing would
 * break), or an
 * eventful persisted aggregate did not advance its version (two commits
@@ -917,10 +916,10 @@ var ReplayRejectedError = class extends InfrastructureError {
 * `UnitOfWork.run` passes it through unchanged instead of wrapping it in
 * `CommitError`.
 */
-var EventHarvestError = class extends KitWiringError {
+var EventCollectionError = class extends KitWiringError {
 	eventType;
 	constructor(message, eventType) {
-		super("EVENT_HARVEST_FAILED", message);
+		super("EVENT_COLLECTION_FAILED", message);
 		this.eventType = eventType;
 	}
 };
@@ -963,8 +962,8 @@ var UnmanagedInstanceError = class extends KitWiringError {
 * helpers. One implementation so the contract cannot drift.
 * Module-internal export; not part of the package entries.
 */
-function assertNoHostileOwnProtoKey(value, subject) {
-	if (Object.hasOwn(value, "__proto__")) throw new HostileStateKeyError("__proto__", subject);
+function assertNoOwnProtoKey(value, subject) {
+	if (Object.hasOwn(value, "__proto__")) throw new PrototypePollutionError("__proto__", subject);
 }
 /**
 * Produced by the in-memory `CommandBus` / `QueryBus` when a message is
@@ -1055,11 +1054,11 @@ var ErrorMapperFailedError = class extends KitWiringError {
 * message names the rule instead: a loaded append-only aggregate must not
 * change.
 */
-var UnenrolledChangesError = class extends KitWiringError {
+var UnregisteredChangesError = class extends KitWiringError {
 	identity;
 	constructor(options) {
-		super("UNENROLLED_CHANGES", `Aggregate ${describeAggregateIdentity(options.identity)} was loaded and changed in this unit of work, ` + (options.appendOnly ? "but its repository is append-only and installs no update. An append-only aggregate must not change after add." : "but no update intent was registered. Call repository.update(aggregate) after the final domain decision so state and events flush together."));
-		this.identity = detachAggregateIdentity(options.identity);
+		super("UNREGISTERED_CHANGES", `Aggregate ${describeAggregateIdentity(options.identity)} was loaded and changed in this unit of work, ` + (options.appendOnly ? "but its repository is append-only and installs no update. An append-only aggregate must not change after add." : "but no update intent was registered. Call repository.update(aggregate) after the final domain decision so state and events flush together."));
+		this.identity = copyAggregateIdentity(options.identity);
 	}
 };
 /**
@@ -1076,7 +1075,7 @@ var AggregateDeletedError = class extends KitWiringError {
 	identity;
 	constructor(options) {
 		super("AGGREGATE_DELETED", `Aggregate ${describeAggregateIdentity(options.identity)} was removed in this unit of work and cannot be added, updated, tracked, or removed through another instance again. Removal is final within an operation. A repeated remove of the SAME instance is an accepted no-op; if the aggregate must remain, do not remove it.`);
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 	}
 };
 var AggregateNotFoundError = class extends InfrastructureError {
@@ -1087,7 +1086,7 @@ var AggregateNotFoundError = class extends InfrastructureError {
 			message: `Aggregate not found: ${describeAggregateIdentity(options.identity)}`,
 			cause: options.cause
 		});
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 	}
 };
 var DuplicateAggregateError = class extends InfrastructureError {
@@ -1098,7 +1097,7 @@ var DuplicateAggregateError = class extends InfrastructureError {
 			message: `Duplicate aggregate: ${describeAggregateIdentity(options.identity)} already exists`,
 			cause: options.cause
 		});
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 	}
 };
 var SnapshotSchemaMismatchError = class extends InfrastructureError {
@@ -1110,7 +1109,7 @@ var SnapshotSchemaMismatchError = class extends InfrastructureError {
 			code: "SNAPSHOT_SCHEMA_MISMATCH",
 			message: `Snapshot schema mismatch on ${describeAggregateIdentity(options.identity)}: the snapshot model expects schema ${options.expectedSchemaVersion}, the stored snapshot carries ${options.actualSchemaVersion}. Override the model's migrate function to upgrade old snapshots, or discard the snapshot and refold from the full event stream.`
 		});
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 		this.expectedSchemaVersion = options.expectedSchemaVersion;
 		this.actualSchemaVersion = options.actualSchemaVersion;
 	}
@@ -1125,7 +1124,7 @@ var SnapshotSchemaMismatchError = class extends InfrastructureError {
 * **Retry means a FRESH unit of work** (a new `UnitOfWork.run()` /
 * `withCommit` invocation): reload, re-apply, and register `update` again. Do NOT catch this
 * inside the same `run()` callback and continue: the failed aggregate
-* is already enrolled (its events would be committed for a write that
+* is already registered (its events would be committed for a write that
 * never happened) and the identity map still serves the same stale
 * instance to any in-place "reload".
 *
@@ -1149,7 +1148,7 @@ var ConcurrencyConflictError = class extends InfrastructureError {
 			cause: options.cause,
 			retryable: options.reason !== "version_unchanged"
 		});
-		this.identity = detachAggregateIdentity(options.identity);
+		this.identity = copyAggregateIdentity(options.identity);
 		this.intent = options.intent ?? null;
 		this.expectedVersion = options.expectedVersion;
 		this.actualVersion = options.actualVersion ?? null;
@@ -1300,5 +1299,5 @@ var IdempotencyCompletionWithoutClaimError = class extends KitWiringError {
 };
 
 //#endregion
-export { isDomainErrorLike as $, MissingHandlerError as A, SnapshotCorruptedError as B, InvalidEventStreamPageError as C, MisattributedEventError as D, KitWiringError as E, ProjectionOrderViolationError as F, UnmintedEventError as G, SnapshotVersionNotRestoredError as H, ProjectionReceiptViolationError as I, UnreplayableAggregateError as J, UnprojectableEventError as K, ReentrantEventRecordingError as L, PendingEventLimitExceededError as M, ProjectionGapError as N, MissingEntityIdError as O, ProjectionIdentityViolationError as P, detachAggregateIdentity as Q, ReplayRejectedError as R, InvalidCommandMessageError as S, InvalidVersionError as T, UnenrolledChangesError as U, SnapshotSchemaMismatchError as V, UnmanagedInstanceError as W, attributeConflictIntent as X, assertNoHostileOwnProtoKey as Y, describeAggregateIdentity as Z, IdempotencyInFlightError as _, DirectStateMutationError as a, InMemoryCapacityExceededError as b, DuplicateEventIdError as c, EventHarvestError as d, isInfrastructureErrorLike as et, FoldReturnedNoStateError as f, IdempotencyCompletionWithoutClaimError as g, IdempotencyClaimLostError as h, ConcurrencyConflictError as i, PendingEventBatchMismatchError as j, MissingFoldError as k, DuplicateHandlerRegistrationError as l, HostileStateKeyError as m, AggregateNotFoundError as n, rewriteErrorMessage as nt, DomainError as o, ForeignEventError as p, UnregisteredHandlerError as q, CapabilityRegistryConflictError as r, DuplicateAggregateError as s, AggregateDeletedError as t, isWiringErrorLike as tt, ErrorMapperFailedError as u, IdempotencyKeyReuseError as v, InvalidIntegrationMessageError as w, InfrastructureError as x, IdempotencyReconciliationRequiredError as y, ReplayTargetMismatchError as z };
+export { isDomainErrorLike as $, MissingHandlerError as A, ReplayTargetMismatchError as B, InvalidEventStreamPageError as C, MisattributedEventError as D, KitWiringError as E, ProjectionOrderViolationError as F, UnprojectableEventError as G, SnapshotSchemaMismatchError as H, ProjectionReceiptViolationError as I, UnreplayableAggregateError as J, UnregisteredChangesError as K, PrototypePollutionError as L, PendingEventLimitExceededError as M, ProjectionGapError as N, MissingEntityIdError as O, ProjectionIdentityViolationError as P, describeAggregateIdentity as Q, ReentrantEventRecordingError as R, InvalidCommandMessageError as S, InvalidVersionError as T, SnapshotVersionNotRestoredError as U, SnapshotCorruptedError as V, UnmanagedInstanceError as W, attributeConflictIntent as X, assertNoOwnProtoKey as Y, copyAggregateIdentity as Z, IdempotencyInFlightError as _, DirectStateMutationError as a, InMemoryCapacityExceededError as b, DuplicateEventIdError as c, EventCollectionError as d, isInfrastructureErrorLike as et, FoldReturnedNoStateError as f, IdempotencyCompletionWithoutClaimError as g, IdempotencyClaimLostError as h, ConcurrencyConflictError as i, PendingEventBatchMismatchError as j, MissingFoldError as k, DuplicateHandlerRegistrationError as l, HandBuiltEventError as m, AggregateNotFoundError as n, rewriteErrorMessage as nt, DomainError as o, ForeignEventError as p, UnregisteredHandlerError as q, CapabilityRegistryConflictError as r, DuplicateAggregateError as s, AggregateDeletedError as t, isWiringErrorLike as tt, ErrorMapperFailedError as u, IdempotencyKeyReuseError as v, InvalidIntegrationMessageError as w, InfrastructureError as x, IdempotencyReconciliationRequiredError as y, ReplayRejectedError as z };
 //# sourceMappingURL=kit-errors.js.map