@event-driven-io/emmett 0.43.0-beta.12 → 0.43.0-beta.14

package/dist/index.js

@@ -1,2915 +1,2205 @@
-import {
-  ConcurrencyError,
-  ConcurrencyInMemoryDatabaseError,
-  EmmettError,
-  IllegalStateError,
-  NotFoundError,
-  ValidationError,
-  ValidationErrors,
-  assertNotEmptyString,
-  assertPositiveNumber,
-  assertUnsignedBigInt,
-  formatDateToUtcYYYYMMDD,
-  isBigint,
-  isErrorConstructor,
-  isNumber,
-  isPluginConfig,
-  isString,
-  isValidYYYYMMDD,
-  parseDateFromUtcYYYYMMDD
-} from "./chunk-AZDDB5SF.js";
+import { _ as isValidYYYYMMDD, a as IllegalStateError, c as isErrorConstructor, d as assertPositiveNumber, f as assertUnsignedBigInt, g as formatDateToUtcYYYYMMDD, h as isString, i as EmmettError, l as ValidationErrors, m as isNumber, n as ConcurrencyError, o as NotFoundError, p as isBigint, r as ConcurrencyInMemoryDatabaseError, s as ValidationError, t as isPluginConfig, u as assertNotEmptyString, v as parseDateFromUtcYYYYMMDD } from "./plugins-CUbnGFPp.js";
+import { v4, v7 } from "uuid";
+import retry from "async-retry";
 
-// src/eventStore/afterCommit/afterEventStoreCommitHandler.ts
+//#region src/eventStore/afterCommit/afterEventStoreCommitHandler.ts
 async function tryPublishMessagesAfterCommit(messages, options, context) {
-  if (options?.onAfterCommit === void 0) return false;
-  try {
-    await options?.onAfterCommit(messages, context);
-    return true;
-  } catch (error) {
-    console.error(`Error in on after commit hook`, error);
-    return false;
-  }
+	if (options?.onAfterCommit === void 0) return false;
+	try {
+		await options?.onAfterCommit(messages, context);
+		return true;
+	} catch (error) {
+		console.error(`Error in on after commit hook`, error);
+		return false;
+	}
 }
 
-// src/eventStore/afterCommit/forwardToMessageBus.ts
-var forwardToMessageBus = (eventPublisher) => (async (messages) => {
-  for (const message2 of messages) {
-    await eventPublisher.publish(message2);
-  }
+//#endregion
+//#region src/eventStore/afterCommit/forwardToMessageBus.ts
+const forwardToMessageBus = (eventPublisher) => (async (messages) => {
+	for (const message of messages) await eventPublisher.publish(message);
 });
 
-// src/typing/command.ts
-var command = (...args) => {
-  const [type, data, metadata] = args;
-  return metadata !== void 0 ? { type, data, metadata, kind: "Command" } : { type, data, kind: "Command" };
+//#endregion
+//#region src/typing/command.ts
+const command = (...args) => {
+	const [type, data, metadata] = args;
+	return metadata !== void 0 ? {
+		type,
+		data,
+		metadata,
+		kind: "Command"
+	} : {
+		type,
+		data,
+		kind: "Command"
+	};
 };
 
-// src/typing/event.ts
-var event = (...args) => {
-  const [type, data, metadata] = args;
-  return metadata !== void 0 ? { type, data, metadata, kind: "Event" } : { type, data, kind: "Event" };
+//#endregion
+//#region src/typing/event.ts
+const event = (...args) => {
+	const [type, data, metadata] = args;
+	return metadata !== void 0 ? {
+		type,
+		data,
+		metadata,
+		kind: "Event"
+	} : {
+		type,
+		data,
+		kind: "Event"
+	};
 };
 
-// src/typing/message.ts
-var message = (...args) => {
-  const [kind, type, data, metadata] = args;
-  return metadata !== void 0 ? { type, data, metadata, kind } : { type, data, kind };
+//#endregion
+//#region src/typing/message.ts
+const message = (...args) => {
+	const [kind, type, data, metadata] = args;
+	return metadata !== void 0 ? {
+		type,
+		data,
+		metadata,
+		kind
+	} : {
+		type,
+		data,
+		kind
+	};
 };
 
-// src/typing/index.ts
-var emmettPrefix = "emt";
-var globalTag = "global";
-var defaultTag = `${emmettPrefix}:default`;
-var unknownTag = `${emmettPrefix}:unknown`;
+//#endregion
+//#region src/typing/index.ts
+const emmettPrefix = "emt";
+const globalTag = "global";
+const defaultTag = `${"emt"}:default`;
+const unknownTag = `${"emt"}:unknown`;
 
-// src/eventStore/events/index.ts
-var GlobalStreamCaughtUpType = "__emt:GlobalStreamCaughtUp";
-var isGlobalStreamCaughtUp = (event2) => event2.type === GlobalStreamCaughtUpType;
-var caughtUpEventFrom = (position) => (event2) => event2.type === GlobalStreamCaughtUpType && event2.metadata?.globalPosition >= position;
-var globalStreamCaughtUp = (data) => event(GlobalStreamCaughtUpType, data, {
-  globalPosition: data.globalPosition
-});
-var isSubscriptionEvent = (event2) => isGlobalStreamCaughtUp(event2);
-var isNotInternalEvent = (event2) => !isGlobalStreamCaughtUp(event2);
+//#endregion
+//#region src/eventStore/events/index.ts
+const GlobalStreamCaughtUpType = "__emt:GlobalStreamCaughtUp";
+const isGlobalStreamCaughtUp = (event) => event.type === GlobalStreamCaughtUpType;
+const caughtUpEventFrom = (position) => (event) => event.type === "__emt:GlobalStreamCaughtUp" && event.metadata?.globalPosition >= position;
+const globalStreamCaughtUp = (data) => event(GlobalStreamCaughtUpType, data, { globalPosition: data.globalPosition });
+const isSubscriptionEvent = (event) => isGlobalStreamCaughtUp(event);
+const isNotInternalEvent = (event) => !isGlobalStreamCaughtUp(event);
 
-// src/eventStore/eventStore.ts
-var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
-var nulloSessionFactory = (eventStore) => ({
-  withSession: (callback) => {
-    const nulloSession = {
-      eventStore,
-      close: () => Promise.resolve()
-    };
-    return callback(nulloSession);
-  }
-});
+//#endregion
+//#region src/eventStore/eventStore.ts
+const canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
+const nulloSessionFactory = (eventStore) => ({ withSession: (callback) => {
+	return callback({
+		eventStore,
+		close: () => Promise.resolve()
+	});
+} });
 
-// src/eventStore/expectedVersion.ts
-var STREAM_EXISTS = "STREAM_EXISTS";
-var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
-var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
-var matchesExpectedVersion = (current, expected, defaultVersion) => {
-  if (expected === NO_CONCURRENCY_CHECK) return true;
-  if (expected == STREAM_DOES_NOT_EXIST) return current === defaultVersion;
-  if (expected == STREAM_EXISTS) return current !== defaultVersion;
-  return current === expected;
-};
-var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) => {
-  expected ??= NO_CONCURRENCY_CHECK;
-  if (!matchesExpectedVersion(current, expected, defaultVersion))
-    throw new ExpectedVersionConflictError(current, expected);
-};
-var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
-  constructor(current, expected) {
-    super(current?.toString(), expected?.toString());
-    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
-  }
-};
-var isExpectedVersionConflictError = (error) => error instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
-  error,
-  ExpectedVersionConflictError.Codes.ConcurrencyError
-);
+//#endregion
+//#region src/eventStore/expectedVersion.ts
+const STREAM_EXISTS = "STREAM_EXISTS";
+const STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
+const NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
+const matchesExpectedVersion = (current, expected, defaultVersion) => {
+	if (expected === "NO_CONCURRENCY_CHECK") return true;
+	if (expected == "STREAM_DOES_NOT_EXIST") return current === defaultVersion;
+	if (expected == "STREAM_EXISTS") return current !== defaultVersion;
+	return current === expected;
+};
+const assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) => {
+	expected ??= NO_CONCURRENCY_CHECK;
+	if (!matchesExpectedVersion(current, expected, defaultVersion)) throw new ExpectedVersionConflictError(current, expected);
+};
+var ExpectedVersionConflictError = class ExpectedVersionConflictError extends ConcurrencyError {
+	constructor(current, expected) {
+		super(current?.toString(), expected?.toString());
+		Object.setPrototypeOf(this, ExpectedVersionConflictError.prototype);
+	}
+};
+const isExpectedVersionConflictError = (error) => error instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(error, ExpectedVersionConflictError.Codes.ConcurrencyError);
 
-// src/eventStore/inMemoryEventStore.ts
-import { v4 as uuid5 } from "uuid";
-
-// src/database/inMemoryDatabase.ts
-import { v7 as uuid2 } from "uuid";
+//#endregion
+//#region src/utils/async/mapAsync.ts
+async function reduceAsync(items, fn, initial) {
+	let accumulator = initial;
+	for (let i = 0; i < items.length; i++) accumulator = await fn(accumulator, items[i], i);
+	return accumulator;
+}
 
-// src/utils/collections/duplicates.ts
-var hasDuplicates = (array, predicate) => {
-  const mapped = array.map(predicate);
-  const uniqueValues = new Set(mapped);
-  return uniqueValues.size < mapped.length;
-};
-var getDuplicates = (array, predicate) => {
-  const map = /* @__PURE__ */ new Map();
-  for (let i = 0; i < array.length; i++) {
-    const item = array[i];
-    const key = predicate(item, i, array);
-    if (!map.has(key)) {
-      map.set(key, []);
-    }
-    map.get(key).push(item);
-  }
-  return Array.from(map.values()).filter((group) => group.length > 1).flat();
+//#endregion
+//#region src/utils/collections/duplicates.ts
+const hasDuplicates = (array, predicate) => {
+	const mapped = array.map(predicate);
+	return new Set(mapped).size < mapped.length;
+};
+const getDuplicates = (array, predicate) => {
+	const map = /* @__PURE__ */ new Map();
+	for (let i = 0; i < array.length; i++) {
+		const item = array[i];
+		const key = predicate(item, i, array);
+		if (!map.has(key)) map.set(key, []);
+		map.get(key).push(item);
+	}
+	return Array.from(map.values()).filter((group) => group.length > 1).flat();
 };
 
-// src/utils/collections/merge.ts
-var merge = (array, item, where, onExisting, onNotFound = () => void 0) => {
-  let wasFound = false;
-  const result = array.map((p) => {
-    if (!where(p)) return p;
-    wasFound = true;
-    return onExisting(p);
-  }).filter((p) => p !== void 0).map((p) => {
-    if (!p) throw Error("That should not happen");
-    return p;
-  });
-  if (!wasFound) {
-    const result2 = onNotFound();
-    if (result2 !== void 0) return [...array, item];
-  }
-  return result;
+//#endregion
+//#region src/utils/collections/merge.ts
+const merge = (array, item, where, onExisting, onNotFound = () => void 0) => {
+	let wasFound = false;
+	const result = array.map((p) => {
+		if (!where(p)) return p;
+		wasFound = true;
+		return onExisting(p);
+	}).filter((p) => p !== void 0).map((p) => {
+		if (!p) throw Error("That should not happen");
+		return p;
+	});
+	if (!wasFound) {
+		if (onNotFound() !== void 0) return [...array, item];
+	}
+	return result;
 };
 
-// src/utils/collections/index.ts
-var arrayUtils = {
-  merge,
-  hasDuplicates,
-  getDuplicates
+//#endregion
+//#region src/utils/collections/index.ts
+const arrayUtils = {
+	merge,
+	hasDuplicates,
+	getDuplicates
 };
 
-// src/utils/deepEquals.ts
-var isPrimitive = (value) => {
-  const type = typeof value;
-  return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
-};
-var compareArrays = (left, right) => {
-  if (left.length !== right.length) {
-    return false;
-  }
-  for (let i = 0; i < left.length; i++) {
-    const leftHas = i in left;
-    const rightHas = i in right;
-    if (leftHas !== rightHas) return false;
-    if (leftHas && !deepEquals(left[i], right[i])) return false;
-  }
-  return true;
-};
-var compareDates = (left, right) => {
-  return left.getTime() === right.getTime();
-};
-var compareRegExps = (left, right) => {
-  return left.toString() === right.toString();
-};
-var compareErrors = (left, right) => {
-  if (left.message !== right.message || left.name !== right.name) {
-    return false;
-  }
-  const leftKeys = Object.keys(left);
-  const rightKeys = Object.keys(right);
-  if (leftKeys.length !== rightKeys.length) return false;
-  const rightKeySet = new Set(rightKeys);
-  for (const key of leftKeys) {
-    if (!rightKeySet.has(key)) return false;
-    if (!deepEquals(left[key], right[key])) return false;
-  }
-  return true;
-};
-var compareMaps = (left, right) => {
-  if (left.size !== right.size) return false;
-  for (const [key, value] of left) {
-    if (isPrimitive(key)) {
-      if (!right.has(key) || !deepEquals(value, right.get(key))) {
-        return false;
-      }
-    } else {
-      let found = false;
-      for (const [rightKey, rightValue] of right) {
-        if (deepEquals(key, rightKey) && deepEquals(value, rightValue)) {
-          found = true;
-          break;
-        }
-      }
-      if (!found) return false;
-    }
-  }
-  return true;
-};
-var compareSets = (left, right) => {
-  if (left.size !== right.size) return false;
-  for (const leftItem of left) {
-    if (isPrimitive(leftItem)) {
-      if (!right.has(leftItem)) return false;
-    } else {
-      let found = false;
-      for (const rightItem of right) {
-        if (deepEquals(leftItem, rightItem)) {
-          found = true;
-          break;
-        }
-      }
-      if (!found) return false;
-    }
-  }
-  return true;
-};
-var compareArrayBuffers = (left, right) => {
-  if (left.byteLength !== right.byteLength) return false;
-  const leftView = new Uint8Array(left);
-  const rightView = new Uint8Array(right);
-  for (let i = 0; i < leftView.length; i++) {
-    if (leftView[i] !== rightView[i]) return false;
-  }
-  return true;
-};
-var compareTypedArrays = (left, right) => {
-  if (left.constructor !== right.constructor) return false;
-  if (left.byteLength !== right.byteLength) return false;
-  const leftArray = new Uint8Array(
-    left.buffer,
-    left.byteOffset,
-    left.byteLength
-  );
-  const rightArray = new Uint8Array(
-    right.buffer,
-    right.byteOffset,
-    right.byteLength
-  );
-  for (let i = 0; i < leftArray.length; i++) {
-    if (leftArray[i] !== rightArray[i]) return false;
-  }
-  return true;
-};
-var compareObjects = (left, right) => {
-  const keys1 = Object.keys(left);
-  const keys2 = Object.keys(right);
-  if (keys1.length !== keys2.length) {
-    return false;
-  }
-  for (const key of keys1) {
-    if (left[key] instanceof Function && right[key] instanceof Function) {
-      continue;
-    }
-    const isEqual = deepEquals(left[key], right[key]);
-    if (!isEqual) {
-      return false;
-    }
-  }
-  return true;
-};
-var getType = (value) => {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const primitiveType = typeof value;
-  if (primitiveType !== "object") return primitiveType;
-  if (Array.isArray(value)) return "array";
-  if (value instanceof Boolean) return "boxed-boolean";
-  if (value instanceof Number) return "boxed-number";
-  if (value instanceof String) return "boxed-string";
-  if (value instanceof Date) return "date";
-  if (value instanceof RegExp) return "regexp";
-  if (value instanceof Error) return "error";
-  if (value instanceof Map) return "map";
-  if (value instanceof Set) return "set";
-  if (value instanceof ArrayBuffer) return "arraybuffer";
-  if (value instanceof DataView) return "dataview";
-  if (value instanceof WeakMap) return "weakmap";
-  if (value instanceof WeakSet) return "weakset";
-  if (ArrayBuffer.isView(value)) return "typedarray";
-  return "object";
-};
-var deepEquals = (left, right) => {
-  if (left === right) return true;
-  if (isEquatable(left)) {
-    return left.equals(right);
-  }
-  const leftType = getType(left);
-  const rightType = getType(right);
-  if (leftType !== rightType) return false;
-  switch (leftType) {
-    case "null":
-    case "undefined":
-    case "boolean":
-    case "number":
-    case "bigint":
-    case "string":
-    case "symbol":
-    case "function":
-      return left === right;
-    case "array":
-      return compareArrays(left, right);
-    case "date":
-      return compareDates(left, right);
-    case "regexp":
-      return compareRegExps(left, right);
-    case "error":
-      return compareErrors(left, right);
-    case "map":
-      return compareMaps(
-        left,
-        right
-      );
-    case "set":
-      return compareSets(left, right);
-    case "arraybuffer":
-      return compareArrayBuffers(left, right);
-    case "dataview":
-    case "weakmap":
-    case "weakset":
-      return false;
-    case "typedarray":
-      return compareTypedArrays(
-        left,
-        right
-      );
-    case "boxed-boolean":
-      return left.valueOf() === right.valueOf();
-    case "boxed-number":
-      return left.valueOf() === right.valueOf();
-    case "boxed-string":
-      return left.valueOf() === right.valueOf();
-    case "object":
-      return compareObjects(
-        left,
-        right
-      );
-    default:
-      return false;
-  }
-};
-var isEquatable = (left) => {
-  return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+//#endregion
+//#region src/utils/deepEquals.ts
+const isPrimitive = (value) => {
+	const type = typeof value;
+	return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
+};
+const compareArrays = (left, right) => {
+	if (left.length !== right.length) return false;
+	for (let i = 0; i < left.length; i++) {
+		const leftHas = i in left;
+		if (leftHas !== i in right) return false;
+		if (leftHas && !deepEquals(left[i], right[i])) return false;
+	}
+	return true;
+};
+const compareDates = (left, right) => {
+	return left.getTime() === right.getTime();
+};
+const compareRegExps = (left, right) => {
+	return left.toString() === right.toString();
+};
+const compareErrors = (left, right) => {
+	if (left.message !== right.message || left.name !== right.name) return false;
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	const rightKeySet = new Set(rightKeys);
+	for (const key of leftKeys) {
+		if (!rightKeySet.has(key)) return false;
+		if (!deepEquals(left[key], right[key])) return false;
+	}
+	return true;
+};
+const compareMaps = (left, right) => {
+	if (left.size !== right.size) return false;
+	for (const [key, value] of left) if (isPrimitive(key)) {
+		if (!right.has(key) || !deepEquals(value, right.get(key))) return false;
+	} else {
+		let found = false;
+		for (const [rightKey, rightValue] of right) if (deepEquals(key, rightKey) && deepEquals(value, rightValue)) {
+			found = true;
+			break;
+		}
+		if (!found) return false;
+	}
+	return true;
+};
+const compareSets = (left, right) => {
+	if (left.size !== right.size) return false;
+	for (const leftItem of left) if (isPrimitive(leftItem)) {
+		if (!right.has(leftItem)) return false;
+	} else {
+		let found = false;
+		for (const rightItem of right) if (deepEquals(leftItem, rightItem)) {
+			found = true;
+			break;
+		}
+		if (!found) return false;
+	}
+	return true;
+};
+const compareArrayBuffers = (left, right) => {
+	if (left.byteLength !== right.byteLength) return false;
+	const leftView = new Uint8Array(left);
+	const rightView = new Uint8Array(right);
+	for (let i = 0; i < leftView.length; i++) if (leftView[i] !== rightView[i]) return false;
+	return true;
+};
+const compareTypedArrays = (left, right) => {
+	if (left.constructor !== right.constructor) return false;
+	if (left.byteLength !== right.byteLength) return false;
+	const leftArray = new Uint8Array(left.buffer, left.byteOffset, left.byteLength);
+	const rightArray = new Uint8Array(right.buffer, right.byteOffset, right.byteLength);
+	for (let i = 0; i < leftArray.length; i++) if (leftArray[i] !== rightArray[i]) return false;
+	return true;
+};
+const compareObjects = (left, right) => {
+	const keys1 = Object.keys(left);
+	const keys2 = Object.keys(right);
+	if (keys1.length !== keys2.length) return false;
+	for (const key of keys1) {
+		if (left[key] instanceof Function && right[key] instanceof Function) continue;
+		if (!deepEquals(left[key], right[key])) return false;
+	}
+	return true;
+};
+const getType = (value) => {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	const primitiveType = typeof value;
+	if (primitiveType !== "object") return primitiveType;
+	if (Array.isArray(value)) return "array";
+	if (value instanceof Boolean) return "boxed-boolean";
+	if (value instanceof Number) return "boxed-number";
+	if (value instanceof String) return "boxed-string";
+	if (value instanceof Date) return "date";
+	if (value instanceof RegExp) return "regexp";
+	if (value instanceof Error) return "error";
+	if (value instanceof Map) return "map";
+	if (value instanceof Set) return "set";
+	if (value instanceof ArrayBuffer) return "arraybuffer";
+	if (value instanceof DataView) return "dataview";
+	if (value instanceof WeakMap) return "weakmap";
+	if (value instanceof WeakSet) return "weakset";
+	if (ArrayBuffer.isView(value)) return "typedarray";
+	return "object";
+};
+const deepEquals = (left, right) => {
+	if (left === right) return true;
+	if (isEquatable(left)) return left.equals(right);
+	const leftType = getType(left);
+	if (leftType !== getType(right)) return false;
+	switch (leftType) {
+		case "null":
+		case "undefined":
+		case "boolean":
+		case "number":
+		case "bigint":
+		case "string":
+		case "symbol":
+		case "function": return left === right;
+		case "array": return compareArrays(left, right);
+		case "date": return compareDates(left, right);
+		case "regexp": return compareRegExps(left, right);
+		case "error": return compareErrors(left, right);
+		case "map": return compareMaps(left, right);
+		case "set": return compareSets(left, right);
+		case "arraybuffer": return compareArrayBuffers(left, right);
+		case "dataview":
+		case "weakmap":
+		case "weakset": return false;
+		case "typedarray": return compareTypedArrays(left, right);
+		case "boxed-boolean": return left.valueOf() === right.valueOf();
+		case "boxed-number": return left.valueOf() === right.valueOf();
+		case "boxed-string": return left.valueOf() === right.valueOf();
+		case "object": return compareObjects(left, right);
+		default: return false;
+	}
+};
+const isEquatable = (left) => {
+	return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
 };
 
-// src/utils/iterators.ts
-var sum = (iterator) => {
-  let value, done, sum2 = 0;
-  do {
-    ({ value, done } = iterator.next());
-    sum2 += value || 0;
-  } while (!done);
-  return sum2;
+//#endregion
+//#region src/utils/iterators.ts
+const sum = (iterator) => {
+	let value, done, sum = 0;
+	do {
+		({value, done} = iterator.next());
+		sum += value || 0;
+	} while (!done);
+	return sum;
 };
 
-// src/taskProcessing/executionGuards.ts
-import { v7 as uuid } from "uuid";
-
-// src/taskProcessing/taskProcessor.ts
+//#endregion
+//#region src/taskProcessing/taskProcessor.ts
 var TaskProcessor = class {
-  queue = [];
-  isProcessing = false;
-  activeTasks = 0;
-  activeGroups = /* @__PURE__ */ new Set();
-  options;
-  stopped = false;
-  constructor(options) {
-    this.options = options;
-  }
-  enqueue(task, options) {
-    if (this.stopped) {
-      return Promise.reject(new EmmettError("TaskProcessor has been stopped"));
-    }
-    if (this.queue.length >= this.options.maxQueueSize) {
-      return Promise.reject(
-        new EmmettError("Too many pending tasks. Please try again later.")
-      );
-    }
-    return this.schedule(task, options);
-  }
-  waitForEndOfProcessing() {
-    return this.schedule(({ ack }) => Promise.resolve(ack()));
-  }
-  async stop(options) {
-    if (this.stopped) return;
-    this.stopped = true;
-    this.queue.length = 0;
-    this.activeGroups.clear();
-    if (!options?.force) {
-      await this.waitForEndOfProcessing();
-    }
-  }
-  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 (error) {
-      console.error(error);
-      throw error;
-    } 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;
-    let timeoutId = null;
-    const deadline = options.deadline ?? DEFAULT_PROMISE_DEADLINE;
-    timeoutId = setTimeout(() => {
-      if (!taskStarted) {
-        reject(
-          new Error("Task was not started within the maximum waiting time")
-        );
-      }
-    }, deadline);
-    timeoutId.unref();
-    executor(
-      (value) => {
-        taskStarted = true;
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-        timeoutId = null;
-        resolve(value);
-      },
-      (reason) => {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-        timeoutId = null;
-        reject(reason);
-      }
-    );
-  });
+	queue = [];
+	isProcessing = false;
+	activeTasks = 0;
+	activeGroups = /* @__PURE__ */ new Set();
+	options;
+	stopped = false;
+	constructor(options) {
+		this.options = options;
+	}
+	enqueue(task, options) {
+		if (this.stopped) return Promise.reject(new EmmettError("TaskProcessor has been stopped"));
+		if (this.queue.length >= this.options.maxQueueSize) return Promise.reject(new EmmettError("Too many pending tasks. Please try again later."));
+		return this.schedule(task, options);
+	}
+	waitForEndOfProcessing() {
+		return this.schedule(({ ack }) => Promise.resolve(ack()));
+	}
+	async stop(options) {
+		if (this.stopped) return;
+		this.stopped = true;
+		this.queue.length = 0;
+		this.activeGroups.clear();
+		if (!options?.force) await this.waitForEndOfProcessing();
+	}
+	schedule(task, options) {
+		return promiseWithDeadline((resolve, reject) => {
+			const taskWithContext = () => {
+				return new Promise((resolveTask, failTask) => {
+					task({ ack: resolveTask }).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++;
+				this.executeItem(item);
+			}
+		} catch (error) {
+			console.error(error);
+			throw error;
+		} 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((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.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;
+};
+const DEFAULT_PROMISE_DEADLINE = 2147483647;
+const promiseWithDeadline = (executor, options) => {
+	return new Promise((resolve, reject) => {
+		let taskStarted = false;
+		let timeoutId = null;
+		const deadline = options.deadline ?? DEFAULT_PROMISE_DEADLINE;
+		timeoutId = setTimeout(() => {
+			if (!taskStarted) reject(/* @__PURE__ */ new Error("Task was not started within the maximum waiting time"));
+		}, deadline);
+		timeoutId.unref();
+		executor((value) => {
+			taskStarted = true;
+			if (timeoutId) clearTimeout(timeoutId);
+			timeoutId = null;
+			resolve(value);
+		}, (reason) => {
+			if (timeoutId) clearTimeout(timeoutId);
+			timeoutId = null;
+			reject(reason);
+		});
+	});
 };
 
-// src/taskProcessing/executionGuards.ts
-var guardExclusiveAccess = (options) => {
-  const taskProcessor = new TaskProcessor({
-    maxActiveTasks: 1,
-    maxQueueSize: options?.maxQueueSize ?? 1e3
-  });
-  return {
-    execute: (operation) => taskProcessor.enqueue(async ({ ack }) => {
-      try {
-        return await operation();
-      } finally {
-        ack();
-      }
-    }),
-    waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
-    stop: (options2) => taskProcessor.stop(options2)
-  };
-};
-var guardBoundedAccess = (getResource, options) => {
-  let isStopped = false;
-  const taskProcessor = new TaskProcessor({
-    maxActiveTasks: options.maxResources,
-    maxQueueSize: options.maxQueueSize ?? 1e3
-  });
-  const resourcePool = [];
-  const allResources = /* @__PURE__ */ new Set();
-  const ackCallbacks = /* @__PURE__ */ new Map();
-  const acquire = async () => taskProcessor.enqueue(async ({ ack }) => {
-    try {
-      let resource;
-      if (options.reuseResources) {
-        resource = resourcePool.pop();
-      }
-      if (!resource) {
-        resource = await getResource();
-        allResources.add(resource);
-      }
-      ackCallbacks.set(resource, ack);
-      return resource;
-    } catch (e) {
-      ack();
-      throw e;
-    }
-  });
-  const release = (resource) => {
-    const ack = ackCallbacks.get(resource);
-    if (ack) {
-      ackCallbacks.delete(resource);
-      if (options.reuseResources) {
-        resourcePool.push(resource);
-      }
-      ack();
-    }
-  };
-  const execute = async (operation) => {
-    const resource = await acquire();
-    try {
-      return await operation(resource);
-    } finally {
-      release(resource);
-    }
-  };
-  return {
-    acquire,
-    release,
-    execute,
-    waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
-    stop: async (stopOptions) => {
-      if (isStopped) return;
-      isStopped = true;
-      if (options?.closeResource) {
-        const resources = [...allResources];
-        allResources.clear();
-        resourcePool.length = 0;
-        await Promise.all(
-          resources.map(
-            async (resource) => await options.closeResource(resource)
-          )
-        );
-      }
-      await taskProcessor.stop(stopOptions);
-    }
-  };
-};
-var guardInitializedOnce = (initialize, options) => {
-  let initPromise = null;
-  const taskProcessor = new TaskProcessor({
-    maxActiveTasks: 1,
-    maxQueueSize: options?.maxQueueSize ?? 1e3
-  });
-  const ensureInitialized = async (retryCount = 0) => {
-    if (initPromise !== null) {
-      return initPromise;
-    }
-    return taskProcessor.enqueue(
-      async ({ ack }) => {
-        if (initPromise !== null) {
-          ack();
-          return initPromise;
-        }
-        try {
-          const promise = initialize();
-          initPromise = promise;
-          const result = await promise;
-          ack();
-          return result;
-        } catch (error) {
-          initPromise = null;
-          ack();
-          const maxRetries = options?.maxRetries ?? 3;
-          if (retryCount < maxRetries) {
-            return ensureInitialized(retryCount + 1);
-          }
-          throw error;
-        }
-      },
-      { taskGroupId: uuid() }
-    );
-  };
-  return {
-    ensureInitialized,
-    reset: () => {
-      initPromise = null;
-    },
-    stop: (options2) => taskProcessor.stop(options2)
-  };
+//#endregion
+//#region src/taskProcessing/executionGuards.ts
+const guardExclusiveAccess = (options) => {
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: 1,
+		maxQueueSize: options?.maxQueueSize ?? 1e3
+	});
+	return {
+		execute: (operation) => taskProcessor.enqueue(async ({ ack }) => {
+			try {
+				return await operation();
+			} finally {
+				ack();
+			}
+		}),
+		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
+		stop: (options) => taskProcessor.stop(options)
+	};
+};
+const guardBoundedAccess = (getResource, options) => {
+	let isStopped = false;
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: options.maxResources,
+		maxQueueSize: options.maxQueueSize ?? 1e3
+	});
+	const resourcePool = [];
+	const allResources = /* @__PURE__ */ new Set();
+	const ackCallbacks = /* @__PURE__ */ new Map();
+	const acquire = async () => taskProcessor.enqueue(async ({ ack }) => {
+		try {
+			let resource;
+			if (options.reuseResources) resource = resourcePool.pop();
+			if (!resource) {
+				resource = await getResource();
+				allResources.add(resource);
+			}
+			ackCallbacks.set(resource, ack);
+			return resource;
+		} catch (e) {
+			ack();
+			throw e;
+		}
+	});
+	const release = (resource) => {
+		const ack = ackCallbacks.get(resource);
+		if (ack) {
+			ackCallbacks.delete(resource);
+			if (options.reuseResources) resourcePool.push(resource);
+			ack();
+		}
+	};
+	const execute = async (operation) => {
+		const resource = await acquire();
+		try {
+			return await operation(resource);
+		} finally {
+			release(resource);
+		}
+	};
+	return {
+		acquire,
+		release,
+		execute,
+		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
+		stop: async (stopOptions) => {
+			if (isStopped) return;
+			isStopped = true;
+			if (options?.closeResource) {
+				const resources = [...allResources];
+				allResources.clear();
+				resourcePool.length = 0;
+				await Promise.all(resources.map(async (resource) => await options.closeResource(resource)));
+			}
+			await taskProcessor.stop(stopOptions);
+		}
+	};
+};
+const guardInitializedOnce = (initialize, options) => {
+	let initPromise = null;
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: 1,
+		maxQueueSize: options?.maxQueueSize ?? 1e3
+	});
+	const ensureInitialized = async (retryCount = 0) => {
+		if (initPromise !== null) return initPromise;
+		return taskProcessor.enqueue(async ({ ack }) => {
+			if (initPromise !== null) {
+				ack();
+				return initPromise;
+			}
+			try {
+				const promise = initialize();
+				initPromise = promise;
+				const result = await promise;
+				ack();
+				return result;
+			} catch (error) {
+				initPromise = null;
+				ack();
+				if (retryCount < (options?.maxRetries ?? 3)) return ensureInitialized(retryCount + 1);
+				throw error;
+			}
+		}, { taskGroupId: v7() });
+	};
+	return {
+		ensureInitialized,
+		reset: () => {
+			initPromise = null;
+		},
+		stop: (options) => taskProcessor.stop(options)
+	};
 };
 
-// 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 }
-      );
-    }
-  };
+//#endregion
+//#region src/utils/locking/index.ts
+const 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/numbers/bigint.ts
-var toNormalizedString = (value) => value.toString().padStart(19, "0");
-var bigInt = {
-  toNormalizedString
-};
+//#endregion
+//#region src/utils/numbers/bigint.ts
+const toNormalizedString = (value) => value.toString().padStart(19, "0");
+const bigInt = { toNormalizedString };
 
-// src/utils/promises.ts
-var delay = (ms) => {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-};
-var asyncAwaiter = () => {
-  const result = {};
-  (result.reset = () => {
-    result.wait = new Promise((res, rej) => {
-      result.resolve = res;
-      result.reject = rej;
-    });
-  })();
-  return result;
+//#endregion
+//#region src/utils/promises.ts
+const delay = (ms) => {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+};
+const asyncAwaiter = () => {
+	const result = {};
+	(result.reset = () => {
+		result.wait = new Promise((res, rej) => {
+			result.resolve = res;
+			result.reject = rej;
+		});
+		result.wait.catch(() => {});
+	})();
+	return result;
 };
 
-// src/utils/retry.ts
-import retry from "async-retry";
-
-// src/serialization/json/jsonSerializer.ts
-var bigIntReplacer = (_key, value) => {
-  return typeof value === "bigint" ? value.toString() : value;
-};
-var dateReplacer = (_key, value) => {
-  return value instanceof Date ? value.toISOString() : value;
-};
-var isFirstLetterNumeric = (str) => {
-  const c = str.charCodeAt(0);
-  return c >= 48 && c <= 57;
-};
-var isFirstLetterNumericOrMinus = (str) => {
-  const c = str.charCodeAt(0);
-  return c >= 48 && c <= 57 || c === 45;
-};
-var bigIntReviver = (_key, value, context) => {
-  if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) {
-    try {
-      return BigInt(context?.source ?? value.toString());
-    } catch {
-      return value;
-    }
-  }
-  if (typeof value === "string" && value.length > 15) {
-    if (isFirstLetterNumericOrMinus(value)) {
-      const num = Number(value);
-      if (Number.isFinite(num) && !Number.isSafeInteger(num)) {
-        try {
-          return BigInt(value);
-        } catch {
-        }
-      }
-    }
-  }
-  return value;
-};
-var dateReviver = (_key, value) => {
-  if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
-    const date = new Date(value);
-    if (!isNaN(date.getTime())) {
-      return date;
-    }
-  }
-  return value;
-};
-var composeJSONReplacers = (...replacers) => {
-  const filteredReplacers = replacers.filter((r) => r !== void 0);
-  if (filteredReplacers.length === 0) return void 0;
-  return (key, value) => (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    filteredReplacers.reduce(
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      (accValue, replacer) => replacer(key, accValue),
-      value
-    )
-  );
-};
-var composeJSONRevivers = (...revivers) => {
-  const filteredRevivers = revivers.filter((r) => r !== void 0);
-  if (filteredRevivers.length === 0) return void 0;
-  return (key, value, context) => (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    filteredRevivers.reduce(
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      (accValue, reviver) => reviver(key, accValue, context),
-      value
-    )
-  );
-};
-var JSONReplacer = (opts) => composeJSONReplacers(
-  opts?.replacer,
-  opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0,
-  opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0
-);
-var JSONReviver = (opts) => composeJSONRevivers(
-  opts?.reviver,
-  opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0,
-  opts?.parseDates === true ? JSONRevivers.date : void 0
-);
-var JSONReplacers = {
-  bigInt: bigIntReplacer,
-  date: dateReplacer
-};
-var JSONRevivers = {
-  bigInt: bigIntReviver,
-  date: dateReviver
-};
-var jsonSerializer = (options) => {
-  const defaultReplacer = JSONReplacer(options);
-  const defaultReviver = JSONReviver(options);
-  return {
-    serialize: (object, serializerOptions) => JSON.stringify(
-      object,
-      serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer
-    ),
-    deserialize: (payload, deserializerOptions) => JSON.parse(
-      payload,
-      deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver
-    )
-  };
-};
-var JSONSerializer = Object.assign(jsonSerializer(), {
-  from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer)
-});
-var JSONCodec = (options) => {
-  const serializer = "serializer" in options && options.serializer ? options.serializer : jsonSerializer(
-    "serializerOptions" in options ? options.serializerOptions : void 0
-  );
-  const upcast = options.upcast ?? ((doc) => doc);
-  const downcast = options.downcast ?? ((doc) => doc);
-  return {
-    decode: (payload, decodeOptions) => {
-      const deserialized = decodeOptions ? serializer.deserialize(payload, decodeOptions) : serializer.deserialize(payload);
-      return upcast(deserialized);
-    },
-    encode: (object, encodeOptions) => {
-      const downcasted = downcast(object);
-      return encodeOptions ? serializer.serialize(downcasted, encodeOptions) : serializer.serialize(downcasted);
-    }
-  };
+//#endregion
+//#region src/serialization/json/jsonSerializer.ts
+const bigIntReplacer = (_key, value) => {
+	return typeof value === "bigint" ? value.toString() : value;
+};
+const dateReplacer = (_key, value) => {
+	return value instanceof Date ? value.toISOString() : value;
+};
+const isFirstLetterNumeric = (str) => {
+	const c = str.charCodeAt(0);
+	return c >= 48 && c <= 57;
+};
+const isFirstLetterNumericOrMinus = (str) => {
+	const c = str.charCodeAt(0);
+	return c >= 48 && c <= 57 || c === 45;
+};
+const bigIntReviver = (_key, value, context) => {
+	if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) try {
+		return BigInt(context?.source ?? value.toString());
+	} catch {
+		return value;
+	}
+	if (typeof value === "string" && value.length > 15) {
+		if (isFirstLetterNumericOrMinus(value)) {
+			const num = Number(value);
+			if (Number.isFinite(num) && !Number.isSafeInteger(num)) try {
+				return BigInt(value);
+			} catch {}
+		}
+	}
+	return value;
+};
+const dateReviver = (_key, value) => {
+	if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+		const date = new Date(value);
+		if (!isNaN(date.getTime())) return date;
+	}
+	return value;
+};
+const composeJSONReplacers = (...replacers) => {
+	const filteredReplacers = replacers.filter((r) => r !== void 0);
+	if (filteredReplacers.length === 0) return void 0;
+	return (key, value) => filteredReplacers.reduce((accValue, replacer) => replacer(key, accValue), value);
+};
+const composeJSONRevivers = (...revivers) => {
+	const filteredRevivers = revivers.filter((r) => r !== void 0);
+	if (filteredRevivers.length === 0) return void 0;
+	return (key, value, context) => filteredRevivers.reduce((accValue, reviver) => reviver(key, accValue, context), value);
+};
+const JSONReplacer = (opts) => composeJSONReplacers(opts?.replacer, opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0, opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0);
+const JSONReviver = (opts) => composeJSONRevivers(opts?.reviver, opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0, opts?.parseDates === true ? JSONRevivers.date : void 0);
+const JSONReplacers = {
+	bigInt: bigIntReplacer,
+	date: dateReplacer
+};
+const JSONRevivers = {
+	bigInt: bigIntReviver,
+	date: dateReviver
+};
+const jsonSerializer = (options) => {
+	const defaultReplacer = JSONReplacer(options);
+	const defaultReviver = JSONReviver(options);
+	return {
+		serialize: (object, serializerOptions) => JSON.stringify(object, serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer),
+		deserialize: (payload, deserializerOptions) => JSON.parse(payload, deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver)
+	};
+};
+const JSONSerializer = Object.assign(jsonSerializer(), { from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer) });
+const JSONCodec = (options) => {
+	const serializer = "serializer" in options && options.serializer ? options.serializer : jsonSerializer("serializerOptions" in options ? options.serializerOptions : void 0);
+	const upcast = options.upcast ?? ((doc) => doc);
+	const downcast = options.downcast ?? ((doc) => doc);
+	return {
+		decode: (payload, decodeOptions) => {
+			return upcast(decodeOptions ? serializer.deserialize(payload, decodeOptions) : serializer.deserialize(payload));
+		},
+		encode: (object, encodeOptions) => {
+			const downcasted = downcast(object);
+			return encodeOptions ? serializer.serialize(downcasted, encodeOptions) : serializer.serialize(downcasted);
+		}
+	};
 };
 
-// src/utils/retry.ts
-var NoRetries = { retries: 0 };
-var asyncRetry = async (fn, opts) => {
-  if (opts === void 0 || opts.retries === 0) return fn();
-  return retry(
-    async (bail) => {
-      try {
-        const result = await fn();
-        if (opts?.shouldRetryResult && opts.shouldRetryResult(result)) {
-          throw new EmmettError(
-            `Retrying because of result: ${JSONSerializer.serialize(result)}`
-          );
-        }
-        return result;
-      } catch (error) {
-        if (opts?.shouldRetryError && !opts.shouldRetryError(error)) {
-          bail(error);
-          return void 0;
-        }
-        throw error;
-      }
-    },
-    opts ?? { retries: 0 }
-  );
+//#endregion
+//#region src/utils/retry.ts
+const NoRetries = { retries: 0 };
+const asyncRetry = async (fn, opts) => {
+	if (opts === void 0 || opts.retries === 0) return fn();
+	return retry(async (bail) => {
+		try {
+			const result = await fn();
+			if (opts?.shouldRetryResult && opts.shouldRetryResult(result)) throw new EmmettError(`Retrying because of result: ${JSONSerializer.serialize(result)}`);
+			return result;
+		} catch (error) {
+			if (opts?.shouldRetryError && !opts.shouldRetryError(error)) {
+				bail(error);
+				return;
+			}
+			throw error;
+		}
+	}, opts ?? { retries: 0 });
 };
 
-// src/utils/shutdown/gracefulShutdown.ts
-var onShutdown = (handler) => {
-  const signals = ["SIGTERM", "SIGINT"];
-  if (typeof process !== "undefined" && typeof process.on === "function") {
-    for (const signal of signals) {
-      process.on(signal, handler);
-    }
-    return () => {
-      for (const signal of signals) {
-        process.off(signal, handler);
-      }
-    };
-  }
-  const deno = globalThis.Deno;
-  if (deno && typeof deno.addSignalListener === "function") {
-    for (const signal of signals) {
-      deno.addSignalListener(signal, handler);
-    }
-    return () => {
-      for (const signal of signals) {
-        deno.removeSignalListener(signal, handler);
-      }
-    };
-  }
-  return () => {
-  };
+//#endregion
+//#region src/utils/shutdown/gracefulShutdown.ts
+/**
+* Registers handlers for OS signals to enable graceful shutdown.
+* Handles SIGTERM and SIGINT by default.
+* Works in Node.js, Bun, and Deno. Safely no-ops in Browser/Cloudflare Workers.
+*
+* @param handler - Function to call when shutdown signal is received
+* @returns Cleanup function to unregister the handlers
+*/
+const onShutdown = (handler) => {
+	const signals = ["SIGTERM", "SIGINT"];
+	if (typeof process !== "undefined" && typeof process.on === "function") {
+		for (const signal of signals) process.on(signal, handler);
+		return () => {
+			for (const signal of signals) process.off(signal, handler);
+		};
+	}
+	const deno = globalThis.Deno;
+	if (deno && typeof deno.addSignalListener === "function") {
+		for (const signal of signals) deno.addSignalListener(signal, handler);
+		return () => {
+			for (const signal of signals) deno.removeSignalListener(signal, handler);
+		};
+	}
+	return () => {};
 };
 
-// src/utils/strings/hashText.ts
-var textEncoder = new TextEncoder();
-var hashText = async (text) => {
-  const hashBuffer = await crypto.subtle.digest(
-    "SHA-256",
-    textEncoder.encode(text)
-  );
-  const view = new BigInt64Array(hashBuffer, 0, 1);
-  return view[0];
+//#endregion
+//#region src/utils/strings/hashText.ts
+const textEncoder = new TextEncoder();
+const hashText = async (text) => {
+	const hashBuffer = await crypto.subtle.digest("SHA-256", textEncoder.encode(text));
+	return new BigInt64Array(hashBuffer, 0, 1)[0];
 };
 
-// src/database/utils.ts
-var isGeneralExpectedDocumentVersion = (version) => {
-  return version === "DOCUMENT_DOES_NOT_EXIST" || version === "DOCUMENT_EXISTS" || version === "NO_CONCURRENCY_CHECK";
-};
-var expectedVersionValue = (version) => version === void 0 || isGeneralExpectedDocumentVersion(version) ? null : version;
-var operationResult = (result, options) => {
-  const operationResult2 = {
-    ...result,
-    acknowledged: true,
-    successful: result.successful,
-    assertSuccessful: (errorMessage) => {
-      const { successful } = result;
-      const { operationName, collectionName } = options;
-      if (!successful)
-        throw new ConcurrencyInMemoryDatabaseError(
-          errorMessage ?? `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONSerializer.serialize(result)}!`
-        );
-    }
-  };
-  if (options.errors?.throwOnOperationFailures)
-    operationResult2.assertSuccessful();
-  return operationResult2;
+//#endregion
+//#region src/database/utils.ts
+const isGeneralExpectedDocumentVersion = (version) => {
+	return version === "DOCUMENT_DOES_NOT_EXIST" || version === "DOCUMENT_EXISTS" || version === "NO_CONCURRENCY_CHECK";
+};
+const expectedVersionValue = (version) => version === void 0 || isGeneralExpectedDocumentVersion(version) ? null : version;
+const operationResult = (result, options) => {
+	const operationResult = {
+		...result,
+		acknowledged: true,
+		successful: result.successful,
+		assertSuccessful: (errorMessage) => {
+			const { successful } = result;
+			const { operationName, collectionName } = options;
+			if (!successful) throw new ConcurrencyInMemoryDatabaseError(errorMessage ?? `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONSerializer.serialize(result)}!`);
+		}
+	};
+	if (options.errors?.throwOnOperationFailures) operationResult.assertSuccessful();
+	return operationResult;
 };
 
-// src/database/inMemoryDatabase.ts
-var getInMemoryDatabase = () => {
-  const storage = /* @__PURE__ */ new Map();
-  return {
-    collection: (collectionName, collectionOptions = {}) => {
-      const ensureCollectionCreated = () => {
-        if (!storage.has(collectionName)) storage.set(collectionName, []);
-      };
-      const errors = collectionOptions.errors;
-      const collection = {
-        collectionName,
-        insertOne: async (document) => {
-          ensureCollectionCreated();
-          const _id = document._id ?? uuid2();
-          const _version = document._version ?? 1n;
-          const existing = await collection.findOne((c) => c._id === _id);
-          if (existing) {
-            return operationResult(
-              {
-                successful: false,
-                insertedId: null,
-                nextExpectedVersion: _version
-              },
-              { operationName: "insertOne", collectionName, errors }
-            );
-          }
-          const documentsInCollection = storage.get(collectionName);
-          const newDocument = { ...document, _id, _version };
-          const newCollection = [...documentsInCollection, newDocument];
-          storage.set(collectionName, newCollection);
-          return operationResult(
-            {
-              successful: true,
-              insertedId: _id,
-              nextExpectedVersion: _version
-            },
-            { operationName: "insertOne", collectionName, errors }
-          );
-        },
-        findOne: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const filteredDocuments = predicate ? documentsInCollection?.filter((doc) => predicate(doc)) : documentsInCollection;
-          const firstOne = filteredDocuments?.[0] ?? null;
-          return Promise.resolve(firstOne);
-        },
-        find: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const filteredDocuments = predicate ? documentsInCollection?.filter((doc) => predicate(doc)) : documentsInCollection;
-          return Promise.resolve(filteredDocuments);
-        },
-        deleteOne: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          if (predicate) {
-            const foundIndex = documentsInCollection.findIndex(
-              (doc) => predicate(doc)
-            );
-            if (foundIndex === -1) {
-              return Promise.resolve(
-                operationResult(
-                  {
-                    successful: false,
-                    matchedCount: 0,
-                    deletedCount: 0
-                  },
-                  { operationName: "deleteOne", collectionName, errors }
-                )
-              );
-            } else {
-              const newCollection2 = documentsInCollection.toSpliced(
-                foundIndex,
-                1
-              );
-              storage.set(collectionName, newCollection2);
-              return Promise.resolve(
-                operationResult(
-                  {
-                    successful: true,
-                    matchedCount: 1,
-                    deletedCount: 1
-                  },
-                  { operationName: "deleteOne", collectionName, errors }
-                )
-              );
-            }
-          }
-          const newCollection = documentsInCollection.slice(1);
-          storage.set(collectionName, newCollection);
-          return Promise.resolve(
-            operationResult(
-              {
-                successful: true,
-                matchedCount: 1,
-                deletedCount: 1
-              },
-              { operationName: "deleteOne", collectionName, errors }
-            )
-          );
-        },
-        replaceOne: (predicate, document, options) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const firstIndex = documentsInCollection.findIndex(
-            (doc) => predicate(doc)
-          );
-          if (firstIndex === void 0 || firstIndex === -1) {
-            return Promise.resolve(
-              operationResult(
-                {
-                  successful: false,
-                  matchedCount: 0,
-                  modifiedCount: 0,
-                  nextExpectedVersion: 0n
-                },
-                { operationName: "replaceOne", collectionName, errors }
-              )
-            );
-          }
-          const existing = documentsInCollection[firstIndex];
-          if (typeof options?.expectedVersion === "bigint" && existing._version !== options.expectedVersion) {
-            return Promise.resolve(
-              operationResult(
-                {
-                  successful: false,
-                  matchedCount: 1,
-                  modifiedCount: 0,
-                  nextExpectedVersion: existing._version
-                },
-                { operationName: "replaceOne", collectionName, errors }
-              )
-            );
-          }
-          const newVersion = existing._version + 1n;
-          const newCollection = documentsInCollection.with(firstIndex, {
-            _id: existing._id,
-            ...document,
-            _version: newVersion
-          });
-          storage.set(collectionName, newCollection);
-          return Promise.resolve(
-            operationResult(
-              {
-                successful: true,
-                modifiedCount: 1,
-                matchedCount: firstIndex,
-                nextExpectedVersion: newVersion
-              },
-              { operationName: "replaceOne", collectionName, errors }
-            )
-          );
-        },
-        handle: async (id, handle, options) => {
-          const { expectedVersion: version, ...operationOptions } = options ?? {};
-          ensureCollectionCreated();
-          const existing = await collection.findOne(({ _id }) => _id === id);
-          const expectedVersion = expectedVersionValue(version);
-          if (existing == null && version === "DOCUMENT_EXISTS" || existing == null && expectedVersion != null || existing != null && version === "DOCUMENT_DOES_NOT_EXIST" || existing != null && expectedVersion !== null && existing._version !== expectedVersion) {
-            return operationResult(
-              {
-                successful: false,
-                document: existing
-              },
-              { operationName: "handle", collectionName, errors }
-            );
-          }
-          const result = handle(existing !== null ? { ...existing } : null);
-          if (deepEquals(existing, result))
-            return operationResult(
-              {
-                successful: true,
-                document: existing
-              },
-              { operationName: "handle", collectionName, errors }
-            );
-          if (!existing && result) {
-            const newDoc = { ...result, _id: id };
-            const insertResult = await collection.insertOne({
-              ...newDoc,
-              _id: id
-            });
-            return {
-              ...insertResult,
-              document: {
-                ...newDoc,
-                _version: insertResult.nextExpectedVersion
-              }
-            };
-          }
-          if (existing && !result) {
-            const deleteResult = await collection.deleteOne(
-              ({ _id }) => id === _id
-            );
-            return { ...deleteResult, document: null };
-          }
-          if (existing && result) {
-            const replaceResult = await collection.replaceOne(
-              ({ _id }) => id === _id,
-              result,
-              {
-                ...operationOptions,
-                expectedVersion: expectedVersion ?? "DOCUMENT_EXISTS"
-              }
-            );
-            return {
-              ...replaceResult,
-              document: {
-                ...result,
-                _version: replaceResult.nextExpectedVersion
-              }
-            };
-          }
-          return operationResult(
-            {
-              successful: true,
-              document: existing
-            },
-            { operationName: "handle", collectionName, errors }
-          );
-        }
-      };
-      return collection;
-    }
-  };
+//#endregion
+//#region src/database/inMemoryDatabase.ts
+const getInMemoryDatabase = () => {
+	const storage = /* @__PURE__ */ new Map();
+	return { collection: (collectionName, collectionOptions = {}) => {
+		const ensureCollectionCreated = () => {
+			if (!storage.has(collectionName)) storage.set(collectionName, []);
+		};
+		const errors = collectionOptions.errors;
+		const collection = {
+			collectionName,
+			insertOne: async (document) => {
+				ensureCollectionCreated();
+				const _id = document._id ?? v7();
+				const _version = document._version ?? 1n;
+				if (await collection.findOne((c) => c._id === _id)) return operationResult({
+					successful: false,
+					insertedId: null,
+					nextExpectedVersion: _version
+				}, {
+					operationName: "insertOne",
+					collectionName,
+					errors
+				});
+				const documentsInCollection = storage.get(collectionName);
+				const newDocument = {
+					...document,
+					_id,
+					_version
+				};
+				const newCollection = [...documentsInCollection, newDocument];
+				storage.set(collectionName, newCollection);
+				return operationResult({
+					successful: true,
+					insertedId: _id,
+					nextExpectedVersion: _version
+				}, {
+					operationName: "insertOne",
+					collectionName,
+					errors
+				});
+			},
+			findOne: (predicate) => {
+				ensureCollectionCreated();
+				const documentsInCollection = storage.get(collectionName);
+				const firstOne = (predicate ? documentsInCollection?.filter((doc) => predicate(doc)) : documentsInCollection)?.[0] ?? null;
+				return Promise.resolve(firstOne);
+			},
+			find: (predicate) => {
+				ensureCollectionCreated();
+				const documentsInCollection = storage.get(collectionName);
+				const filteredDocuments = predicate ? documentsInCollection?.filter((doc) => predicate(doc)) : documentsInCollection;
+				return Promise.resolve(filteredDocuments);
+			},
+			deleteOne: (predicate) => {
+				ensureCollectionCreated();
+				const documentsInCollection = storage.get(collectionName);
+				if (predicate) {
+					const foundIndex = documentsInCollection.findIndex((doc) => predicate(doc));
+					if (foundIndex === -1) return Promise.resolve(operationResult({
+						successful: false,
+						matchedCount: 0,
+						deletedCount: 0
+					}, {
+						operationName: "deleteOne",
+						collectionName,
+						errors
+					}));
+					else {
+						const newCollection = documentsInCollection.toSpliced(foundIndex, 1);
+						storage.set(collectionName, newCollection);
+						return Promise.resolve(operationResult({
+							successful: true,
+							matchedCount: 1,
+							deletedCount: 1
+						}, {
+							operationName: "deleteOne",
+							collectionName,
+							errors
+						}));
+					}
+				}
+				const newCollection = documentsInCollection.slice(1);
+				storage.set(collectionName, newCollection);
+				return Promise.resolve(operationResult({
+					successful: true,
+					matchedCount: 1,
+					deletedCount: 1
+				}, {
+					operationName: "deleteOne",
+					collectionName,
+					errors
+				}));
+			},
+			replaceOne: (predicate, document, options) => {
+				ensureCollectionCreated();
+				const documentsInCollection = storage.get(collectionName);
+				const firstIndex = documentsInCollection.findIndex((doc) => predicate(doc));
+				if (firstIndex === void 0 || firstIndex === -1) return Promise.resolve(operationResult({
+					successful: false,
+					matchedCount: 0,
+					modifiedCount: 0,
+					nextExpectedVersion: 0n
+				}, {
+					operationName: "replaceOne",
+					collectionName,
+					errors
+				}));
+				const existing = documentsInCollection[firstIndex];
+				if (typeof options?.expectedVersion === "bigint" && existing._version !== options.expectedVersion) return Promise.resolve(operationResult({
+					successful: false,
+					matchedCount: 1,
+					modifiedCount: 0,
+					nextExpectedVersion: existing._version
+				}, {
+					operationName: "replaceOne",
+					collectionName,
+					errors
+				}));
+				const newVersion = existing._version + 1n;
+				const newCollection = documentsInCollection.with(firstIndex, {
+					_id: existing._id,
+					...document,
+					_version: newVersion
+				});
+				storage.set(collectionName, newCollection);
+				return Promise.resolve(operationResult({
+					successful: true,
+					modifiedCount: 1,
+					matchedCount: firstIndex,
+					nextExpectedVersion: newVersion
+				}, {
+					operationName: "replaceOne",
+					collectionName,
+					errors
+				}));
+			},
+			handle: async (id, handle, options) => {
+				const { expectedVersion: version, ...operationOptions } = options ?? {};
+				ensureCollectionCreated();
+				const existing = await collection.findOne(({ _id }) => _id === id);
+				const expectedVersion = expectedVersionValue(version);
+				if (existing == null && version === "DOCUMENT_EXISTS" || existing == null && expectedVersion != null || existing != null && version === "DOCUMENT_DOES_NOT_EXIST" || existing != null && expectedVersion !== null && existing._version !== expectedVersion) return operationResult({
+					successful: false,
+					document: existing
+				}, {
+					operationName: "handle",
+					collectionName,
+					errors
+				});
+				const result = handle(existing !== null ? { ...existing } : null);
+				if (deepEquals(existing, result)) return operationResult({
+					successful: true,
+					document: existing
+				}, {
+					operationName: "handle",
+					collectionName,
+					errors
+				});
+				if (!existing && result) {
+					const newDoc = {
+						...result,
+						_id: id
+					};
+					const insertResult = await collection.insertOne({
+						...newDoc,
+						_id: id
+					});
+					return {
+						...insertResult,
+						document: {
+							...newDoc,
+							_version: insertResult.nextExpectedVersion
+						}
+					};
+				}
+				if (existing && !result) return {
+					...await collection.deleteOne(({ _id }) => id === _id),
+					document: null
+				};
+				if (existing && result) {
+					const replaceResult = await collection.replaceOne(({ _id }) => id === _id, result, {
+						...operationOptions,
+						expectedVersion: expectedVersion ?? "DOCUMENT_EXISTS"
+					});
+					return {
+						...replaceResult,
+						document: {
+							...result,
+							_version: replaceResult.nextExpectedVersion
+						}
+					};
+				}
+				return operationResult({
+					successful: true,
+					document: existing
+				}, {
+					operationName: "handle",
+					collectionName,
+					errors
+				});
+			}
+		};
+		return collection;
+	} };
 };
 
-// src/processors/processors.ts
-import { v7 as uuid3 } from "uuid";
-var getCheckpoint = (message2) => {
-  return message2.metadata.checkpoint;
-};
-var wasMessageHandled = (message2, checkpoint) => {
-  const messageCheckpoint = getCheckpoint(message2);
-  return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpoint !== null && checkpoint !== void 0 && messageCheckpoint <= checkpoint;
-};
-var MessageProcessorType = {
-  PROJECTOR: "projector",
-  REACTOR: "reactor"
-};
-var MessageProcessor = {
-  result: {
-    skip: (options) => ({
-      type: "SKIP",
-      ...options ?? {}
-    }),
-    stop: (options) => ({
-      type: "STOP",
-      ...options ?? {}
-    })
-  }
-};
-var defaultProcessingMessageProcessingScope = (handler, partialContext) => handler(partialContext);
-var bigIntProcessorCheckpoint = (value) => bigInt.toNormalizedString(value);
-var parseBigIntProcessorCheckpoint = (value) => BigInt(value);
-var defaultProcessorVersion = 1;
-var defaultProcessorPartition = defaultTag;
-var getProcessorInstanceId = (processorId) => `${processorId}:${uuid3()}`;
-var getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
-var reactor = (options) => {
-  const {
-    checkpoints,
-    processorId,
-    processorInstanceId: instanceId = getProcessorInstanceId(processorId),
-    type = MessageProcessorType.REACTOR,
-    version = defaultProcessorVersion,
-    partition = defaultProcessorPartition,
-    hooks = {},
-    processingScope = defaultProcessingMessageProcessingScope,
-    startFrom,
-    canHandle,
-    stopAfter
-  } = options;
-  const eachMessage = "eachMessage" in options && options.eachMessage ? options.eachMessage : () => Promise.resolve();
-  let isInitiated = false;
-  let isActive = false;
-  let lastCheckpoint = null;
-  let closeSignal = null;
-  const init = async (initOptions) => {
-    if (isInitiated) return;
-    if (hooks.onInit === void 0) {
-      isInitiated = true;
-      return;
-    }
-    return await processingScope(async (context) => {
-      await hooks.onInit(context);
-      isInitiated = true;
-    }, initOptions);
-  };
-  const close = async (closeOptions) => {
-    isActive = false;
-    if (closeSignal) {
-      closeSignal();
-      closeSignal = null;
-    }
-    if (hooks.onClose) {
-      await processingScope(hooks.onClose, closeOptions);
-    }
-  };
-  return {
-    // TODO: Consider whether not make it optional or add URN prefix
-    id: processorId,
-    instanceId,
-    type,
-    canHandle,
-    init,
-    start: async (startOptions) => {
-      if (isActive) return;
-      await init(startOptions);
-      isActive = true;
-      closeSignal = onShutdown(() => close(startOptions));
-      if (lastCheckpoint !== null)
-        return {
-          lastCheckpoint
-        };
-      return await processingScope(async (context) => {
-        if (hooks.onStart) {
-          await hooks.onStart(context);
-        }
-        if (startFrom && startFrom !== "CURRENT") return startFrom;
-        if (checkpoints) {
-          const readResult = await checkpoints?.read(
-            {
-              processorId,
-              partition
-            },
-            { ...startOptions, ...context }
-          );
-          lastCheckpoint = readResult.lastCheckpoint;
-        }
-        if (lastCheckpoint === null) return "BEGINNING";
-        return {
-          lastCheckpoint
-        };
-      }, startOptions);
-    },
-    close,
-    get isActive() {
-      return isActive;
-    },
-    handle: async (messages, partialContext) => {
-      if (!isActive) return Promise.resolve();
-      return await processingScope(async (context) => {
-        let result = void 0;
-        for (const message2 of messages) {
-          if (wasMessageHandled(message2, lastCheckpoint)) continue;
-          const upcasted = upcastRecordedMessage(
-            // TODO: Make it smarter
-            message2,
-            options.messageOptions?.schema?.versioning
-          );
-          if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
-            continue;
-          const messageProcessingResult = await eachMessage(upcasted, context);
-          if (checkpoints) {
-            const storeCheckpointResult = await checkpoints.store(
-              {
-                processorId,
-                version,
-                message: upcasted,
-                lastCheckpoint,
-                partition
-              },
-              context
-            );
-            if (storeCheckpointResult.success) {
-              lastCheckpoint = storeCheckpointResult.newCheckpoint;
-            }
-          }
-          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
-            isActive = false;
-            result = messageProcessingResult;
-            break;
-          }
-          if (stopAfter && stopAfter(upcasted)) {
-            isActive = false;
-            result = { type: "STOP", reason: "Stop condition reached" };
-            break;
-          }
-          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
-            continue;
-        }
-        return result;
-      }, partialContext);
-    }
-  };
-};
-var projector = (options) => {
-  const {
-    projection: projection2,
-    processorId = getProjectorId({
-      projectionName: projection2.name ?? "unknown"
-    }),
-    ...rest
-  } = options;
-  return reactor({
-    ...rest,
-    type: MessageProcessorType.PROJECTOR,
-    canHandle: projection2.canHandle,
-    processorId,
-    messageOptions: options.projection.eventsOptions,
-    hooks: {
-      onInit: options.hooks?.onInit,
-      onStart: options.truncateOnStart && options.projection.truncate || options.hooks?.onStart ? async (context) => {
-        if (options.truncateOnStart && options.projection.truncate)
-          await options.projection.truncate(context);
-        if (options.hooks?.onStart) await options.hooks?.onStart(context);
-      } : void 0,
-      onClose: options.hooks?.onClose
-    },
-    eachMessage: async (event2, context) => projection2.handle([event2], context)
-  });
+//#endregion
+//#region src/processors/processors.ts
+const getCheckpoint = (message) => {
+	return message.metadata.checkpoint;
+};
+const wasMessageHandled = (message, checkpoint) => {
+	const messageCheckpoint = getCheckpoint(message);
+	return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpoint !== null && checkpoint !== void 0 && messageCheckpoint <= checkpoint;
+};
+const MessageProcessorType = {
+	PROJECTOR: "projector",
+	REACTOR: "reactor"
+};
+const MessageProcessor = { result: {
+	skip: (options) => ({
+		type: "SKIP",
+		...options ?? {}
+	}),
+	stop: (options) => ({
+		type: "STOP",
+		...options ?? {}
+	})
+} };
+const defaultProcessingMessageProcessingScope = (handler, partialContext) => handler(partialContext);
+const bigIntProcessorCheckpoint = (value) => bigInt.toNormalizedString(value);
+const parseBigIntProcessorCheckpoint = (value) => BigInt(value);
+const defaultProcessorVersion = 1;
+const defaultProcessorPartition = defaultTag;
+const getProcessorInstanceId = (processorId) => `${processorId}:${v7()}`;
+const getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
+const reactor = (options) => {
+	const { checkpoints, processorId, processorInstanceId: instanceId = getProcessorInstanceId(processorId), type = MessageProcessorType.REACTOR, version = 1, partition = defaultProcessorPartition, hooks = {}, processingScope = defaultProcessingMessageProcessingScope, startFrom, canHandle, stopAfter } = options;
+	const isCustomBatch = "eachBatch" in options && !!options.eachBatch;
+	const eachBatch = isCustomBatch ? options.eachBatch : async (messages, context) => {
+		let result = void 0;
+		for (let i = 0; i < messages.length; i++) {
+			const message = messages[i];
+			const messageProcessingResult = await options.eachMessage(message, context);
+			if (messageProcessingResult && messageProcessingResult.type === "STOP") {
+				result = {
+					...messageProcessingResult,
+					lastSuccessfulMessage: messageProcessingResult.error ? messages[i - 1] : message
+				};
+				break;
+			}
+			if (stopAfter && stopAfter(message)) {
+				result = {
+					type: "STOP",
+					reason: "Stop condition reached",
+					lastSuccessfulMessage: message
+				};
+				break;
+			}
+			if (messageProcessingResult && messageProcessingResult.type === "SKIP") {
+				result = {
+					...messageProcessingResult,
+					lastSuccessfulMessage: message
+				};
+				continue;
+			}
+		}
+		return result;
+	};
+	let isInitiated = false;
+	let isActive = false;
+	let lastCheckpoint = null;
+	let closeSignal = null;
+	const init = async (initOptions) => {
+		if (isInitiated) return;
+		if (hooks.onInit === void 0) {
+			isInitiated = true;
+			return;
+		}
+		return await processingScope(async (context) => {
+			await hooks.onInit(context);
+			isInitiated = true;
+		}, initOptions);
+	};
+	const close = async (closeOptions) => {
+		isActive = false;
+		if (closeSignal) {
+			closeSignal();
+			closeSignal = null;
+		}
+		if (hooks.onClose) await processingScope(hooks.onClose, closeOptions);
+	};
+	return {
+		id: processorId,
+		instanceId,
+		type,
+		canHandle,
+		init,
+		start: async (startOptions) => {
+			if (isActive) return;
+			await init(startOptions);
+			isActive = true;
+			closeSignal = onShutdown(() => close(startOptions));
+			if (lastCheckpoint !== null) return { lastCheckpoint };
+			return await processingScope(async (context) => {
+				if (hooks.onStart) await hooks.onStart(context);
+				if (startFrom && startFrom !== "CURRENT") return startFrom;
+				if (checkpoints) lastCheckpoint = (await checkpoints?.read({
+					processorId,
+					partition
+				}, {
+					...startOptions,
+					...context
+				})).lastCheckpoint;
+				if (lastCheckpoint === null) return "BEGINNING";
+				return { lastCheckpoint };
+			}, startOptions);
+		},
+		close,
+		get isActive() {
+			return isActive;
+		},
+		handle: async (messages, partialContext) => {
+			if (!isActive) return Promise.resolve();
+			return await processingScope(async (context) => {
+				const messagesAboveCheckpoint = messages.filter((message) => !wasMessageHandled(message, lastCheckpoint));
+				const upcastedMessages = messagesAboveCheckpoint.map((message) => upcastRecordedMessage(message, options.messageOptions?.schema?.versioning)).filter((upcasted) => !canHandle || canHandle.includes(upcasted.type));
+				const stopMessageIndex = isCustomBatch && stopAfter ? upcastedMessages.findIndex(stopAfter) : -1;
+				const unhandledMessages = stopMessageIndex !== -1 ? upcastedMessages.slice(0, stopMessageIndex + 1) : upcastedMessages;
+				const batchResult = await eachBatch(unhandledMessages, context);
+				const messageProcessingResult = batchResult?.type === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
+					type: "STOP",
+					reason: "Stop condition reached",
+					lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
+				} : batchResult;
+				const isStop = messageProcessingResult && messageProcessingResult.type === "STOP";
+				const checkpointMessage = messageProcessingResult?.type === "STOP" ? messageProcessingResult.lastSuccessfulMessage : messagesAboveCheckpoint[messagesAboveCheckpoint.length - 1];
+				if (checkpointMessage && checkpoints) {
+					const storeCheckpointResult = await checkpoints.store({
+						processorId,
+						version,
+						message: checkpointMessage,
+						lastCheckpoint,
+						partition
+					}, context);
+					if (storeCheckpointResult.success) lastCheckpoint = storeCheckpointResult.newCheckpoint;
+				}
+				if (isStop) {
+					isActive = false;
+					return messageProcessingResult;
+				}
+			}, partialContext);
+		}
+	};
+};
+const projector = (options) => {
+	const { projection, processorId = getProjectorId({ projectionName: projection.name ?? "unknown" }), ...rest } = options;
+	return reactor({
+		...rest,
+		type: MessageProcessorType.PROJECTOR,
+		canHandle: projection.canHandle,
+		processorId,
+		messageOptions: options.projection.eventsOptions,
+		hooks: {
+			onInit: options.hooks?.onInit,
+			onStart: options.truncateOnStart && options.projection.truncate || options.hooks?.onStart ? async (context) => {
+				if (options.truncateOnStart && options.projection.truncate) await options.projection.truncate(context);
+				if (options.hooks?.onStart) await options.hooks?.onStart(context);
+			} : void 0,
+			onClose: options.hooks?.onClose
+		},
+		eachBatch: async (events, context) => projection.handle(events, context)
+	});
 };
 
-// src/processors/inMemoryProcessors.ts
-var inMemoryCheckpointer = () => {
-  return {
-    read: async ({ processorId }, { database }) => {
-      const checkpoint = await database.collection("emt_processor_checkpoints").findOne((d) => d._id === processorId);
-      return Promise.resolve({
-        lastCheckpoint: checkpoint?.lastCheckpoint ?? null
-      });
-    },
-    store: async (context, { database }) => {
-      const { message: message2, processorId, lastCheckpoint } = context;
-      const checkpoints = database.collection(
-        "emt_processor_checkpoints"
-      );
-      const checkpoint = await checkpoints.findOne(
-        (d) => d._id === processorId
-      );
-      const currentPosition = checkpoint?.lastCheckpoint ?? null;
-      const newCheckpoint = getCheckpoint(message2);
-      if (currentPosition && (currentPosition === newCheckpoint || currentPosition !== lastCheckpoint)) {
-        return {
-          success: false,
-          reason: currentPosition === newCheckpoint ? "IGNORED" : newCheckpoint !== null && currentPosition > newCheckpoint ? "CURRENT_AHEAD" : "MISMATCH"
-        };
-      }
-      await checkpoints.handle(processorId, (existing) => ({
-        ...existing ?? {},
-        _id: processorId,
-        lastCheckpoint: newCheckpoint
-      }));
-      return { success: true, newCheckpoint };
-    }
-  };
-};
-var inMemoryProcessingScope = (options) => {
-  const processorDatabase = options.database;
-  const processingScope = (handler, partialContext) => {
-    const database = processorDatabase ?? partialContext?.database;
-    if (!database)
-      throw new EmmettError(
-        `InMemory processor '${options.processorId}' is missing database. Ensure that you passed it through options`
-      );
-    return handler({ ...partialContext, database });
-  };
-  return processingScope;
-};
-var inMemoryProjector = (options) => {
-  const database = options.connectionOptions?.database ?? getInMemoryDatabase();
-  const hooks = {
-    onInit: options.hooks?.onInit,
-    onStart: options.hooks?.onStart,
-    onClose: options.hooks?.onClose ? async (context) => {
-      if (options.hooks?.onClose) await options.hooks?.onClose(context);
-    } : void 0
-  };
-  const processor = projector({
-    ...options,
-    hooks,
-    processingScope: inMemoryProcessingScope({
-      database,
-      processorId: options.processorId ?? `projection:${options.projection.name}`
-    }),
-    checkpoints: inMemoryCheckpointer()
-  });
-  return Object.assign(processor, { database });
-};
-var inMemoryReactor = (options) => {
-  const database = options.connectionOptions?.database ?? getInMemoryDatabase();
-  const hooks = {
-    onInit: options.hooks?.onInit,
-    onStart: options.hooks?.onStart,
-    onClose: options.hooks?.onClose
-  };
-  const processor = reactor({
-    ...options,
-    hooks,
-    processingScope: inMemoryProcessingScope({
-      database,
-      processorId: options.processorId
-    }),
-    checkpoints: inMemoryCheckpointer()
-  });
-  return Object.assign(processor, { database });
+//#endregion
+//#region src/processors/inMemoryProcessors.ts
+const inMemoryCheckpointer = () => {
+	return {
+		read: async ({ processorId }, { database }) => {
+			const checkpoint = await database.collection("emt_processor_checkpoints").findOne((d) => d._id === processorId);
+			return Promise.resolve({ lastCheckpoint: checkpoint?.lastCheckpoint ?? null });
+		},
+		store: async (context, { database }) => {
+			const { message, processorId, lastCheckpoint } = context;
+			const checkpoints = database.collection("emt_processor_checkpoints");
+			const currentPosition = (await checkpoints.findOne((d) => d._id === processorId))?.lastCheckpoint ?? null;
+			const newCheckpoint = getCheckpoint(message);
+			if (currentPosition && (currentPosition === newCheckpoint || currentPosition !== lastCheckpoint)) return {
+				success: false,
+				reason: currentPosition === newCheckpoint ? "IGNORED" : newCheckpoint !== null && currentPosition > newCheckpoint ? "CURRENT_AHEAD" : "MISMATCH"
+			};
+			await checkpoints.handle(processorId, (existing) => ({
+				...existing ?? {},
+				_id: processorId,
+				lastCheckpoint: newCheckpoint
+			}));
+			return {
+				success: true,
+				newCheckpoint
+			};
+		}
+	};
+};
+const inMemoryProcessingScope = (options) => {
+	const processorDatabase = options.database;
+	const processingScope = (handler, partialContext) => {
+		const database = processorDatabase ?? partialContext?.database;
+		if (!database) throw new EmmettError(`InMemory processor '${options.processorId}' is missing database. Ensure that you passed it through options`);
+		return handler({
+			...partialContext,
+			database
+		});
+	};
+	return processingScope;
+};
+const inMemoryProjector = (options) => {
+	const database = options.connectionOptions?.database ?? getInMemoryDatabase();
+	const hooks = {
+		onInit: options.hooks?.onInit,
+		onStart: options.hooks?.onStart,
+		onClose: options.hooks?.onClose ? async (context) => {
+			if (options.hooks?.onClose) await options.hooks?.onClose(context);
+		} : void 0
+	};
+	const processor = projector({
+		...options,
+		hooks,
+		processingScope: inMemoryProcessingScope({
+			database,
+			processorId: options.processorId ?? `projection:${options.projection.name}`
+		}),
+		checkpoints: inMemoryCheckpointer()
+	});
+	return Object.assign(processor, { database });
+};
+const inMemoryReactor = (options) => {
+	const database = options.connectionOptions?.database ?? getInMemoryDatabase();
+	const hooks = {
+		onInit: options.hooks?.onInit,
+		onStart: options.hooks?.onStart,
+		onClose: options.hooks?.onClose
+	};
+	const processor = reactor({
+		...options,
+		hooks,
+		processingScope: inMemoryProcessingScope({
+			database,
+			processorId: options.processorId
+		}),
+		checkpoints: inMemoryCheckpointer()
+	});
+	return Object.assign(processor, { database });
 };
 
-// src/eventStore/projections/inMemory/inMemoryProjection.ts
-var DATABASE_REQUIRED_ERROR_MESSAGE = "Database is required in context for InMemory projections";
-var handleInMemoryProjections = async (options) => {
-  const { projections: projections2, events, database, eventStore } = options;
-  const eventTypes = events.map((e) => e.type);
-  const relevantProjections = projections2.filter(
-    (p) => p.canHandle.some((type) => eventTypes.includes(type))
-  );
-  for (const projection2 of relevantProjections) {
-    await projection2.handle(events, {
-      eventStore,
-      database
-    });
-  }
-};
-var inMemoryProjection = ({
-  truncate,
-  handle,
-  canHandle
-}) => ({
-  canHandle,
-  handle: async (events, context) => {
-    if (!context.database) {
-      throw new Error(DATABASE_REQUIRED_ERROR_MESSAGE);
-    }
-    await handle(events, {
-      ...context,
-      database: context.database
-    });
-  },
-  truncate: truncate ? (context) => {
-    if (!context.database) {
-      throw new Error(DATABASE_REQUIRED_ERROR_MESSAGE);
-    }
-    return truncate({
-      ...context,
-      database: context.database
-    });
-  } : void 0
+//#endregion
+//#region src/eventStore/projections/inMemory/inMemoryProjection.ts
+const DATABASE_REQUIRED_ERROR_MESSAGE = "Database is required in context for InMemory projections";
+/**
+* Handles projections for the InMemoryEventStore
+* Similar to the PostgreSQL implementation, this processes events through projections
+*/
+const handleInMemoryProjections = async (options) => {
+	const { projections, events, database, eventStore } = options;
+	const eventTypes = events.map((e) => e.type);
+	const relevantProjections = projections.filter((p) => p.canHandle.some((type) => eventTypes.includes(type)));
+	for (const projection of relevantProjections) await projection.handle(events, {
+		eventStore,
+		database
+	});
+};
+/**
+* Creates an InMemory projection
+*/
+const inMemoryProjection = ({ truncate, handle, canHandle }) => ({
+	canHandle,
+	handle: async (events, context) => {
+		if (!context.database) throw new Error(DATABASE_REQUIRED_ERROR_MESSAGE);
+		await handle(events, {
+			...context,
+			database: context.database
+		});
+	},
+	truncate: truncate ? (context) => {
+		if (!context.database) throw new Error(DATABASE_REQUIRED_ERROR_MESSAGE);
+		return truncate({
+			...context,
+			database: context.database
+		});
+	} : void 0
 });
-var inMemoryMultiStreamProjection = (options) => {
-  const { collectionName, getDocumentId, canHandle } = options;
-  return inMemoryProjection({
-    handle: async (events, { database }) => {
-      const collection = database.collection(collectionName);
-      for (const event2 of events) {
-        await collection.handle(getDocumentId(event2), (document) => {
-          if ("initialState" in options) {
-            return options.evolve(document ?? options.initialState(), event2);
-          } else {
-            return options.evolve(document, event2);
-          }
-        });
-      }
-    },
-    canHandle,
-    truncate: async ({
-      database
-    }) => {
-      const collection = database.collection(collectionName);
-      const documents = await collection.find();
-      for (const doc of documents) {
-        if (doc && "_id" in doc) {
-          const id = doc._id;
-          await collection.deleteOne((d) => d._id === id);
-        }
-      }
-    }
-  });
-};
-var inMemorySingleStreamProjection = (options) => {
-  return inMemoryMultiStreamProjection({
-    ...options,
-    getDocumentId: options.getDocumentId ?? ((event2) => event2.metadata.streamName)
-  });
+/**
+* Creates a projection that handles events across multiple streams
+*/
+const inMemoryMultiStreamProjection = (options) => {
+	const { collectionName, getDocumentId, canHandle } = options;
+	return inMemoryProjection({
+		handle: async (events, { database }) => {
+			const collection = database.collection(collectionName);
+			for (const event of events) await collection.handle(getDocumentId(event), (document) => {
+				if ("initialState" in options) return options.evolve(document ?? options.initialState(), event);
+				else return options.evolve(document, event);
+			});
+		},
+		canHandle,
+		truncate: async ({ database }) => {
+			const collection = database.collection(collectionName);
+			const documents = await collection.find();
+			for (const doc of documents) if (doc && "_id" in doc) {
+				const id = doc._id;
+				await collection.deleteOne((d) => d._id === id);
+			}
+		}
+	});
+};
+/**
+* Creates a projection that handles events from a single stream
+*/
+const inMemorySingleStreamProjection = (options) => {
+	return inMemoryMultiStreamProjection({
+		...options,
+		getDocumentId: options.getDocumentId ?? ((event) => event.metadata.streamName)
+	});
 };
 
-// src/eventStore/projections/inMemory/inMemoryProjectionSpec.ts
-import { v4 as uuid4 } from "uuid";
-
-// src/testing/assertions.ts
+//#endregion
+//#region src/testing/assertions.ts
 var AssertionError = class extends Error {
-  constructor(message2) {
-    super(message2);
-  }
-};
-var isSubset = (superObj, subObj) => {
-  const sup = superObj;
-  const sub = subObj;
-  assertOk(sup);
-  assertOk(sub);
-  return Object.keys(sub).every((ele) => {
-    if (sub[ele] !== null && typeof sub[ele] == "object") {
-      return isSubset(sup[ele], sub[ele]);
-    }
-    return sub[ele] === sup[ele];
-  });
-};
-var assertFails = (message2) => {
-  throw new AssertionError(message2 ?? "That should not ever happened, right?");
-};
-var assertThrowsAsync = async (fun, errorCheck) => {
-  try {
-    await fun();
-  } catch (error) {
-    const typedError = error;
-    if (typedError instanceof AssertionError || !errorCheck) {
-      assertFalse(
-        typedError instanceof AssertionError,
-        "Function didn't throw expected error"
-      );
-      return typedError;
-    }
-    assertTrue(
-      errorCheck(typedError),
-      `Error doesn't match the expected condition: ${JSONSerializer.serialize(error)}`
-    );
-    return typedError;
-  }
-  throw new AssertionError("Function didn't throw expected error");
-};
-var assertThrows = (fun, errorCheck) => {
-  try {
-    fun();
-  } catch (error) {
-    const typedError = error;
-    if (errorCheck) {
-      assertTrue(
-        errorCheck(typedError),
-        `Error doesn't match the expected condition: ${JSONSerializer.serialize(error)}`
-      );
-    } else if (typedError instanceof AssertionError) {
-      assertFalse(
-        typedError instanceof AssertionError,
-        "Function didn't throw expected error"
-      );
-    }
-    return typedError;
-  }
-  throw new AssertionError("Function didn't throw expected error");
-};
-var assertDoesNotThrow = (fun, errorCheck) => {
-  try {
-    fun();
-    return null;
-  } catch (error) {
-    const typedError = error;
-    if (errorCheck) {
-      assertFalse(
-        errorCheck(typedError),
-        `Error matching the expected condition was thrown!: ${JSONSerializer.serialize(error)}`
-      );
-    } else {
-      assertFails(
-        `Function threw an error: ${JSONSerializer.serialize(error)}`
-      );
-    }
-    return typedError;
-  }
-};
-var assertRejects = async (promise, errorCheck) => {
-  try {
-    await promise;
-    throw new AssertionError("Function didn't throw expected error");
-  } catch (error) {
-    if (!errorCheck) return;
-    if (errorCheck instanceof Error) assertDeepEqual(error, errorCheck);
-    else assertTrue(errorCheck(error));
-  }
-};
-var assertMatches = (actual, expected, message2) => {
-  if (!isSubset(actual, expected))
-    throw new AssertionError(
-      message2 ?? `subObj:
-${JSONSerializer.serialize(expected)}
-is not subset of
-${JSONSerializer.serialize(actual)}`
-    );
-};
-var assertDeepEqual = (actual, expected, message2) => {
-  if (!deepEquals(actual, expected))
-    throw new AssertionError(
-      message2 ?? `subObj:
-${JSONSerializer.serialize(expected)}
-is not equal to
-${JSONSerializer.serialize(actual)}`
-    );
-};
-var assertNotDeepEqual = (actual, expected, message2) => {
-  if (deepEquals(actual, expected))
-    throw new AssertionError(
-      message2 ?? `subObj:
-${JSONSerializer.serialize(expected)}
-is equals to
-${JSONSerializer.serialize(actual)}`
-    );
-};
-var assertThat = (item) => {
-  return {
-    isEqualTo: (other) => assertTrue(deepEquals(item, other))
-  };
-};
-var assertDefined = (value, message2) => {
-  assertOk(value, message2 instanceof Error ? message2.message : message2);
-};
-function assertFalse(condition, message2) {
-  if (condition !== false)
-    throw new AssertionError(message2 ?? `Condition is true`);
+	constructor(message) {
+		super(message);
+	}
+};
+const isSubset = (superObj, subObj) => {
+	const sup = superObj;
+	const sub = subObj;
+	assertOk(sup);
+	assertOk(sub);
+	return Object.keys(sub).every((ele) => {
+		if (sub[ele] !== null && typeof sub[ele] == "object") return isSubset(sup[ele], sub[ele]);
+		return sub[ele] === sup[ele];
+	});
+};
+const assertFails = (message) => {
+	throw new AssertionError(message ?? "That should not ever happened, right?");
+};
+const assertThrowsAsync = async (fun, errorCheck) => {
+	try {
+		await fun();
+	} catch (error) {
+		const typedError = error;
+		if (typedError instanceof AssertionError || !errorCheck) {
+			assertFalse(typedError instanceof AssertionError, "Function didn't throw expected error");
+			return typedError;
+		}
+		assertTrue(errorCheck(typedError), `Error doesn't match the expected condition: ${JSONSerializer.serialize(error)}`);
+		return typedError;
+	}
+	throw new AssertionError("Function didn't throw expected error");
+};
+const assertThrows = (fun, errorCheck) => {
+	try {
+		fun();
+	} catch (error) {
+		const typedError = error;
+		if (errorCheck) assertTrue(errorCheck(typedError), `Error doesn't match the expected condition: ${JSONSerializer.serialize(error)}`);
+		else if (typedError instanceof AssertionError) assertFalse(typedError instanceof AssertionError, "Function didn't throw expected error");
+		return typedError;
+	}
+	throw new AssertionError("Function didn't throw expected error");
+};
+const assertDoesNotThrow = (fun, errorCheck) => {
+	try {
+		fun();
+		return null;
+	} catch (error) {
+		const typedError = error;
+		if (errorCheck) assertFalse(errorCheck(typedError), `Error matching the expected condition was thrown!: ${JSONSerializer.serialize(error)}`);
+		else assertFails(`Function threw an error: ${JSONSerializer.serialize(error)}`);
+		return typedError;
+	}
+};
+const assertRejects = async (promise, errorCheck) => {
+	try {
+		await promise;
+		throw new AssertionError("Function didn't throw expected error");
+	} catch (error) {
+		if (!errorCheck) return;
+		if (errorCheck instanceof Error) assertDeepEqual(error, errorCheck);
+		else assertTrue(errorCheck(error));
+	}
+};
+const assertMatches = (actual, expected, message) => {
+	if (!isSubset(actual, expected)) throw new AssertionError(message ?? `subObj:\n${JSONSerializer.serialize(expected)}\nis not subset of\n${JSONSerializer.serialize(actual)}`);
+};
+const assertDeepEqual = (actual, expected, message) => {
+	if (!deepEquals(actual, expected)) throw new AssertionError(message ?? `subObj:\n${JSONSerializer.serialize(expected)}\nis not equal to\n${JSONSerializer.serialize(actual)}`);
+};
+const assertNotDeepEqual = (actual, expected, message) => {
+	if (deepEquals(actual, expected)) throw new AssertionError(message ?? `subObj:\n${JSONSerializer.serialize(expected)}\nis equals to\n${JSONSerializer.serialize(actual)}`);
+};
+const assertThat = (item) => {
+	return { isEqualTo: (other) => assertTrue(deepEquals(item, other)) };
+};
+const assertDefined = (value, message) => {
+	assertOk(value, message instanceof Error ? message.message : message);
+};
+function assertFalse(condition, message) {
+	if (condition !== false) throw new AssertionError(message ?? `Condition is true`);
 }
-function assertTrue(condition, message2) {
-  if (condition !== true)
-    throw new AssertionError(message2 ?? `Condition is false`);
+function assertTrue(condition, message) {
+	if (condition !== true) throw new AssertionError(message ?? `Condition is false`);
 }
-function assertOk(obj, message2) {
-  if (!obj) throw new AssertionError(message2 ?? `Condition is not truthy`);
+function assertOk(obj, message) {
+	if (!obj) throw new AssertionError(message ?? `Condition is not truthy`);
 }
-function assertEqual(expected, actual, message2) {
-  if (expected !== actual)
-    throw new AssertionError(
-      `${message2 ?? "Objects are not equal"}:
-Expected: ${JSONSerializer.serialize(expected)}
-Actual: ${JSONSerializer.serialize(actual)}`
-    );
+function assertEqual(expected, actual, message) {
+	if (expected !== actual) throw new AssertionError(`${message ?? "Objects are not equal"}:\nExpected: ${JSONSerializer.serialize(expected)}\nActual: ${JSONSerializer.serialize(actual)}`);
 }
-function assertNotEqual(obj, other, message2) {
-  if (obj === other)
-    throw new AssertionError(
-      message2 ?? `Objects are equal: ${JSONSerializer.serialize(obj)}`
-    );
+function assertNotEqual(obj, other, message) {
+	if (obj === other) throw new AssertionError(message ?? `Objects are equal: ${JSONSerializer.serialize(obj)}`);
 }
 function assertIsNotNull(result) {
-  assertNotEqual(result, null);
-  assertOk(result);
+	assertNotEqual(result, null);
+	assertOk(result);
 }
 function assertIsNull(result) {
-  assertEqual(result, null);
+	assertEqual(result, null);
 }
-var argValue = (value) => (arg) => deepEquals(arg, value);
-var argMatches = (matches) => (arg) => matches(arg);
+const argValue = (value) => (arg) => deepEquals(arg, value);
+const argMatches = (matches) => (arg) => matches(arg);
 function verifyThat(fn) {
-  return {
-    calledTimes: (times) => {
-      assertEqual(fn.mock?.calls?.length, times);
-    },
-    notCalled: () => {
-      assertEqual(fn?.mock?.calls?.length, 0);
-    },
-    called: () => {
-      assertTrue(
-        fn.mock?.calls.length !== void 0 && fn.mock.calls.length > 0
-      );
-    },
-    calledWith: (...args) => {
-      assertTrue(
-        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
-      );
-    },
-    calledOnceWith: (...args) => {
-      assertTrue(
-        fn.mock?.calls.length !== void 0 && fn.mock.calls.length === 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
-      );
-    },
-    calledWithArgumentMatching: (...matches) => {
-      assertTrue(
-        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1
-      );
-      assertTrue(
-        fn.mock?.calls.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(
-        fn.mock?.calls.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])
-        )
-      );
-    }
-  };
+	return {
+		calledTimes: (times) => {
+			assertEqual(fn.mock?.calls?.length, times);
+		},
+		notCalled: () => {
+			assertEqual(fn?.mock?.calls?.length, 0);
+		},
+		called: () => {
+			assertTrue(fn.mock?.calls.length !== void 0 && fn.mock.calls.length > 0);
+		},
+		calledWith: (...args) => {
+			assertTrue(fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args)));
+		},
+		calledOnceWith: (...args) => {
+			assertTrue(fn.mock?.calls.length !== void 0 && fn.mock.calls.length === 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args)));
+		},
+		calledWithArgumentMatching: (...matches) => {
+			assertTrue(fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1);
+			assertTrue(fn.mock?.calls.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(fn.mock?.calls.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])));
+		}
+	};
 }
-var assertThatArray = (array) => {
-  return {
-    isEmpty: () => assertEqual(
-      array.length,
-      0,
-      `Array is not empty ${JSONSerializer.serialize(array)}`
-    ),
-    isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
-    hasSize: (length) => assertEqual(array.length, length),
-    containsElements: (other) => {
-      assertTrue(other.every((ts) => array.some((o) => deepEquals(ts, o))));
-    },
-    containsElementsMatching: (other) => {
-      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
-    },
-    containsOnlyElementsMatching: (other) => {
-      assertEqual(array.length, other.length, `Arrays lengths don't match`);
-      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
-    },
-    containsExactlyInAnyOrder: (other) => {
-      assertEqual(array.length, other.length);
-      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
-    },
-    containsExactlyInAnyOrderElementsOf: (other) => {
-      assertEqual(array.length, other.length);
-      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
-    },
-    containsExactlyElementsOf: (other) => {
-      assertEqual(array.length, other.length);
-      for (let i = 0; i < array.length; i++) {
-        assertTrue(deepEquals(array[i], other[i]));
-      }
-    },
-    containsExactly: (elem) => {
-      assertEqual(array.length, 1);
-      assertTrue(deepEquals(array[0], elem));
-    },
-    contains: (elem) => {
-      assertTrue(array.some((a) => deepEquals(a, elem)));
-    },
-    containsOnlyOnceElementsOf: (other) => {
-      assertTrue(
-        other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
-      );
-    },
-    containsAnyOf: (other) => {
-      assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
-    },
-    allMatch: (matches) => {
-      assertTrue(array.every(matches));
-    },
-    anyMatches: (matches) => {
-      assertTrue(array.some(matches));
-    },
-    allMatchAsync: async (matches) => {
-      for (const item of array) {
-        assertTrue(await matches(item));
-      }
-    }
-  };
+const assertThatArray = (array) => {
+	return {
+		isEmpty: () => assertEqual(array.length, 0, `Array is not empty ${JSONSerializer.serialize(array)}`),
+		isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
+		hasSize: (length) => assertEqual(array.length, length),
+		containsElements: (other) => {
+			assertTrue(other.every((ts) => array.some((o) => deepEquals(ts, o))));
+		},
+		containsElementsMatching: (other) => {
+			assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
+		},
+		containsOnlyElementsMatching: (other) => {
+			assertEqual(array.length, other.length, `Arrays lengths don't match`);
+			assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
+		},
+		containsExactlyInAnyOrder: (other) => {
+			assertEqual(array.length, other.length);
+			assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+		},
+		containsExactlyInAnyOrderElementsOf: (other) => {
+			assertEqual(array.length, other.length);
+			assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+		},
+		containsExactlyElementsOf: (other) => {
+			assertEqual(array.length, other.length);
+			for (let i = 0; i < array.length; i++) assertTrue(deepEquals(array[i], other[i]));
+		},
+		containsExactly: (elem) => {
+			assertEqual(array.length, 1);
+			assertTrue(deepEquals(array[0], elem));
+		},
+		contains: (elem) => {
+			assertTrue(array.some((a) => deepEquals(a, elem)));
+		},
+		containsOnlyOnceElementsOf: (other) => {
+			assertTrue(other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length);
+		},
+		containsAnyOf: (other) => {
+			assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
+		},
+		allMatch: (matches) => {
+			assertTrue(array.every(matches));
+		},
+		anyMatches: (matches) => {
+			assertTrue(array.some(matches));
+		},
+		allMatchAsync: async (matches) => {
+			for (const item of array) assertTrue(await matches(item));
+		}
+	};
 };
 
-// src/testing/deciderSpecification.ts
-var DeciderSpecification = {
-  for: deciderSpecificationFor
-};
+//#endregion
+//#region src/testing/deciderSpecification.ts
+const DeciderSpecification = { for: deciderSpecificationFor };
 function deciderSpecificationFor(decider) {
-  {
-    return (givenEvents) => {
-      return {
-        when: (command2) => {
-          const handle = () => {
-            const existingEvents = Array.isArray(givenEvents) ? givenEvents : [givenEvents];
-            const currentState = existingEvents.reduce(
-              decider.evolve,
-              decider.initialState()
-            );
-            return decider.decide(command2, currentState);
-          };
-          return {
-            then: (expectedEvents) => {
-              const resultEvents = handle();
-              if (resultEvents instanceof Promise) {
-                return resultEvents.then((events) => {
-                  thenHandler(events, expectedEvents);
-                });
-              }
-              thenHandler(resultEvents, expectedEvents);
-            },
-            thenNothingHappened: () => {
-              const resultEvents = handle();
-              if (resultEvents instanceof Promise) {
-                return resultEvents.then((events) => {
-                  thenNothingHappensHandler(events);
-                });
-              }
-              thenNothingHappensHandler(resultEvents);
-            },
-            thenThrows: (...args) => {
-              try {
-                const result = handle();
-                if (result instanceof Promise) {
-                  return result.then(() => {
-                    throw new AssertionError(
-                      "Handler did not fail as expected"
-                    );
-                  }).catch((error) => {
-                    thenThrowsErrorHandler(error, args);
-                  });
-                }
-                throw new AssertionError("Handler did not fail as expected");
-              } catch (error) {
-                thenThrowsErrorHandler(error, args);
-              }
-            }
-          };
-        }
-      };
-    };
-  }
+	return (givenEvents) => {
+		return { when: (command) => {
+			const handle = () => {
+				const currentState = (Array.isArray(givenEvents) ? givenEvents : [givenEvents]).reduce(decider.evolve, decider.initialState());
+				return decider.decide(command, currentState);
+			};
+			return {
+				then: (expectedEvents) => {
+					const resultEvents = handle();
+					if (resultEvents instanceof Promise) return resultEvents.then((events) => {
+						thenHandler$1(events, expectedEvents);
+					});
+					thenHandler$1(resultEvents, expectedEvents);
+				},
+				thenNothingHappened: () => {
+					const resultEvents = handle();
+					if (resultEvents instanceof Promise) return resultEvents.then((events) => {
+						thenNothingHappensHandler$1(events);
+					});
+					thenNothingHappensHandler$1(resultEvents);
+				},
+				thenThrows: (...args) => {
+					try {
+						const result = handle();
+						if (result instanceof Promise) return result.then(() => {
+							throw new AssertionError("Handler did not fail as expected");
+						}).catch((error) => {
+							thenThrowsErrorHandler$1(error, args);
+						});
+						throw new AssertionError("Handler did not fail as expected");
+					} catch (error) {
+						thenThrowsErrorHandler$1(error, args);
+					}
+				}
+			};
+		} };
+	};
 }
-function thenHandler(events, expectedEvents) {
-  const resultEventsArray = Array.isArray(events) ? events : [events];
-  const expectedEventsArray = Array.isArray(expectedEvents) ? expectedEvents : [expectedEvents];
-  assertThatArray(resultEventsArray).containsOnlyElementsMatching(
-    expectedEventsArray
-  );
+function thenHandler$1(events, expectedEvents) {
+	const resultEventsArray = Array.isArray(events) ? events : [events];
+	const expectedEventsArray = Array.isArray(expectedEvents) ? expectedEvents : [expectedEvents];
+	assertThatArray(resultEventsArray).containsOnlyElementsMatching(expectedEventsArray);
 }
-function thenNothingHappensHandler(events) {
-  const resultEventsArray = Array.isArray(events) ? events : [events];
-  assertThatArray(resultEventsArray).isEmpty();
+function thenNothingHappensHandler$1(events) {
+	assertThatArray(Array.isArray(events) ? events : [events]).isEmpty();
 }
-function thenThrowsErrorHandler(error, args) {
-  if (error instanceof AssertionError) throw error;
-  if (args.length === 0) return;
-  if (!isErrorConstructor(args[0])) {
-    assertTrue(
-      args[0](error),
-      `Error didn't match the error condition: ${error?.toString()}`
-    );
-    return;
-  }
-  assertTrue(
-    error instanceof args[0],
-    `Caught error is not an instance of the expected type: ${error?.toString()}`
-  );
-  if (args[1]) {
-    assertTrue(
-      args[1](error),
-      `Error didn't match the error condition: ${error?.toString()}`
-    );
-  }
+function thenThrowsErrorHandler$1(error, args) {
+	if (error instanceof AssertionError) throw error;
+	if (args.length === 0) return;
+	if (!isErrorConstructor(args[0])) {
+		assertTrue(args[0](error), `Error didn't match the error condition: ${error?.toString()}`);
+		return;
+	}
+	assertTrue(error instanceof args[0], `Caught error is not an instance of the expected type: ${error?.toString()}`);
+	if (args[1]) assertTrue(args[1](error), `Error didn't match the error condition: ${error?.toString()}`);
 }
 
-// src/testing/workflowSpecification.ts
-var WorkflowSpecification = {
-  for: workflowSpecificationFor
-};
+//#endregion
+//#region src/testing/workflowSpecification.ts
+const WorkflowSpecification = { for: workflowSpecificationFor };
 function workflowSpecificationFor(workflow) {
-  return (givenEvents) => {
-    return {
-      when: (input) => {
-        const handle = () => {
-          const existingEvents = Array.isArray(givenEvents) ? givenEvents : [givenEvents];
-          const currentState = existingEvents.reduce(
-            workflow.evolve,
-            workflow.initialState()
-          );
-          return workflow.decide(input, currentState);
-        };
-        return {
-          then: (expectedOutput) => {
-            const result = handle();
-            thenHandler2(result, expectedOutput);
-          },
-          thenNothingHappened: () => {
-            const result = handle();
-            thenNothingHappensHandler2(result);
-          },
-          thenThrows: (...args) => {
-            try {
-              handle();
-              throw new AssertionError("Handler did not fail as expected");
-            } catch (error) {
-              thenThrowsErrorHandler2(error, args);
-            }
-          }
-        };
-      }
-    };
-  };
+	return (givenEvents) => {
+		return { when: (input) => {
+			const handle = () => {
+				const currentState = (Array.isArray(givenEvents) ? givenEvents : [givenEvents]).reduce(workflow.evolve, workflow.initialState());
+				return workflow.decide(input, currentState);
+			};
+			return {
+				then: (expectedOutput) => {
+					thenHandler(handle(), expectedOutput);
+				},
+				thenNothingHappened: () => {
+					thenNothingHappensHandler(handle());
+				},
+				thenThrows: (...args) => {
+					try {
+						handle();
+						throw new AssertionError("Handler did not fail as expected");
+					} catch (error) {
+						thenThrowsErrorHandler(error, args);
+					}
+				}
+			};
+		} };
+	};
 }
-function thenHandler2(result, expectedOutput) {
-  const resultArray = Array.isArray(result) ? result : [result];
-  const expectedArray = Array.isArray(expectedOutput) ? expectedOutput : [expectedOutput];
-  assertThatArray(resultArray).containsOnlyElementsMatching(expectedArray);
+function thenHandler(result, expectedOutput) {
+	const resultArray = Array.isArray(result) ? result : [result];
+	const expectedArray = Array.isArray(expectedOutput) ? expectedOutput : [expectedOutput];
+	assertThatArray(resultArray).containsOnlyElementsMatching(expectedArray);
 }
-function thenNothingHappensHandler2(result) {
-  const resultArray = Array.isArray(result) ? result : [result];
-  assertThatArray(resultArray).isEmpty();
+function thenNothingHappensHandler(result) {
+	assertThatArray(Array.isArray(result) ? result : [result]).isEmpty();
 }
-function thenThrowsErrorHandler2(error, args) {
-  if (error instanceof AssertionError) throw error;
-  if (args.length === 0) return;
-  if (!isErrorConstructor(args[0])) {
-    assertTrue(
-      args[0](error),
-      `Error didn't match the error condition: ${error?.toString()}`
-    );
-    return;
-  }
-  assertTrue(
-    error instanceof args[0],
-    `Caught error is not an instance of the expected type: ${error?.toString()}`
-  );
-  if (args[1]) {
-    assertTrue(
-      args[1](error),
-      `Error didn't match the error condition: ${error?.toString()}`
-    );
-  }
+function thenThrowsErrorHandler(error, args) {
+	if (error instanceof AssertionError) throw error;
+	if (args.length === 0) return;
+	if (!isErrorConstructor(args[0])) {
+		assertTrue(args[0](error), `Error didn't match the error condition: ${error?.toString()}`);
+		return;
+	}
+	assertTrue(error instanceof args[0], `Caught error is not an instance of the expected type: ${error?.toString()}`);
+	if (args[1]) assertTrue(args[1](error), `Error didn't match the error condition: ${error?.toString()}`);
 }
 
-// src/testing/wrapEventStore.ts
-var WrapEventStore = (eventStore) => {
-  const appendedEvents = /* @__PURE__ */ new Map();
-  const wrapped = {
-    ...eventStore,
-    aggregateStream(streamName, options) {
-      return eventStore.aggregateStream(streamName, options);
-    },
-    async readStream(streamName, options) {
-      return await eventStore.readStream(
-        streamName,
-        options
-      );
-    },
-    appendToStream: async (streamName, events, options) => {
-      const result = await eventStore.appendToStream(
-        streamName,
-        events,
-        options
-      );
-      const currentStream = appendedEvents.get(streamName) ?? [streamName, []];
-      appendedEvents.set(streamName, [
-        streamName,
-        [...currentStream[1], ...events]
-      ]);
-      return result;
-    },
-    appendedEvents,
-    setup: async (streamName, events) => {
-      return eventStore.appendToStream(streamName, events);
-    }
-    // streamEvents: (): ReadableStream<
-    //   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-    //   ReadEvent<Event, ReadEventMetadataType> | GlobalSubscriptionEvent
-    // > => {
-    //   return eventStore.streamEvents();
-    // },
-  };
-  return wrapped;
+//#endregion
+//#region src/testing/wrapEventStore.ts
+const WrapEventStore = (eventStore) => {
+	const appendedEvents = /* @__PURE__ */ new Map();
+	return {
+		...eventStore,
+		aggregateStream(streamName, options) {
+			return eventStore.aggregateStream(streamName, options);
+		},
+		async readStream(streamName, options) {
+			return await eventStore.readStream(streamName, options);
+		},
+		appendToStream: async (streamName, events, options) => {
+			const result = await eventStore.appendToStream(streamName, events, options);
+			const currentStream = appendedEvents.get(streamName) ?? [streamName, []];
+			appendedEvents.set(streamName, [streamName, [...currentStream[1], ...events]]);
+			return result;
+		},
+		appendedEvents,
+		setup: async (streamName, events) => {
+			return eventStore.appendToStream(streamName, events);
+		}
+	};
 };
 
-// src/eventStore/projections/inMemory/inMemoryProjectionSpec.ts
-var InMemoryProjectionSpec = {
-  for: (options) => {
-    const { projection: projection2 } = options;
-    return (givenEvents) => {
-      return {
-        when: (events, options2) => {
-          const allEvents = [];
-          const run = async (database) => {
-            let globalPosition = 0n;
-            const numberOfTimes = options2?.numberOfTimes ?? 1;
-            for (const event2 of [
-              ...givenEvents,
-              ...Array.from({ length: numberOfTimes }).flatMap(() => events)
-            ]) {
-              const metadata = {
-                checkpoint: bigIntProcessorCheckpoint(++globalPosition),
-                globalPosition,
-                streamPosition: globalPosition,
-                streamName: event2.metadata?.streamName ?? `test-${uuid4()}`,
-                messageId: uuid4()
-              };
-              allEvents.push({
-                ...event2,
-                kind: "Event",
-                metadata: {
-                  ...metadata,
-                  ..."metadata" in event2 ? event2.metadata ?? {} : {}
-                }
-              });
-            }
-            const mockEventStore = {
-              database,
-              aggregateStream: async () => {
-                return Promise.resolve({
-                  state: {},
-                  currentStreamVersion: 0n,
-                  streamExists: false
-                });
-              },
-              readStream: async () => {
-                return Promise.resolve({
-                  events: [],
-                  currentStreamVersion: 0n,
-                  streamExists: false
-                });
-              },
-              appendToStream: async () => {
-                return Promise.resolve({
-                  nextExpectedStreamVersion: 0n,
-                  createdNewStream: false
-                });
-              },
-              streamExists: async () => {
-                return Promise.resolve(false);
-              }
-            };
-            await handleInMemoryProjections({
-              events: allEvents,
-              projections: [projection2],
-              database,
-              eventStore: mockEventStore
-            });
-          };
-          return {
-            then: async (assertFn, message2) => {
-              const database = getInMemoryDatabase();
-              await run(database);
-              const succeeded = await assertFn({ database });
-              if (succeeded !== void 0 && succeeded === false) {
-                assertFails(
-                  message2 ?? "Projection specification didn't match the criteria"
-                );
-              }
-            },
-            thenThrows: async (...args) => {
-              const database = getInMemoryDatabase();
-              try {
-                await run(database);
-                throw new AssertionError("Handler did not fail as expected");
-              } catch (error) {
-                if (error instanceof AssertionError) throw error;
-                if (args.length === 0) return;
-                if (!isErrorConstructor(args[0])) {
-                  assertTrue(
-                    args[0](error),
-                    `Error didn't match the error condition: ${error?.toString()}`
-                  );
-                  return;
-                }
-                assertTrue(
-                  error instanceof args[0],
-                  `Caught error is not an instance of the expected type: ${error?.toString()}`
-                );
-                if (args[1]) {
-                  assertTrue(
-                    args[1](error),
-                    `Error didn't match the error condition: ${error?.toString()}`
-                  );
-                }
-              }
-            }
-          };
-        }
-      };
-    };
-  }
-};
-var eventInStream = (streamName, event2) => {
-  return {
-    ...event2,
-    metadata: {
-      ...event2.metadata ?? {},
-      streamName: event2.metadata?.streamName ?? streamName
-    }
-  };
-};
-var eventsInStream = (streamName, events) => {
-  return events.map((e) => eventInStream(streamName, e));
-};
-var newEventsInStream = eventsInStream;
+//#endregion
+//#region src/eventStore/projections/inMemory/inMemoryProjectionSpec.ts
+const InMemoryProjectionSpec = { for: (options) => {
+	const { projection } = options;
+	return (givenEvents) => {
+		return { when: (events, options) => {
+			const allEvents = [];
+			const run = async (database) => {
+				let globalPosition = 0n;
+				const numberOfTimes = options?.numberOfTimes ?? 1;
+				for (const event of [...givenEvents, ...Array.from({ length: numberOfTimes }).flatMap(() => events)]) {
+					const metadata = {
+						checkpoint: bigIntProcessorCheckpoint(++globalPosition),
+						globalPosition,
+						streamPosition: globalPosition,
+						streamName: event.metadata?.streamName ?? `test-${v4()}`,
+						messageId: v4()
+					};
+					allEvents.push({
+						...event,
+						kind: "Event",
+						metadata: {
+							...metadata,
+							..."metadata" in event ? event.metadata ?? {} : {}
+						}
+					});
+				}
+				await handleInMemoryProjections({
+					events: allEvents,
+					projections: [projection],
+					database,
+					eventStore: {
+						database,
+						aggregateStream: async () => {
+							return Promise.resolve({
+								state: {},
+								currentStreamVersion: 0n,
+								streamExists: false
+							});
+						},
+						readStream: async () => {
+							return Promise.resolve({
+								events: [],
+								currentStreamVersion: 0n,
+								streamExists: false
+							});
+						},
+						appendToStream: async () => {
+							return Promise.resolve({
+								nextExpectedStreamVersion: 0n,
+								createdNewStream: false
+							});
+						},
+						streamExists: async () => {
+							return Promise.resolve(false);
+						}
+					}
+				});
+			};
+			return {
+				then: async (assertFn, message) => {
+					const database = getInMemoryDatabase();
+					await run(database);
+					const succeeded = await assertFn({ database });
+					if (succeeded !== void 0 && succeeded === false) assertFails(message ?? "Projection specification didn't match the criteria");
+				},
+				thenThrows: async (...args) => {
+					const database = getInMemoryDatabase();
+					try {
+						await run(database);
+						throw new AssertionError("Handler did not fail as expected");
+					} catch (error) {
+						if (error instanceof AssertionError) throw error;
+						if (args.length === 0) return;
+						if (!isErrorConstructor(args[0])) {
+							assertTrue(args[0](error), `Error didn't match the error condition: ${error?.toString()}`);
+							return;
+						}
+						assertTrue(error instanceof args[0], `Caught error is not an instance of the expected type: ${error?.toString()}`);
+						if (args[1]) assertTrue(args[1](error), `Error didn't match the error condition: ${error?.toString()}`);
+					}
+				}
+			};
+		} };
+	};
+} };
+const eventInStream = (streamName, event) => {
+	return {
+		...event,
+		metadata: {
+			...event.metadata ?? {},
+			streamName: event.metadata?.streamName ?? streamName
+		}
+	};
+};
+const eventsInStream = (streamName, events) => {
+	return events.map((e) => eventInStream(streamName, e));
+};
+const newEventsInStream = eventsInStream;
 function documentExists(expected, options) {
-  return async ({ database }) => {
-    const collection = database.collection(options.inCollection);
-    const document = await collection.findOne((doc) => {
-      const docId = "_id" in doc ? doc._id : void 0;
-      return docId === options.withId;
-    });
-    if (!document) {
-      assertFails(
-        `Document with ID ${options.withId} does not exist in collection ${options.inCollection}`
-      );
-      return Promise.resolve(false);
-    }
-    for (const [key, value] of Object.entries(expected)) {
-      const propKey = key;
-      if (!(key in document) || JSONSerializer.serialize(document[propKey]) !== JSONSerializer.serialize(value)) {
-        assertFails(`Property ${key} doesn't match the expected value`);
-        return Promise.resolve(false);
-      }
-    }
-    return Promise.resolve(true);
-  };
+	return async ({ database }) => {
+		const document = await database.collection(options.inCollection).findOne((doc) => {
+			return ("_id" in doc ? doc._id : void 0) === options.withId;
+		});
+		if (!document) {
+			assertFails(`Document with ID ${options.withId} does not exist in collection ${options.inCollection}`);
+			return Promise.resolve(false);
+		}
+		for (const [key, value] of Object.entries(expected)) {
+			const propKey = key;
+			if (!(key in document) || JSONSerializer.serialize(document[propKey]) !== JSONSerializer.serialize(value)) {
+				assertFails(`Property ${key} doesn't match the expected value`);
+				return Promise.resolve(false);
+			}
+		}
+		return Promise.resolve(true);
+	};
 }
-var expectInMemoryDocuments = {
-  fromCollection: (collectionName) => ({
-    withId: (id) => ({
-      toBeEqual: (expected) => documentExists(expected, {
-        inCollection: collectionName,
-        withId: id
-      })
-    })
-  })
-};
+const expectInMemoryDocuments = { fromCollection: (collectionName) => ({ withId: (id) => ({ toBeEqual: (expected) => documentExists(expected, {
+	inCollection: collectionName,
+	withId: id
+}) }) }) };
 
-// src/eventStore/versioning/downcasting.ts
-var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!options?.downcast)
-    return recordedMessage;
-  const downcasted = options.downcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: downcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in downcasted ? downcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!options?.downcast)
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
-  );
+//#endregion
+//#region src/eventStore/versioning/downcasting.ts
+const downcastRecordedMessage = (recordedMessage, options) => {
+	if (!options?.downcast) return recordedMessage;
+	const downcasted = options.downcast(recordedMessage);
+	return {
+		...recordedMessage,
+		data: downcasted.data,
+		..."metadata" in recordedMessage || "metadata" in downcasted ? { metadata: {
+			..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+			..."metadata" in downcasted ? downcasted.metadata : {}
+		} } : {}
+	};
+};
+const downcastRecordedMessages = (recordedMessages, options) => {
+	if (!options?.downcast) return recordedMessages;
+	return recordedMessages.map((recordedMessage) => downcastRecordedMessage(recordedMessage, options));
 };
 
-// src/eventStore/versioning/upcasting.ts
-var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!options?.upcast)
-    return recordedMessage;
-  const upcasted = options.upcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: upcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in upcasted ? upcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-var upcastRecordedMessages = (recordedMessages, options) => {
-  if (!options?.upcast)
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => upcastRecordedMessage(recordedMessage, options)
-  );
+//#endregion
+//#region src/eventStore/versioning/upcasting.ts
+const upcastRecordedMessage = (recordedMessage, options) => {
+	if (!options?.upcast) return recordedMessage;
+	const upcasted = options.upcast(recordedMessage);
+	return {
+		...recordedMessage,
+		data: upcasted.data,
+		..."metadata" in recordedMessage || "metadata" in upcasted ? { metadata: {
+			..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+			..."metadata" in upcasted ? upcasted.metadata : {}
+		} } : {}
+	};
+};
+const upcastRecordedMessages = (recordedMessages, options) => {
+	if (!options?.upcast) return recordedMessages;
+	return recordedMessages.map((recordedMessage) => upcastRecordedMessage(recordedMessage, options));
 };
 
-// src/eventStore/inMemoryEventStore.ts
-var InMemoryEventStoreDefaultStreamVersion = 0n;
-var getInMemoryEventStore = (eventStoreOptions) => {
-  const streams = /* @__PURE__ */ new Map();
-  const getAllEventsCount = () => {
-    return Array.from(streams.values()).map((s) => s.length).reduce((p, c) => p + c, 0);
-  };
-  const database = eventStoreOptions?.database || getInMemoryDatabase();
-  const inlineProjections2 = (eventStoreOptions?.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const eventStore = {
-    database,
-    async aggregateStream(streamName, options) {
-      const { evolve, initialState, read } = options;
-      const result = await this.readStream(
-        streamName,
-        read
-      );
-      const events = result?.events ?? [];
-      const state = events.reduce((s, e) => evolve(s, e), initialState());
-      return {
-        currentStreamVersion: BigInt(events.length),
-        state,
-        streamExists: result.streamExists
-      };
-    },
-    readStream: (streamName, readOptions) => {
-      const events = streams.get(streamName);
-      const currentStreamVersion = events ? BigInt(events.length) : InMemoryEventStoreDefaultStreamVersion;
-      assertExpectedVersionMatchesCurrent(
-        currentStreamVersion,
-        readOptions?.expectedStreamVersion,
-        InMemoryEventStoreDefaultStreamVersion
-      );
-      const from = Number(readOptions?.from ?? 0);
-      const to = Number(
-        readOptions?.to ?? (readOptions?.maxCount ? (readOptions.from ?? 0n) + readOptions.maxCount : events?.length ?? 1)
-      );
-      const resultEvents = events !== void 0 && events.length > 0 ? upcastRecordedMessages(
-        events.slice(from, to),
-        readOptions?.schema?.versioning
-      ) : [];
-      const result = {
-        currentStreamVersion,
-        events: resultEvents,
-        streamExists: events !== void 0 && events.length > 0
-      };
-      return Promise.resolve(result);
-    },
-    appendToStream: async (streamName, events, options) => {
-      const currentEvents = streams.get(streamName) ?? [];
-      const currentStreamVersion = currentEvents.length > 0 ? BigInt(currentEvents.length) : InMemoryEventStoreDefaultStreamVersion;
-      assertExpectedVersionMatchesCurrent(
-        currentStreamVersion,
-        options?.expectedStreamVersion,
-        InMemoryEventStoreDefaultStreamVersion
-      );
-      const newEvents = events.map((event2, index) => {
-        const globalPosition = BigInt(getAllEventsCount() + index + 1);
-        const metadata = {
-          streamName,
-          messageId: uuid5(),
-          streamPosition: BigInt(currentEvents.length + index + 1),
-          globalPosition,
-          checkpoint: bigIntProcessorCheckpoint(globalPosition)
-        };
-        return {
-          ...event2,
-          kind: event2.kind ?? "Event",
-          metadata: {
-            ..."metadata" in event2 ? event2.metadata ?? {} : {},
-            ...metadata
-          }
-        };
-      });
-      const positionOfLastEventInTheStream = BigInt(
-        newEvents.slice(-1)[0].metadata.streamPosition
-      );
-      streams.set(streamName, [
-        ...currentEvents,
-        ...downcastRecordedMessages(newEvents, options?.schema?.versioning)
-      ]);
-      if (inlineProjections2.length > 0) {
-        await handleInMemoryProjections({
-          projections: inlineProjections2,
-          events: newEvents,
-          database: eventStore.database,
-          eventStore
-        });
-      }
-      const result = {
-        nextExpectedStreamVersion: positionOfLastEventInTheStream,
-        createdNewStream: currentStreamVersion === InMemoryEventStoreDefaultStreamVersion
-      };
-      await tryPublishMessagesAfterCommit(
-        newEvents,
-        eventStoreOptions?.hooks
-      );
-      return result;
-    },
-    streamExists: (streamName) => {
-      const events = streams.get(streamName);
-      return Promise.resolve(events !== void 0 && events.length > 0);
-    }
-  };
-  return eventStore;
+//#endregion
+//#region src/eventStore/inMemoryEventStore.ts
+const InMemoryEventStoreDefaultStreamVersion = 0n;
+const getInMemoryEventStore = (eventStoreOptions) => {
+	const streams = /* @__PURE__ */ new Map();
+	const getAllEventsCount = () => {
+		return Array.from(streams.values()).map((s) => s.length).reduce((p, c) => p + c, 0);
+	};
+	const database = eventStoreOptions?.database || getInMemoryDatabase();
+	const inlineProjections = (eventStoreOptions?.projections ?? []).filter(({ type }) => type === "inline").map(({ projection }) => projection);
+	const eventStore = {
+		database,
+		async aggregateStream(streamName, options) {
+			const { evolve, initialState, read } = options;
+			const result = await this.readStream(streamName, read);
+			const events = result?.events ?? [];
+			const state = events.reduce((s, e) => evolve(s, e), initialState());
+			return {
+				currentStreamVersion: BigInt(events.length),
+				state,
+				streamExists: result.streamExists
+			};
+		},
+		readStream: (streamName, readOptions) => {
+			const events = streams.get(streamName);
+			const currentStreamVersion = events ? BigInt(events.length) : InMemoryEventStoreDefaultStreamVersion;
+			assertExpectedVersionMatchesCurrent(currentStreamVersion, readOptions?.expectedStreamVersion, InMemoryEventStoreDefaultStreamVersion);
+			const from = Number(readOptions?.from ?? 0);
+			const to = Number(readOptions?.to ?? (readOptions?.maxCount ? (readOptions.from ?? 0n) + readOptions.maxCount : events?.length ?? 1));
+			const result = {
+				currentStreamVersion,
+				events: events !== void 0 && events.length > 0 ? upcastRecordedMessages(events.slice(from, to), readOptions?.schema?.versioning) : [],
+				streamExists: events !== void 0 && events.length > 0
+			};
+			return Promise.resolve(result);
+		},
+		appendToStream: async (streamName, events, options) => {
+			const currentEvents = streams.get(streamName) ?? [];
+			const currentStreamVersion = currentEvents.length > 0 ? BigInt(currentEvents.length) : InMemoryEventStoreDefaultStreamVersion;
+			assertExpectedVersionMatchesCurrent(currentStreamVersion, options?.expectedStreamVersion, InMemoryEventStoreDefaultStreamVersion);
+			const newEvents = events.map((event, index) => {
+				const globalPosition = BigInt(getAllEventsCount() + index + 1);
+				const metadata = {
+					streamName,
+					messageId: v4(),
+					streamPosition: BigInt(currentEvents.length + index + 1),
+					globalPosition,
+					checkpoint: bigIntProcessorCheckpoint(globalPosition)
+				};
+				return {
+					...event,
+					kind: event.kind ?? "Event",
+					metadata: {
+						..."metadata" in event ? event.metadata ?? {} : {},
+						...metadata
+					}
+				};
+			});
+			const positionOfLastEventInTheStream = BigInt(newEvents.slice(-1)[0].metadata.streamPosition);
+			streams.set(streamName, [...currentEvents, ...downcastRecordedMessages(newEvents, options?.schema?.versioning)]);
+			if (inlineProjections.length > 0) await handleInMemoryProjections({
+				projections: inlineProjections,
+				events: newEvents,
+				database: eventStore.database,
+				eventStore
+			});
+			const result = {
+				nextExpectedStreamVersion: positionOfLastEventInTheStream,
+				createdNewStream: currentStreamVersion === InMemoryEventStoreDefaultStreamVersion
+			};
+			await tryPublishMessagesAfterCommit(newEvents, eventStoreOptions?.hooks);
+			return result;
+		},
+		streamExists: (streamName) => {
+			const events = streams.get(streamName);
+			return Promise.resolve(events !== void 0 && events.length > 0);
+		}
+	};
+	return eventStore;
 };
 
-// src/commandHandling/handleCommand.ts
-var CommandHandlerStreamVersionConflictRetryOptions = {
-  retries: 3,
-  minTimeout: 100,
-  factor: 1.5,
-  shouldRetryError: isExpectedVersionConflictError
-};
-var fromCommandHandlerRetryOptions = (retryOptions) => {
-  if (retryOptions === void 0) return NoRetries;
-  if ("onVersionConflict" in retryOptions) {
-    if (typeof retryOptions.onVersionConflict === "boolean")
-      return CommandHandlerStreamVersionConflictRetryOptions;
-    else if (typeof retryOptions.onVersionConflict === "number")
-      return {
-        ...CommandHandlerStreamVersionConflictRetryOptions,
-        retries: retryOptions.onVersionConflict
-      };
-    else return retryOptions.onVersionConflict;
-  }
-  return retryOptions;
-};
-var CommandHandler = (options) => async (store, id, handle, handleOptions) => asyncRetry(
-  async () => {
-    const result = await withSession(store, async ({ eventStore }) => {
-      const { evolve, initialState } = options;
-      const mapToStreamId = options.mapToStreamId ?? ((id2) => id2);
-      const streamName = mapToStreamId(id);
-      const aggregationResult = await eventStore.aggregateStream(streamName, {
-        evolve,
-        initialState,
-        read: {
-          schema: options.schema,
-          ...handleOptions,
-          serialization: options.serialization,
-          // expected stream version is passed to fail fast
-          // if stream is in the wrong state
-          expectedStreamVersion: handleOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
-        }
-      });
-      const {
-        currentStreamVersion,
-        streamExists: _streamExists,
-        ...restOfAggregationResult
-      } = aggregationResult;
-      let state = aggregationResult.state;
-      const handlers = Array.isArray(handle) ? handle : [handle];
-      let eventsToAppend = [];
-      for (const handler of handlers) {
-        const result2 = await handler(state);
-        const newEvents = Array.isArray(result2) ? result2 : [result2];
-        if (newEvents.length > 0) {
-          state = newEvents.reduce(evolve, state);
-        }
-        eventsToAppend = [...eventsToAppend, ...newEvents];
-      }
-      if (eventsToAppend.length === 0) {
-        return {
-          ...restOfAggregationResult,
-          newEvents: [],
-          newState: state,
-          nextExpectedStreamVersion: currentStreamVersion,
-          createdNewStream: false
-        };
-      }
-      const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST);
-      const appendResult = await eventStore.appendToStream(
-        streamName,
-        eventsToAppend,
-        {
-          ...handleOptions,
-          expectedStreamVersion
-        }
-      );
-      return {
-        ...appendResult,
-        newEvents: eventsToAppend,
-        newState: state
-      };
-    });
-    return result;
-  },
-  fromCommandHandlerRetryOptions(
-    handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry
-  )
-);
-var withSession = (eventStore, callback) => {
-  const sessionFactory = canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore);
-  return sessionFactory.withSession(callback);
+//#endregion
+//#region src/commandHandling/handleCommand.ts
+const CommandHandlerStreamVersionConflictRetryOptions = {
+	retries: 3,
+	minTimeout: 100,
+	factor: 1.5,
+	shouldRetryError: isExpectedVersionConflictError
+};
+const fromCommandHandlerRetryOptions = (retryOptions) => {
+	if (retryOptions === void 0) return NoRetries;
+	if ("onVersionConflict" in retryOptions) if (typeof retryOptions.onVersionConflict === "boolean") return CommandHandlerStreamVersionConflictRetryOptions;
+	else if (typeof retryOptions.onVersionConflict === "number") return {
+		...CommandHandlerStreamVersionConflictRetryOptions,
+		retries: retryOptions.onVersionConflict
+	};
+	else return retryOptions.onVersionConflict;
+	return retryOptions;
+};
+const CommandHandler = (options) => async (store, id, handle, handleOptions) => asyncRetry(async () => {
+	return await withSession$1(store, async ({ eventStore }) => {
+		const { evolve, initialState } = options;
+		const streamName = (options.mapToStreamId ?? ((id) => id))(id);
+		const aggregationResult = await eventStore.aggregateStream(streamName, {
+			evolve,
+			initialState,
+			read: {
+				schema: options.schema,
+				...handleOptions,
+				serialization: options.serialization,
+				expectedStreamVersion: handleOptions?.expectedStreamVersion ?? "NO_CONCURRENCY_CHECK"
+			}
+		});
+		const { currentStreamVersion, streamExists: _streamExists, ...restOfAggregationResult } = aggregationResult;
+		let state = aggregationResult.state;
+		const handlers = Array.isArray(handle) ? handle : [handle];
+		let eventsToAppend = [];
+		for (const handler of handlers) {
+			const result = await handler(state);
+			const newEvents = Array.isArray(result) ? result : [result];
+			if (newEvents.length > 0) state = newEvents.reduce(evolve, state);
+			eventsToAppend = [...eventsToAppend, ...newEvents];
+		}
+		if (eventsToAppend.length === 0) return {
+			...restOfAggregationResult,
+			newEvents: [],
+			newState: state,
+			nextExpectedStreamVersion: currentStreamVersion,
+			createdNewStream: false
+		};
+		const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : "STREAM_DOES_NOT_EXIST");
+		return {
+			...await eventStore.appendToStream(streamName, eventsToAppend, {
+				...handleOptions,
+				expectedStreamVersion
+			}),
+			newEvents: eventsToAppend,
+			newState: state
+		};
+	});
+}, fromCommandHandlerRetryOptions(handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry));
+const withSession$1 = (eventStore, callback) => {
+	return (canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore)).withSession(callback);
 };
 
-// src/commandHandling/handleCommandWithDecider.ts
-var DeciderCommandHandler = (options) => async (eventStore, id, commands, handleOptions) => {
-  const { decide, ...rest } = options;
-  const deciders = (Array.isArray(commands) ? commands : [commands]).map(
-    (command2) => (state) => decide(command2, state)
-  );
-  return CommandHandler(rest)(
-    eventStore,
-    id,
-    deciders,
-    handleOptions
-  );
+//#endregion
+//#region src/commandHandling/handleCommandWithDecider.ts
+const DeciderCommandHandler = (options) => async (eventStore, id, commands, handleOptions) => {
+	const { decide, ...rest } = options;
+	const deciders = (Array.isArray(commands) ? commands : [commands]).map((command) => (state) => decide(command, state));
+	return CommandHandler(rest)(eventStore, id, deciders, handleOptions);
 };
 
-// src/messageBus/index.ts
-var getInMemoryMessageBus = () => {
-  const allHandlers = /* @__PURE__ */ new Map();
-  let pendingMessages = [];
-  return {
-    send: async (command2) => {
-      const handlers = allHandlers.get(command2.type);
-      if (handlers === void 0 || handlers.length === 0)
-        throw new EmmettError(
-          `No handler registered for command ${command2.type}!`
-        );
-      const commandHandler = handlers[0];
-      await commandHandler(command2);
-    },
-    publish: async (event2) => {
-      const handlers = allHandlers.get(event2.type) ?? [];
-      for (const handler of handlers) {
-        const eventHandler = handler;
-        await eventHandler(event2);
-      }
-    },
-    schedule: (message2, when) => {
-      pendingMessages = [...pendingMessages, { message: message2, options: when }];
-    },
-    handle: (commandHandler, ...commandTypes) => {
-      const alreadyRegistered = [...allHandlers.keys()].filter(
-        (registered) => commandTypes.includes(registered)
-      );
-      if (alreadyRegistered.length > 0)
-        throw new EmmettError(
-          `Cannot register handler for commands ${alreadyRegistered.join(", ")} as they're already registered!`
-        );
-      for (const commandType of commandTypes) {
-        allHandlers.set(commandType, [
-          commandHandler
-        ]);
-      }
-    },
-    subscribe(eventHandler, ...eventTypes) {
-      for (const eventType of eventTypes) {
-        if (!allHandlers.has(eventType)) allHandlers.set(eventType, []);
-        allHandlers.set(eventType, [
-          ...allHandlers.get(eventType) ?? [],
-          eventHandler
-        ]);
-      }
-    },
-    dequeue: () => {
-      const pending = pendingMessages;
-      pendingMessages = [];
-      return pending;
-    }
-  };
+//#endregion
+//#region src/messageBus/index.ts
+const getInMemoryMessageBus = () => {
+	const allHandlers = /* @__PURE__ */ new Map();
+	let pendingMessages = [];
+	return {
+		send: async (command) => {
+			const handlers = allHandlers.get(command.type);
+			if (handlers === void 0 || handlers.length === 0) throw new EmmettError(`No handler registered for command ${command.type}!`);
+			const commandHandler = handlers[0];
+			await commandHandler(command);
+		},
+		publish: async (event) => {
+			const handlers = allHandlers.get(event.type) ?? [];
+			for (const handler of handlers) await handler(event);
+		},
+		schedule: (message, when) => {
+			pendingMessages = [...pendingMessages, {
+				message,
+				options: when
+			}];
+		},
+		handle: (commandHandler, ...commandTypes) => {
+			const alreadyRegistered = [...allHandlers.keys()].filter((registered) => commandTypes.includes(registered));
+			if (alreadyRegistered.length > 0) throw new EmmettError(`Cannot register handler for commands ${alreadyRegistered.join(", ")} as they're already registered!`);
+			for (const commandType of commandTypes) allHandlers.set(commandType, [commandHandler]);
+		},
+		subscribe(eventHandler, ...eventTypes) {
+			for (const eventType of eventTypes) {
+				if (!allHandlers.has(eventType)) allHandlers.set(eventType, []);
+				allHandlers.set(eventType, [...allHandlers.get(eventType) ?? [], eventHandler]);
+			}
+		},
+		dequeue: () => {
+			const pending = pendingMessages;
+			pendingMessages = [];
+			return pending;
+		}
+	};
 };
 
-// src/projections/index.ts
-var filterProjections = (type, projections2) => {
-  const inlineProjections2 = projections2.filter((projection2) => projection2.type === type).map(({ projection: projection2 }) => projection2);
-  const duplicateRegistrations = arrayUtils.getDuplicates(
-    inlineProjections2,
-    (proj) => proj.name
-  );
-  if (duplicateRegistrations.length > 0) {
-    throw new EmmettError(`You cannot register multiple projections with the same name (or without the name).
+//#endregion
+//#region src/projections/index.ts
+const filterProjections = (type, projections) => {
+	const inlineProjections = projections.filter((projection) => projection.type === type).map(({ projection }) => projection);
+	const duplicateRegistrations = arrayUtils.getDuplicates(inlineProjections, (proj) => proj.name);
+	if (duplicateRegistrations.length > 0) throw new EmmettError(`You cannot register multiple projections with the same name (or without the name).
       Ensure that:
       ${JSONSerializer.serialize(duplicateRegistrations)}
       have different names`);
-  }
-  return inlineProjections2;
+	return inlineProjections;
 };
-var projection = (definition) => definition;
-var inlineProjections = (definitions) => definitions.map((definition) => ({
-  type: "inline",
-  projection: definition
+const projection = (definition) => definition;
+const inlineProjections = (definitions) => definitions.map((definition) => ({
+	type: "inline",
+	projection: definition
 }));
-var asyncProjections = (definitions) => definitions.map((definition) => ({
-  type: "inline",
-  projection: definition
+const asyncProjections = (definitions) => definitions.map((definition) => ({
+	type: "inline",
+	projection: definition
 }));
-var projections = {
-  inline: inlineProjections,
-  async: asyncProjections
+const projections = {
+	inline: inlineProjections,
+	async: asyncProjections
 };
 
-// src/workflows/handleWorkflow.ts
-import { v7 as uuid6 } from "uuid";
-var WorkflowHandlerStreamVersionConflictRetryOptions = {
-  retries: 3,
-  minTimeout: 100,
-  factor: 1.5,
-  shouldRetryError: isExpectedVersionConflictError
-};
-var fromWorkflowHandlerRetryOptions = (retryOptions) => {
-  if (retryOptions === void 0) return NoRetries;
-  if ("onVersionConflict" in retryOptions) {
-    if (typeof retryOptions.onVersionConflict === "boolean")
-      return WorkflowHandlerStreamVersionConflictRetryOptions;
-    else if (typeof retryOptions.onVersionConflict === "number")
-      return {
-        ...WorkflowHandlerStreamVersionConflictRetryOptions,
-        retries: retryOptions.onVersionConflict
-      };
-    else return retryOptions.onVersionConflict;
-  }
-  return retryOptions;
-};
-var emptyHandlerResult = (nextExpectedStreamVersion = 0n) => ({
-  newMessages: [],
-  createdNewStream: false,
-  nextExpectedStreamVersion
+//#endregion
+//#region src/workflows/handleWorkflow.ts
+const WorkflowHandlerStreamVersionConflictRetryOptions = {
+	retries: 3,
+	minTimeout: 100,
+	factor: 1.5,
+	shouldRetryError: isExpectedVersionConflictError
+};
+const fromWorkflowHandlerRetryOptions = (retryOptions) => {
+	if (retryOptions === void 0) return NoRetries;
+	if ("onVersionConflict" in retryOptions) if (typeof retryOptions.onVersionConflict === "boolean") return WorkflowHandlerStreamVersionConflictRetryOptions;
+	else if (typeof retryOptions.onVersionConflict === "number") return {
+		...WorkflowHandlerStreamVersionConflictRetryOptions,
+		retries: retryOptions.onVersionConflict
+	};
+	else return retryOptions.onVersionConflict;
+	return retryOptions;
+};
+const emptyHandlerResult = (nextExpectedStreamVersion = 0n) => ({
+	newMessages: [],
+	createdNewStream: false,
+	nextExpectedStreamVersion
 });
-var createInputMetadata = (originalMessageId, action) => ({
-  originalMessageId,
-  input: true,
-  action
+const createInputMetadata = (originalMessageId, action) => ({
+	originalMessageId,
+	input: true,
+	action
 });
-var tagOutputMessage = (msg, action) => {
-  const existingMetadata = "metadata" in msg && msg.metadata ? msg.metadata : {};
-  return {
-    ...msg,
-    metadata: {
-      ...existingMetadata,
-      action
-    }
-  };
-};
-var createWrappedInitialState = (initialState) => {
-  return () => ({
-    userState: initialState(),
-    processedInputIds: /* @__PURE__ */ new Set()
-  });
-};
-var createWrappedEvolve = (evolve, workflowName, separateInputInboxFromProcessing) => {
-  return (state, event2) => {
-    const metadata = event2.metadata;
-    let processedInputIds = state.processedInputIds;
-    if (metadata?.input === true && typeof metadata?.originalMessageId === "string") {
-      processedInputIds = new Set(state.processedInputIds);
-      processedInputIds.add(metadata.originalMessageId);
-    }
-    if (separateInputInboxFromProcessing && metadata?.input === true) {
-      return {
-        userState: state.userState,
-        processedInputIds
-      };
-    }
-    const eventType = event2.type;
-    const eventForEvolve = eventType.startsWith(`${workflowName}:`) ? {
-      ...event2,
-      type: eventType.replace(`${workflowName}:`, "")
-    } : event2;
-    return {
-      userState: evolve(state.userState, eventForEvolve),
-      processedInputIds
-    };
-  };
-};
-var workflowStreamName = ({
-  workflowName,
-  workflowId
-}) => `emt:workflow:${workflowName}:${workflowId}`;
-var WorkflowHandler = (options) => async (store, message2, handleOptions) => asyncRetry(
-  async () => {
-    const result = await withSession2(store, async ({ eventStore }) => {
-      const {
-        workflow: { evolve, initialState, decide, name: workflowName },
-        getWorkflowId: getWorkflowId2
-      } = options;
-      const inputMessageId = (
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        ("metadata" in message2 && message2.metadata?.messageId ? (
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          message2.metadata.messageId
-        ) : void 0) ?? uuid6()
-      );
-      const messageWithMetadata = {
-        ...message2,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        metadata: {
-          messageId: inputMessageId,
-          ...message2.metadata
-        }
-      };
-      const workflowId = getWorkflowId2(messageWithMetadata);
-      if (!workflowId) {
-        return emptyHandlerResult();
-      }
-      const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({ workflowName, workflowId });
-      const messageType = messageWithMetadata.type;
-      const hasWorkflowPrefix = messageType.startsWith(`${workflowName}:`);
-      if (options.separateInputInboxFromProcessing && !hasWorkflowPrefix) {
-        const inputMetadata2 = createInputMetadata(
-          inputMessageId,
-          "InitiatedBy"
-        );
-        const inputToStore2 = {
-          type: `${workflowName}:${messageWithMetadata.type}`,
-          data: messageWithMetadata.data,
-          kind: messageWithMetadata.kind,
-          metadata: inputMetadata2
-        };
-        const appendResult2 = await eventStore.appendToStream(
-          streamName,
-          [inputToStore2],
-          {
-            ...handleOptions,
-            expectedStreamVersion: handleOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
-          }
-        );
-        return {
-          ...appendResult2,
-          newMessages: []
-        };
-      }
-      const wrappedInitialState = createWrappedInitialState(initialState);
-      const wrappedEvolve = createWrappedEvolve(
-        evolve,
-        workflowName,
-        options.separateInputInboxFromProcessing ?? false
-      );
-      const aggregationResult = await eventStore.aggregateStream(streamName, {
-        evolve: wrappedEvolve,
-        initialState: wrappedInitialState,
-        read: {
-          ...handleOptions,
-          // expected stream version is passed to fail fast
-          // if stream is in the wrong state
-          expectedStreamVersion: handleOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
-        }
-      });
-      const { currentStreamVersion } = aggregationResult;
-      const { userState: state, processedInputIds } = aggregationResult.state;
-      if (processedInputIds.has(inputMessageId)) {
-        return emptyHandlerResult(currentStreamVersion);
-      }
-      const messageForDecide = hasWorkflowPrefix ? {
-        ...messageWithMetadata,
-        type: messageType.replace(`${workflowName}:`, "")
-      } : messageWithMetadata;
-      const result2 = decide(messageForDecide, state);
-      const inputMetadata = createInputMetadata(
-        inputMessageId,
-        aggregationResult.streamExists ? "Received" : "InitiatedBy"
-      );
-      const inputToStore = {
-        type: `${workflowName}:${messageWithMetadata.type}`,
-        data: messageWithMetadata.data,
-        kind: messageWithMetadata.kind,
-        metadata: inputMetadata
-      };
-      const outputMessages = (Array.isArray(result2) ? result2 : [result2]).filter((msg) => msg !== void 0 && msg !== null);
-      const outputCommandTypes = options.outputs?.commands ?? [];
-      const taggedOutputMessages = outputMessages.map((msg) => {
-        const action = outputCommandTypes.includes(
-          msg.type
-        ) ? "Sent" : "Published";
-        return tagOutputMessage(msg, action);
-      });
-      const messagesToAppend = options.separateInputInboxFromProcessing && hasWorkflowPrefix ? [...taggedOutputMessages] : [inputToStore, ...taggedOutputMessages];
-      if (messagesToAppend.length === 0) {
-        return emptyHandlerResult(currentStreamVersion);
-      }
-      const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST);
-      const appendResult = await eventStore.appendToStream(
-        streamName,
-        // TODO: Fix this cast
-        messagesToAppend,
-        {
-          ...handleOptions,
-          expectedStreamVersion
-        }
-      );
-      return {
-        ...appendResult,
-        newMessages: outputMessages
-      };
-    });
-    return result;
-  },
-  fromWorkflowHandlerRetryOptions(
-    handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry
-  )
-);
-var withSession2 = (eventStore, callback) => {
-  const sessionFactory = canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore);
-  return sessionFactory.withSession(callback);
+const tagOutputMessage = (msg, action) => {
+	const existingMetadata = "metadata" in msg && msg.metadata ? msg.metadata : {};
+	return {
+		...msg,
+		metadata: {
+			...existingMetadata,
+			action
+		}
+	};
+};
+const createWrappedInitialState = (initialState) => {
+	return () => ({
+		userState: initialState(),
+		processedInputIds: /* @__PURE__ */ new Set()
+	});
+};
+const createWrappedEvolve = (evolve, workflowName, separateInputInboxFromProcessing) => {
+	return (state, event) => {
+		const metadata = event.metadata;
+		let processedInputIds = state.processedInputIds;
+		if (metadata?.input === true && typeof metadata?.originalMessageId === "string") {
+			processedInputIds = new Set(state.processedInputIds);
+			processedInputIds.add(metadata.originalMessageId);
+		}
+		if (separateInputInboxFromProcessing && metadata?.input === true) return {
+			userState: state.userState,
+			processedInputIds
+		};
+		const eventType = event.type;
+		const eventForEvolve = eventType.startsWith(`${workflowName}:`) ? {
+			...event,
+			type: eventType.replace(`${workflowName}:`, "")
+		} : event;
+		return {
+			userState: evolve(state.userState, eventForEvolve),
+			processedInputIds
+		};
+	};
+};
+const workflowStreamName = ({ workflowName, workflowId }) => `emt:workflow:${workflowName}:${workflowId}`;
+const WorkflowHandler = (options) => async (store, message, handleOptions) => asyncRetry(async () => {
+	return await withSession(store, async ({ eventStore }) => {
+		const { workflow: { evolve, initialState, decide, name: workflowName }, getWorkflowId } = options;
+		const inputMessageId = ("metadata" in message && message.metadata?.messageId ? message.metadata.messageId : void 0) ?? v7();
+		const messageWithMetadata = {
+			...message,
+			metadata: {
+				messageId: inputMessageId,
+				...message.metadata
+			}
+		};
+		const workflowId = getWorkflowId(messageWithMetadata);
+		if (!workflowId) return emptyHandlerResult();
+		const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({
+			workflowName,
+			workflowId
+		});
+		const messageType = messageWithMetadata.type;
+		const hasWorkflowPrefix = messageType.startsWith(`${workflowName}:`);
+		if (options.separateInputInboxFromProcessing && !hasWorkflowPrefix) {
+			const inputMetadata = createInputMetadata(inputMessageId, "InitiatedBy");
+			const inputToStore = {
+				type: `${workflowName}:${messageWithMetadata.type}`,
+				data: messageWithMetadata.data,
+				kind: messageWithMetadata.kind,
+				metadata: inputMetadata
+			};
+			return {
+				...await eventStore.appendToStream(streamName, [inputToStore], {
+					...handleOptions,
+					expectedStreamVersion: handleOptions?.expectedStreamVersion ?? "NO_CONCURRENCY_CHECK"
+				}),
+				newMessages: []
+			};
+		}
+		const wrappedInitialState = createWrappedInitialState(initialState);
+		const wrappedEvolve = createWrappedEvolve(evolve, workflowName, options.separateInputInboxFromProcessing ?? false);
+		const aggregationResult = await eventStore.aggregateStream(streamName, {
+			evolve: wrappedEvolve,
+			initialState: wrappedInitialState,
+			read: {
+				...handleOptions,
+				expectedStreamVersion: handleOptions?.expectedStreamVersion ?? "NO_CONCURRENCY_CHECK"
+			}
+		});
+		const { currentStreamVersion } = aggregationResult;
+		const { userState: state, processedInputIds } = aggregationResult.state;
+		if (processedInputIds.has(inputMessageId)) return emptyHandlerResult(currentStreamVersion);
+		const result = decide(hasWorkflowPrefix ? {
+			...messageWithMetadata,
+			type: messageType.replace(`${workflowName}:`, "")
+		} : messageWithMetadata, state);
+		const inputMetadata = createInputMetadata(inputMessageId, aggregationResult.streamExists ? "Received" : "InitiatedBy");
+		const inputToStore = {
+			type: `${workflowName}:${messageWithMetadata.type}`,
+			data: messageWithMetadata.data,
+			kind: messageWithMetadata.kind,
+			metadata: inputMetadata
+		};
+		const outputMessages = (Array.isArray(result) ? result : [result]).filter((msg) => msg !== void 0 && msg !== null);
+		const outputCommandTypes = options.outputs?.commands ?? [];
+		const taggedOutputMessages = outputMessages.map((msg) => {
+			return tagOutputMessage(msg, outputCommandTypes.includes(msg.type) ? "Sent" : "Published");
+		});
+		const messagesToAppend = options.separateInputInboxFromProcessing && hasWorkflowPrefix ? [...taggedOutputMessages] : [inputToStore, ...taggedOutputMessages];
+		if (messagesToAppend.length === 0) return emptyHandlerResult(currentStreamVersion);
+		const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : "STREAM_DOES_NOT_EXIST");
+		return {
+			...await eventStore.appendToStream(streamName, messagesToAppend, {
+				...handleOptions,
+				expectedStreamVersion
+			}),
+			newMessages: outputMessages
+		};
+	});
+}, fromWorkflowHandlerRetryOptions(handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry));
+const withSession = (eventStore, callback) => {
+	return (canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore)).withSession(callback);
 };
 
-// src/workflows/workflow.ts
-var Workflow = (workflow) => {
-  return workflow;
+//#endregion
+//#region src/workflows/workflow.ts
+const Workflow = (workflow) => {
+	return workflow;
 };
 
-// src/workflows/workflowProcessor.ts
-var workflowOutputHandler = (handler) => handler;
-var getWorkflowId = (options) => `emt:processor:workflow:${options.workflowName}`;
-var workflowProcessor = (options) => {
-  const { workflow, ...rest } = options;
-  const inputs = [...options.inputs.commands, ...options.inputs.events];
-  let canHandle = inputs;
-  if (options.separateInputInboxFromProcessing)
-    canHandle = [
-      ...canHandle,
-      ...options.inputs.commands.map((t) => `${workflow.name}:${t}`),
-      ...options.inputs.events.map((t) => `${workflow.name}:${t}`)
-    ];
-  if (options.outputHandler)
-    canHandle = [...canHandle, ...options.outputHandler.canHandle];
-  const handle = WorkflowHandler(options);
-  return reactor({
-    ...rest,
-    processorId: options.processorId ?? getWorkflowId({ workflowName: workflow.name }),
-    canHandle,
-    type: MessageProcessorType.PROJECTOR,
-    eachMessage: async (message2, context) => {
-      const messageType = message2.type;
-      const metadata = message2.metadata;
-      const isInput = metadata?.input === true;
-      if (isInput || inputs.includes(messageType)) {
-        const result = await handle(
-          context.connection.messageStore,
-          message2,
-          context
-        );
-        if (options.stopAfter && result.newMessages.length > 0) {
-          for (const outputMessage of result.newMessages) {
-            if (options.stopAfter(
-              outputMessage
-            )) {
-              return { type: "STOP", reason: "Stop condition reached" };
-            }
-          }
-        }
-        return;
-      }
-      if (options.outputHandler?.canHandle.includes(messageType) === true) {
-        const recordedMessage = message2;
-        const handledOutputMessages = options.outputHandler.eachBatch ? await options.outputHandler.eachBatch([recordedMessage], context) : await options.outputHandler.eachMessage(recordedMessage, context);
-        if (handledOutputMessages instanceof EmmettError) {
-          return {
-            type: "STOP",
-            reason: "Routing error",
-            error: handledOutputMessages
-          };
-        }
-        const messagesToAppend = Array.isArray(handledOutputMessages) ? handledOutputMessages : handledOutputMessages ? [handledOutputMessages] : [];
-        if (messagesToAppend.length === 0) {
-          return;
-        }
-        const workflowId = options.getWorkflowId(
-          message2
-        );
-        if (!workflowId) return;
-        const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({
-          workflowName: workflow.name,
-          workflowId
-        });
-        await context.connection.messageStore.appendToStream(
-          streamName,
-          messagesToAppend
-        );
-        return;
-      }
-      return;
-    }
-  });
-};
-export {
-  AssertionError,
-  CommandHandler,
-  CommandHandlerStreamVersionConflictRetryOptions,
-  ConcurrencyError,
-  ConcurrencyInMemoryDatabaseError,
-  DATABASE_REQUIRED_ERROR_MESSAGE,
-  DeciderCommandHandler,
-  DeciderSpecification,
-  EmmettError,
-  ExpectedVersionConflictError,
-  GlobalStreamCaughtUpType,
-  IllegalStateError,
-  InMemoryEventStoreDefaultStreamVersion,
-  InMemoryProjectionSpec,
-  InProcessLock,
-  JSONCodec,
-  JSONReplacer,
-  JSONReplacers,
-  JSONReviver,
-  JSONRevivers,
-  JSONSerializer,
-  MessageProcessor,
-  MessageProcessorType,
-  NO_CONCURRENCY_CHECK,
-  NoRetries,
-  NotFoundError,
-  STREAM_DOES_NOT_EXIST,
-  STREAM_EXISTS,
-  TaskProcessor,
-  ValidationError,
-  ValidationErrors,
-  Workflow,
-  WorkflowHandler,
-  WorkflowHandlerStreamVersionConflictRetryOptions,
-  WorkflowSpecification,
-  WrapEventStore,
-  argMatches,
-  argValue,
-  arrayUtils,
-  assertDeepEqual,
-  assertDefined,
-  assertDoesNotThrow,
-  assertEqual,
-  assertExpectedVersionMatchesCurrent,
-  assertFails,
-  assertFalse,
-  assertIsNotNull,
-  assertIsNull,
-  assertMatches,
-  assertNotDeepEqual,
-  assertNotEmptyString,
-  assertNotEqual,
-  assertOk,
-  assertPositiveNumber,
-  assertRejects,
-  assertThat,
-  assertThatArray,
-  assertThrows,
-  assertThrowsAsync,
-  assertTrue,
-  assertUnsignedBigInt,
-  asyncAwaiter,
-  asyncProjections,
-  asyncRetry,
-  bigInt,
-  bigIntProcessorCheckpoint,
-  canCreateEventStoreSession,
-  caughtUpEventFrom,
-  command,
-  composeJSONReplacers,
-  composeJSONRevivers,
-  deepEquals,
-  defaultProcessingMessageProcessingScope,
-  defaultProcessorPartition,
-  defaultProcessorVersion,
-  defaultTag,
-  delay,
-  documentExists,
-  downcastRecordedMessage,
-  downcastRecordedMessages,
-  emmettPrefix,
-  event,
-  eventInStream,
-  eventsInStream,
-  expectInMemoryDocuments,
-  filterProjections,
-  formatDateToUtcYYYYMMDD,
-  forwardToMessageBus,
-  getCheckpoint,
-  getInMemoryDatabase,
-  getInMemoryEventStore,
-  getInMemoryMessageBus,
-  getProcessorInstanceId,
-  getProjectorId,
-  getWorkflowId,
-  globalStreamCaughtUp,
-  globalTag,
-  guardBoundedAccess,
-  guardExclusiveAccess,
-  guardInitializedOnce,
-  handleInMemoryProjections,
-  hashText,
-  inMemoryCheckpointer,
-  inMemoryMultiStreamProjection,
-  inMemoryProjection,
-  inMemoryProjector,
-  inMemoryReactor,
-  inMemorySingleStreamProjection,
-  inlineProjections,
-  isBigint,
-  isEquatable,
-  isErrorConstructor,
-  isExpectedVersionConflictError,
-  isGlobalStreamCaughtUp,
-  isNotInternalEvent,
-  isNumber,
-  isPluginConfig,
-  isString,
-  isSubscriptionEvent,
-  isSubset,
-  isValidYYYYMMDD,
-  jsonSerializer,
-  matchesExpectedVersion,
-  merge,
-  message,
-  newEventsInStream,
-  nulloSessionFactory,
-  onShutdown,
-  parseBigIntProcessorCheckpoint,
-  parseDateFromUtcYYYYMMDD,
-  projection,
-  projections,
-  projector,
-  reactor,
-  sum,
-  toNormalizedString,
-  tryPublishMessagesAfterCommit,
-  unknownTag,
-  upcastRecordedMessage,
-  upcastRecordedMessages,
-  verifyThat,
-  wasMessageHandled,
-  workflowOutputHandler,
-  workflowProcessor,
-  workflowStreamName
+//#endregion
+//#region src/workflows/workflowProcessor.ts
+const workflowOutputHandler = (handler) => handler;
+const getWorkflowId = (options) => `emt:processor:workflow:${options.workflowName}`;
+const workflowProcessor = (options) => {
+	const { workflow, ...rest } = options;
+	const inputs = [...options.inputs.commands, ...options.inputs.events];
+	let canHandle = inputs;
+	if (options.separateInputInboxFromProcessing) canHandle = [
+		...canHandle,
+		...options.inputs.commands.map((t) => `${workflow.name}:${t}`),
+		...options.inputs.events.map((t) => `${workflow.name}:${t}`)
+	];
+	if (options.outputHandler) canHandle = [...canHandle, ...options.outputHandler.canHandle];
+	const handle = WorkflowHandler(options);
+	return reactor({
+		...rest,
+		processorId: options.processorId ?? getWorkflowId({ workflowName: workflow.name }),
+		canHandle,
+		type: MessageProcessorType.PROJECTOR,
+		eachMessage: async (message, context) => {
+			const messageType = message.type;
+			if (message.metadata?.input === true || inputs.includes(messageType)) {
+				const result = await handle(context.connection.messageStore, message, context);
+				if (options.stopAfter && result.newMessages.length > 0) {
+					for (const outputMessage of result.newMessages) if (options.stopAfter(outputMessage)) return {
+						type: "STOP",
+						reason: "Stop condition reached"
+					};
+				}
+				return;
+			}
+			if (options.outputHandler?.canHandle.includes(messageType) === true) {
+				const recordedMessage = message;
+				const handledOutputMessages = options.outputHandler.eachBatch ? await options.outputHandler.eachBatch([recordedMessage], context) : await options.outputHandler.eachMessage(recordedMessage, context);
+				if (handledOutputMessages instanceof EmmettError) return {
+					type: "STOP",
+					reason: "Routing error",
+					error: handledOutputMessages
+				};
+				const messagesToAppend = Array.isArray(handledOutputMessages) ? handledOutputMessages : handledOutputMessages ? [handledOutputMessages] : [];
+				if (messagesToAppend.length === 0) return;
+				const workflowId = options.getWorkflowId(message);
+				if (!workflowId) return;
+				const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({
+					workflowName: workflow.name,
+					workflowId
+				});
+				await context.connection.messageStore.appendToStream(streamName, messagesToAppend);
+				return;
+			}
+		}
+	});
 };
+
+//#endregion
+export { AssertionError, CommandHandler, CommandHandlerStreamVersionConflictRetryOptions, ConcurrencyError, ConcurrencyInMemoryDatabaseError, DATABASE_REQUIRED_ERROR_MESSAGE, DeciderCommandHandler, DeciderSpecification, EmmettError, ExpectedVersionConflictError, GlobalStreamCaughtUpType, IllegalStateError, InMemoryEventStoreDefaultStreamVersion, InMemoryProjectionSpec, InProcessLock, JSONCodec, JSONReplacer, JSONReplacers, JSONReviver, JSONRevivers, JSONSerializer, MessageProcessor, MessageProcessorType, NO_CONCURRENCY_CHECK, NoRetries, NotFoundError, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, TaskProcessor, ValidationError, ValidationErrors, Workflow, WorkflowHandler, WorkflowHandlerStreamVersionConflictRetryOptions, WorkflowSpecification, WrapEventStore, argMatches, argValue, arrayUtils, assertDeepEqual, assertDefined, assertDoesNotThrow, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertFalse, assertIsNotNull, assertIsNull, assertMatches, assertNotDeepEqual, assertNotEmptyString, assertNotEqual, assertOk, assertPositiveNumber, assertRejects, assertThat, assertThatArray, assertThrows, assertThrowsAsync, assertTrue, assertUnsignedBigInt, asyncAwaiter, asyncProjections, asyncRetry, bigInt, bigIntProcessorCheckpoint, canCreateEventStoreSession, caughtUpEventFrom, command, composeJSONReplacers, composeJSONRevivers, deepEquals, defaultProcessingMessageProcessingScope, defaultProcessorPartition, defaultProcessorVersion, defaultTag, delay, documentExists, downcastRecordedMessage, downcastRecordedMessages, emmettPrefix, event, eventInStream, eventsInStream, expectInMemoryDocuments, filterProjections, formatDateToUtcYYYYMMDD, forwardToMessageBus, getCheckpoint, getInMemoryDatabase, getInMemoryEventStore, getInMemoryMessageBus, getProcessorInstanceId, getProjectorId, getWorkflowId, globalStreamCaughtUp, globalTag, guardBoundedAccess, guardExclusiveAccess, guardInitializedOnce, handleInMemoryProjections, hashText, inMemoryCheckpointer, inMemoryMultiStreamProjection, inMemoryProjection, inMemoryProjector, inMemoryReactor, inMemorySingleStreamProjection, inlineProjections, isBigint, isEquatable, isErrorConstructor, isExpectedVersionConflictError, isGlobalStreamCaughtUp, isNotInternalEvent, isNumber, isPluginConfig, isString, isSubscriptionEvent, isSubset, isValidYYYYMMDD, jsonSerializer, matchesExpectedVersion, merge, message, newEventsInStream, nulloSessionFactory, onShutdown, parseBigIntProcessorCheckpoint, parseDateFromUtcYYYYMMDD, projection, projections, projector, reactor, reduceAsync, sum, toNormalizedString, tryPublishMessagesAfterCommit, unknownTag, upcastRecordedMessage, upcastRecordedMessages, verifyThat, wasMessageHandled, workflowOutputHandler, workflowProcessor, workflowStreamName };
 //# sourceMappingURL=index.js.map