@event-driven-io/emmett 0.23.0-alpha.5 → 0.23.0-alpha.7

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7;
 
 
 
@@ -17,18 +17,6 @@
 
 var _chunkFNITWKARcjs = require('./chunk-FNITWKAR.cjs');
 
-// src/eventStore/eventStore.ts
-var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
-var nulloSessionFactory = (eventStore) => ({
-  withSession: (callback) => {
-    const nulloSession = {
-      eventStore,
-      close: () => Promise.resolve()
-    };
-    return callback(nulloSession);
-  }
-});
-
 // src/typing/command.ts
 var command = (type, data, metadata) => {
   return {
@@ -94,16 +82,47 @@ var accept = () => {
   return { kind: "Accept" };
 };
 
+// src/eventStore/afterCommit/afterEventStoreCommitHandler.ts
+async function tryPublishMessagesAfterCommit(messages, options, context) {
+  if (_optionalChain([options, 'optionalAccess', _2 => _2.onAfterCommit]) === void 0) return false;
+  try {
+    await _optionalChain([options, 'optionalAccess', _3 => _3.onAfterCommit, 'call', _4 => _4(messages, context)]);
+    return true;
+  } catch (error2) {
+    console.error(`Error in on after commit hook`, error2);
+    return false;
+  }
+}
+
+// src/eventStore/afterCommit/forwardToMessageBus.ts
+var forwardToMessageBus = (eventPublisher) => async (messages) => {
+  for (const message of messages) {
+    await eventPublisher.publish(message);
+  }
+};
+
 // src/eventStore/events/index.ts
 var GlobalStreamCaughtUpType = "__emt:GlobalStreamCaughtUp";
 var isGlobalStreamCaughtUp = (event2) => event2.type === GlobalStreamCaughtUpType;
-var caughtUpEventFrom = (position) => (event2) => event2.type === GlobalStreamCaughtUpType && _optionalChain([event2, 'access', _2 => _2.metadata, 'optionalAccess', _3 => _3.globalPosition]) >= position;
+var caughtUpEventFrom = (position) => (event2) => event2.type === GlobalStreamCaughtUpType && _optionalChain([event2, 'access', _5 => _5.metadata, 'optionalAccess', _6 => _6.globalPosition]) >= position;
 var globalStreamCaughtUp = (data) => event(GlobalStreamCaughtUpType, data, {
   globalPosition: data.globalPosition
 });
 var isSubscriptionEvent = (event2) => isGlobalStreamCaughtUp(event2);
 var isNotInternalEvent = (event2) => !isGlobalStreamCaughtUp(event2);
 
+// src/eventStore/eventStore.ts
+var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
+var nulloSessionFactory = (eventStore) => ({
+  withSession: (callback) => {
+    const nulloSession = {
+      eventStore,
+      close: () => Promise.resolve()
+    };
+    return callback(nulloSession);
+  }
+});
+
 // src/eventStore/expectedVersion.ts
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
@@ -121,7 +140,7 @@ var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) =>
 };
 var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends _chunkFNITWKARcjs.ConcurrencyError {
   constructor(current, expected) {
-    super(_optionalChain([current, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), _optionalChain([expected, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]));
+    super(_optionalChain([current, 'optionalAccess', _7 => _7.toString, 'call', _8 => _8()]), _optionalChain([expected, 'optionalAccess', _9 => _9.toString, 'call', _10 => _10()]));
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
@@ -178,9 +197,9 @@ var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfi
       }
     });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
     this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.streamId]), () => ( _uuid.v4.call(void 0, )));
+    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.streamId]), () => ( _uuid.v4.call(void 0, )));
     this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => ( 20)));
+    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _12 => _12.intervalCheckInMs]), () => ( 20)));
   }
   __init() {this.checkInterval = null}
   
@@ -257,7 +276,7 @@ var StreamingCoordinator = () => {
 
 // src/eventStore/inMemoryEventStore.ts
 var InMemoryEventStoreDefaultStreamVersion = 0n;
-var getInMemoryEventStore = () => {
+var getInMemoryEventStore = (eventStoreOptions) => {
   const streams = /* @__PURE__ */ new Map();
   const streamingCoordinator = StreamingCoordinator();
   const getAllEventsCount = () => {
@@ -267,7 +286,7 @@ var getInMemoryEventStore = () => {
     async aggregateStream(streamName, options) {
       const { evolve, initialState, read } = options;
       const result = await this.readStream(streamName, read);
-      const events = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _10 => _10.events]), () => ( []));
+      const events = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _13 => _13.events]), () => ( []));
       return {
         currentStreamVersion: BigInt(events.length),
         state: events.reduce(evolve, initialState()),
@@ -279,12 +298,12 @@ var getInMemoryEventStore = () => {
       const currentStreamVersion = events ? BigInt(events.length) : InMemoryEventStoreDefaultStreamVersion;
       assertExpectedVersionMatchesCurrent(
         currentStreamVersion,
-        _optionalChain([options, 'optionalAccess', _11 => _11.expectedStreamVersion]),
+        _optionalChain([options, 'optionalAccess', _14 => _14.expectedStreamVersion]),
         InMemoryEventStoreDefaultStreamVersion
       );
       const from = Number(options && "from" in options ? options.from : 0);
       const to = Number(
-        options && "to" in options ? options.to : options && "maxCount" in options && options.maxCount ? options.from + options.maxCount : _nullishCoalesce(_optionalChain([events, 'optionalAccess', _12 => _12.length]), () => ( 1))
+        options && "to" in options ? options.to : options && "maxCount" in options && options.maxCount ? options.from + options.maxCount : _nullishCoalesce(_optionalChain([events, 'optionalAccess', _15 => _15.length]), () => ( 1))
       );
       const resultEvents = events !== void 0 && events.length > 0 ? events.map(
         (e) => e
@@ -301,7 +320,7 @@ var getInMemoryEventStore = () => {
       const currentStreamVersion = currentEvents.length > 0 ? BigInt(currentEvents.length) : InMemoryEventStoreDefaultStreamVersion;
       assertExpectedVersionMatchesCurrent(
         currentStreamVersion,
-        _optionalChain([options, 'optionalAccess', _13 => _13.expectedStreamVersion]),
+        _optionalChain([options, 'optionalAccess', _16 => _16.expectedStreamVersion]),
         InMemoryEventStoreDefaultStreamVersion
       );
       const newEvents = events.map((event2, index) => {
@@ -325,6 +344,7 @@ var getInMemoryEventStore = () => {
         nextExpectedStreamVersion: positionOfLastEventInTheStream,
         createdNewStream: currentStreamVersion === InMemoryEventStoreDefaultStreamVersion
       };
+      await tryPublishMessagesAfterCommit(newEvents, _optionalChain([eventStoreOptions, 'optionalAccess', _17 => _17.hooks]));
       return result;
     }
     //streamEvents: streamingCoordinator.stream,
@@ -371,6 +391,178 @@ var sum = (iterator) => {
   return sum2;
 };
 
+// src/taskProcessing/taskProcessor.ts
+var TaskProcessor = (_class2 = class {
+  constructor(options) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);
+    this.options = options;
+  }
+  __init3() {this.queue = []}
+  __init4() {this.isProcessing = false}
+  __init5() {this.activeTasks = 0}
+  __init6() {this.activeGroups = /* @__PURE__ */ new Set()}
+  enqueue(task, options) {
+    if (this.queue.length >= this.options.maxQueueSize) {
+      return Promise.reject(
+        new (0, _chunkFNITWKARcjs.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 = _optionalChain([item, 'access', _22 => _22.options, 'optionalAccess', _23 => _23.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();
+    }
+  }
+  __init7() {this.takeFirstAvailableItem = () => {
+    const taskIndex = this.queue.findIndex(
+      (item2) => !_optionalChain([item2, 'access', _24 => _24.options, 'optionalAccess', _25 => _25.taskGroupId]) || !this.activeGroups.has(item2.options.taskGroupId)
+    );
+    if (taskIndex === -1) {
+      return null;
+    }
+    const [item] = this.queue.splice(taskIndex, 1);
+    return _nullishCoalesce(item, () => ( null));
+  }}
+  __init8() {this.hasItemsToProcess = () => this.queue.findIndex(
+    (item) => !_optionalChain([item, 'access', _26 => _26.options, 'optionalAccess', _27 => _27.taskGroupId]) || !this.activeGroups.has(item.options.taskGroupId)
+  ) !== -1}
+}, _class2);
+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;
@@ -399,7 +591,7 @@ var asyncRetry = async (fn, opts) => {
       try {
         return await fn();
       } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _14 => _14.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+        if (_optionalChain([opts, 'optionalAccess', _28 => _28.shouldRetryError]) && !opts.shouldRetryError(error2)) {
           bail(error2);
         }
         throw error2;
@@ -443,7 +635,7 @@ var CommandHandler = (options) => async (store, id, handle, handleOptions) => as
           // expected stream version is passed to fail fast
           // if stream is in the wrong state
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _15 => _15.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _29 => _29.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         }
       });
       const {
@@ -465,7 +657,7 @@ var CommandHandler = (options) => async (store, id, handle, handleOptions) => as
           createdNewStream: false
         };
       }
-      const expectedStreamVersion = _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _16 => _16.expectedStreamVersion]), () => ( (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST)));
+      const expectedStreamVersion = _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _30 => _30.expectedStreamVersion]), () => ( (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST)));
       const appendResult = await eventStore.appendToStream(
         streamName,
         newEvents,
@@ -573,17 +765,17 @@ var ParseError = class extends Error {
 var JSONParser = {
   stringify: (value, options) => {
     return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _17 => _17.map]) ? options.map(value) : value,
+      _optionalChain([options, 'optionalAccess', _31 => _31.map]) ? options.map(value) : value,
       //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       (_, v) => typeof v === "bigint" ? v.toString() : v
     );
   },
   parse: (text, options) => {
-    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _18 => _18.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _19 => _19.typeCheck]) && !_optionalChain([options, 'optionalAccess', _20 => _20.typeCheck, 'call', _21 => _21(parsed)]))
+    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _32 => _32.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _33 => _33.typeCheck]) && !_optionalChain([options, 'optionalAccess', _34 => _34.typeCheck, 'call', _35 => _35(parsed)]))
       throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _22 => _22.map]) ? options.map(parsed) : parsed;
+    return _optionalChain([options, 'optionalAccess', _36 => _36.map]) ? options.map(parsed) : parsed;
   }
 };
 
@@ -609,8 +801,8 @@ var collect = async (stream) => {
 };
 
 // src/streaming/decoders/binary.ts
-var BinaryJsonDecoder = (_class2 = class {constructor() { _class2.prototype.__init3.call(this); }
-  __init3() {this.buffer = []}
+var BinaryJsonDecoder = (_class3 = class {constructor() { _class3.prototype.__init9.call(this); }
+  __init9() {this.buffer = []}
   addToBuffer(data) {
     this.buffer.push(data);
   }
@@ -637,15 +829,15 @@ var BinaryJsonDecoder = (_class2 = class {constructor() { _class2.prototype.__in
     this.buffer = remaining.byteLength > 0 ? [remaining] : [];
     return JSON.parse(jsonString);
   }
-}, _class2);
+}, _class3);
 
 // src/streaming/decoders/string.ts
-var StringDecoder = (_class3 = class {
-  constructor(transform) {;_class3.prototype.__init4.call(this);
+var StringDecoder = (_class4 = class {
+  constructor(transform) {;_class4.prototype.__init10.call(this);
     this.transform = transform;
     this.transform = transform;
   }
-  __init4() {this.buffer = []}
+  __init10() {this.buffer = []}
   addToBuffer(data) {
     this.buffer.push(data);
   }
@@ -668,7 +860,7 @@ var StringDecoder = (_class3 = class {
     this.buffer = [completeString.slice(delimiterIndex + 1)];
     return this.transform(message);
   }
-}, _class3);
+}, _class4);
 
 // src/streaming/decoders/json.ts
 var JsonDecoder = class extends StringDecoder {
@@ -678,8 +870,8 @@ var JsonDecoder = class extends StringDecoder {
 };
 
 // src/streaming/decoders/object.ts
-var ObjectDecoder = (_class4 = class {constructor() { _class4.prototype.__init5.call(this); }
-  __init5() {this.buffer = null}
+var ObjectDecoder = (_class5 = class {constructor() { _class5.prototype.__init11.call(this); }
+  __init11() {this.buffer = null}
   addToBuffer(data) {
     this.buffer = data;
   }
@@ -697,7 +889,7 @@ var ObjectDecoder = (_class4 = class {constructor() { _class4.prototype.__init5.
     this.clearBuffer();
     return data;
   }
-}, _class4);
+}, _class5);
 
 // src/streaming/decoders/composite.ts
 var CompositeDecoder = class {
@@ -710,7 +902,7 @@ var CompositeDecoder = class {
     return decoder[1];
   }
   addToBuffer(data) {
-    _optionalChain([this, 'access', _23 => _23.decoderFor, 'call', _24 => _24(data), 'optionalAccess', _25 => _25.addToBuffer, 'call', _26 => _26(data)]);
+    _optionalChain([this, 'access', _37 => _37.decoderFor, 'call', _38 => _38(data), 'optionalAccess', _39 => _39.addToBuffer, 'call', _40 => _40(data)]);
   }
   clearBuffer() {
     for (const decoder of this.decoders.map((d) => d[1])) {
@@ -722,7 +914,7 @@ var CompositeDecoder = class {
   }
   decode() {
     const decoder = this.decoders.map((d) => d[1]).find((d) => d.hasCompleteMessage());
-    return _nullishCoalesce(_optionalChain([decoder, 'optionalAccess', _27 => _27.decode, 'call', _28 => _28()]), () => ( null));
+    return _nullishCoalesce(_optionalChain([decoder, 'optionalAccess', _41 => _41.decode, 'call', _42 => _42()]), () => ( null));
   }
 };
 var DefaultDecoder = class extends CompositeDecoder {
@@ -824,8 +1016,8 @@ var onRestream = async (createSourceStream, handleChunk2, controller) => {
 // src/streaming/transformations/skip.ts
 
 var skip = (limit) => new SkipTransformStream(limit);
-var SkipTransformStream = (_class5 = class extends _webstreamspolyfill.TransformStream {
-  __init6() {this.count = 0}
+var SkipTransformStream = (_class6 = class extends _webstreamspolyfill.TransformStream {
+  __init12() {this.count = 0}
   
   constructor(skip2) {
     super({
@@ -835,10 +1027,10 @@ var SkipTransformStream = (_class5 = class extends _webstreamspolyfill.Transform
           controller.enqueue(chunk);
         }
       }
-    });_class5.prototype.__init6.call(this);;
+    });_class6.prototype.__init12.call(this);;
     this.skip = skip2;
   }
-}, _class5);
+}, _class6);
 
 // src/streaming/transformations/stopAfter.ts
 
@@ -867,8 +1059,8 @@ var stopOn = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
 // src/streaming/transformations/take.ts
 
 var take = (limit) => new TakeTransformStream(limit);
-var TakeTransformStream = (_class6 = class extends _webstreamspolyfill.TransformStream {
-  __init7() {this.count = 0}
+var TakeTransformStream = (_class7 = class extends _webstreamspolyfill.TransformStream {
+  __init13() {this.count = 0}
   
   constructor(limit) {
     super({
@@ -880,10 +1072,10 @@ var TakeTransformStream = (_class6 = class extends _webstreamspolyfill.Transform
           controller.terminate();
         }
       }
-    });_class6.prototype.__init7.call(this);;
+    });_class7.prototype.__init13.call(this);;
     this.limit = limit;
   }
-}, _class6);
+}, _class7);
 
 // src/streaming/transformations/waitAtMost.ts
 
@@ -937,7 +1129,7 @@ var decodeAndTransform = (decoder, transform, controller) => {
     const transformed = transform(decoded);
     controller.enqueue(transformed);
   } catch (error2) {
-    controller.error(new Error(`Decoding error: ${_optionalChain([error2, 'optionalAccess', _29 => _29.toString, 'call', _30 => _30()])}`));
+    controller.error(new Error(`Decoding error: ${_optionalChain([error2, 'optionalAccess', _43 => _43.toString, 'call', _44 => _44()])}`));
   }
 };
 
@@ -1098,39 +1290,39 @@ var argMatches = (matches) => (arg) => matches(arg);
 function verifyThat(fn) {
   return {
     calledTimes: (times) => {
-      assertEqual(_optionalChain([fn, 'access', _31 => _31.mock, 'optionalAccess', _32 => _32.calls, 'optionalAccess', _33 => _33.length]), times);
+      assertEqual(_optionalChain([fn, 'access', _45 => _45.mock, 'optionalAccess', _46 => _46.calls, 'optionalAccess', _47 => _47.length]), times);
     },
     notCalled: () => {
-      assertEqual(_optionalChain([fn, 'optionalAccess', _34 => _34.mock, 'optionalAccess', _35 => _35.calls, 'optionalAccess', _36 => _36.length]), 0);
+      assertEqual(_optionalChain([fn, 'optionalAccess', _48 => _48.mock, 'optionalAccess', _49 => _49.calls, 'optionalAccess', _50 => _50.length]), 0);
     },
     called: () => {
       assertTrue(
-        _optionalChain([fn, 'access', _37 => _37.mock, 'optionalAccess', _38 => _38.calls, 'access', _39 => _39.length]) !== void 0 && fn.mock.calls.length > 0
+        _optionalChain([fn, 'access', _51 => _51.mock, 'optionalAccess', _52 => _52.calls, 'access', _53 => _53.length]) !== void 0 && fn.mock.calls.length > 0
       );
     },
     calledWith: (...args) => {
       assertTrue(
-        _optionalChain([fn, 'access', _40 => _40.mock, 'optionalAccess', _41 => _41.calls, 'access', _42 => _42.length]) !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
+        _optionalChain([fn, 'access', _54 => _54.mock, 'optionalAccess', _55 => _55.calls, 'access', _56 => _56.length]) !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
       );
     },
     calledOnceWith: (...args) => {
       assertTrue(
-        _optionalChain([fn, 'access', _43 => _43.mock, 'optionalAccess', _44 => _44.calls, 'access', _45 => _45.length]) !== void 0 && fn.mock.calls.length === 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
+        _optionalChain([fn, 'access', _57 => _57.mock, 'optionalAccess', _58 => _58.calls, 'access', _59 => _59.length]) !== void 0 && fn.mock.calls.length === 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
       );
     },
     calledWithArgumentMatching: (...matches) => {
       assertTrue(
-        _optionalChain([fn, 'access', _46 => _46.mock, 'optionalAccess', _47 => _47.calls, 'access', _48 => _48.length]) !== void 0 && fn.mock.calls.length >= 1
+        _optionalChain([fn, 'access', _60 => _60.mock, 'optionalAccess', _61 => _61.calls, 'access', _62 => _62.length]) !== void 0 && fn.mock.calls.length >= 1
       );
       assertTrue(
-        _optionalChain([fn, 'access', _49 => _49.mock, 'optionalAccess', _50 => _50.calls, 'access', _51 => _51.length]) !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some(
+        _optionalChain([fn, 'access', _63 => _63.mock, 'optionalAccess', _64 => _64.calls, 'access', _65 => _65.length]) !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some(
           (call) => call.arguments && call.arguments.length >= matches.length && matches.every((match, index) => match(call.arguments[index]))
         )
       );
     },
     notCalledWithArgumentMatching: (...matches) => {
       assertFalse(
-        _optionalChain([fn, 'access', _52 => _52.mock, 'optionalAccess', _53 => _53.calls, 'access', _54 => _54.length]) !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls[0].arguments && fn.mock.calls[0].arguments.length >= matches.length && matches.every(
+        _optionalChain([fn, 'access', _66 => _66.mock, 'optionalAccess', _67 => _67.calls, 'access', _68 => _68.length]) !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls[0].arguments && fn.mock.calls[0].arguments.length >= matches.length && matches.every(
           (match, index) => match(fn.mock.calls[0].arguments[index])
         )
       );
@@ -1238,18 +1430,18 @@ var DeciderSpecification = {
                   if (!_chunkFNITWKARcjs.isErrorConstructor.call(void 0, args[0])) {
                     assertTrue(
                       args[0](error2),
-                      `Error didn't match the error condition: ${_optionalChain([error2, 'optionalAccess', _55 => _55.toString, 'call', _56 => _56()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error2, 'optionalAccess', _69 => _69.toString, 'call', _70 => _70()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error2 instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error2, 'optionalAccess', _57 => _57.toString, 'call', _58 => _58()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error2, 'optionalAccess', _71 => _71.toString, 'call', _72 => _72()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error2),
-                      `Error didn't match the error condition: ${_optionalChain([error2, 'optionalAccess', _59 => _59.toString, 'call', _60 => _60()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error2, 'optionalAccess', _73 => _73.toString, 'call', _74 => _74()])}`
                     );
                   }
                 }
@@ -1399,5 +1591,9 @@ var WrapEventStore = (eventStore) => {
 
 
 
-exports.AssertionError = AssertionError; exports.BinaryJsonDecoder = BinaryJsonDecoder; exports.CaughtUpTransformStream = CaughtUpTransformStream; exports.CommandHandler = CommandHandler; exports.CommandHandlerStreamVersionConflictRetryOptions = CommandHandlerStreamVersionConflictRetryOptions; exports.CompositeDecoder = CompositeDecoder; exports.ConcurrencyError = _chunkFNITWKARcjs.ConcurrencyError; exports.DeciderCommandHandler = DeciderCommandHandler; exports.DeciderSpecification = DeciderSpecification; exports.DefaultDecoder = DefaultDecoder; exports.EmmettError = _chunkFNITWKARcjs.EmmettError; exports.ExpectedVersionConflictError = ExpectedVersionConflictError; exports.GlobalStreamCaughtUpType = GlobalStreamCaughtUpType; exports.IllegalStateError = _chunkFNITWKARcjs.IllegalStateError; exports.InMemoryEventStoreDefaultStreamVersion = InMemoryEventStoreDefaultStreamVersion; exports.JSONParser = JSONParser; exports.JsonDecoder = JsonDecoder; exports.NO_CONCURRENCY_CHECK = NO_CONCURRENCY_CHECK; exports.NoRetries = NoRetries; exports.NotFoundError = _chunkFNITWKARcjs.NotFoundError; exports.ObjectDecoder = ObjectDecoder; exports.ParseError = ParseError; exports.STREAM_DOES_NOT_EXIST = STREAM_DOES_NOT_EXIST; exports.STREAM_EXISTS = STREAM_EXISTS; exports.StreamingCoordinator = StreamingCoordinator; exports.StringDecoder = StringDecoder; exports.ValidationError = _chunkFNITWKARcjs.ValidationError; exports.ValidationErrors = _chunkFNITWKARcjs.ValidationErrors; exports.WrapEventStore = WrapEventStore; exports.accept = accept; exports.argMatches = argMatches; exports.argValue = argValue; exports.assertDeepEqual = assertDeepEqual; exports.assertDoesNotThrow = assertDoesNotThrow; exports.assertEqual = assertEqual; exports.assertExpectedVersionMatchesCurrent = assertExpectedVersionMatchesCurrent; exports.assertFails = assertFails; exports.assertFalse = assertFalse; exports.assertIsNotNull = assertIsNotNull; exports.assertIsNull = assertIsNull; exports.assertMatches = assertMatches; exports.assertNotDeepEqual = assertNotDeepEqual; exports.assertNotEmptyString = _chunkFNITWKARcjs.assertNotEmptyString; exports.assertNotEqual = assertNotEqual; exports.assertOk = assertOk; exports.assertPositiveNumber = _chunkFNITWKARcjs.assertPositiveNumber; exports.assertRejects = assertRejects; exports.assertThat = assertThat; exports.assertThatArray = assertThatArray; exports.assertThrows = assertThrows; exports.assertThrowsAsync = assertThrowsAsync; exports.assertTrue = assertTrue; exports.assertUnsignedBigInt = _chunkFNITWKARcjs.assertUnsignedBigInt; exports.asyncProjections = asyncProjections; exports.asyncRetry = asyncRetry; exports.canCreateEventStoreSession = canCreateEventStoreSession; exports.caughtUpEventFrom = caughtUpEventFrom; exports.collect = collect; exports.command = command; exports.complete = complete; exports.concatUint8Arrays = concatUint8Arrays; exports.deepEquals = deepEquals; exports.error = error; exports.event = event; exports.formatDateToUtcYYYYMMDD = _chunkFNITWKARcjs.formatDateToUtcYYYYMMDD; exports.getInMemoryEventStore = getInMemoryEventStore; exports.getInMemoryMessageBus = getInMemoryMessageBus; exports.globalStreamCaughtUp = globalStreamCaughtUp; exports.ignore = ignore; exports.inlineProjections = inlineProjections; exports.isEquatable = isEquatable; exports.isErrorConstructor = _chunkFNITWKARcjs.isErrorConstructor; exports.isExpectedVersionConflictError = isExpectedVersionConflictError; exports.isGlobalStreamCaughtUp = isGlobalStreamCaughtUp; exports.isNotInternalEvent = isNotInternalEvent; exports.isNumber = _chunkFNITWKARcjs.isNumber; exports.isPluginConfig = _chunkFNITWKARcjs.isPluginConfig; exports.isString = _chunkFNITWKARcjs.isString; exports.isSubscriptionEvent = isSubscriptionEvent; exports.isSubset = isSubset; exports.isValidYYYYMMDD = _chunkFNITWKARcjs.isValidYYYYMMDD; exports.matchesExpectedVersion = matchesExpectedVersion; exports.merge = merge; exports.nulloSessionFactory = nulloSessionFactory; exports.parseDateFromUtcYYYYMMDD = _chunkFNITWKARcjs.parseDateFromUtcYYYYMMDD; exports.projection = projection; exports.projections = projections; exports.publish = publish; exports.reply = reply; exports.restream = restream; exports.schedule = schedule; exports.send = send; exports.streamGenerators = streamGenerators; exports.streamTrackingGlobalPosition = streamTrackingGlobalPosition; exports.streamTransformations = streamTransformations; exports.sum = sum; exports.verifyThat = verifyThat;
+
+
+
+
+exports.AssertionError = AssertionError; exports.BinaryJsonDecoder = BinaryJsonDecoder; exports.CaughtUpTransformStream = CaughtUpTransformStream; exports.CommandHandler = CommandHandler; exports.CommandHandlerStreamVersionConflictRetryOptions = CommandHandlerStreamVersionConflictRetryOptions; exports.CompositeDecoder = CompositeDecoder; exports.ConcurrencyError = _chunkFNITWKARcjs.ConcurrencyError; exports.DeciderCommandHandler = DeciderCommandHandler; exports.DeciderSpecification = DeciderSpecification; exports.DefaultDecoder = DefaultDecoder; exports.EmmettError = _chunkFNITWKARcjs.EmmettError; exports.ExpectedVersionConflictError = ExpectedVersionConflictError; exports.GlobalStreamCaughtUpType = GlobalStreamCaughtUpType; exports.IllegalStateError = _chunkFNITWKARcjs.IllegalStateError; exports.InMemoryEventStoreDefaultStreamVersion = InMemoryEventStoreDefaultStreamVersion; exports.InProcessLock = InProcessLock; exports.JSONParser = JSONParser; exports.JsonDecoder = JsonDecoder; exports.NO_CONCURRENCY_CHECK = NO_CONCURRENCY_CHECK; exports.NoRetries = NoRetries; exports.NotFoundError = _chunkFNITWKARcjs.NotFoundError; exports.ObjectDecoder = ObjectDecoder; exports.ParseError = ParseError; exports.STREAM_DOES_NOT_EXIST = STREAM_DOES_NOT_EXIST; exports.STREAM_EXISTS = STREAM_EXISTS; exports.StreamingCoordinator = StreamingCoordinator; exports.StringDecoder = StringDecoder; exports.TaskProcessor = TaskProcessor; exports.ValidationError = _chunkFNITWKARcjs.ValidationError; exports.ValidationErrors = _chunkFNITWKARcjs.ValidationErrors; exports.WrapEventStore = WrapEventStore; exports.accept = accept; exports.argMatches = argMatches; exports.argValue = argValue; exports.assertDeepEqual = assertDeepEqual; exports.assertDoesNotThrow = assertDoesNotThrow; exports.assertEqual = assertEqual; exports.assertExpectedVersionMatchesCurrent = assertExpectedVersionMatchesCurrent; exports.assertFails = assertFails; exports.assertFalse = assertFalse; exports.assertIsNotNull = assertIsNotNull; exports.assertIsNull = assertIsNull; exports.assertMatches = assertMatches; exports.assertNotDeepEqual = assertNotDeepEqual; exports.assertNotEmptyString = _chunkFNITWKARcjs.assertNotEmptyString; exports.assertNotEqual = assertNotEqual; exports.assertOk = assertOk; exports.assertPositiveNumber = _chunkFNITWKARcjs.assertPositiveNumber; exports.assertRejects = assertRejects; exports.assertThat = assertThat; exports.assertThatArray = assertThatArray; exports.assertThrows = assertThrows; exports.assertThrowsAsync = assertThrowsAsync; exports.assertTrue = assertTrue; exports.assertUnsignedBigInt = _chunkFNITWKARcjs.assertUnsignedBigInt; exports.asyncProjections = asyncProjections; exports.asyncRetry = asyncRetry; exports.canCreateEventStoreSession = canCreateEventStoreSession; exports.caughtUpEventFrom = caughtUpEventFrom; exports.collect = collect; exports.command = command; exports.complete = complete; exports.concatUint8Arrays = concatUint8Arrays; exports.deepEquals = deepEquals; exports.error = error; exports.event = event; exports.formatDateToUtcYYYYMMDD = _chunkFNITWKARcjs.formatDateToUtcYYYYMMDD; exports.forwardToMessageBus = forwardToMessageBus; exports.getInMemoryEventStore = getInMemoryEventStore; exports.getInMemoryMessageBus = getInMemoryMessageBus; exports.globalStreamCaughtUp = globalStreamCaughtUp; exports.ignore = ignore; exports.inlineProjections = inlineProjections; exports.isEquatable = isEquatable; exports.isErrorConstructor = _chunkFNITWKARcjs.isErrorConstructor; exports.isExpectedVersionConflictError = isExpectedVersionConflictError; exports.isGlobalStreamCaughtUp = isGlobalStreamCaughtUp; exports.isNotInternalEvent = isNotInternalEvent; exports.isNumber = _chunkFNITWKARcjs.isNumber; exports.isPluginConfig = _chunkFNITWKARcjs.isPluginConfig; exports.isString = _chunkFNITWKARcjs.isString; exports.isSubscriptionEvent = isSubscriptionEvent; exports.isSubset = isSubset; exports.isValidYYYYMMDD = _chunkFNITWKARcjs.isValidYYYYMMDD; exports.matchesExpectedVersion = matchesExpectedVersion; exports.merge = merge; exports.nulloSessionFactory = nulloSessionFactory; exports.parseDateFromUtcYYYYMMDD = _chunkFNITWKARcjs.parseDateFromUtcYYYYMMDD; exports.projection = projection; exports.projections = projections; exports.publish = publish; exports.reply = reply; exports.restream = restream; exports.schedule = schedule; exports.send = send; exports.streamGenerators = streamGenerators; exports.streamTrackingGlobalPosition = streamTrackingGlobalPosition; exports.streamTransformations = streamTransformations; exports.sum = sum; exports.tryPublishMessagesAfterCommit = tryPublishMessagesAfterCommit; exports.verifyThat = verifyThat;
 //# sourceMappingURL=index.cjs.map