@event-driven-io/emmett 0.23.0-alpha.4 → 0.23.0-alpha.6

package/dist/index.d.cts

@@ -251,6 +251,23 @@ declare const isEquatable: <T>(left: T) => left is Equatable<T>;
 
 declare const sum: (iterator: Iterator<number, number, number> | Iterator<number>) => number;
 
+type LockOptions = {
+    lockId: number;
+};
+type AcquireLockOptions = {
+    lockId: string;
+};
+type ReleaseLockOptions = {
+    lockId: string;
+};
+type Lock = {
+    acquire(options: AcquireLockOptions): Promise<void>;
+    tryAcquire(options: AcquireLockOptions): Promise<boolean>;
+    release(options: ReleaseLockOptions): Promise<boolean>;
+    withAcquire: <Result = unknown>(handle: () => Promise<Result>, options: AcquireLockOptions) => Promise<Result>;
+};
+declare const InProcessLock: () => Lock;
+
 declare const merge: <T>(array: T[], item: T, where: (current: T) => boolean, onExisting: (current: T) => T, onNotFound?: () => T | undefined) => T[];
 
 type AsyncRetryOptions = retry.Options & {
@@ -478,6 +495,40 @@ declare const streamTransformations: {
     waitAtMost: <Item>(waitTimeInMs: number) => web_streams_polyfill.TransformStream<Item, Item>;
 };
 
+type TaskQueue = TaskQueueItem[];
+type TaskQueueItem = {
+    task: () => Promise<void>;
+    options?: EnqueueTaskOptions;
+};
+type TaskProcessorOptions = {
+    maxActiveTasks: number;
+    maxQueueSize: number;
+    maxTaskIdleTime?: number;
+};
+type Task<T> = (context: TaskContext) => Promise<T>;
+type TaskContext = {
+    ack: () => void;
+};
+type EnqueueTaskOptions = {
+    taskGroupId?: string;
+};
+declare class TaskProcessor {
+    private options;
+    private queue;
+    private isProcessing;
+    private activeTasks;
+    private activeGroups;
+    constructor(options: TaskProcessorOptions);
+    enqueue<T>(task: Task<T>, options?: EnqueueTaskOptions): Promise<T>;
+    waitForEndOfProcessing(): Promise<void>;
+    private schedule;
+    private ensureProcessing;
+    private processQueue;
+    private executeItem;
+    private takeFirstAvailableItem;
+    private hasItemsToProcess;
+}
+
 declare class AssertionError extends Error {
     constructor(message: string);
 }
@@ -547,7 +598,7 @@ type ThenThrows<ErrorType extends Error> = (() => void) | ((errorConstructor: Er
 type DeciderSpecfication<Command, Event> = (givenEvents: Event | Event[]) => {
     when: (command: Command) => {
         then: (expectedEvents: Event | Event[]) => void;
-        thenDoesNothing: () => void;
+        thenNothingHappened: () => void;
         thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => void;
     };
 };
@@ -584,4 +635,4 @@ declare const assertNotEmptyString: (value: unknown) => string;
 declare const assertPositiveNumber: (value: unknown) => number;
 declare const assertUnsignedBigInt: (value: string) => bigint;
 
-export { type AggregateStreamOptions, type AggregateStreamResult, type AggregateStreamResultOfEventStore, type AggregateStreamResultWithGlobalPosition, type AppendStreamResultOfEventStore, type AppendToStreamOptions, type AppendToStreamResult, type AppendToStreamResultWithGlobalPosition, type ArgumentMatcher, AssertionError, type AsyncRetryOptions, type BigIntGlobalPosition, type BigIntStreamPosition, BinaryJsonDecoder, type Brand, type CanHandle, CaughtUpTransformStream, type Command, type CommandBus, type CommandDataOf, CommandHandler$1 as CommandHandler, type CommandHandlerOptions, type CommandHandlerResult, type CommandHandlerRetryOptions, CommandHandlerStreamVersionConflictRetryOptions, type CommandMetaDataOf, type CommandProcessor, type CommandSender, type CommandTypeOf, CompositeDecoder, ConcurrencyError, type CreateCommandType, type CreateEventType, type Decider, DeciderCommandHandler, type DeciderCommandHandlerOptions, type DeciderSpecfication, DeciderSpecification, type Decoder, type DeepReadonly, type DefaultCommandMetadata, DefaultDecoder, type DefaultRecord, type Equatable, ErrorConstructor, type Event, type EventBus, type EventDataOf, type EventHandler$1 as EventHandler, type EventMetaDataOf, type EventProcessor, type EventStore, type EventStoreReadEventMetadata, type EventStoreSession, type EventStoreSessionFactory, type EventStoreWrapper, type EventTypeOf, type EventsPublisher, type ExpectedStreamVersion, type ExpectedStreamVersionGeneral, type ExpectedStreamVersionWithValue, ExpectedVersionConflictError, type Flavour, type GlobalPositionTypeOfEventStore, type GlobalPositionTypeOfReadEventMetadata, type GlobalStreamCaughtUp, GlobalStreamCaughtUpType, type GlobalSubscriptionEvent, type HandleOptions, type InMemoryEventStore, InMemoryEventStoreDefaultStreamVersion, JSONParser, JsonDecoder, type Mapper, type MapperArgs, type MessageBus, type MessageHandler, type MessageProcessor, type MessageScheduler, type MockedFunction, type Mutable, NO_CONCURRENCY_CHECK, NoRetries, type NonNullable, ObjectDecoder, ParseError, type ParseOptions, type ProjectionDefinition, type ProjectionHandler, type ProjectionHandlingType, type ProjectionRegistration, type ReadEvent, type ReadEventMetadata, type ReadEventMetadataWithGlobalPosition, type ReadEventMetadataWithoutGlobalPosition, type ReadStreamOptions, type ReadStreamResult, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, type ScheduleOptions, type ScheduledMessage, type ScheduledMessageProcessor, type StreamPositionTypeOfEventStore, type StreamPositionTypeOfReadEventMetadata, StreamingCoordinator, StringDecoder, type StringifyOptions, type TestEventStream, type ThenThrows, type TypedProjectionDefinition, ValidationErrors, type Workflow, type WorkflowCommand, type WorkflowEvent, type WorkflowOutput, WrapEventStore, accept, argMatches, argValue, assertDeepEqual, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUnsignedBigInt, asyncProjections, asyncRetry, canCreateEventStoreSession, caughtUpEventFrom, collect, command, complete, concatUint8Arrays, deepEquals, error, event, formatDateToUtcYYYYMMDD, getInMemoryEventStore, getInMemoryMessageBus, globalStreamCaughtUp, ignore, inlineProjections, isEquatable, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, matchesExpectedVersion, merge, nulloSessionFactory, parseDateFromUtcYYYYMMDD, projection, projections, publish, reply, restream, schedule, send, streamGenerators, streamTrackingGlobalPosition, streamTransformations, sum, verifyThat };
+export { type AcquireLockOptions, type AggregateStreamOptions, type AggregateStreamResult, type AggregateStreamResultOfEventStore, type AggregateStreamResultWithGlobalPosition, type AppendStreamResultOfEventStore, type AppendToStreamOptions, type AppendToStreamResult, type AppendToStreamResultWithGlobalPosition, type ArgumentMatcher, AssertionError, type AsyncRetryOptions, type BigIntGlobalPosition, type BigIntStreamPosition, BinaryJsonDecoder, type Brand, type CanHandle, CaughtUpTransformStream, type Command, type CommandBus, type CommandDataOf, CommandHandler$1 as CommandHandler, type CommandHandlerOptions, type CommandHandlerResult, type CommandHandlerRetryOptions, CommandHandlerStreamVersionConflictRetryOptions, type CommandMetaDataOf, type CommandProcessor, type CommandSender, type CommandTypeOf, CompositeDecoder, ConcurrencyError, type CreateCommandType, type CreateEventType, type Decider, DeciderCommandHandler, type DeciderCommandHandlerOptions, type DeciderSpecfication, DeciderSpecification, type Decoder, type DeepReadonly, type DefaultCommandMetadata, DefaultDecoder, type DefaultRecord, type EnqueueTaskOptions, type Equatable, ErrorConstructor, type Event, type EventBus, type EventDataOf, type EventHandler$1 as EventHandler, type EventMetaDataOf, type EventProcessor, type EventStore, type EventStoreReadEventMetadata, type EventStoreSession, type EventStoreSessionFactory, type EventStoreWrapper, type EventTypeOf, type EventsPublisher, type ExpectedStreamVersion, type ExpectedStreamVersionGeneral, type ExpectedStreamVersionWithValue, ExpectedVersionConflictError, type Flavour, type GlobalPositionTypeOfEventStore, type GlobalPositionTypeOfReadEventMetadata, type GlobalStreamCaughtUp, GlobalStreamCaughtUpType, type GlobalSubscriptionEvent, type HandleOptions, type InMemoryEventStore, InMemoryEventStoreDefaultStreamVersion, InProcessLock, JSONParser, JsonDecoder, type Lock, type LockOptions, type Mapper, type MapperArgs, type MessageBus, type MessageHandler, type MessageProcessor, type MessageScheduler, type MockedFunction, type Mutable, NO_CONCURRENCY_CHECK, NoRetries, type NonNullable, ObjectDecoder, ParseError, type ParseOptions, type ProjectionDefinition, type ProjectionHandler, type ProjectionHandlingType, type ProjectionRegistration, type ReadEvent, type ReadEventMetadata, type ReadEventMetadataWithGlobalPosition, type ReadEventMetadataWithoutGlobalPosition, type ReadStreamOptions, type ReadStreamResult, type ReleaseLockOptions, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, type ScheduleOptions, type ScheduledMessage, type ScheduledMessageProcessor, type StreamPositionTypeOfEventStore, type StreamPositionTypeOfReadEventMetadata, StreamingCoordinator, StringDecoder, type StringifyOptions, type Task, type TaskContext, TaskProcessor, type TaskProcessorOptions, type TaskQueue, type TaskQueueItem, type TestEventStream, type ThenThrows, type TypedProjectionDefinition, ValidationErrors, type Workflow, type WorkflowCommand, type WorkflowEvent, type WorkflowOutput, WrapEventStore, accept, argMatches, argValue, assertDeepEqual, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUnsignedBigInt, asyncProjections, asyncRetry, canCreateEventStoreSession, caughtUpEventFrom, collect, command, complete, concatUint8Arrays, deepEquals, error, event, formatDateToUtcYYYYMMDD, getInMemoryEventStore, getInMemoryMessageBus, globalStreamCaughtUp, ignore, inlineProjections, isEquatable, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, matchesExpectedVersion, merge, nulloSessionFactory, parseDateFromUtcYYYYMMDD, projection, projections, publish, reply, restream, schedule, send, streamGenerators, streamTrackingGlobalPosition, streamTransformations, sum, verifyThat };

package/dist/index.d.ts

@@ -251,6 +251,23 @@ declare const isEquatable: <T>(left: T) => left is Equatable<T>;
 
 declare const sum: (iterator: Iterator<number, number, number> | Iterator<number>) => number;
 
+type LockOptions = {
+    lockId: number;
+};
+type AcquireLockOptions = {
+    lockId: string;
+};
+type ReleaseLockOptions = {
+    lockId: string;
+};
+type Lock = {
+    acquire(options: AcquireLockOptions): Promise<void>;
+    tryAcquire(options: AcquireLockOptions): Promise<boolean>;
+    release(options: ReleaseLockOptions): Promise<boolean>;
+    withAcquire: <Result = unknown>(handle: () => Promise<Result>, options: AcquireLockOptions) => Promise<Result>;
+};
+declare const InProcessLock: () => Lock;
+
 declare const merge: <T>(array: T[], item: T, where: (current: T) => boolean, onExisting: (current: T) => T, onNotFound?: () => T | undefined) => T[];
 
 type AsyncRetryOptions = retry.Options & {
@@ -478,6 +495,40 @@ declare const streamTransformations: {
     waitAtMost: <Item>(waitTimeInMs: number) => web_streams_polyfill.TransformStream<Item, Item>;
 };
 
+type TaskQueue = TaskQueueItem[];
+type TaskQueueItem = {
+    task: () => Promise<void>;
+    options?: EnqueueTaskOptions;
+};
+type TaskProcessorOptions = {
+    maxActiveTasks: number;
+    maxQueueSize: number;
+    maxTaskIdleTime?: number;
+};
+type Task<T> = (context: TaskContext) => Promise<T>;
+type TaskContext = {
+    ack: () => void;
+};
+type EnqueueTaskOptions = {
+    taskGroupId?: string;
+};
+declare class TaskProcessor {
+    private options;
+    private queue;
+    private isProcessing;
+    private activeTasks;
+    private activeGroups;
+    constructor(options: TaskProcessorOptions);
+    enqueue<T>(task: Task<T>, options?: EnqueueTaskOptions): Promise<T>;
+    waitForEndOfProcessing(): Promise<void>;
+    private schedule;
+    private ensureProcessing;
+    private processQueue;
+    private executeItem;
+    private takeFirstAvailableItem;
+    private hasItemsToProcess;
+}
+
 declare class AssertionError extends Error {
     constructor(message: string);
 }
@@ -547,7 +598,7 @@ type ThenThrows<ErrorType extends Error> = (() => void) | ((errorConstructor: Er
 type DeciderSpecfication<Command, Event> = (givenEvents: Event | Event[]) => {
     when: (command: Command) => {
         then: (expectedEvents: Event | Event[]) => void;
-        thenDoesNothing: () => void;
+        thenNothingHappened: () => void;
         thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => void;
     };
 };
@@ -584,4 +635,4 @@ declare const assertNotEmptyString: (value: unknown) => string;
 declare const assertPositiveNumber: (value: unknown) => number;
 declare const assertUnsignedBigInt: (value: string) => bigint;
 
-export { type AggregateStreamOptions, type AggregateStreamResult, type AggregateStreamResultOfEventStore, type AggregateStreamResultWithGlobalPosition, type AppendStreamResultOfEventStore, type AppendToStreamOptions, type AppendToStreamResult, type AppendToStreamResultWithGlobalPosition, type ArgumentMatcher, AssertionError, type AsyncRetryOptions, type BigIntGlobalPosition, type BigIntStreamPosition, BinaryJsonDecoder, type Brand, type CanHandle, CaughtUpTransformStream, type Command, type CommandBus, type CommandDataOf, CommandHandler$1 as CommandHandler, type CommandHandlerOptions, type CommandHandlerResult, type CommandHandlerRetryOptions, CommandHandlerStreamVersionConflictRetryOptions, type CommandMetaDataOf, type CommandProcessor, type CommandSender, type CommandTypeOf, CompositeDecoder, ConcurrencyError, type CreateCommandType, type CreateEventType, type Decider, DeciderCommandHandler, type DeciderCommandHandlerOptions, type DeciderSpecfication, DeciderSpecification, type Decoder, type DeepReadonly, type DefaultCommandMetadata, DefaultDecoder, type DefaultRecord, type Equatable, ErrorConstructor, type Event, type EventBus, type EventDataOf, type EventHandler$1 as EventHandler, type EventMetaDataOf, type EventProcessor, type EventStore, type EventStoreReadEventMetadata, type EventStoreSession, type EventStoreSessionFactory, type EventStoreWrapper, type EventTypeOf, type EventsPublisher, type ExpectedStreamVersion, type ExpectedStreamVersionGeneral, type ExpectedStreamVersionWithValue, ExpectedVersionConflictError, type Flavour, type GlobalPositionTypeOfEventStore, type GlobalPositionTypeOfReadEventMetadata, type GlobalStreamCaughtUp, GlobalStreamCaughtUpType, type GlobalSubscriptionEvent, type HandleOptions, type InMemoryEventStore, InMemoryEventStoreDefaultStreamVersion, JSONParser, JsonDecoder, type Mapper, type MapperArgs, type MessageBus, type MessageHandler, type MessageProcessor, type MessageScheduler, type MockedFunction, type Mutable, NO_CONCURRENCY_CHECK, NoRetries, type NonNullable, ObjectDecoder, ParseError, type ParseOptions, type ProjectionDefinition, type ProjectionHandler, type ProjectionHandlingType, type ProjectionRegistration, type ReadEvent, type ReadEventMetadata, type ReadEventMetadataWithGlobalPosition, type ReadEventMetadataWithoutGlobalPosition, type ReadStreamOptions, type ReadStreamResult, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, type ScheduleOptions, type ScheduledMessage, type ScheduledMessageProcessor, type StreamPositionTypeOfEventStore, type StreamPositionTypeOfReadEventMetadata, StreamingCoordinator, StringDecoder, type StringifyOptions, type TestEventStream, type ThenThrows, type TypedProjectionDefinition, ValidationErrors, type Workflow, type WorkflowCommand, type WorkflowEvent, type WorkflowOutput, WrapEventStore, accept, argMatches, argValue, assertDeepEqual, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUnsignedBigInt, asyncProjections, asyncRetry, canCreateEventStoreSession, caughtUpEventFrom, collect, command, complete, concatUint8Arrays, deepEquals, error, event, formatDateToUtcYYYYMMDD, getInMemoryEventStore, getInMemoryMessageBus, globalStreamCaughtUp, ignore, inlineProjections, isEquatable, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, matchesExpectedVersion, merge, nulloSessionFactory, parseDateFromUtcYYYYMMDD, projection, projections, publish, reply, restream, schedule, send, streamGenerators, streamTrackingGlobalPosition, streamTransformations, sum, verifyThat };
+export { type AcquireLockOptions, type AggregateStreamOptions, type AggregateStreamResult, type AggregateStreamResultOfEventStore, type AggregateStreamResultWithGlobalPosition, type AppendStreamResultOfEventStore, type AppendToStreamOptions, type AppendToStreamResult, type AppendToStreamResultWithGlobalPosition, type ArgumentMatcher, AssertionError, type AsyncRetryOptions, type BigIntGlobalPosition, type BigIntStreamPosition, BinaryJsonDecoder, type Brand, type CanHandle, CaughtUpTransformStream, type Command, type CommandBus, type CommandDataOf, CommandHandler$1 as CommandHandler, type CommandHandlerOptions, type CommandHandlerResult, type CommandHandlerRetryOptions, CommandHandlerStreamVersionConflictRetryOptions, type CommandMetaDataOf, type CommandProcessor, type CommandSender, type CommandTypeOf, CompositeDecoder, ConcurrencyError, type CreateCommandType, type CreateEventType, type Decider, DeciderCommandHandler, type DeciderCommandHandlerOptions, type DeciderSpecfication, DeciderSpecification, type Decoder, type DeepReadonly, type DefaultCommandMetadata, DefaultDecoder, type DefaultRecord, type EnqueueTaskOptions, type Equatable, ErrorConstructor, type Event, type EventBus, type EventDataOf, type EventHandler$1 as EventHandler, type EventMetaDataOf, type EventProcessor, type EventStore, type EventStoreReadEventMetadata, type EventStoreSession, type EventStoreSessionFactory, type EventStoreWrapper, type EventTypeOf, type EventsPublisher, type ExpectedStreamVersion, type ExpectedStreamVersionGeneral, type ExpectedStreamVersionWithValue, ExpectedVersionConflictError, type Flavour, type GlobalPositionTypeOfEventStore, type GlobalPositionTypeOfReadEventMetadata, type GlobalStreamCaughtUp, GlobalStreamCaughtUpType, type GlobalSubscriptionEvent, type HandleOptions, type InMemoryEventStore, InMemoryEventStoreDefaultStreamVersion, InProcessLock, JSONParser, JsonDecoder, type Lock, type LockOptions, type Mapper, type MapperArgs, type MessageBus, type MessageHandler, type MessageProcessor, type MessageScheduler, type MockedFunction, type Mutable, NO_CONCURRENCY_CHECK, NoRetries, type NonNullable, ObjectDecoder, ParseError, type ParseOptions, type ProjectionDefinition, type ProjectionHandler, type ProjectionHandlingType, type ProjectionRegistration, type ReadEvent, type ReadEventMetadata, type ReadEventMetadataWithGlobalPosition, type ReadEventMetadataWithoutGlobalPosition, type ReadStreamOptions, type ReadStreamResult, type ReleaseLockOptions, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, type ScheduleOptions, type ScheduledMessage, type ScheduledMessageProcessor, type StreamPositionTypeOfEventStore, type StreamPositionTypeOfReadEventMetadata, StreamingCoordinator, StringDecoder, type StringifyOptions, type Task, type TaskContext, TaskProcessor, type TaskProcessorOptions, type TaskQueue, type TaskQueueItem, type TestEventStream, type ThenThrows, type TypedProjectionDefinition, ValidationErrors, type Workflow, type WorkflowCommand, type WorkflowEvent, type WorkflowOutput, WrapEventStore, accept, argMatches, argValue, assertDeepEqual, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUnsignedBigInt, asyncProjections, asyncRetry, canCreateEventStoreSession, caughtUpEventFrom, collect, command, complete, concatUint8Arrays, deepEquals, error, event, formatDateToUtcYYYYMMDD, getInMemoryEventStore, getInMemoryMessageBus, globalStreamCaughtUp, ignore, inlineProjections, isEquatable, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, matchesExpectedVersion, merge, nulloSessionFactory, parseDateFromUtcYYYYMMDD, projection, projections, publish, reply, restream, schedule, send, streamGenerators, streamTrackingGlobalPosition, streamTransformations, sum, verifyThat };

package/dist/index.js

@@ -371,6 +371,178 @@ var sum = (iterator) => {
   return sum2;
 };
 
+// src/taskProcessing/taskProcessor.ts
+var TaskProcessor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  queue = [];
+  isProcessing = false;
+  activeTasks = 0;
+  activeGroups = /* @__PURE__ */ new Set();
+  enqueue(task, options) {
+    if (this.queue.length >= this.options.maxQueueSize) {
+      return Promise.reject(
+        new EmmettError(
+          "Too many pending connections. Please try again later."
+        )
+      );
+    }
+    return this.schedule(task, options);
+  }
+  waitForEndOfProcessing() {
+    return this.schedule(({ ack }) => Promise.resolve(ack()));
+  }
+  schedule(task, options) {
+    return promiseWithDeadline(
+      (resolve, reject) => {
+        const taskWithContext = () => {
+          return new Promise((resolveTask, failTask) => {
+            const taskPromise = task({
+              ack: resolveTask
+            });
+            taskPromise.then(resolve).catch((err) => {
+              failTask(err);
+              reject(err);
+            });
+          });
+        };
+        this.queue.push({ task: taskWithContext, options });
+        if (!this.isProcessing) {
+          this.ensureProcessing();
+        }
+      },
+      { deadline: this.options.maxTaskIdleTime }
+    );
+  }
+  ensureProcessing() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    this.processQueue();
+  }
+  processQueue() {
+    try {
+      while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
+        const item = this.takeFirstAvailableItem();
+        if (item === null) return;
+        const groupId = item.options?.taskGroupId;
+        if (groupId) {
+          this.activeGroups.add(groupId);
+        }
+        this.activeTasks++;
+        void this.executeItem(item);
+      }
+    } catch (error2) {
+      console.error(error2);
+      throw error2;
+    } finally {
+      this.isProcessing = false;
+      if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) {
+        this.ensureProcessing();
+      }
+    }
+  }
+  async executeItem({ task, options }) {
+    try {
+      await task();
+    } finally {
+      this.activeTasks--;
+      if (options && options.taskGroupId) {
+        this.activeGroups.delete(options.taskGroupId);
+      }
+      this.ensureProcessing();
+    }
+  }
+  takeFirstAvailableItem = () => {
+    const taskIndex = this.queue.findIndex(
+      (item2) => !item2.options?.taskGroupId || !this.activeGroups.has(item2.options.taskGroupId)
+    );
+    if (taskIndex === -1) {
+      return null;
+    }
+    const [item] = this.queue.splice(taskIndex, 1);
+    return item ?? null;
+  };
+  hasItemsToProcess = () => this.queue.findIndex(
+    (item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)
+  ) !== -1;
+};
+var DEFAULT_PROMISE_DEADLINE = 2147483647;
+var promiseWithDeadline = (executor, options) => {
+  return new Promise((resolve, reject) => {
+    let taskStarted = false;
+    const maxWaitingTime = options.deadline || DEFAULT_PROMISE_DEADLINE;
+    let timeoutId = setTimeout(() => {
+      if (!taskStarted) {
+        reject(
+          new Error("Task was not started within the maximum waiting time")
+        );
+      }
+    }, maxWaitingTime);
+    executor((value) => {
+      taskStarted = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = null;
+      resolve(value);
+    }, reject);
+  });
+};
+
+// src/utils/locking/index.ts
+var InProcessLock = () => {
+  const taskProcessor = new TaskProcessor({
+    maxActiveTasks: Number.MAX_VALUE,
+    maxQueueSize: Number.MAX_VALUE
+  });
+  const locks = /* @__PURE__ */ new Map();
+  return {
+    async acquire({ lockId }) {
+      await new Promise((resolve, reject) => {
+        taskProcessor.enqueue(
+          ({ ack }) => {
+            locks.set(lockId, ack);
+            resolve();
+            return Promise.resolve();
+          },
+          { taskGroupId: lockId }
+        ).catch(reject);
+      });
+    },
+    async tryAcquire({ lockId }) {
+      if (locks.has(lockId)) {
+        return false;
+      }
+      await this.acquire({ lockId });
+      return true;
+    },
+    release({ lockId }) {
+      const ack = locks.get(lockId);
+      if (ack === void 0) {
+        return Promise.resolve(true);
+      }
+      locks.delete(lockId);
+      ack();
+      return Promise.resolve(true);
+    },
+    async withAcquire(handle, { lockId }) {
+      return taskProcessor.enqueue(
+        async ({ ack }) => {
+          locks.set(lockId, ack);
+          try {
+            return await handle();
+          } finally {
+            locks.delete(lockId);
+            ack();
+          }
+        },
+        { taskGroupId: lockId }
+      );
+    }
+  };
+};
+
 // src/utils/merge.ts
 var merge = (array, item, where, onExisting, onNotFound = () => void 0) => {
   let wasFound = false;
@@ -1223,7 +1395,7 @@ var DeciderSpecification = {
                   expectedEventsArray
                 );
               },
-              thenDoesNothing: () => {
+              thenNothingHappened: () => {
                 const resultEvents = handle();
                 const resultEventsArray = Array.isArray(resultEvents) ? resultEvents : [resultEvents];
                 assertThatArray(resultEventsArray).isEmpty();
@@ -1317,6 +1489,7 @@ export {
   GlobalStreamCaughtUpType,
   IllegalStateError,
   InMemoryEventStoreDefaultStreamVersion,
+  InProcessLock,
   JSONParser,
   JsonDecoder,
   NO_CONCURRENCY_CHECK,
@@ -1328,6 +1501,7 @@ export {
   STREAM_EXISTS,
   StreamingCoordinator,
   StringDecoder,
+  TaskProcessor,
   ValidationError,
   ValidationErrors,
   WrapEventStore,