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

package/dist/index.cjs

@@ -1,1763 +1,471 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// ../emmett/dist/chunk-AZDDB5SF.js
-var isNumber = (val) => typeof val === "number" && val === val;
-var isString = (val) => typeof val === "string";
-var isErrorConstructor = (expect) => {
-  return typeof expect === "function" && expect.prototype && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  expect.prototype.constructor === expect;
-};
-var EmmettError = (_class = class _EmmettError extends Error {
-  static __initStatic() {this.Codes = {
-    ValidationError: 400,
-    IllegalStateError: 403,
-    NotFoundError: 404,
-    ConcurrencyError: 412,
-    InternalServerError: 500
-  }}
-  
-  constructor(options) {
-    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : _EmmettError.Codes.InternalServerError;
-    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Emmett processing`;
-    super(message);
-    this.errorCode = errorCode;
-    Object.setPrototypeOf(this, _EmmettError.prototype);
-  }
-  static mapFrom(error) {
-    if (_EmmettError.isInstanceOf(error)) {
-      return error;
-    }
-    return new _EmmettError({
-      errorCode: "errorCode" in error && error.errorCode !== void 0 && error.errorCode !== null ? error.errorCode : _EmmettError.Codes.InternalServerError,
-      message: _nullishCoalesce(error.message, () => ( "An unknown error occurred"))
-    });
-  }
-  static isInstanceOf(error, errorCode) {
-    return typeof error === "object" && error !== null && "errorCode" in error && isNumber(error.errorCode) && (errorCode === void 0 || error.errorCode === errorCode);
-  }
-}, _class.__initStatic(), _class);
-var ConcurrencyError = class _ConcurrencyError extends EmmettError {
-  constructor(current, expected, message) {
-    super({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _ => _.toString, 'call', _2 => _2()])}`))
-    });
-    this.current = current;
-    this.expected = expected;
-    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
-  }
-};
-
-// ../emmett/dist/index.js
-var _uuid = require('uuid');
-
-
-var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
-
-
-
-var emmettPrefix = "emt";
-var defaultTag = `${emmettPrefix}:default`;
-var unknownTag = `${emmettPrefix}:unknown`;
-var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
-var nulloSessionFactory = (eventStore) => ({
-  withSession: (callback) => {
-    const nulloSession = {
-      eventStore,
-      close: () => Promise.resolve()
-    };
-    return callback(nulloSession);
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _event_driven_io_emmett = require("@event-driven-io/emmett");
+let _event_driven_io_pongo = require("@event-driven-io/pongo");
+let _event_driven_io_dumbo = require("@event-driven-io/dumbo");
+let uuid = require("uuid");
+
+//#region src/eventStore/projections/pongo/pongoProjections.ts
+const pongoProjection = ({ name, kind, version, truncate, handle, canHandle, eventsOptions }) => sqliteProjection({
+	name,
+	version,
+	kind: kind ?? "emt:projections:postgresql:pongo:generic",
+	canHandle,
+	eventsOptions,
+	handle: async (events, context) => {
+		const { connection } = context;
+		const pongo = (0, _event_driven_io_pongo.pongoClient)({
+			driver: await pongoDriverRegistry.tryResolve(context.driverType),
+			connectionOptions: { connection }
+		});
+		try {
+			await handle(events, {
+				...context,
+				pongo
+			});
+		} finally {
+			await pongo.close();
+		}
+	},
+	truncate: truncate ? async (context) => {
+		const { connection } = context;
+		const pongo = (0, _event_driven_io_pongo.pongoClient)({
+			driver: await pongoDriverRegistry.tryResolve(context.driverType),
+			connectionOptions: { connection }
+		});
+		try {
+			await truncate({
+				...context,
+				pongo
+			});
+		} finally {
+			await pongo.close();
+		}
+	} : void 0
 });
-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(_optionalChain([current, 'optionalAccess', _3 => _3.toString, 'call', _4 => _4()]), _optionalChain([expected, 'optionalAccess', _5 => _5.toString, 'call', _6 => _6()]));
-    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
-  }
-};
-var isExpectedVersionConflictError = (error) => error instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
-  error,
-  ExpectedVersionConflictError.Codes.ConcurrencyError
-);
-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;
-}
-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";
-};
-var toNormalizedString = (value) => value.toString().padStart(19, "0");
-var bigInt = {
-  toNormalizedString
-};
-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(_nullishCoalesce(_optionalChain([context, 'optionalAccess', _7 => _7.source]), () => ( value.toString())));
-    } catch (e2) {
-      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 (e3) {
-        }
-      }
-    }
-  }
-  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(
-  _optionalChain([opts, 'optionalAccess', _8 => _8.replacer]),
-  _optionalChain([opts, 'optionalAccess', _9 => _9.failOnBigIntSerialization]) !== true ? JSONReplacers.bigInt : void 0,
-  _optionalChain([opts, 'optionalAccess', _10 => _10.useDefaultDateSerialization]) !== true ? JSONReplacers.date : void 0
-);
-var JSONReviver = (opts) => composeJSONRevivers(
-  _optionalChain([opts, 'optionalAccess', _11 => _11.reviver]),
-  _optionalChain([opts, 'optionalAccess', _12 => _12.parseBigInts]) === true ? JSONRevivers.bigInt : void 0,
-  _optionalChain([opts, 'optionalAccess', _13 => _13.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) => _nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.serialization, 'optionalAccess', _15 => _15.serializer]), () => ( (_optionalChain([options, 'optionalAccess', _16 => _16.serialization, 'optionalAccess', _17 => _17.options]) ? jsonSerializer(_optionalChain([options, 'optionalAccess', _18 => _18.serialization, 'optionalAccess', _19 => _19.options])) : JSONSerializer)))
+const pongoMultiStreamProjection = (options) => {
+	const { collectionName, getDocumentId, canHandle } = options;
+	const collectionNameWithVersion = options.version && options.version > 0 ? `${collectionName}_v${options.version}` : collectionName;
+	return pongoProjection({
+		name: collectionNameWithVersion,
+		version: options.version,
+		kind: options.kind ?? "emt:projections:postgresql:pongo:multi_stream",
+		eventsOptions: options.eventsOptions,
+		handle: async (events, { pongo }) => {
+			const collection = pongo.db().collection(collectionNameWithVersion, options.collectionOptions);
+			const eventsByDocumentId = events.map((event) => {
+				return {
+					documentId: getDocumentId(event),
+					event
+				};
+			}).reduce((acc, { documentId, event }) => {
+				if (!acc.has(documentId)) acc.set(documentId, []);
+				acc.get(documentId).push(event);
+				return acc;
+			}, /* @__PURE__ */ new Map());
+			await collection.handle([...eventsByDocumentId.keys()], (document, id) => {
+				return (0, _event_driven_io_emmett.reduceAsync)(eventsByDocumentId.get(id), async (acc, event) => await options.evolve(acc, event), document ?? ("initialState" in options ? options.initialState() : null));
+			});
+		},
+		canHandle,
+		truncate: async (context) => {
+			const { connection } = context;
+			const pongo = (0, _event_driven_io_pongo.pongoClient)({
+				driver: await pongoDriverRegistry.tryResolve(context.driverType),
+				connectionOptions: { connection }
+			});
+			try {
+				await pongo.db().collection(collectionNameWithVersion, options.collectionOptions).deleteMany();
+			} finally {
+				await pongo.close();
+			}
+		},
+		init: async (context) => {
+			const { connection } = context;
+			const driver = await pongoDriverRegistry.tryResolve(context.driverType);
+			const pongo = (0, _event_driven_io_pongo.pongoClient)({
+				connectionOptions: { connection },
+				driver
+			});
+			try {
+				await pongo.db().collection(collectionNameWithVersion, options.collectionOptions).schema.migrate();
+			} finally {
+				await pongo.close();
+			}
+		}
+	});
+};
+const pongoSingleStreamProjection = (options) => {
+	return pongoMultiStreamProjection({
+		...options,
+		kind: "emt:projections:postgresql:pongo:single_stream",
+		getDocumentId: options.getDocumentId ?? ((event) => event.metadata.streamName)
+	});
+};
+
+//#endregion
+//#region src/eventStore/projections/pongo/pongoProjectionSpec.ts
+const withCollection = async (handle, options) => {
+	const { connection, inDatabase, inCollection } = options;
+	const driver = await pongoDriverRegistry.tryResolve(connection.driverType);
+	const pongo = (0, _event_driven_io_pongo.pongoClient)({
+		connectionOptions: { connection },
+		driver
+	});
+	try {
+		return handle(pongo.db(inDatabase).collection(inCollection));
+	} finally {
+		await pongo.close();
+	}
+};
+const withoutIdAndVersion = (doc) => {
+	const { _id, _version, ...without } = doc;
+	return without;
+};
+const assertDocumentsEqual = (actual, expected) => {
+	if ("_id" in expected) (0, _event_driven_io_emmett.assertEqual)(expected._id, actual._id, `Document ids are not matching! Expected: ${expected._id}, Actual: ${actual._id}`);
+	return (0, _event_driven_io_emmett.assertDeepEqual)(withoutIdAndVersion(actual), withoutIdAndVersion(expected));
+};
+const documentExists = (document, options) => (assertOptions) => withCollection(async (collection) => {
+	const result = await collection.findOne("withId" in options ? { _id: options.withId } : options.matchingFilter);
+	(0, _event_driven_io_emmett.assertIsNotNull)(result);
+	assertDocumentsEqual(result, document);
+}, {
+	...options,
+	...assertOptions
 });
-var NoRetries = { retries: 0 };
-var asyncRetry = async (fn, opts) => {
-  if (opts === void 0 || opts.retries === 0) return fn();
-  return _asyncretry2.default.call(void 0, 
-    async (bail) => {
-      try {
-        const result = await fn();
-        if (_optionalChain([opts, 'optionalAccess', _20 => _20.shouldRetryResult]) && opts.shouldRetryResult(result)) {
-          throw new EmmettError(
-            `Retrying because of result: ${JSONSerializer.serialize(result)}`
-          );
-        }
-        return result;
-      } catch (error) {
-        if (_optionalChain([opts, 'optionalAccess', _21 => _21.shouldRetryError]) && !opts.shouldRetryError(error)) {
-          bail(error);
-          return void 0;
-        }
-        throw error;
-      }
-    },
-    _nullishCoalesce(opts, () => ( { retries: 0 }))
-  );
-};
-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 () => {
-  };
-};
-var textEncoder = new TextEncoder();
-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 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}:${_uuid.v7.call(void 0, )}`;
-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 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 message2 = messages[i];
-      const messageProcessingResult = await options.eachMessage(
-        message2,
-        context
-      );
-      if (messageProcessingResult && messageProcessingResult.type === "STOP") {
-        result = {
-          ...messageProcessingResult,
-          lastSuccessfulMessage: messageProcessingResult.error ? messages[i - 1] : message2
-        };
-        break;
-      }
-      if (stopAfter && stopAfter(message2)) {
-        result = {
-          type: "STOP",
-          reason: "Stop condition reached",
-          lastSuccessfulMessage: message2
-        };
-        break;
-      }
-      if (messageProcessingResult && messageProcessingResult.type === "SKIP") {
-        result = {
-          ...messageProcessingResult,
-          lastSuccessfulMessage: message2
-        };
-        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 {
-    // 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 _optionalChain([checkpoints, 'optionalAccess', _22 => _22.read, 'call', _23 => _23(
-            {
-              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) => {
-        const messagesAboveCheckpoint = messages.filter(
-          (message2) => !wasMessageHandled(message2, lastCheckpoint)
-        );
-        const upcastedMessages = messagesAboveCheckpoint.map(
-          (message2) => upcastRecordedMessage(
-            // TODO: Make it smarter
-            message2,
-            _optionalChain([options, 'access', _24 => _24.messageOptions, 'optionalAccess', _25 => _25.schema, 'optionalAccess', _26 => _26.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 = _optionalChain([batchResult, 'optionalAccess', _27 => _27.type]) === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
-          type: "STOP",
-          reason: "Stop condition reached",
-          lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
-        } : batchResult;
-        const isStop = messageProcessingResult && messageProcessingResult.type === "STOP";
-        const checkpointMessage = _optionalChain([messageProcessingResult, 'optionalAccess', _28 => _28.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;
-        }
-        return void 0;
-      }, partialContext);
-    }
-  };
-};
-var projector = (options) => {
-  const {
-    projection: projection2,
-    processorId = getProjectorId({
-      projectionName: _nullishCoalesce(projection2.name, () => ( "unknown"))
-    }),
-    ...rest
-  } = options;
-  return reactor({
-    ...rest,
-    type: MessageProcessorType.PROJECTOR,
-    canHandle: projection2.canHandle,
-    processorId,
-    messageOptions: options.projection.eventsOptions,
-    hooks: {
-      onInit: _optionalChain([options, 'access', _29 => _29.hooks, 'optionalAccess', _30 => _30.onInit]),
-      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _31 => _31.hooks, 'optionalAccess', _32 => _32.onStart]) ? async (context) => {
-        if (options.truncateOnStart && options.projection.truncate)
-          await options.projection.truncate(context);
-        if (_optionalChain([options, 'access', _33 => _33.hooks, 'optionalAccess', _34 => _34.onStart])) await _optionalChain([options, 'access', _35 => _35.hooks, 'optionalAccess', _36 => _36.onStart, 'call', _37 => _37(context)]);
-      } : void 0,
-      onClose: _optionalChain([options, 'access', _38 => _38.hooks, 'optionalAccess', _39 => _39.onClose])
-    },
-    eachBatch: async (events, context) => projection2.handle(events, context)
-  });
-};
-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(_nullishCoalesce(message2, () => ( "That should not ever happened, right?")));
-};
-var assertDeepEqual = (actual, expected, message2) => {
-  if (!deepEquals(actual, expected))
-    throw new AssertionError(
-      _nullishCoalesce(message2, () => ( `subObj:
-${JSONSerializer.serialize(expected)}
-is not equal to
-${JSONSerializer.serialize(actual)}`))
-    );
-};
-function assertTrue(condition, message2) {
-  if (condition !== true)
-    throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is false`)));
-}
-function assertOk(obj, message2) {
-  if (!obj) throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is not truthy`)));
-}
-function assertEqual(expected, actual, message2) {
-  if (expected !== actual)
-    throw new AssertionError(
-      `${_nullishCoalesce(message2, () => ( "Objects are not equal"))}:
-Expected: ${JSONSerializer.serialize(expected)}
-Actual: ${JSONSerializer.serialize(actual)}`
-    );
-}
-function assertNotEqual(obj, other, message2) {
-  if (obj === other)
-    throw new AssertionError(
-      _nullishCoalesce(message2, () => ( `Objects are equal: ${JSONSerializer.serialize(obj)}`))
-    );
-}
-function assertIsNotNull(result) {
-  assertNotEqual(result, null);
-  assertOk(result);
-}
-function assertIsNull(result) {
-  assertEqual(result, null);
-}
-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));
-      }
-    }
-  };
-};
-var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _40 => _40.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 (!_optionalChain([options, 'optionalAccess', _41 => _41.downcast]))
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
-  );
-};
-var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _42 => _42.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 projection = (definition) => definition;
-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
+const documentsAreTheSame = (documents, options) => (assertOptions) => withCollection(async (collection) => {
+	const result = await collection.find("withId" in options ? { _id: options.withId } : options.matchingFilter);
+	(0, _event_driven_io_emmett.assertEqual)(documents.length, result.length, "Different Documents Count than expected");
+	for (let i = 0; i < documents.length; i++) (0, _event_driven_io_emmett.assertThatArray)(result).contains(documents[i]);
+}, {
+	...options,
+	...assertOptions
 });
-var createInputMetadata = (originalMessageId, action) => ({
-  originalMessageId,
-  input: true,
-  action
+const documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) => withCollection(async (collection) => {
+	(0, _event_driven_io_emmett.assertEqual)(expectedCount, (await collection.find("withId" in options ? { _id: options.withId } : options.matchingFilter)).length, "Different Documents Count than expected");
+}, {
+	...options,
+	...assertOptions
 });
-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 (_optionalChain([metadata, 'optionalAccess', _43 => _43.input]) === true && typeof _optionalChain([metadata, 'optionalAccess', _44 => _44.originalMessageId]) === "string") {
-      processedInputIds = new Set(state.processedInputIds);
-      processedInputIds.add(metadata.originalMessageId);
-    }
-    if (separateInputInboxFromProcessing && _optionalChain([metadata, 'optionalAccess', _45 => _45.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
-        _nullishCoalesce(("metadata" in message2 && _optionalChain([message2, 'access', _46 => _46.metadata, 'optionalAccess', _47 => _47.messageId]) ? (
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          message2.metadata.messageId
-        ) : void 0), () => ( _uuid.v7.call(void 0, )))
-      );
-      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: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _48 => _48.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
-          }
-        );
-        return {
-          ...appendResult2,
-          newMessages: []
-        };
-      }
-      const wrappedInitialState = createWrappedInitialState(initialState);
-      const wrappedEvolve = createWrappedEvolve(
-        evolve,
-        workflowName,
-        _nullishCoalesce(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: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _49 => _49.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 = _nullishCoalesce(_optionalChain([options, 'access', _50 => _50.outputs, 'optionalAccess', _51 => _51.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 = _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _52 => _52.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);
-};
-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: _nullishCoalesce(options.processorId, () => ( getWorkflowId({ workflowName: workflow.name }))),
-    canHandle,
-    type: MessageProcessorType.PROJECTOR,
-    eachMessage: async (message2, context) => {
-      const messageType = message2.type;
-      const metadata = message2.metadata;
-      const isInput = _optionalChain([metadata, 'optionalAccess', _53 => _53.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 (_optionalChain([options, 'access', _54 => _54.outputHandler, 'optionalAccess', _55 => _55.canHandle, 'access', _56 => _56.includes, 'call', _57 => _57(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;
-    }
-  });
-};
-
-// src/eventStore/projections/pongo/pongoProjections.ts
-
-
-var _pongo = require('@event-driven-io/pongo');
-var pongoProjection = ({
-  name,
-  kind,
-  version,
-  truncate,
-  handle,
-  canHandle,
-  eventsOptions
-}) => sqliteProjection({
-  name,
-  version,
-  kind: _nullishCoalesce(kind, () => ( "emt:projections:postgresql:pongo:generic")),
-  canHandle,
-  eventsOptions,
-  handle: async (events, context) => {
-    const { connection } = context;
-    const driver = await pongoDriverRegistry.tryResolve(
-      context.driverType
-    );
-    const pongo = _pongo.pongoClient.call(void 0, {
-      driver,
-      connectionOptions: { connection }
-    });
-    try {
-      await handle(events, {
-        ...context,
-        pongo
-      });
-    } finally {
-      await pongo.close();
-    }
-  },
-  truncate: truncate ? async (context) => {
-    const { connection } = context;
-    const driver = await pongoDriverRegistry.tryResolve(
-      context.driverType
-    );
-    const pongo = _pongo.pongoClient.call(void 0, {
-      driver,
-      connectionOptions: { connection }
-    });
-    try {
-      await truncate({
-        ...context,
-        pongo
-      });
-    } finally {
-      await pongo.close();
-    }
-  } : void 0
+const documentMatchingExists = (options) => (assertOptions) => withCollection(async (collection) => {
+	(0, _event_driven_io_emmett.assertThatArray)(await collection.find("withId" in options ? { _id: options.withId } : options.matchingFilter)).isNotEmpty();
+}, {
+	...options,
+	...assertOptions
 });
-var pongoMultiStreamProjection = (options) => {
-  const { collectionName, getDocumentId, canHandle } = options;
-  const collectionNameWithVersion = options.version && options.version > 0 ? `${collectionName}_v${options.version}` : collectionName;
-  return pongoProjection({
-    name: collectionNameWithVersion,
-    version: options.version,
-    kind: _nullishCoalesce(options.kind, () => ( "emt:projections:postgresql:pongo:multi_stream")),
-    eventsOptions: options.eventsOptions,
-    handle: async (events, { pongo }) => {
-      const collection = pongo.db().collection(
-        collectionNameWithVersion,
-        options.collectionOptions
-      );
-      const eventsByDocumentId = events.map((event) => {
-        const documentId = getDocumentId(event);
-        return {
-          documentId,
-          event
-        };
-      }).reduce((acc, { documentId, event }) => {
-        if (!acc.has(documentId)) {
-          acc.set(documentId, []);
-        }
-        acc.get(documentId).push(event);
-        return acc;
-      }, /* @__PURE__ */ new Map());
-      await collection.handle(
-        [...eventsByDocumentId.keys()],
-        (document, id) => {
-          const events2 = eventsByDocumentId.get(id);
-          return reduceAsync(
-            events2,
-            async (acc, event) => await options.evolve(acc, event),
-            _nullishCoalesce(document, () => ( ("initialState" in options ? options.initialState() : null)))
-          );
-        }
-      );
-    },
-    canHandle,
-    truncate: async (context) => {
-      const { connection } = context;
-      const driver = await pongoDriverRegistry.tryResolve(
-        context.driverType
-      );
-      const pongo = _pongo.pongoClient.call(void 0, {
-        driver,
-        connectionOptions: { connection }
-      });
-      try {
-        await pongo.db().collection(
-          collectionNameWithVersion,
-          options.collectionOptions
-        ).deleteMany();
-      } finally {
-        await pongo.close();
-      }
-    },
-    init: async (context) => {
-      const { connection } = context;
-      const driver = await pongoDriverRegistry.tryResolve(
-        context.driverType
-      );
-      const pongo = _pongo.pongoClient.call(void 0, {
-        connectionOptions: { connection },
-        driver
-      });
-      try {
-        await pongo.db().collection(
-          collectionNameWithVersion,
-          options.collectionOptions
-        ).schema.migrate();
-      } finally {
-        await pongo.close();
-      }
-    }
-  });
-};
-var pongoSingleStreamProjection = (options) => {
-  return pongoMultiStreamProjection({
-    ...options,
-    kind: "emt:projections:postgresql:pongo:single_stream",
-    getDocumentId: _nullishCoalesce(options.getDocumentId, () => ( ((event) => event.metadata.streamName)))
-  });
-};
-
-// src/eventStore/projections/pongo/pongoProjectionSpec.ts
-
-
-
-var withCollection = async (handle, options) => {
-  const { connection, inDatabase, inCollection } = options;
-  const driver = await pongoDriverRegistry.tryResolve(
-    connection.driverType
-  );
-  const pongo = _pongo.pongoClient.call(void 0, {
-    connectionOptions: { connection },
-    driver
-  });
-  try {
-    const collection = pongo.db(inDatabase).collection(inCollection);
-    return handle(collection);
-  } finally {
-    await pongo.close();
-  }
-};
-var withoutIdAndVersion = (doc) => {
-  const { _id, _version, ...without } = doc;
-  return without;
-};
-var assertDocumentsEqual = (actual, expected) => {
-  if ("_id" in expected)
-    assertEqual(
-      expected._id,
-      actual._id,
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-      `Document ids are not matching! Expected: ${expected._id}, Actual: ${actual._id}`
-    );
-  return assertDeepEqual(
-    withoutIdAndVersion(actual),
-    withoutIdAndVersion(expected)
-  );
-};
-var documentExists = (document, options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.findOne(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertIsNotNull(result);
-    assertDocumentsEqual(result, document);
-  },
-  { ...options, ...assertOptions }
-);
-var documentsAreTheSame = (documents, options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.find(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertEqual(
-      documents.length,
-      result.length,
-      "Different Documents Count than expected"
-    );
-    for (let i = 0; i < documents.length; i++) {
-      assertThatArray(result).contains(documents[i]);
-    }
-  },
-  { ...options, ...assertOptions }
-);
-var documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.find(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertEqual(
-      expectedCount,
-      result.length,
-      "Different Documents Count than expected"
-    );
-  },
-  { ...options, ...assertOptions }
-);
-var documentMatchingExists = (options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.find(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertThatArray(result).isNotEmpty();
-  },
-  { ...options, ...assertOptions }
-);
-var documentDoesNotExist = (options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.findOne(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertIsNull(result);
-  },
-  { ...options, ...assertOptions }
-);
-var expectPongoDocuments = {
-  fromCollection: (collectionName) => {
-    return {
-      withId: (id) => {
-        return {
-          toBeEqual: (document) => documentExists(document, {
-            withId: id,
-            inCollection: collectionName
-          }),
-          toExist: () => documentMatchingExists({
-            withId: id,
-            inCollection: collectionName
-          }),
-          notToExist: () => documentDoesNotExist({
-            withId: id,
-            inCollection: collectionName
-          })
-        };
-      },
-      matching: (filter) => {
-        return {
-          toBeTheSame: (documents) => documentsAreTheSame(documents, {
-            matchingFilter: filter,
-            inCollection: collectionName
-          }),
-          toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
-            matchingFilter: filter,
-            inCollection: collectionName
-          }),
-          toExist: () => documentMatchingExists({
-            matchingFilter: filter,
-            inCollection: collectionName
-          }),
-          notToExist: () => documentDoesNotExist({
-            matchingFilter: filter,
-            inCollection: collectionName
-          })
-        };
-      }
-    };
-  }
-};
-
-// src/eventStore/projections/sqliteProjection.ts
-var handleProjections = async (options) => {
-  const {
-    projections: allProjections,
-    events,
-    connection,
-    execute,
-    driverType
-  } = options;
-  const eventTypes = events.map((e) => e.type);
-  for (const projection2 of allProjections) {
-    if (!projection2.canHandle.some((type) => eventTypes.includes(type))) {
-      continue;
-    }
-    await projection2.handle(events, {
-      connection,
-      execute,
-      driverType
-    });
-  }
-};
-var sqliteProjection = (definition) => projection(definition);
-var sqliteRawBatchSQLProjection = (options) => sqliteProjection({
-  name: options.name,
-  kind: _nullishCoalesce(options.kind, () => ( "emt:projections:sqlite:raw_sql:batch")),
-  version: options.version,
-  canHandle: options.canHandle,
-  eventsOptions: options.eventsOptions,
-  handle: async (events, context) => {
-    const sqls = await options.evolve(events, context);
-    await context.execute.batchCommand(sqls);
-  },
-  init: async (initOptions) => {
-    const initSQL = options.init ? await options.init(initOptions) : void 0;
-    if (initSQL) {
-      if (Array.isArray(initSQL)) {
-        await initOptions.context.execute.batchCommand(initSQL);
-      } else {
-        await initOptions.context.execute.command(initSQL);
-      }
-    }
-  }
+const documentDoesNotExist = (options) => (assertOptions) => withCollection(async (collection) => {
+	(0, _event_driven_io_emmett.assertIsNull)(await collection.findOne("withId" in options ? { _id: options.withId } : options.matchingFilter));
+}, {
+	...options,
+	...assertOptions
 });
-var sqliteRawSQLProjection = (options) => {
-  const { evolve, kind, ...rest } = options;
-  return sqliteRawBatchSQLProjection({
-    kind: _nullishCoalesce(kind, () => ( "emt:projections:sqlite:raw:_sql:single")),
-    ...rest,
-    evolve: async (events, context) => {
-      const sqls = [];
-      for (const event of events) {
-        const pendingSqls = await evolve(event, context);
-        if (Array.isArray(pendingSqls)) {
-          sqls.push(...pendingSqls);
-        } else {
-          sqls.push(pendingSqls);
-        }
-      }
-      return sqls;
-    }
-  });
-};
-
-// src/eventStore/projections/sqliteProjectionSpec.ts
-var _dumbo = require('@event-driven-io/dumbo');
-
-var SQLiteProjectionSpec = {
-  for: (options) => {
-    {
-      const driverType = options.driver.driverType;
-      const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
-        serialization: options.serialization,
-        transactionOptions: {
-          allowNestedTransactions: true,
-          mode: "session_based"
-        },
-        ...options.driver.mapToDumboOptions(options)
-      })));
-      const projection2 = options.projection;
-      let wasInitialized = false;
-      return (givenEvents) => {
-        return {
-          when: (events, options2) => {
-            const allEvents = [];
-            const run = async (connection) => {
-              let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _58 => _58.numberOfTimes]), () => ( 1));
-              for (const event of [
-                ...givenEvents,
-                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
-              ]) {
-                const metadata = {
-                  checkpoint: bigIntProcessorCheckpoint(++globalPosition),
-                  globalPosition,
-                  streamPosition: globalPosition,
-                  streamName: `test-${_uuid.v4.call(void 0, )}`,
-                  messageId: _uuid.v4.call(void 0, )
-                };
-                allEvents.push({
-                  ...event,
-                  kind: "Event",
-                  metadata: {
-                    ...metadata,
-                    ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
-                  }
-                });
-              }
-              if (!wasInitialized && projection2.init) {
-                await projection2.init({
-                  registrationType: "async",
-                  status: "active",
-                  context: {
-                    execute: connection.execute,
-                    connection,
-                    driverType
-                  },
-                  version: _nullishCoalesce(projection2.version, () => ( 1))
-                });
-                wasInitialized = true;
-              }
-              await connection.withTransaction(
-                () => handleProjections({
-                  events: allEvents,
-                  projections: [projection2],
-                  execute: connection.execute,
-                  connection,
-                  driverType
-                })
-              );
-            };
-            return {
-              then: (assert, message) => pool.withConnection(async (connection) => {
-                await run(connection);
-                const succeeded = await assert({
-                  connection
-                });
-                if (succeeded !== void 0 && succeeded === false)
-                  assertFails(
-                    _nullishCoalesce(message, () => ( "Projection specification didn't match the criteria"))
-                  );
-              }),
-              thenThrows: (...args) => pool.withConnection(async (connection) => {
-                try {
-                  await run(connection);
-                  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: ${_optionalChain([error, 'optionalAccess', _59 => _59.toString, 'call', _60 => _60()])}`
-                    );
-                    return;
-                  }
-                  assertTrue(
-                    error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _61 => _61.toString, 'call', _62 => _62()])}`
-                  );
-                  if (args[1]) {
-                    assertTrue(
-                      args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _63 => _63.toString, 'call', _64 => _64()])}`
-                    );
-                  }
-                }
-              })
-            };
-          }
-        };
-      };
-    }
-  }
-};
-var eventInStream = (streamName, event) => {
-  return {
-    ...event,
-    metadata: {
-      ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _65 => _65.metadata, 'optionalAccess', _66 => _66.streamName]), () => ( streamName))
-    }
-  };
-};
-var eventsInStream = (streamName, events) => {
-  return events.map((e) => eventInStream(streamName, e));
-};
-var newEventsInStream = eventsInStream;
-var assertSQLQueryResultMatches = (sql, rows) => async ({
-  connection
-}) => {
-  const result = await connection.execute.query(sql);
-  assertThatArray(rows).containsExactlyInAnyOrder(result.rows);
-};
-var expectSQL = {
-  query: (sql) => ({
-    resultRows: {
-      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows)
-    }
-  })
-};
-
-// src/eventStore/schema/appendToStream.ts
-
-
-
-
-
-
-
-
-
-// src/eventStore/schema/typing.ts
-var emmettPrefix2 = "emt";
-var globalTag = "global";
-var defaultTag2 = `${emmettPrefix2}:default`;
-var unknownTag2 = `${emmettPrefix2}:unknown`;
-var globalNames = {
-  module: `${emmettPrefix2}:module:${globalTag}`
-};
-var columns = {
-  partition: {
-    name: "partition"
-  },
-  isArchived: { name: "is_archived" }
-};
-var streamsTable = {
-  name: `${emmettPrefix2}_streams`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-var messagesTable = {
-  name: `${emmettPrefix2}_messages`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-var processorsTable = {
-  name: `${emmettPrefix2}_processors`
-};
-var projectionsTable = {
-  name: `${emmettPrefix2}_projections`
-};
-
-// src/eventStore/schema/appendToStream.ts
-var { identifier, merge } = _dumbo.SQL;
-var appendToStream = async (connection, streamName, streamType, messages, options) => {
-  if (messages.length === 0) return { success: false };
-  const expectedStreamVersion = toExpectedVersion(
-    _optionalChain([options, 'optionalAccess', _67 => _67.expectedStreamVersion])
-  );
-  const messagesToAppend = messages.map(
-    (m, i) => ({
-      ...m,
-      kind: _nullishCoalesce(m.kind, () => ( "Event")),
-      metadata: {
-        streamName,
-        messageId: _uuid.v4.call(void 0, ),
-        streamPosition: BigInt(i + 1),
-        ..."metadata" in m ? _nullishCoalesce(m.metadata, () => ( {})) : {}
-      }
-    })
-  );
-  try {
-    return await connection.withTransaction(
-      async (transaction) => {
-        const result = await appendToStreamRaw(
-          transaction.execute,
-          streamName,
-          streamType,
-          downcastRecordedMessages(
-            messagesToAppend,
-            _optionalChain([options, 'optionalAccess', _68 => _68.schema, 'optionalAccess', _69 => _69.versioning])
-          ),
-          {
-            expectedStreamVersion
-          }
-        );
-        if (_optionalChain([options, 'optionalAccess', _70 => _70.onBeforeCommit]))
-          await options.onBeforeCommit(messagesToAppend, { connection });
-        return { success: true, result };
-      }
-    );
-  } catch (err) {
-    if (isExpectedVersionConflictError(err) || _dumbo.DumboError.isInstanceOf(err, {
-      errorType: _dumbo.UniqueConstraintError.ErrorType
-    }) || _dumbo.DumboError.isInstanceOf(err, {
-      errorType: _dumbo.BatchCommandNoChangesError.ErrorType
-    })) {
-      return { success: false };
-    }
-    throw err;
-  }
-};
-var toExpectedVersion = (expected) => {
-  if (expected === void 0) return null;
-  if (expected === NO_CONCURRENCY_CHECK) return null;
-  if (expected == STREAM_DOES_NOT_EXIST) return null;
-  if (expected == STREAM_EXISTS) return null;
-  return expected;
-};
-var appendToStreamRaw = async (execute, streamId, streamType, messages, options) => {
-  let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _71 => _71.expectedStreamVersion]), () => ( null));
-  const currentStreamVersion = await getLastStreamPosition(
-    execute,
-    streamId,
-    expectedStreamVersion
-  );
-  expectedStreamVersion ??= _nullishCoalesce(currentStreamVersion, () => ( 0n));
-  if (expectedStreamVersion !== currentStreamVersion) {
-    throw new ExpectedVersionConflictError(
-      currentStreamVersion,
-      expectedStreamVersion
-    );
-  }
-  const streamSQL = expectedStreamVersion === 0n ? _dumbo.SQL`INSERT INTO ${identifier(streamsTable.name)}
+const expectPongoDocuments = { fromCollection: (collectionName) => {
+	return {
+		withId: (id) => {
+			return {
+				toBeEqual: (document) => documentExists(document, {
+					withId: id,
+					inCollection: collectionName
+				}),
+				toExist: () => documentMatchingExists({
+					withId: id,
+					inCollection: collectionName
+				}),
+				notToExist: () => documentDoesNotExist({
+					withId: id,
+					inCollection: collectionName
+				})
+			};
+		},
+		matching: (filter) => {
+			return {
+				toBeTheSame: (documents) => documentsAreTheSame(documents, {
+					matchingFilter: filter,
+					inCollection: collectionName
+				}),
+				toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
+					matchingFilter: filter,
+					inCollection: collectionName
+				}),
+				toExist: () => documentMatchingExists({
+					matchingFilter: filter,
+					inCollection: collectionName
+				}),
+				notToExist: () => documentDoesNotExist({
+					matchingFilter: filter,
+					inCollection: collectionName
+				})
+			};
+		}
+	};
+} };
+
+//#endregion
+//#region src/eventStore/projections/sqliteProjection.ts
+const handleProjections = async (options) => {
+	const { projections: allProjections, events, connection, execute, driverType } = options;
+	const eventTypes = events.map((e) => e.type);
+	for (const projection of allProjections) {
+		if (!projection.canHandle.some((type) => eventTypes.includes(type))) continue;
+		await projection.handle(events, {
+			connection,
+			execute,
+			driverType
+		});
+	}
+};
+const sqliteProjection = (definition) => (0, _event_driven_io_emmett.projection)(definition);
+const sqliteRawBatchSQLProjection = (options) => sqliteProjection({
+	name: options.name,
+	kind: options.kind ?? "emt:projections:sqlite:raw_sql:batch",
+	version: options.version,
+	canHandle: options.canHandle,
+	eventsOptions: options.eventsOptions,
+	handle: async (events, context) => {
+		const sqls = await options.evolve(events, context);
+		await context.execute.batchCommand(sqls);
+	},
+	init: async (initOptions) => {
+		const initSQL = options.init ? await options.init(initOptions) : void 0;
+		if (initSQL) if (Array.isArray(initSQL)) await initOptions.context.execute.batchCommand(initSQL);
+		else await initOptions.context.execute.command(initSQL);
+	}
+});
+const sqliteRawSQLProjection = (options) => {
+	const { evolve, kind, ...rest } = options;
+	return sqliteRawBatchSQLProjection({
+		kind: kind ?? "emt:projections:sqlite:raw:_sql:single",
+		...rest,
+		evolve: async (events, context) => {
+			const sqls = [];
+			for (const event of events) {
+				const pendingSqls = await evolve(event, context);
+				if (Array.isArray(pendingSqls)) sqls.push(...pendingSqls);
+				else sqls.push(pendingSqls);
+			}
+			return sqls;
+		}
+	});
+};
+
+//#endregion
+//#region src/eventStore/projections/sqliteProjectionSpec.ts
+const SQLiteProjectionSpec = { for: (options) => {
+	{
+		const driverType = options.driver.driverType;
+		const pool = options.pool ?? (0, _event_driven_io_dumbo.dumbo)({
+			serialization: options.serialization,
+			transactionOptions: {
+				allowNestedTransactions: true,
+				mode: "session_based"
+			},
+			...options.driver.mapToDumboOptions(options)
+		});
+		const projection = options.projection;
+		let wasInitialized = false;
+		return (givenEvents) => {
+			return { when: (events, options) => {
+				const allEvents = [];
+				const run = async (connection) => {
+					let globalPosition = 0n;
+					const numberOfTimes = options?.numberOfTimes ?? 1;
+					for (const event of [...givenEvents, ...Array.from({ length: numberOfTimes }).flatMap(() => events)]) {
+						const metadata = {
+							checkpoint: (0, _event_driven_io_emmett.bigIntProcessorCheckpoint)(++globalPosition),
+							globalPosition,
+							streamPosition: globalPosition,
+							streamName: `test-${(0, uuid.v4)()}`,
+							messageId: (0, uuid.v4)()
+						};
+						allEvents.push({
+							...event,
+							kind: "Event",
+							metadata: {
+								...metadata,
+								..."metadata" in event ? event.metadata ?? {} : {}
+							}
+						});
+					}
+					if (!wasInitialized && projection.init) {
+						await projection.init({
+							registrationType: "async",
+							status: "active",
+							context: {
+								execute: connection.execute,
+								connection,
+								driverType
+							},
+							version: projection.version ?? 1
+						});
+						wasInitialized = true;
+					}
+					await connection.withTransaction(() => handleProjections({
+						events: allEvents,
+						projections: [projection],
+						execute: connection.execute,
+						connection,
+						driverType
+					}));
+				};
+				return {
+					then: (assert, message) => pool.withConnection(async (connection) => {
+						await run(connection);
+						const succeeded = await assert({ connection });
+						if (succeeded !== void 0 && succeeded === false) (0, _event_driven_io_emmett.assertFails)(message ?? "Projection specification didn't match the criteria");
+					}),
+					thenThrows: (...args) => pool.withConnection(async (connection) => {
+						try {
+							await run(connection);
+							throw new _event_driven_io_emmett.AssertionError("Handler did not fail as expected");
+						} catch (error) {
+							if (error instanceof _event_driven_io_emmett.AssertionError) throw error;
+							if (args.length === 0) return;
+							if (!(0, _event_driven_io_emmett.isErrorConstructor)(args[0])) {
+								(0, _event_driven_io_emmett.assertTrue)(args[0](error), `Error didn't match the error condition: ${error?.toString()}`);
+								return;
+							}
+							(0, _event_driven_io_emmett.assertTrue)(error instanceof args[0], `Caught error is not an instance of the expected type: ${error?.toString()}`);
+							if (args[1]) (0, _event_driven_io_emmett.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;
+const assertSQLQueryResultMatches = (sql, rows) => async ({ connection }) => {
+	const result = await connection.execute.query(sql);
+	(0, _event_driven_io_emmett.assertThatArray)(rows).containsExactlyInAnyOrder(result.rows);
+};
+const expectSQL = { query: (sql) => ({ resultRows: { toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows) } }) };
+
+//#endregion
+//#region src/eventStore/schema/typing.ts
+const emmettPrefix = "emt";
+const globalTag = "global";
+const defaultTag = `${"emt"}:default`;
+const unknownTag = `${"emt"}:unknown`;
+const globalNames = { module: `${"emt"}:module:${globalTag}` };
+const columns = {
+	partition: { name: "partition" },
+	isArchived: { name: "is_archived" }
+};
+const streamsTable = {
+	name: `${"emt"}_streams`,
+	columns: {
+		partition: columns.partition,
+		isArchived: columns.isArchived
+	}
+};
+const messagesTable = {
+	name: `${"emt"}_messages`,
+	columns: {
+		partition: columns.partition,
+		isArchived: columns.isArchived
+	}
+};
+const processorsTable = { name: `${"emt"}_processors` };
+const projectionsTable = { name: `${"emt"}_projections` };
+
+//#endregion
+//#region src/eventStore/schema/appendToStream.ts
+const { identifier: identifier$7, merge } = _event_driven_io_dumbo.SQL;
+const appendToStream = async (connection, streamName, streamType, messages, options) => {
+	if (messages.length === 0) return { success: false };
+	const expectedStreamVersion = toExpectedVersion(options?.expectedStreamVersion);
+	const messagesToAppend = messages.map((m, i) => ({
+		...m,
+		kind: m.kind ?? "Event",
+		metadata: {
+			streamName,
+			messageId: (0, uuid.v4)(),
+			streamPosition: BigInt(i + 1),
+			..."metadata" in m ? m.metadata ?? {} : {}
+		}
+	}));
+	try {
+		return await connection.withTransaction(async (transaction) => {
+			const result = await appendToStreamRaw(transaction.execute, streamName, streamType, (0, _event_driven_io_emmett.downcastRecordedMessages)(messagesToAppend, options?.schema?.versioning), { expectedStreamVersion });
+			if (options?.onBeforeCommit) await options.onBeforeCommit(messagesToAppend, { connection });
+			return {
+				success: true,
+				result
+			};
+		});
+	} catch (err) {
+		if ((0, _event_driven_io_emmett.isExpectedVersionConflictError)(err) || _event_driven_io_dumbo.DumboError.isInstanceOf(err, { errorType: _event_driven_io_dumbo.UniqueConstraintError.ErrorType }) || _event_driven_io_dumbo.DumboError.isInstanceOf(err, { errorType: _event_driven_io_dumbo.BatchCommandNoChangesError.ErrorType })) return { success: false };
+		throw err;
+	}
+};
+const toExpectedVersion = (expected) => {
+	if (expected === void 0) return null;
+	if (expected === _event_driven_io_emmett.NO_CONCURRENCY_CHECK) return null;
+	if (expected == _event_driven_io_emmett.STREAM_DOES_NOT_EXIST) return null;
+	if (expected == _event_driven_io_emmett.STREAM_EXISTS) return null;
+	return expected;
+};
+const appendToStreamRaw = async (execute, streamId, streamType, messages, options) => {
+	let expectedStreamVersion = options?.expectedStreamVersion ?? null;
+	const currentStreamVersion = await getLastStreamPosition(execute, streamId, expectedStreamVersion);
+	expectedStreamVersion ??= currentStreamVersion ?? 0n;
+	if (expectedStreamVersion !== currentStreamVersion) throw new _event_driven_io_emmett.ExpectedVersionConflictError(currentStreamVersion, expectedStreamVersion);
+	const streamSQL = expectedStreamVersion === 0n ? _event_driven_io_dumbo.SQL`INSERT INTO ${identifier$7(streamsTable.name)}
             (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
             VALUES  (
                 ${streamId},
                 ${messages.length},
-                ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _72 => _72.partition]), () => ( streamsTable.columns.partition))},
+                ${options?.partition ?? streamsTable.columns.partition},
                 ${streamType},
                 '[]',
                 false
             )
             RETURNING stream_position;
-          ` : _dumbo.SQL`UPDATE ${identifier(streamsTable.name)}
+          ` : _event_driven_io_dumbo.SQL`UPDATE ${identifier$7(streamsTable.name)}
             SET stream_position = stream_position + ${messages.length}
             WHERE stream_id = ${streamId}
             AND stream_position = ${expectedStreamVersion}
-            AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _73 => _73.partition]), () => ( streamsTable.columns.partition))}
+            AND partition = ${options?.partition ?? streamsTable.columns.partition}
             AND is_archived = false
             RETURNING stream_position;
           `;
-  const insertSQL = buildMessageInsertQuery(
-    messages,
-    expectedStreamVersion,
-    streamId,
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _74 => _74.partition, 'optionalAccess', _75 => _75.toString, 'call', _76 => _76()]), () => ( defaultTag2))
-  );
-  const results = await execute.batchCommand([streamSQL, insertSQL], { assertChanges: true });
-  const [streamResult, messagesResult] = results;
-  const streamPosition = _optionalChain([streamResult, 'optionalAccess', _77 => _77.rows, 'access', _78 => _78[0], 'optionalAccess', _79 => _79.stream_position]);
-  const globalPosition = _optionalChain([messagesResult, 'optionalAccess', _80 => _80.rows, 'access', _81 => _81.at, 'call', _82 => _82(-1), 'optionalAccess', _83 => _83.global_position]);
-  if (!streamPosition)
-    throw new ExpectedVersionConflictError(0n, _nullishCoalesce(expectedStreamVersion, () => ( 0n)));
-  if (!globalPosition) throw new Error("Could not find global position");
-  return {
-    success: true,
-    nextStreamPosition: BigInt(streamPosition),
-    lastGlobalPosition: BigInt(globalPosition)
-  };
+	const insertSQL = buildMessageInsertQuery(messages, expectedStreamVersion, streamId, options?.partition?.toString() ?? defaultTag);
+	const [streamResult, messagesResult] = await execute.batchCommand([streamSQL, insertSQL], { assertChanges: true });
+	const streamPosition = streamResult?.rows[0]?.stream_position;
+	const globalPosition = messagesResult?.rows.at(-1)?.global_position;
+	if (!streamPosition) throw new _event_driven_io_emmett.ExpectedVersionConflictError(0n, expectedStreamVersion ?? 0n);
+	if (!globalPosition) throw new Error("Could not find global position");
+	return {
+		success: true,
+		nextStreamPosition: BigInt(streamPosition),
+		lastGlobalPosition: BigInt(globalPosition)
+	};
 };
 async function getLastStreamPosition(execute, streamId, expectedStreamVersion) {
-  const result = await _dumbo.singleOrNull.call(void 0, 
-    execute.query(
-      _dumbo.SQL`SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${identifier(streamsTable.name)} WHERE stream_id = ${streamId}`
-    )
-  );
-  if (_optionalChain([result, 'optionalAccess', _84 => _84.stream_position]) == null) {
-    expectedStreamVersion = 0n;
-  } else {
-    expectedStreamVersion = BigInt(result.stream_position);
-  }
-  return expectedStreamVersion;
+	const result = await (0, _event_driven_io_dumbo.singleOrNull)(execute.query(_event_driven_io_dumbo.SQL`SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${identifier$7(streamsTable.name)} WHERE stream_id = ${streamId}`));
+	if (result?.stream_position == null) expectedStreamVersion = 0n;
+	else expectedStreamVersion = BigInt(result.stream_position);
+	return expectedStreamVersion;
 }
-var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
-  const values = messages.map((message) => {
-    if (_optionalChain([message, 'access', _85 => _85.metadata, 'optionalAccess', _86 => _86.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
-      throw new Error("Stream position is required");
-    }
-    const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
-    return _dumbo.SQL`(${streamId},${_nullishCoalesce(streamPosition, () => ( 0n))},${_nullishCoalesce(partition, () => ( defaultTag2))},${message.kind === "Event" ? "E" : "C"},${message.data},${message.metadata},${_nullishCoalesce(expectedStreamVersion, () => ( 0n))},${message.type},${message.metadata.messageId},${false})`;
-  });
-  return _dumbo.SQL`
-      INSERT INTO ${identifier(messagesTable.name)} (
+const buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
+	const values = messages.map((message) => {
+		if (message.metadata?.streamPosition == null || typeof message.metadata.streamPosition !== "bigint") throw new Error("Stream position is required");
+		return _event_driven_io_dumbo.SQL`(${streamId},${BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion) ?? 0n},${partition ?? defaultTag},${message.kind === "Event" ? "E" : "C"},${message.data},${message.metadata},${expectedStreamVersion ?? 0n},${message.type},${message.metadata.messageId},${false})`;
+	});
+	return _event_driven_io_dumbo.SQL`
+      INSERT INTO ${identifier$7(messagesTable.name)} (
           stream_id, 
           stream_position, 
           partition, 
@@ -1775,10 +483,10 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
     `;
 };
 
-// src/eventStore/schema/migrations/0_41_0/0_41_0.snapshot.ts
-
-var schema_0_41_0 = [
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_streams(
+//#endregion
+//#region src/eventStore/schema/migrations/0_41_0/0_41_0.snapshot.ts
+const schema_0_41_0 = [
+	_event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_streams(
     stream_id         TEXT                      NOT NULL,
     stream_position   BIGINT                    NOT NULL DEFAULT 0,
     partition         TEXT                      NOT NULL DEFAULT 'global',
@@ -1788,7 +496,7 @@ var schema_0_41_0 = [
     PRIMARY KEY (stream_id, partition, is_archived),
     UNIQUE (stream_id, partition, is_archived)
 )`,
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_messages(
+	_event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_messages(
     stream_id              TEXT                      NOT NULL,
     stream_position        BIGINT                    NOT NULL,
     partition              TEXT                      NOT NULL DEFAULT 'global',
@@ -1803,7 +511,7 @@ var schema_0_41_0 = [
     created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
     UNIQUE (stream_id, stream_position, partition, is_archived)
 )`,
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_subscriptions(
+	_event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_subscriptions(
     subscription_id                 TEXT                   NOT NULL,
     version                         INTEGER                NOT NULL DEFAULT 1,
     partition                       TEXT                   NOT NULL DEFAULT 'global',
@@ -1812,30 +520,30 @@ var schema_0_41_0 = [
 )`
 ];
 
-// src/eventStore/schema/migrations/0_42_0/0_42_0.migration.ts
-
-var { identifier: identifier2, plain } = _dumbo.SQL;
-var migration_0_42_0_SQLs = [
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier2(processorsTable.name)}(
+//#endregion
+//#region src/eventStore/schema/migrations/0_42_0/0_42_0.migration.ts
+const { identifier: identifier$6, plain: plain$1 } = _event_driven_io_dumbo.SQL;
+const migration_0_42_0_SQLs = [
+	_event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier$6(processorsTable.name)}(
     processor_id                 TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
-    partition                    TEXT                  NOT NULL DEFAULT '${plain(globalTag)}',
+    partition                    TEXT                  NOT NULL DEFAULT '${plain$1(globalTag)}',
     status                       TEXT                  NOT NULL DEFAULT 'stopped',
     last_processed_checkpoint    TEXT                  NOT NULL,
     processor_instance_id        TEXT                  DEFAULT 'emt:unknown',
     PRIMARY KEY (processor_id, partition, version)
 )`,
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier2(projectionsTable.name)}(
+	_event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier$6(projectionsTable.name)}(
     name                         TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
-    partition                    TEXT                  NOT NULL DEFAULT '${plain(globalTag)}',
+    partition                    TEXT                  NOT NULL DEFAULT '${plain$1(globalTag)}',
     type                         CHAR(1)               NOT NULL,
     kind                         TEXT                  NOT NULL,
     status                       TEXT                  NOT NULL,
     definition                   JSONB                 NOT NULL DEFAULT '{}',
     PRIMARY KEY (name, partition, version)
 )`,
-  _dumbo.SQL`INSERT INTO ${identifier2(processorsTable.name)}
+	_event_driven_io_dumbo.SQL`INSERT INTO ${identifier$6(processorsTable.name)}
     (processor_id, version, partition, status, last_processed_checkpoint, processor_instance_id)
   SELECT
     subscription_id,
@@ -1845,24 +553,17 @@ var migration_0_42_0_SQLs = [
     printf('%019d', last_processed_position),
     'emt:unknown'
   FROM emt_subscriptions`,
-  _dumbo.SQL`DROP TABLE emt_subscriptions`
+	_event_driven_io_dumbo.SQL`DROP TABLE emt_subscriptions`
 ];
-var migration_0_42_0_FromSubscriptionsToProcessors = async (execute) => {
-  const tableExists = await _dumbo.singleOrNull.call(void 0, 
-    execute.query(
-      _dumbo.SQL`SELECT name FROM sqlite_master WHERE type='table' AND name='emt_subscriptions'`
-    )
-  );
-  if (!tableExists) {
-    return;
-  }
-  await execute.batchCommand(migration_0_42_0_SQLs);
+const migration_0_42_0_FromSubscriptionsToProcessors = async (execute) => {
+	if (!await (0, _event_driven_io_dumbo.singleOrNull)(execute.query(_event_driven_io_dumbo.SQL`SELECT name FROM sqlite_master WHERE type='table' AND name='emt_subscriptions'`))) return;
+	await execute.batchCommand(migration_0_42_0_SQLs);
 };
 
-// src/eventStore/schema/migrations/0_42_0/0_42_0.snapshot.ts
-
-var schema_0_42_0 = [
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_streams(
+//#endregion
+//#region src/eventStore/schema/migrations/0_42_0/0_42_0.snapshot.ts
+const schema_0_42_0 = [
+	_event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_streams(
     stream_id         TEXT                      NOT NULL,
     stream_position   BIGINT                    NOT NULL DEFAULT 0,
     partition         TEXT                      NOT NULL DEFAULT 'global',
@@ -1872,7 +573,7 @@ var schema_0_42_0 = [
     PRIMARY KEY (stream_id, partition, is_archived),
     UNIQUE (stream_id, partition, is_archived)
 )`,
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_messages(
+	_event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_messages(
     stream_id              TEXT                      NOT NULL,
     stream_position        BIGINT                    NOT NULL,
     partition              TEXT                      NOT NULL DEFAULT 'global',
@@ -1887,7 +588,7 @@ var schema_0_42_0 = [
     created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
     UNIQUE (stream_id, stream_position, partition, is_archived)
 )`,
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_processors(
+	_event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_processors(
     processor_id                 TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT 'global',
@@ -1896,7 +597,7 @@ var schema_0_42_0 = [
     processor_instance_id        TEXT                  DEFAULT 'emt:unknown',
     PRIMARY KEY (processor_id, partition, version)
 )`,
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_projections(
+	_event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS emt_projections(
     name                         TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT 'global',
@@ -1908,801 +609,657 @@ var schema_0_42_0 = [
 )`
 ];
 
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-
-var { identifier: identifier3 } = _dumbo.SQL;
-var readLastMessageGlobalPosition = async (execute, options) => {
-  const result = await _dumbo.singleOrNull.call(void 0, 
-    execute.query(
-      _dumbo.SQL`
+//#endregion
+//#region src/eventStore/schema/readLastMessageGlobalPosition.ts
+const { identifier: identifier$5 } = _event_driven_io_dumbo.SQL;
+const readLastMessageGlobalPosition = async (execute, options) => {
+	const result = await (0, _event_driven_io_dumbo.singleOrNull)(execute.query(_event_driven_io_dumbo.SQL`
          SELECT global_position
-         FROM ${identifier3(messagesTable.name)}
-         WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _87 => _87.partition]), () => ( defaultTag2))} AND is_archived = FALSE
-         ORDER BY global_position
-         LIMIT 1`
-    )
-  );
-  return {
-    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
-  };
-};
-
-// src/eventStore/schema/readMessagesBatch.ts
-
-var { identifier: identifier4 } = _dumbo.SQL;
-var readMessagesBatch = async (execute, options) => {
-  const { serializer } = options;
-  const from = "from" in options ? options.from : void 0;
-  const after = "after" in options ? options.after : void 0;
-  const batchSize = "batchSize" in options ? options.batchSize : options.to - options.from;
-  const fromCondition = from !== void 0 ? _dumbo.SQL`AND global_position >= ${from}` : after !== void 0 ? _dumbo.SQL`AND global_position > ${after}` : _dumbo.SQL.EMPTY;
-  const toCondition = "to" in options ? _dumbo.SQL`AND global_position <= ${options.to}` : _dumbo.SQL.EMPTY;
-  const limitCondition = "batchSize" in options ? _dumbo.SQL`LIMIT ${options.batchSize}` : _dumbo.SQL.EMPTY;
-  const messages = await _dumbo.mapRows.call(void 0, 
-    execute.query(
-      _dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-           FROM ${identifier4(messagesTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _88 => _88.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
+         FROM ${identifier$5(messagesTable.name)}
+         WHERE partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE
+         ORDER BY global_position DESC
+         LIMIT 1`));
+	return { currentGlobalPosition: result !== null ? BigInt(result.global_position) : null };
+};
+
+//#endregion
+//#region src/eventStore/schema/readMessagesBatch.ts
+const { identifier: identifier$4 } = _event_driven_io_dumbo.SQL;
+const readMessagesBatch = async (execute, options) => {
+	const { serializer } = options;
+	const from = "from" in options ? options.from : void 0;
+	const after = "after" in options ? options.after : void 0;
+	const batchSize = "batchSize" in options ? options.batchSize : options.to - options.from;
+	const fromCondition = from !== void 0 ? _event_driven_io_dumbo.SQL`AND global_position >= ${from}` : after !== void 0 ? _event_driven_io_dumbo.SQL`AND global_position > ${after}` : _event_driven_io_dumbo.SQL.EMPTY;
+	const toCondition = "to" in options ? _event_driven_io_dumbo.SQL`AND global_position <= ${options.to}` : _event_driven_io_dumbo.SQL.EMPTY;
+	const limitCondition = "batchSize" in options ? _event_driven_io_dumbo.SQL`LIMIT ${options.batchSize}` : _event_driven_io_dumbo.SQL.EMPTY;
+	const messages = await (0, _event_driven_io_dumbo.mapRows)(execute.query(_event_driven_io_dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+           FROM ${identifier$4(messagesTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE ${fromCondition} ${toCondition}
            ORDER BY global_position
-           ${limitCondition}`
-    ),
-    (row) => {
-      const rawEvent = {
-        type: row.message_type,
-        data: serializer.deserialize(row.message_data),
-        metadata: serializer.deserialize(row.message_metadata)
-      };
-      const metadata = {
-        ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
-        messageId: row.message_id,
-        streamName: row.stream_id,
-        streamPosition: BigInt(row.stream_position),
-        globalPosition: BigInt(row.global_position),
-        checkpoint: bigIntProcessorCheckpoint(BigInt(row.global_position))
-      };
-      return {
-        ...rawEvent,
-        kind: "Event",
-        metadata
-      };
-    }
-  );
-  return messages.length > 0 ? {
-    currentGlobalPosition: messages[messages.length - 1].metadata.globalPosition,
-    messages,
-    areMessagesLeft: messages.length === batchSize
-  } : {
-    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
-    messages: [],
-    areMessagesLeft: false
-  };
-};
-
-// src/eventStore/schema/readProcessorCheckpoint.ts
-
-var { identifier: identifier5 } = _dumbo.SQL;
-var readProcessorCheckpoint = async (execute, options) => {
-  const result = await _dumbo.singleOrNull.call(void 0, 
-    execute.query(
-      _dumbo.SQL`SELECT last_processed_checkpoint
-           FROM ${identifier5(processorsTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _89 => _89.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId}
-           LIMIT 1`
-    )
-  );
-  return {
-    lastProcessedCheckpoint: result !== null ? result.last_processed_checkpoint : null
-  };
-};
-
-// src/eventStore/schema/readStream.ts
-
-
-// src/eventStore/SQLiteEventStore.ts
-
-
-// src/eventStore/consumers/messageBatchProcessing/index.ts
-var DefaultSQLiteEventStoreProcessorBatchSize = 100;
-var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
-var sqliteEventStoreMessageBatchPuller = ({
-  executor,
-  batchSize,
-  eachBatch,
-  pullingFrequencyInMs,
-  stopWhen,
-  signal,
-  serialization
-}) => {
-  let isRunning = false;
-  let start;
-  const serializer = JSONSerializer.from({ serialization });
-  const pullMessages = async (options) => {
-    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? await _asyncNullishCoalesce((await readLastMessageGlobalPosition(executor)).currentGlobalPosition, async () => ( 0n)) : parseBigIntProcessorCheckpoint(options.startFrom.lastCheckpoint);
-    const readMessagesOptions = {
-      after,
-      batchSize,
-      serializer
-    };
-    let waitTime = 100;
-    while (isRunning && !_optionalChain([signal, 'optionalAccess', _90 => _90.aborted])) {
-      const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
-      if (messages.length > 0) {
-        const result = await eachBatch(messages);
-        if (result && result.type === "STOP") {
-          isRunning = false;
-          break;
-        }
-      }
-      readMessagesOptions.after = currentGlobalPosition;
-      await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (_optionalChain([stopWhen, 'optionalAccess', _91 => _91.noMessagesLeft]) === true && !areMessagesLeft) {
-        isRunning = false;
-        break;
-      }
-      if (!areMessagesLeft) {
-        waitTime = Math.min(waitTime * 2, 1e3);
-      } else {
-        waitTime = pullingFrequencyInMs;
-      }
-    }
-  };
-  return {
-    get isRunning() {
-      return isRunning;
-    },
-    start: (options) => {
-      if (isRunning) return start;
-      isRunning = true;
-      start = (async () => {
-        return pullMessages(options);
-      })();
-      return start;
-    },
-    stop: async () => {
-      if (!isRunning) return;
-      isRunning = false;
-      await start;
-    }
-  };
-};
-var zipSQLiteEventStoreMessageBatchPullerStartFrom = (options) => {
-  if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING"))
-    return "BEGINNING";
-  if (options.every((o) => o === "END")) return "END";
-  return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
-};
-
-// src/eventStore/consumers/sqliteEventStoreConsumer.ts
-
-
-
-// src/eventStore/consumers/sqliteCheckpointer.ts
-var sqliteCheckpointer = () => ({
-  read: async (options, context) => {
-    const result = await readProcessorCheckpoint(context.execute, options);
-    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _92 => _92.lastProcessedCheckpoint]) };
-  },
-  store: async (options, context) => {
-    const newCheckpoint = getCheckpoint(options.message);
-    const result = await storeProcessorCheckpoint(context.execute, {
-      lastProcessedCheckpoint: options.lastCheckpoint,
-      newCheckpoint,
-      processorId: options.processorId,
-      partition: options.partition,
-      version: options.version
-    });
-    return result.success ? { success: true, newCheckpoint: result.newCheckpoint } : result;
-  }
+           ${limitCondition}`), (row) => {
+		const rawEvent = {
+			type: row.message_type,
+			data: serializer.deserialize(row.message_data),
+			metadata: serializer.deserialize(row.message_metadata)
+		};
+		const metadata = {
+			..."metadata" in rawEvent ? rawEvent.metadata ?? {} : {},
+			messageId: row.message_id,
+			streamName: row.stream_id,
+			streamPosition: BigInt(row.stream_position),
+			globalPosition: BigInt(row.global_position),
+			checkpoint: (0, _event_driven_io_emmett.bigIntProcessorCheckpoint)(BigInt(row.global_position))
+		};
+		return {
+			...rawEvent,
+			kind: "Event",
+			metadata
+		};
+	});
+	return messages.length > 0 ? {
+		currentGlobalPosition: messages[messages.length - 1].metadata.globalPosition,
+		messages,
+		areMessagesLeft: messages.length === batchSize
+	} : {
+		currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
+		messages: [],
+		areMessagesLeft: false
+	};
+};
+
+//#endregion
+//#region src/eventStore/schema/readProcessorCheckpoint.ts
+const { identifier: identifier$3 } = _event_driven_io_dumbo.SQL;
+const readProcessorCheckpoint = async (execute, options) => {
+	const result = await (0, _event_driven_io_dumbo.singleOrNull)(execute.query(_event_driven_io_dumbo.SQL`SELECT last_processed_checkpoint
+           FROM ${identifier$3(processorsTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag} AND processor_id = ${options.processorId}
+           LIMIT 1`));
+	return { lastProcessedCheckpoint: result !== null ? result.last_processed_checkpoint : null };
+};
+
+//#endregion
+//#region src/eventStore/consumers/messageBatchProcessing/index.ts
+const sqliteEventStoreMessageBatchPuller = ({ executor, batchSize, eachBatch, pullingFrequencyInMs, stopWhen, signal, serialization }) => {
+	let isRunning = false;
+	let start;
+	const serializer = _event_driven_io_emmett.JSONSerializer.from({ serialization });
+	const pullMessages = async (options) => {
+		let after;
+		try {
+			after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 0n : (0, _event_driven_io_emmett.parseBigIntProcessorCheckpoint)(options.startFrom.lastCheckpoint);
+		} catch (error) {
+			options.started?.reject(error);
+			throw error;
+		}
+		options.started?.resolve();
+		const readMessagesOptions = {
+			after,
+			batchSize,
+			serializer
+		};
+		let waitTime = 100;
+		while (isRunning && !signal?.aborted) {
+			const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
+			if (messages.length > 0) {
+				const result = await eachBatch(messages);
+				if (result && result.type === "STOP") {
+					isRunning = false;
+					break;
+				}
+			}
+			readMessagesOptions.after = currentGlobalPosition;
+			await new Promise((resolve) => setTimeout(resolve, waitTime));
+			if (stopWhen?.noMessagesLeft === true && !areMessagesLeft) {
+				isRunning = false;
+				break;
+			}
+			if (!areMessagesLeft) waitTime = Math.min(waitTime * 2, 1e3);
+			else waitTime = pullingFrequencyInMs;
+		}
+	};
+	return {
+		get isRunning() {
+			return isRunning;
+		},
+		start: (options) => {
+			if (isRunning) return start;
+			isRunning = true;
+			start = (async () => {
+				return pullMessages(options);
+			})();
+			return start;
+		},
+		stop: async () => {
+			if (!isRunning) return;
+			isRunning = false;
+			await start;
+		}
+	};
+};
+const zipSQLiteEventStoreMessageBatchPullerStartFrom = (options) => {
+	if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING")) return "BEGINNING";
+	if (options.every((o) => o === "END")) return "END";
+	return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
+};
+
+//#endregion
+//#region src/eventStore/consumers/sqliteCheckpointer.ts
+const sqliteCheckpointer = () => ({
+	read: async (options, context) => {
+		return { lastCheckpoint: (await readProcessorCheckpoint(context.execute, options))?.lastProcessedCheckpoint };
+	},
+	store: async (options, context) => {
+		const newCheckpoint = (0, _event_driven_io_emmett.getCheckpoint)(options.message);
+		const result = await storeProcessorCheckpoint(context.execute, {
+			lastProcessedCheckpoint: options.lastCheckpoint,
+			newCheckpoint,
+			processorId: options.processorId,
+			partition: options.partition,
+			version: options.version
+		});
+		return result.success ? {
+			success: true,
+			newCheckpoint: result.newCheckpoint
+		} : result;
+	}
 });
 
-// src/eventStore/consumers/sqliteProcessor.ts
-var sqliteProcessingScope = () => {
-  const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _93 => _93.connection]);
-    if (!connection)
-      throw new EmmettError("Connection is required in context or options");
-    return connection.withTransaction(
-      async (transaction) => {
-        return handler({
-          ...partialContext,
-          connection,
-          execute: transaction.execute
-        });
-      }
-    );
-  };
-  return processingScope;
-};
-var sqliteWorkflowProcessingScope = (messageStore) => {
-  const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _94 => _94.connection]);
-    if (!connection)
-      throw new EmmettError("Connection is required in context or options");
-    return connection.withTransaction(
-      async (transaction) => {
-        return handler({
-          ...partialContext,
-          connection: Object.assign(connection, { messageStore }),
-          execute: transaction.execute
-        });
-      }
-    );
-  };
-  return processingScope;
-};
-var sqliteWorkflowProcessor = (options) => {
-  const {
-    processorId = _nullishCoalesce(options.processorId, () => ( getWorkflowId({
-      workflowName: _nullishCoalesce(options.workflow.name, () => ( "unknown"))
-    }))),
-    processorInstanceId = getProcessorInstanceId(processorId),
-    version = defaultProcessorVersion,
-    partition = defaultProcessorPartition
-  } = options;
-  const hooks = {
-    ..._nullishCoalesce(options.hooks, () => ( {})),
-    onClose: _optionalChain([options, 'access', _95 => _95.hooks, 'optionalAccess', _96 => _96.onClose])
-  };
-  return workflowProcessor({
-    ...options,
-    processorId,
-    processorInstanceId,
-    version,
-    partition,
-    hooks,
-    processingScope: sqliteWorkflowProcessingScope(
-      options.messageStore
-    ),
-    checkpoints: sqliteCheckpointer()
-  });
-};
-var sqliteReactor = (options) => {
-  const {
-    processorId = options.processorId,
-    processorInstanceId = getProcessorInstanceId(processorId),
-    version = defaultProcessorVersion,
-    partition = defaultProcessorPartition,
-    hooks
-  } = options;
-  return reactor({
-    ...options,
-    processorId,
-    processorInstanceId,
-    version,
-    partition,
-    hooks,
-    processingScope: sqliteProcessingScope(),
-    checkpoints: sqliteCheckpointer()
-  });
-};
-var sqliteProjector = (options) => {
-  const {
-    processorId = getProjectorId({
-      projectionName: _nullishCoalesce(options.projection.name, () => ( "unknown"))
-    }),
-    processorInstanceId = getProcessorInstanceId(processorId),
-    version = defaultProcessorVersion,
-    partition = defaultProcessorPartition
-  } = options;
-  const hooks = {
-    ..._nullishCoalesce(options.hooks, () => ( {})),
-    onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _97 => _97.hooks, 'optionalAccess', _98 => _98.onInit]) ? async (context) => {
-      if (options.projection.init)
-        await options.projection.init({
-          version: _nullishCoalesce(options.projection.version, () => ( version)),
-          status: "active",
-          registrationType: "async",
-          context: {
-            ...context,
-            migrationOptions: options.migrationOptions
-          }
-        });
-      if (_optionalChain([options, 'access', _99 => _99.hooks, 'optionalAccess', _100 => _100.onInit]))
-        await options.hooks.onInit({
-          ...context,
-          migrationOptions: options.migrationOptions
-        });
-    } : _optionalChain([options, 'access', _101 => _101.hooks, 'optionalAccess', _102 => _102.onInit]),
-    onClose: _optionalChain([options, 'access', _103 => _103.hooks, 'optionalAccess', _104 => _104.onClose])
-  };
-  const processor = projector({
-    ...options,
-    processorId,
-    processorInstanceId,
-    version,
-    partition,
-    hooks,
-    processingScope: sqliteProcessingScope(),
-    checkpoints: sqliteCheckpointer()
-  });
-  return processor;
-};
-
-// src/eventStore/consumers/sqliteEventStoreConsumer.ts
-var sqliteEventStoreConsumer = (options) => {
-  let isRunning = false;
-  let isInitialized = false;
-  const { pulling } = options;
-  const processors = _nullishCoalesce(options.processors, () => ( []));
-  let abortController = null;
-  let start;
-  let messagePuller;
-  const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
-    serialization: options.serialization,
-    transactionOptions: {
-      allowNestedTransactions: true,
-      mode: "session_based"
-    },
-    ...options.driver.mapToDumboOptions(options)
-  })));
-  const eachBatch = (messagesBatch) => pool.withConnection(async (connection) => {
-    const activeProcessors = processors.filter((s) => s.isActive);
-    if (activeProcessors.length === 0)
-      return {
-        type: "STOP",
-        reason: "No active processors"
-      };
-    const result = await Promise.allSettled(
-      activeProcessors.map(async (s) => {
-        return await s.handle(messagesBatch, {
-          connection,
-          execute: connection.execute
-        });
-      })
-    );
-    return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _105 => _105.value, 'optionalAccess', _106 => _106.type]) !== "STOP"
-    ) ? void 0 : {
-      type: "STOP"
-    };
-  });
-  const processorContext = {
-    execute: void 0,
-    connection: void 0
-  };
-  const stopProcessors = () => Promise.all(processors.map((p) => p.close(processorContext)));
-  const stop = async () => {
-    if (!isRunning) return;
-    isRunning = false;
-    if (messagePuller) {
-      _optionalChain([abortController, 'optionalAccess', _107 => _107.abort, 'call', _108 => _108()]);
-      await messagePuller.stop();
-    }
-    await start;
-    messagePuller = void 0;
-    abortController = null;
-    await stopProcessors();
-  };
-  const init = async () => {
-    if (isInitialized) return;
-    const sqliteProcessors = processors;
-    await pool.withConnection(async (connection) => {
-      for (const processor of sqliteProcessors) {
-        if (processor.init) {
-          await processor.init({
-            ...processorContext,
-            connection,
-            execute: connection.execute
-          });
-        }
-      }
-    });
-    isInitialized = true;
-  };
-  return {
-    consumerId: _nullishCoalesce(options.consumerId, () => ( _uuid.v7.call(void 0, ))),
-    get isRunning() {
-      return isRunning;
-    },
-    processors,
-    init,
-    reactor: (options2) => {
-      const processor = sqliteReactor(options2);
-      processors.push(
-        // TODO: change that
-        processor
-      );
-      return processor;
-    },
-    projector: (options2) => {
-      const processor = sqliteProjector(options2);
-      processors.push(
-        // TODO: change that
-        processor
-      );
-      return processor;
-    },
-    workflowProcessor: (processorOptions) => {
-      const messageStore = getSQLiteEventStore({
-        ...options,
-        pool,
-        schema: { autoMigration: "None" }
-      });
-      const processor = sqliteWorkflowProcessor({
-        ...processorOptions,
-        messageStore
-      });
-      processors.push(
-        // TODO: change that
-        processor
-      );
-      return processor;
-    },
-    start: () => {
-      if (isRunning) return start;
-      if (processors.length === 0)
-        throw new EmmettError(
-          "Cannot start consumer without at least a single processor"
-        );
-      isRunning = true;
-      abortController = new AbortController();
-      messagePuller = sqliteEventStoreMessageBatchPuller({
-        stopWhen: options.stopWhen,
-        executor: pool.execute,
-        eachBatch,
-        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _109 => _109.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
-        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _110 => _110.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs)),
-        signal: abortController.signal
-      });
-      start = (async () => {
-        if (!isRunning) return;
-        if (!isInitialized) {
-          await init();
-        }
-        const startFrom = await pool.withConnection(
-          async (connection) => zipSQLiteEventStoreMessageBatchPullerStartFrom(
-            await Promise.all(
-              processors.map(async (o) => {
-                const result = await o.start({
-                  execute: connection.execute,
-                  connection
-                });
-                return result;
-              })
-            )
-          )
-        );
-        await messagePuller.start({ startFrom });
-        await stopProcessors();
-        isRunning = false;
-      })();
-      return start;
-    },
-    stop,
-    close: async () => {
-      await stop();
-      await pool.close();
-    }
-  };
-};
-
-// src/eventStore/SQLiteEventStore.ts
-var SQLiteEventStoreDefaultStreamVersion = 0n;
-var getSQLiteEventStore = (options) => {
-  let autoGenerateSchema = false;
-  const serializer = JSONSerializer.from(options);
-  const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
-    serialization: options.serialization,
-    transactionOptions: {
-      allowNestedTransactions: true,
-      mode: "session_based"
-    },
-    ...options.driver.mapToDumboOptions(options)
-  })));
-  let migrateSchema = void 0;
-  const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const onBeforeCommitHook = _optionalChain([options, 'access', _111 => _111.hooks, 'optionalAccess', _112 => _112.onBeforeCommit]);
-  if (options) {
-    autoGenerateSchema = _optionalChain([options, 'access', _113 => _113.schema, 'optionalAccess', _114 => _114.autoMigration]) === void 0 || _optionalChain([options, 'access', _115 => _115.schema, 'optionalAccess', _116 => _116.autoMigration]) !== "None";
-  }
-  const migrate = (connection) => {
-    if (!migrateSchema) {
-      migrateSchema = createEventStoreSchema(connection, {
-        onBeforeSchemaCreated: async (context) => {
-          for (const projection2 of inlineProjections) {
-            if (projection2.init) {
-              await projection2.init({
-                version: _nullishCoalesce(projection2.version, () => ( 1)),
-                registrationType: "async",
-                status: "active",
-                context: {
-                  execute: context.connection.execute,
-                  connection: context.connection,
-                  driverType: options.driver.driverType
-                }
-              });
-            }
-          }
-          if (_optionalChain([options, 'access', _117 => _117.hooks, 'optionalAccess', _118 => _118.onBeforeSchemaCreated])) {
-            await options.hooks.onBeforeSchemaCreated(context);
-          }
-        },
-        onAfterSchemaCreated: _optionalChain([options, 'access', _119 => _119.hooks, 'optionalAccess', _120 => _120.onAfterSchemaCreated])
-      });
-    }
-    return migrateSchema;
-  };
-  const ensureSchemaExists = () => {
-    if (!autoGenerateSchema) return Promise.resolve();
-    return pool.withConnection((connection) => migrate(connection));
-  };
-  return {
-    async aggregateStream(streamName, options2) {
-      await ensureSchemaExists();
-      const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _121 => _121.expectedStreamVersion]);
-      let state = initialState();
-      if (typeof streamName !== "string") {
-        throw new Error("Stream name is not string");
-      }
-      const result = await readStream(
-        pool.execute,
-        streamName,
-        { ...read, serializer: _nullishCoalesce(_optionalChain([read, 'optionalAccess', _122 => _122.serialization, 'optionalAccess', _123 => _123.serializer]), () => ( serializer)) }
-      );
-      const currentStreamVersion = result.currentStreamVersion;
-      assertExpectedVersionMatchesCurrent(
-        currentStreamVersion,
-        expectedStreamVersion,
-        SQLiteEventStoreDefaultStreamVersion
-      );
-      for (const event of result.events) {
-        if (!event) continue;
-        state = evolve(state, event);
-      }
-      return {
-        currentStreamVersion,
-        state,
-        streamExists: result.streamExists
-      };
-    },
-    readStream: async (streamName, readOptions) => {
-      await ensureSchemaExists();
-      return readStream(pool.execute, streamName, {
-        ...readOptions,
-        serializer: _nullishCoalesce(_optionalChain([options, 'access', _124 => _124.serialization, 'optionalAccess', _125 => _125.serializer]), () => ( serializer))
-      });
-    },
-    appendToStream: async (streamName, events, appendOptions) => {
-      await ensureSchemaExists();
-      const [firstPart, ...rest] = streamName.split("-");
-      const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag2;
-      const appendResult = await pool.withConnection(
-        (connection) => appendToStream(connection, streamName, streamType, events, {
-          ...appendOptions,
-          onBeforeCommit: async (messages, context) => {
-            if (inlineProjections.length > 0)
-              await handleProjections({
-                projections: inlineProjections,
-                events: messages,
-                execute: context.connection.execute,
-                connection: context.connection,
-                driverType: options.driver.driverType
-              });
-            if (onBeforeCommitHook)
-              await onBeforeCommitHook(messages, context);
-          }
-        }),
-        { readonly: false }
-      );
-      if (!appendResult.success)
-        throw new ExpectedVersionConflictError(
-          -1n,
-          //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([appendOptions, 'optionalAccess', _126 => _126.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
-        );
-      return {
-        nextExpectedStreamVersion: appendResult.nextStreamPosition,
-        lastEventGlobalPosition: appendResult.lastGlobalPosition,
-        createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
-      };
-    },
-    async streamExists(streamName, options2) {
-      await ensureSchemaExists();
-      return streamExists(pool.execute, streamName, options2);
-    },
-    consumer: (consumerOptions) => sqliteEventStoreConsumer({
-      ..._nullishCoalesce(options, () => ( {})),
-      ..._nullishCoalesce(consumerOptions, () => ( {})),
-      pool
-    }),
-    async withSession(callback) {
-      return await pool.withConnection(async (connection) => {
-        const sessionStore = getSQLiteEventStore({
-          ...options,
-          pool: _dumbo.dumbo.call(void 0, {
-            ...options.driver.mapToDumboOptions(options),
-            connection,
-            serialization: options.serialization
-          }),
-          transactionOptions: {
-            allowNestedTransactions: true,
-            mode: "session_based"
-          },
-          schema: {
-            ...options.schema,
-            autoMigration: "None"
-          },
-          serialization: options.serialization
-        });
-        await ensureSchemaExists();
-        return callback({
-          eventStore: sessionStore,
-          close: () => Promise.resolve()
-        });
-      });
-    },
-    close: () => pool.close(),
-    schema: {
-      sql: () => schemaSQL.join(""),
-      print: () => console.log(schemaSQL.join("")),
-      migrate: () => pool.withConnection(migrate)
-    }
-  };
-};
-
-// src/eventStore/schema/readStream.ts
-var { identifier: identifier6 } = _dumbo.SQL;
-var readStream = async (execute, streamId, options) => {
-  const { serializer } = options;
-  const fromCondition = options.from ? _dumbo.SQL`AND stream_position >= ${options.from}` : _dumbo.SQL.EMPTY;
-  const to = Number(
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _127 => _127.to]), () => ( (_optionalChain([options, 'optionalAccess', _128 => _128.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
-  );
-  const toCondition = !isNaN(to) ? _dumbo.SQL`AND stream_position <= ${to}` : _dumbo.SQL.EMPTY;
-  const { rows: results } = await execute.query(
-    _dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-        FROM ${identifier6(messagesTable.name)}
-        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _129 => _129.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
-        ORDER BY stream_position ASC`
-  );
-  const messages = results.map((row) => {
-    const rawEvent = {
-      type: row.message_type,
-      data: serializer.deserialize(row.message_data),
-      metadata: serializer.deserialize(row.message_metadata)
-    };
-    const metadata = {
-      ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
-      messageId: row.message_id,
-      streamName: streamId,
-      streamPosition: BigInt(row.stream_position),
-      globalPosition: BigInt(row.global_position),
-      checkpoint: bigIntProcessorCheckpoint(BigInt(row.global_position))
-    };
-    const event = {
-      ...rawEvent,
-      kind: "Event",
-      metadata
-    };
-    return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _130 => _130.schema, 'optionalAccess', _131 => _131.versioning]));
-  });
-  return messages.length > 0 ? {
-    currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
-    events: messages,
-    streamExists: true
-  } : {
-    currentStreamVersion: SQLiteEventStoreDefaultStreamVersion,
-    events: [],
-    streamExists: false
-  };
-};
-
-// src/eventStore/schema/storeProcessorCheckpoint.ts
-
-
-
-
-
-
-var { identifier: identifier7 } = _dumbo.SQL;
+//#endregion
+//#region src/eventStore/consumers/sqliteProcessor.ts
+const sqliteProcessingScope = () => {
+	const processingScope = async (handler, partialContext) => {
+		const connection = partialContext?.connection;
+		if (!connection) throw new _event_driven_io_emmett.EmmettError("Connection is required in context or options");
+		return connection.withTransaction(async (transaction) => {
+			return handler({
+				...partialContext,
+				connection,
+				execute: transaction.execute
+			});
+		});
+	};
+	return processingScope;
+};
+const sqliteWorkflowProcessingScope = (messageStore) => {
+	const processingScope = async (handler, partialContext) => {
+		const connection = partialContext?.connection;
+		if (!connection) throw new _event_driven_io_emmett.EmmettError("Connection is required in context or options");
+		return connection.withTransaction(async (transaction) => {
+			return handler({
+				...partialContext,
+				connection: Object.assign(connection, { messageStore }),
+				execute: transaction.execute
+			});
+		});
+	};
+	return processingScope;
+};
+const sqliteWorkflowProcessor = (options) => {
+	const { processorId = options.processorId ?? (0, _event_driven_io_emmett.getWorkflowId)({ workflowName: options.workflow.name ?? "unknown" }), processorInstanceId = (0, _event_driven_io_emmett.getProcessorInstanceId)(processorId), version = _event_driven_io_emmett.defaultProcessorVersion, partition = _event_driven_io_emmett.defaultProcessorPartition } = options;
+	const hooks = {
+		...options.hooks ?? {},
+		onClose: options.hooks?.onClose
+	};
+	return (0, _event_driven_io_emmett.workflowProcessor)({
+		...options,
+		processorId,
+		processorInstanceId,
+		version,
+		partition,
+		hooks,
+		processingScope: sqliteWorkflowProcessingScope(options.messageStore),
+		checkpoints: sqliteCheckpointer()
+	});
+};
+const sqliteReactor = (options) => {
+	const { processorId = options.processorId, processorInstanceId = (0, _event_driven_io_emmett.getProcessorInstanceId)(processorId), version = _event_driven_io_emmett.defaultProcessorVersion, partition = _event_driven_io_emmett.defaultProcessorPartition, hooks } = options;
+	return (0, _event_driven_io_emmett.reactor)({
+		...options,
+		processorId,
+		processorInstanceId,
+		version,
+		partition,
+		hooks,
+		processingScope: sqliteProcessingScope(),
+		checkpoints: sqliteCheckpointer()
+	});
+};
+const sqliteProjector = (options) => {
+	const { processorId = (0, _event_driven_io_emmett.getProjectorId)({ projectionName: options.projection.name ?? "unknown" }), processorInstanceId = (0, _event_driven_io_emmett.getProcessorInstanceId)(processorId), version = _event_driven_io_emmett.defaultProcessorVersion, partition = _event_driven_io_emmett.defaultProcessorPartition } = options;
+	const hooks = {
+		...options.hooks ?? {},
+		onInit: options.projection.init !== void 0 || options.hooks?.onInit ? async (context) => {
+			if (options.projection.init) await options.projection.init({
+				version: options.projection.version ?? version,
+				status: "active",
+				registrationType: "async",
+				context: {
+					...context,
+					migrationOptions: options.migrationOptions
+				}
+			});
+			if (options.hooks?.onInit) await options.hooks.onInit({
+				...context,
+				migrationOptions: options.migrationOptions
+			});
+		} : options.hooks?.onInit,
+		onClose: options.hooks?.onClose
+	};
+	return (0, _event_driven_io_emmett.projector)({
+		...options,
+		processorId,
+		processorInstanceId,
+		version,
+		partition,
+		hooks,
+		processingScope: sqliteProcessingScope(),
+		checkpoints: sqliteCheckpointer()
+	});
+};
+
+//#endregion
+//#region src/eventStore/consumers/sqliteEventStoreConsumer.ts
+const sqliteEventStoreConsumer = (options) => {
+	let isRunning = false;
+	let isInitialized = false;
+	const { pulling } = options;
+	const processors = options.processors ?? [];
+	let abortController = null;
+	let start;
+	let messagePuller;
+	const startedAwaiter = (0, _event_driven_io_emmett.asyncAwaiter)();
+	const pool = options.pool ?? (0, _event_driven_io_dumbo.dumbo)({
+		serialization: options.serialization,
+		transactionOptions: {
+			allowNestedTransactions: true,
+			mode: "session_based"
+		},
+		...options.driver.mapToDumboOptions(options)
+	});
+	const eachBatch = (messagesBatch) => pool.withConnection(async (connection) => {
+		const activeProcessors = processors.filter((s) => s.isActive);
+		if (activeProcessors.length === 0) return {
+			type: "STOP",
+			reason: "No active processors"
+		};
+		return (await Promise.allSettled(activeProcessors.map(async (s) => {
+			return await s.handle(messagesBatch, {
+				connection,
+				execute: connection.execute
+			});
+		}))).some((r) => r.status === "fulfilled" && r.value?.type !== "STOP") ? void 0 : { type: "STOP" };
+	});
+	const processorContext = {
+		execute: void 0,
+		connection: void 0
+	};
+	const stopProcessors = () => Promise.all(processors.map((p) => p.close(processorContext)));
+	const stop = async () => {
+		if (!isRunning) return;
+		isRunning = false;
+		if (messagePuller) {
+			abortController?.abort();
+			await messagePuller.stop();
+		}
+		await start;
+		messagePuller = void 0;
+		abortController = null;
+		await stopProcessors();
+	};
+	const init = async () => {
+		if (isInitialized) return;
+		const sqliteProcessors = processors;
+		await pool.withConnection(async (connection) => {
+			for (const processor of sqliteProcessors) if (processor.init) await processor.init({
+				...processorContext,
+				connection,
+				execute: connection.execute
+			});
+		});
+		isInitialized = true;
+	};
+	return {
+		consumerId: options.consumerId ?? (0, uuid.v7)(),
+		get isRunning() {
+			return isRunning;
+		},
+		whenStarted: () => startedAwaiter.wait,
+		processors,
+		init,
+		reactor: (options) => {
+			const processor = sqliteReactor(options);
+			processors.push(processor);
+			return processor;
+		},
+		projector: (options) => {
+			const processor = sqliteProjector(options);
+			processors.push(processor);
+			return processor;
+		},
+		workflowProcessor: (processorOptions) => {
+			const messageStore = getSQLiteEventStore({
+				...options,
+				pool,
+				schema: { autoMigration: "None" }
+			});
+			const processor = sqliteWorkflowProcessor({
+				...processorOptions,
+				messageStore
+			});
+			processors.push(processor);
+			return processor;
+		},
+		start: () => {
+			if (isRunning) return start;
+			startedAwaiter.reset();
+			if (processors.length === 0) {
+				const error = new _event_driven_io_emmett.EmmettError("Cannot start consumer without at least a single processor");
+				startedAwaiter.reject(error);
+				return Promise.reject(error);
+			}
+			isRunning = true;
+			abortController = new AbortController();
+			start = (async () => {
+				if (!isRunning) return;
+				try {
+					messagePuller = sqliteEventStoreMessageBatchPuller({
+						stopWhen: options.stopWhen,
+						executor: pool.execute,
+						eachBatch,
+						batchSize: pulling?.batchSize ?? 100,
+						pullingFrequencyInMs: pulling?.pullingFrequencyInMs ?? 50,
+						signal: abortController.signal
+					});
+					if (!isInitialized) await init();
+					const startFrom = await pool.withConnection(async (connection) => zipSQLiteEventStoreMessageBatchPullerStartFrom(await Promise.all(processors.map(async (o) => {
+						return await o.start({
+							execute: connection.execute,
+							connection
+						});
+					}))));
+					await messagePuller.start({
+						startFrom,
+						started: startedAwaiter
+					});
+				} catch (error) {
+					isRunning = false;
+					startedAwaiter.reject(error);
+					throw error;
+				} finally {
+					await stopProcessors();
+				}
+			})();
+			return start;
+		},
+		stop,
+		close: async () => {
+			await stop();
+			await pool.close();
+		}
+	};
+};
+
+//#endregion
+//#region src/eventStore/SQLiteEventStore.ts
+const SQLiteEventStoreDefaultStreamVersion = 0n;
+const getSQLiteEventStore = (options) => {
+	let autoGenerateSchema = false;
+	const serializer = _event_driven_io_emmett.JSONSerializer.from(options);
+	const pool = options.pool ?? (0, _event_driven_io_dumbo.dumbo)({
+		serialization: options.serialization,
+		transactionOptions: {
+			allowNestedTransactions: true,
+			mode: "session_based"
+		},
+		...options.driver.mapToDumboOptions(options)
+	});
+	let migrateSchema = void 0;
+	const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection }) => projection);
+	const onBeforeCommitHook = options.hooks?.onBeforeCommit;
+	if (options) autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
+	const migrate = (connection) => {
+		if (!migrateSchema) migrateSchema = createEventStoreSchema(connection, {
+			onBeforeSchemaCreated: async (context) => {
+				for (const projection of inlineProjections) if (projection.init) await projection.init({
+					version: projection.version ?? 1,
+					registrationType: "async",
+					status: "active",
+					context: {
+						execute: context.connection.execute,
+						connection: context.connection,
+						driverType: options.driver.driverType
+					}
+				});
+				if (options.hooks?.onBeforeSchemaCreated) await options.hooks.onBeforeSchemaCreated(context);
+			},
+			onAfterSchemaCreated: options.hooks?.onAfterSchemaCreated
+		});
+		return migrateSchema;
+	};
+	const ensureSchemaExists = () => {
+		if (!autoGenerateSchema) return Promise.resolve();
+		return pool.withConnection((connection) => migrate(connection));
+	};
+	return {
+		async aggregateStream(streamName, options) {
+			await ensureSchemaExists();
+			const { evolve, initialState, read } = options;
+			const expectedStreamVersion = read?.expectedStreamVersion;
+			let state = initialState();
+			if (typeof streamName !== "string") throw new Error("Stream name is not string");
+			const result = await readStream(pool.execute, streamName, {
+				...read,
+				serializer: read?.serialization?.serializer ?? serializer
+			});
+			const currentStreamVersion = result.currentStreamVersion;
+			(0, _event_driven_io_emmett.assertExpectedVersionMatchesCurrent)(currentStreamVersion, expectedStreamVersion, SQLiteEventStoreDefaultStreamVersion);
+			for (const event of result.events) {
+				if (!event) continue;
+				state = evolve(state, event);
+			}
+			return {
+				currentStreamVersion,
+				state,
+				streamExists: result.streamExists
+			};
+		},
+		readStream: async (streamName, readOptions) => {
+			await ensureSchemaExists();
+			return readStream(pool.execute, streamName, {
+				...readOptions,
+				serializer: options.serialization?.serializer ?? serializer
+			});
+		},
+		appendToStream: async (streamName, events, appendOptions) => {
+			await ensureSchemaExists();
+			const [firstPart, ...rest] = streamName.split("-");
+			const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag;
+			const appendResult = await pool.withConnection((connection) => appendToStream(connection, streamName, streamType, events, {
+				...appendOptions,
+				onBeforeCommit: async (messages, context) => {
+					if (inlineProjections.length > 0) await handleProjections({
+						projections: inlineProjections,
+						events: messages,
+						execute: context.connection.execute,
+						connection: context.connection,
+						driverType: options.driver.driverType
+					});
+					if (onBeforeCommitHook) await onBeforeCommitHook(messages, context);
+				}
+			}), { readonly: false });
+			if (!appendResult.success) throw new _event_driven_io_emmett.ExpectedVersionConflictError(-1n, appendOptions?.expectedStreamVersion ?? _event_driven_io_emmett.NO_CONCURRENCY_CHECK);
+			return {
+				nextExpectedStreamVersion: appendResult.nextStreamPosition,
+				lastEventGlobalPosition: appendResult.lastGlobalPosition,
+				createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
+			};
+		},
+		async streamExists(streamName, options) {
+			await ensureSchemaExists();
+			return streamExists(pool.execute, streamName, options);
+		},
+		consumer: (consumerOptions) => sqliteEventStoreConsumer({
+			...options ?? {},
+			...consumerOptions ?? {},
+			pool
+		}),
+		async withSession(callback) {
+			return await pool.withConnection(async (connection) => {
+				const sessionStore = getSQLiteEventStore({
+					...options,
+					pool: (0, _event_driven_io_dumbo.dumbo)({
+						...options.driver.mapToDumboOptions(options),
+						connection,
+						serialization: options.serialization
+					}),
+					transactionOptions: {
+						allowNestedTransactions: true,
+						mode: "session_based"
+					},
+					schema: {
+						...options.schema,
+						autoMigration: "None"
+					},
+					serialization: options.serialization
+				});
+				await ensureSchemaExists();
+				return callback({
+					eventStore: sessionStore,
+					close: () => Promise.resolve()
+				});
+			});
+		},
+		close: () => pool.close(),
+		schema: {
+			sql: () => schemaSQL.join(""),
+			print: () => console.log(schemaSQL.join("")),
+			migrate: () => pool.withConnection(migrate)
+		}
+	};
+};
+
+//#endregion
+//#region src/eventStore/schema/readStream.ts
+const { identifier: identifier$2 } = _event_driven_io_dumbo.SQL;
+const readStream = async (execute, streamId, options) => {
+	const { serializer } = options;
+	const fromCondition = options.from ? _event_driven_io_dumbo.SQL`AND stream_position >= ${options.from}` : _event_driven_io_dumbo.SQL.EMPTY;
+	const to = Number(options?.to ?? (options?.maxCount ? (options.from ?? 0n) + options.maxCount : NaN));
+	const toCondition = !isNaN(to) ? _event_driven_io_dumbo.SQL`AND stream_position <= ${to}` : _event_driven_io_dumbo.SQL.EMPTY;
+	const { rows: results } = await execute.query(_event_driven_io_dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+        FROM ${identifier$2(messagesTable.name)}
+        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE ${fromCondition} ${toCondition}
+        ORDER BY stream_position ASC`);
+	const messages = results.map((row) => {
+		const rawEvent = {
+			type: row.message_type,
+			data: serializer.deserialize(row.message_data),
+			metadata: serializer.deserialize(row.message_metadata)
+		};
+		const metadata = {
+			..."metadata" in rawEvent ? rawEvent.metadata ?? {} : {},
+			messageId: row.message_id,
+			streamName: streamId,
+			streamPosition: BigInt(row.stream_position),
+			globalPosition: BigInt(row.global_position),
+			checkpoint: (0, _event_driven_io_emmett.bigIntProcessorCheckpoint)(BigInt(row.global_position))
+		};
+		return (0, _event_driven_io_emmett.upcastRecordedMessage)({
+			...rawEvent,
+			kind: "Event",
+			metadata
+		}, options?.schema?.versioning);
+	});
+	return messages.length > 0 ? {
+		currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
+		events: messages,
+		streamExists: true
+	} : {
+		currentStreamVersion: SQLiteEventStoreDefaultStreamVersion,
+		events: [],
+		streamExists: false
+	};
+};
+
+//#endregion
+//#region src/eventStore/schema/storeProcessorCheckpoint.ts
+const { identifier: identifier$1 } = _event_driven_io_dumbo.SQL;
 async function storeSubscriptionCheckpointSQLite(execute, processorId, version, position, checkPosition, partition, processorInstanceId) {
-  processorInstanceId ??= unknownTag2;
-  if (checkPosition !== null) {
-    const updateResult = await execute.command(
-      _dumbo.SQL`
-          UPDATE ${identifier7(processorsTable.name)}
+	processorInstanceId ??= unknownTag;
+	if (checkPosition !== null) {
+		const updateResult = await execute.command(_event_driven_io_dumbo.SQL`
+          UPDATE ${identifier$1(processorsTable.name)}
           SET 
             last_processed_checkpoint = ${position},
             processor_instance_id = ${processorInstanceId}
           WHERE processor_id = ${processorId} 
             AND last_processed_checkpoint = ${checkPosition} 
             AND partition = ${partition}
-        `
-    );
-    if (updateResult.rowCount && updateResult.rowCount > 0) {
-      return 1;
-    }
-    const current_position = await _dumbo.singleOrNull.call(void 0, 
-      execute.query(
-        _dumbo.SQL`
-          SELECT last_processed_checkpoint FROM ${identifier7(processorsTable.name)} 
-               WHERE processor_id = ${processorId} AND partition = ${partition}`
-      )
-    );
-    const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _132 => _132.last_processed_checkpoint]) !== null ? current_position.last_processed_checkpoint : null;
-    if (currentPosition === position) {
-      return 0;
-    } else if (position !== null && currentPosition !== null && currentPosition > position) {
-      return 2;
-    } else {
-      return 2;
-    }
-  } else {
-    try {
-      await execute.command(
-        _dumbo.SQL`INSERT INTO ${identifier7(processorsTable.name)} (processor_id, version, last_processed_checkpoint, partition, processor_instance_id) 
-        VALUES (${processorId}, ${version}, ${position}, ${partition}, ${processorInstanceId})`
-      );
-      return 1;
-    } catch (err) {
-      if (!_dumbo.DumboError.isInstanceOf(err, {
-        errorType: _dumbo.UniqueConstraintError.ErrorType
-      })) {
-        throw err;
-      }
-      const current = await _dumbo.singleOrNull.call(void 0, 
-        execute.query(
-          _dumbo.SQL`
-            SELECT last_processed_checkpoint FROM ${identifier7(processorsTable.name)} 
-            WHERE processor_id = ${processorId} AND partition = ${partition}`
-        )
-      );
-      const currentPosition = current && _optionalChain([current, 'optionalAccess', _133 => _133.last_processed_checkpoint]) !== null ? BigInt(current.last_processed_checkpoint) : null;
-      if (currentPosition === position) {
-        return 0;
-      } else {
-        return 2;
-      }
-    }
-  }
+        `);
+		if (updateResult.rowCount && updateResult.rowCount > 0) return 1;
+		const current_position = await (0, _event_driven_io_dumbo.singleOrNull)(execute.query(_event_driven_io_dumbo.SQL`
+          SELECT last_processed_checkpoint FROM ${identifier$1(processorsTable.name)} 
+               WHERE processor_id = ${processorId} AND partition = ${partition}`));
+		const currentPosition = current_position && current_position?.last_processed_checkpoint !== null ? current_position.last_processed_checkpoint : null;
+		if (currentPosition === position) return 0;
+		else if (position !== null && currentPosition !== null && currentPosition > position) return 2;
+		else return 2;
+	} else try {
+		await execute.command(_event_driven_io_dumbo.SQL`INSERT INTO ${identifier$1(processorsTable.name)} (processor_id, version, last_processed_checkpoint, partition, processor_instance_id) 
+        VALUES (${processorId}, ${version}, ${position}, ${partition}, ${processorInstanceId})`);
+		return 1;
+	} catch (err) {
+		if (!_event_driven_io_dumbo.DumboError.isInstanceOf(err, { errorType: _event_driven_io_dumbo.UniqueConstraintError.ErrorType })) throw err;
+		const current = await (0, _event_driven_io_dumbo.singleOrNull)(execute.query(_event_driven_io_dumbo.SQL`
+            SELECT last_processed_checkpoint FROM ${identifier$1(processorsTable.name)} 
+            WHERE processor_id = ${processorId} AND partition = ${partition}`));
+		if ((current && current?.last_processed_checkpoint !== null ? BigInt(current.last_processed_checkpoint) : null) === position) return 0;
+		else return 2;
+	}
 }
 async function storeProcessorCheckpoint(execute, options) {
-  try {
-    const result = await storeSubscriptionCheckpointSQLite(
-      execute,
-      options.processorId,
-      _nullishCoalesce(options.version, () => ( 1)),
-      options.newCheckpoint,
-      options.lastProcessedCheckpoint,
-      _nullishCoalesce(options.partition, () => ( defaultTag2))
-    );
-    return result === 1 ? { success: true, newCheckpoint: options.newCheckpoint } : { success: false, reason: result === 0 ? "IGNORED" : "MISMATCH" };
-  } catch (error) {
-    console.log(error);
-    throw error;
-  }
+	try {
+		const result = await storeSubscriptionCheckpointSQLite(execute, options.processorId, options.version ?? 1, options.newCheckpoint, options.lastProcessedCheckpoint, options.partition ?? defaultTag);
+		return result === 1 ? {
+			success: true,
+			newCheckpoint: options.newCheckpoint
+		} : {
+			success: false,
+			reason: result === 0 ? "IGNORED" : "MISMATCH"
+		};
+	} catch (error) {
+		console.log(error);
+		throw error;
+	}
 }
 
-// src/eventStore/schema/streamExists.ts
-
-var streamExists = (execute, streamId, options) => _dumbo.exists.call(void 0, 
-  execute.query(
-    _dumbo.SQL`SELECT EXISTS (
+//#endregion
+//#region src/eventStore/schema/streamExists.ts
+const streamExists = (execute, streamId, options) => (0, _event_driven_io_dumbo.exists)(execute.query(_event_driven_io_dumbo.SQL`SELECT EXISTS (
         SELECT 1
-        from ${_dumbo.SQL.identifier(streamsTable.name)}
-        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _134 => _134.partition]), () => ( defaultTag2))} AND is_archived = FALSE) as exists
-      `
-  )
-);
-
-// src/eventStore/schema/tables.ts
-
-var { identifier: identifier8, plain: plain2 } = _dumbo.SQL;
-var streamsTableSQL = _dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier8(streamsTable.name)}(
+        from ${_event_driven_io_dumbo.SQL.identifier(streamsTable.name)}
+        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE) as exists
+      `));
+
+//#endregion
+//#region src/eventStore/schema/tables.ts
+const { identifier, plain } = _event_driven_io_dumbo.SQL;
+const streamsTableSQL = _event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier(streamsTable.name)}(
       stream_id         TEXT                      NOT NULL,
       stream_position   BIGINT                    NOT NULL DEFAULT 0,
-      partition         TEXT                      NOT NULL DEFAULT '${plain2(globalTag)}',
+      partition         TEXT                      NOT NULL DEFAULT '${plain(globalTag)}',
       stream_type       TEXT                      NOT NULL,
       stream_metadata   JSONB                     NOT NULL,
       is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
       PRIMARY KEY (stream_id, partition, is_archived),
       UNIQUE (stream_id, partition, is_archived)
   );`;
-var messagesTableSQL = _dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier8(messagesTable.name)}(
+const messagesTableSQL = _event_driven_io_dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier(messagesTable.name)}(
       stream_id              TEXT                      NOT NULL,
       stream_position        BIGINT                    NOT NULL,
-      partition              TEXT                      NOT NULL DEFAULT '${plain2(globalTag)}',
+      partition              TEXT                      NOT NULL DEFAULT '${plain(globalTag)}',
       message_kind           CHAR(1)                   NOT NULL DEFAULT 'E',
       message_data           JSONB                     NOT NULL,
       message_metadata       JSONB                     NOT NULL,
@@ -2715,22 +1272,22 @@ var messagesTableSQL = _dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier8(messa
       UNIQUE (stream_id, stream_position, partition, is_archived)
   ); 
 `;
-var processorsTableSQL = _dumbo.SQL`
-  CREATE TABLE IF NOT EXISTS ${_dumbo.SQL.identifier(processorsTable.name)}(
+const processorsTableSQL = _event_driven_io_dumbo.SQL`
+  CREATE TABLE IF NOT EXISTS ${_event_driven_io_dumbo.SQL.identifier(processorsTable.name)}(
       processor_id                 TEXT                  NOT NULL,
       version                      INTEGER               NOT NULL DEFAULT 1,
-      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
+      partition                    TEXT                  NOT NULL DEFAULT '${plain(globalTag)}',
       status                       TEXT                  NOT NULL DEFAULT 'stopped',
       last_processed_checkpoint    TEXT                  NOT NULL,
-      processor_instance_id        TEXT                  DEFAULT '${plain2(unknownTag2)}',
+      processor_instance_id        TEXT                  DEFAULT '${plain(unknownTag)}',
       PRIMARY KEY (processor_id, partition, version)
   );
 `;
-var projectionsTableSQL = _dumbo.SQL`
-  CREATE TABLE IF NOT EXISTS ${_dumbo.SQL.identifier(projectionsTable.name)}(
+const projectionsTableSQL = _event_driven_io_dumbo.SQL`
+  CREATE TABLE IF NOT EXISTS ${_event_driven_io_dumbo.SQL.identifier(projectionsTable.name)}(
       name                         TEXT                  NOT NULL,
       version                      INTEGER               NOT NULL DEFAULT 1,
-      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
+      partition                    TEXT                  NOT NULL DEFAULT '${plain(globalTag)}',
       type                         CHAR(1)               NOT NULL,
       kind                         TEXT                  NOT NULL,
       status                       TEXT                  NOT NULL,
@@ -2738,73 +1295,67 @@ var projectionsTableSQL = _dumbo.SQL`
       PRIMARY KEY (name, partition, version)
   );
 `;
-var schemaSQL = [
-  streamsTableSQL,
-  messagesTableSQL,
-  processorsTableSQL,
-  projectionsTableSQL
+const schemaSQL = [
+	streamsTableSQL,
+	messagesTableSQL,
+	processorsTableSQL,
+	projectionsTableSQL
 ];
-var createEventStoreSchema = async (pool, hooks) => {
-  await pool.withTransaction(async (tx) => {
-    await migration_0_42_0_FromSubscriptionsToProcessors(tx.execute);
-    if (_optionalChain([hooks, 'optionalAccess', _135 => _135.onBeforeSchemaCreated])) {
-      await hooks.onBeforeSchemaCreated({
-        connection: tx.connection
-      });
-    }
-    await tx.execute.batchCommand(schemaSQL);
-    if (_optionalChain([hooks, 'optionalAccess', _136 => _136.onAfterSchemaCreated])) {
-      await hooks.onAfterSchemaCreated();
-    }
-  });
-};
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.SQLiteProjectionSpec = SQLiteProjectionSpec; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag2; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix2; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.migration_0_42_0_FromSubscriptionsToProcessors = migration_0_42_0_FromSubscriptionsToProcessors; exports.migration_0_42_0_SQLs = migration_0_42_0_SQLs; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.schema_0_41_0 = schema_0_41_0; exports.schema_0_42_0 = schema_0_42_0; exports.sqliteProjection = sqliteProjection; exports.sqliteRawBatchSQLProjection = sqliteRawBatchSQLProjection; exports.sqliteRawSQLProjection = sqliteRawSQLProjection; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.unknownTag = unknownTag2;
+const createEventStoreSchema = async (pool, hooks) => {
+	await pool.withTransaction(async (tx) => {
+		await migration_0_42_0_FromSubscriptionsToProcessors(tx.execute);
+		if (hooks?.onBeforeSchemaCreated) await hooks.onBeforeSchemaCreated({ connection: tx.connection });
+		await tx.execute.batchCommand(schemaSQL);
+		if (hooks?.onAfterSchemaCreated) await hooks.onAfterSchemaCreated();
+	});
+};
+
+//#endregion
+exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion;
+exports.SQLiteProjectionSpec = SQLiteProjectionSpec;
+exports.appendToStream = appendToStream;
+exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches;
+exports.createEventStoreSchema = createEventStoreSchema;
+exports.defaultTag = defaultTag;
+exports.documentDoesNotExist = documentDoesNotExist;
+exports.documentExists = documentExists;
+exports.documentMatchingExists = documentMatchingExists;
+exports.documentsAreTheSame = documentsAreTheSame;
+exports.documentsMatchingHaveCount = documentsMatchingHaveCount;
+exports.emmettPrefix = emmettPrefix;
+exports.eventInStream = eventInStream;
+exports.eventsInStream = eventsInStream;
+exports.expectPongoDocuments = expectPongoDocuments;
+exports.expectSQL = expectSQL;
+exports.getSQLiteEventStore = getSQLiteEventStore;
+exports.globalNames = globalNames;
+exports.globalTag = globalTag;
+exports.handleProjections = handleProjections;
+exports.messagesTable = messagesTable;
+exports.messagesTableSQL = messagesTableSQL;
+exports.migration_0_42_0_FromSubscriptionsToProcessors = migration_0_42_0_FromSubscriptionsToProcessors;
+exports.migration_0_42_0_SQLs = migration_0_42_0_SQLs;
+exports.newEventsInStream = newEventsInStream;
+exports.pongoMultiStreamProjection = pongoMultiStreamProjection;
+exports.pongoProjection = pongoProjection;
+exports.pongoSingleStreamProjection = pongoSingleStreamProjection;
+exports.processorsTable = processorsTable;
+exports.processorsTableSQL = processorsTableSQL;
+exports.projectionsTable = projectionsTable;
+exports.projectionsTableSQL = projectionsTableSQL;
+exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition;
+exports.readMessagesBatch = readMessagesBatch;
+exports.readProcessorCheckpoint = readProcessorCheckpoint;
+exports.readStream = readStream;
+exports.schemaSQL = schemaSQL;
+exports.schema_0_41_0 = schema_0_41_0;
+exports.schema_0_42_0 = schema_0_42_0;
+exports.sqliteProjection = sqliteProjection;
+exports.sqliteRawBatchSQLProjection = sqliteRawBatchSQLProjection;
+exports.sqliteRawSQLProjection = sqliteRawSQLProjection;
+exports.storeProcessorCheckpoint = storeProcessorCheckpoint;
+exports.streamExists = streamExists;
+exports.streamsTable = streamsTable;
+exports.streamsTableSQL = streamsTableSQL;
+exports.unknownTag = unknownTag;
 //# sourceMappingURL=index.cjs.map