@shirudo/ddd-kit 3.0.0-rc.6 → 3.0.0-rc.8

package/dist/chunks/snapshot-store.d.ts

@@ -931,9 +931,11 @@ interface AggregateSnapshot<TState> {
  * part of this surface. The application shell holds that authority.
  *
  * @template TId    - The aggregate root identifier (branded via `Id<Tag>`)
- * @template TEvent - The domain-event union, defaults to `never`
+ * @template TEvent - The domain-event union. Defaults to `AnyDomainEvent`,
+ *   so a bound written as `Aggregate<TId>` admits every aggregate root,
+ *   with or without events.
  */
-interface Aggregate<TId extends Id<string>, TEvent extends AnyDomainEvent = never> {
+interface Aggregate<TId extends Id<string>, TEvent extends AnyDomainEvent = AnyDomainEvent> {
   readonly id: TId;
   readonly version: Version;
   readonly pendingEvents: ReadonlyArray<PendingDomainEvent<TEvent>>;

package/dist/index.d.ts

@@ -1533,6 +1533,12 @@ interface RepositoryTracking<TAggregate extends Aggregate<Id<string>, AnyDomainE
  * the exact moment at which the application registered its write intent.
  * Adapters must use the expected/current version pair for their OCC predicate
  * and must not read mutable write state back from an aggregate reference.
+ *
+ * The predicate itself is adapter code. The compare-and-set must run in the
+ * store's own write statement. The kit does not know the store, so it cannot
+ * write that statement. The kit owns the version pair and
+ * {@link ConcurrencyConflictError}; the repository contract suite proves the
+ * predicate.
  */
 interface AggregatePersistenceWrite<TAggregate extends Aggregate<Id<string>, AnyDomainEvent>, TChangeSet> {
   readonly intent: AggregateWriteIntent;
@@ -1731,7 +1737,12 @@ interface RunOptions {
 declare const repositoryDefinitionBrand: unique symbol;
 /** Adapter wiring accepted by {@link defineRepository}. */
 interface RepositoryDefinitionOptions<TCtx, TRepositoryPort extends object, TAggregate extends Aggregate<Id<string>, AnyDomainEvent>, TBaseline, TChangeSet, TRemoval extends boolean = false> {
-  /** Concrete aggregate class used as the Identity Map key. */
+  /**
+   * Concrete aggregate class used as the Identity Map key, and for nothing
+   * else. The read adapter passes the same class to `identityMap.get`, so
+   * the class is exported. Its protected constructor keeps `new` out of
+   * reach; the static factories stay the only door.
+   */
   readonly aggregate: AggregateClass<TAggregate>;
   /** Adapter-owned projection, baseline, and change-set policy. */
   readonly persistence: PersistenceModel<TAggregate, TBaseline, TChangeSet>;
@@ -4017,7 +4028,7 @@ declare class InMemoryEventStore<Evt extends AnyDomainEvent> implements EventSto
  * @template TAggregate - Aggregate root loaded and registered by the port.
  * @template TId - Branded aggregate identifier.
  */
-interface AggregatePersistence<TAggregate extends Aggregate<TId>, TId extends Id<string>> {
+interface AggregatePersistence<TAggregate extends Aggregate<TId, AnyDomainEvent>, TId extends Id<string>> {
   /**
    * Finds an aggregate by identity.
    *
@@ -4066,7 +4077,7 @@ interface AggregatePersistence<TAggregate extends Aggregate<TId>, TId extends Id
  * by an order command, while read-heavy access remains on a projection or query
  * port.
  */
-interface Repository<TAggregate extends Aggregate<TId>, TId extends Id<string>> extends AggregatePersistence<TAggregate, TId> {
+interface Repository<TAggregate extends Aggregate<TId, AnyDomainEvent>, TId extends Id<string>> extends AggregatePersistence<TAggregate, TId> {
   /**
    * Registers a tracked aggregate for physical removal at commit.
    *

package/dist/index.js

@@ -1,5 +1,5 @@
 import { A as NonProgressingEventStreamPageError, B as SnapshotSchemaMismatchError, C as InvalidIntegrationMessageError, D as MissingEntityIdError, E as MisaddressedEventError, F as ProjectionOrderViolationError, G as UnprojectableEventError, H as UnenrolledChangesError, I as ProjectionReceiptViolationError, J as assertNoHostileOwnProtoKey, K as UnregisteredHandlerError, L as ReentrantEventRecordingError, M as PendingEventLimitExceededError, N as ProjectionGapError, O as MissingFoldError, P as ProjectionIdentityViolationError, R as ReplayHeadMismatchError, S as InvalidCommandMessageError, T as KitWiringError, U as UnmanagedInstanceError, V as SnapshotVersionNotRestoredError, W as UnmintedEventError, X as isInfrastructureErrorLike, Y as isDomainErrorLike, _ as IdempotencyInFlightError, a as DirectStateMutationError, b as InMemoryCapacityExceededError, c as DuplicateEventIdError, d as EventHarvestError, f as FoldReturnedNoStateError, g as IdempotencyCompletionWithoutClaimError, h as IdempotencyClaimLostError, i as ConcurrencyConflictError, j as PendingEventBatchMismatchError, k as MissingHandlerError, l as DuplicateHandlerRegistrationError, m as HostileStateKeyError, n as AggregateNotFoundError, o as DomainError, p as ForeignEventError, q as UnreplayableAggregateError, r as CapabilityRegistryConflictError, s as DuplicateAggregateError, t as AggregateDeletedError, u as ErrorMapperFailedError, v as IdempotencyKeyReuseError, w as InvalidVersionError, x as InfrastructureError, y as IdempotencyReconciliationRequiredError, z as SnapshotCorruptedError } from "./chunks/kit-errors.js";
-import { A as isBuiltInObject, C as voWithValidation, D as builtInTagWithoutInvokingAccessors, E as deepEqual, M as isWeakMap, O as findPropertyDescriptor, S as voEqualsExcept, T as deepOmit, _ as stampCooperativeBrand, a as createDomainEvent, b as vo, c as createUncommittedDomainEvent, d as isUncommittedDomainEvent, f as mergeMetadata, g as hasCooperativeBrand, h as SnapshotTimeValidationError, i as copyMetadata, j as isIntrinsicConstructorPrototype, k as hasIntrinsicPrototypeChain, l as defaultDomainEventFactory, m as DomainEventValidationError, n as adoptRecordedDomainEvent, o as createDomainEventFactory, p as recordDomainEvent, r as adoptUncommittedDomainEvent, s as createDomainEventFromFacts, t as isDispatchTrackingOutbox, u as isRecordedDomainEvent, v as ValueObject, w as deepEqualExcept, x as voEquals, y as deepFreeze } from "./chunks/ports.js";
+import { A as voWithValidation, C as hasCooperativeBrand, D as vo, E as deepFreeze, F as findPropertyDescriptor, I as hasIntrinsicPrototypeChain, L as isBuiltInObject, M as deepOmit, N as deepEqual, O as voEquals, P as builtInTagWithoutInvokingAccessors, R as isIntrinsicConstructorPrototype, S as SnapshotTimeValidationError, T as ValueObject, _ as isRecordedDomainEvent, a as assertNonNegativeFinite, b as recordDomainEvent, c as abortReason, d as copyMetadata, f as createDomainEvent, g as defaultDomainEventFactory, h as createUncommittedDomainEvent, i as runBoundedExecution, j as deepEqualExcept, k as voEqualsExcept, l as adoptRecordedDomainEvent, m as createDomainEventFromFacts, n as DEFAULT_EXECUTION_TIMEOUT_MS, o as assertPositiveInteger, p as createDomainEventFactory, r as ownerSignalOf, s as assertPositiveSafeInteger, t as isDispatchTrackingOutbox, u as adoptUncommittedDomainEvent, v as isUncommittedDomainEvent, w as stampCooperativeBrand, x as DomainEventValidationError, y as mergeMetadata, z as isWeakMap } from "./chunks/ports.js";
 import { err, ok } from "@shirudo/result";
 import { ValidationError, someChainRetryable } from "@shirudo/base-error";
 
@@ -363,130 +363,6 @@ function pendingEventLifecycleReadViewFor(aggregate) {
 	return pendingEventLifecycleCapabilityFor(aggregate);
 }
 
-//#endregion
-//#region src/internal/async/abort.ts
-/**
-* The value to reject with when an `AbortSignal` has fired.
-*
-* Returns the signal's `reason` (a `DOMException` `AbortError` for
-* `controller.abort()`, `TimeoutError` for `AbortSignal.timeout`), falling
-* back to a plain `Error` with `fallbackMessage` when `reason` is nullish.
-* A spec-compliant signal always populates `reason` when aborted, so the
-* fallback only fires for a non-spec polyfill; without it, a bare
-* `throw undefined` would surface, breaking `instanceof Error` handling.
-*
-* Centralizes the `signal.reason ?? new Error(...)` idiom used at every
-* abort site (event bus, `withCommit`, `UnitOfWork.run`, the retrying
-* scope) so a single fix covers all of them.
-*/
-function abortReason(signal, fallbackMessage) {
-	return signal.reason ?? new Error(fallbackMessage);
-}
-
-//#endregion
-//#region src/internal/validate.ts
-/**
-* Shared construction-time guards for numeric options. `context` names
-* the throwing component so the error reads like the component's own
-* validation ("OutboxDispatcher: pollIntervalMs must be...").
-*/
-/** Guard for numeric options that must be a non-negative finite number. */
-function assertNonNegativeFinite(context, field, value) {
-	if (!Number.isFinite(value) || value < 0) throw new Error(`${context}: ${field} must be a non-negative finite number, got ${value}`);
-}
-/** Guard for count options that must be a whole number of at least 1. */
-function assertPositiveInteger(context, field, value) {
-	if (!Number.isInteger(value) || value < 1) throw new Error(`${context}: ${field} must be an integer >= 1, got ${value}`);
-}
-/** Guard for retained-record capacities that must fit exact JS integers. */
-function assertPositiveSafeInteger(context, field, value) {
-	if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`${context}: ${field} must be a positive safe integer, got ${value}`);
-}
-
-//#endregion
-//#region src/internal/async/execution.ts
-/** Default bound for delivery and post-commit operations. */
-const DEFAULT_EXECUTION_TIMEOUT_MS = 3e4;
-/**
-* Owner signal of each child signal that {@link runBoundedExecution} minted.
-*
-* One bounded operation often wraps another, and every hop derives a fresh
-* signal. A consumer that follows a call chain by signal identity alone loses
-* the link at the first hop. Key and value are both weak: a long chain of
-* nested operations must not hold its whole ancestry alive.
-*/
-const executionOwners = /* @__PURE__ */ new WeakMap();
-/**
-* The signal that a bounded execution derived this one from, or `undefined`
-* when the signal did not come from {@link runBoundedExecution} or had no
-* owner. Walk it to follow a chain across nested bounded executions.
-*/
-function ownerSignalOf(signal) {
-	return executionOwners.get(signal)?.deref();
-}
-/**
-* Runs one operation with a child signal that combines owner cancellation and a
-* shell-owned timeout. The returned promise settles on abort even when an
-* adapter ignores the signal; the adapter promise remains observed so a later
-* rejection cannot become an unhandled rejection.
-*
-* This bounds how long the shell waits; JavaScript cannot forcibly terminate
-* an arbitrary promise. An I/O adapter that must prevent zombie work and
-* overlapping retries has to pass `context.signal` to its native operation or
-* enforce a native timeout no later than `context.deadlineAt`.
-*/
-function runBoundedExecution(label, options, operation) {
-	if (options.deadlineAt === void 0) assertNonNegativeFinite(label, "timeoutMs", options.timeoutMs);
-	else assertNonNegativeFinite(label, "deadlineAt", options.deadlineAt);
-	const startedAt = Date.now();
-	const deadlineAt = options.deadlineAt ?? startedAt + options.timeoutMs;
-	const timeoutMs = Math.max(0, deadlineAt - startedAt);
-	const timeoutError = () => new DOMException(`${label} timed out after ${timeoutMs}ms`, "TimeoutError");
-	const controller = new AbortController();
-	const context = Object.freeze({
-		signal: controller.signal,
-		deadlineAt
-	});
-	const ownerSignal = options.signal;
-	if (ownerSignal !== void 0) executionOwners.set(controller.signal, new WeakRef(ownerSignal));
-	const abortFromOwner = () => {
-		controller.abort(ownerSignal === void 0 ? /* @__PURE__ */ new Error(`${label} aborted`) : abortReason(ownerSignal, `${label} aborted`));
-	};
-	if (ownerSignal?.aborted) abortFromOwner();
-	else ownerSignal?.addEventListener("abort", abortFromOwner, { once: true });
-	if (!controller.signal.aborted && options.deadlineAt !== void 0 && deadlineAt <= startedAt) controller.abort(timeoutError());
-	const timer = setTimeout(() => {
-		controller.abort(timeoutError());
-	}, timeoutMs);
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		const finish = (complete) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			ownerSignal?.removeEventListener("abort", abortFromOwner);
-			controller.signal.removeEventListener("abort", onAbort);
-			complete();
-		};
-		const onAbort = () => {
-			queueMicrotask(() => finish(() => reject(abortReason(controller.signal, `${label} aborted`))));
-		};
-		if (controller.signal.aborted) {
-			onAbort();
-			return;
-		}
-		controller.signal.addEventListener("abort", onAbort, { once: true });
-		let outcome;
-		try {
-			outcome = Promise.resolve(operation(context));
-		} catch (error) {
-			finish(() => reject(error));
-			return;
-		}
-		outcome.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
-	});
-}
-
 //#endregion
 //#region src/internal/observer.ts
 /**