@event-driven-io/emmett-sqlite 0.43.0-apha.2 → 0.43.0-beta.10

package/dist/index.js

@@ -1,6 +1,132 @@
+// src/eventStore/projections/pongo/pongoProjections.ts
+import {
+  pongoClient
+} from "@event-driven-io/pongo";
+var 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 driver = await pongoDriverRegistry.tryResolve(
+      context.driverType
+    );
+    const pongo = pongoClient({
+      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 = pongoClient({
+      driver,
+      connectionOptions: { connection }
+    });
+    try {
+      await truncate({
+        ...context,
+        pongo
+      });
+    } finally {
+      await pongo.close();
+    }
+  } : void 0
+});
+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: options.kind ?? "emt:projections:postgresql:pongo:multi_stream",
+    eventsOptions: options.eventsOptions,
+    handle: async (events, { pongo }) => {
+      const collection = pongo.db().collection(
+        collectionNameWithVersion,
+        options.collectionOptions
+      );
+      for (const event of events) {
+        await collection.handle(getDocumentId(event), async (document) => {
+          return "initialState" in options ? await options.evolve(
+            document ?? options.initialState(),
+            event
+          ) : await options.evolve(
+            document,
+            event
+          );
+        });
+      }
+    },
+    canHandle,
+    truncate: async (context) => {
+      const { connection } = context;
+      const driver = await pongoDriverRegistry.tryResolve(
+        context.driverType
+      );
+      const pongo = pongoClient({
+        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 = pongoClient({
+        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: options.getDocumentId ?? ((event) => event.metadata.streamName)
+  });
+};
+
 // ../emmett/dist/chunk-AZDDB5SF.js
 var isNumber = (val) => typeof val === "number" && val === val;
-var isBigint = (val) => typeof val === "bigint" && 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
@@ -48,14 +174,26 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
 };
 
 // ../emmett/dist/index.js
-import { v4 as uuid3 } from "uuid";
+import { v4 as uuid5 } from "uuid";
+import { v7 as uuid2 } from "uuid";
 import { v7 as uuid } from "uuid";
 import retry from "async-retry";
-import { v4 as uuid2 } from "uuid";
-import { v7 as uuid4 } from "uuid";
+import { v7 as uuid3 } from "uuid";
+import { v4 as uuid4 } from "uuid";
+import { v7 as uuid6 } from "uuid";
 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);
+  }
+});
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
 var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
@@ -76,8 +214,8 @@ var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends C
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
-var isExpectedVersionConflictError = (error2) => error2 instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
-  error2,
+var isExpectedVersionConflictError = (error) => error instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
+  error,
   ExpectedVersionConflictError.Codes.ConcurrencyError
 );
 var isPrimitive = (value) => {
@@ -281,28 +419,336 @@ var deepEquals = (left, right) => {
 var isEquatable = (left) => {
   return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
 };
-var ParseError = class extends Error {
-  constructor(text) {
-    super(`Cannot parse! ${text}`);
+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(context?.source ?? value.toString());
+    } catch {
+      return value;
+    }
+  }
+  if (typeof value === "string" && value.length > 15) {
+    if (isFirstLetterNumericOrMinus(value)) {
+      const num = Number(value);
+      if (Number.isFinite(num) && !Number.isSafeInteger(num)) {
+        try {
+          return BigInt(value);
+        } catch {
+        }
+      }
+    }
+  }
+  return value;
+};
+var dateReviver = (_key, value) => {
+  if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
   }
+  return value;
 };
-var JSONParser = {
-  stringify: (value, options) => {
-    return JSON.stringify(
-      options?.map ? options.map(value) : value,
-      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
+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
-      (_, v) => typeof v === "bigint" ? v.toString() : v
-    );
-  },
-  parse: (text, options) => {
-    const parsed = JSON.parse(text, options?.reviver);
-    if (options?.typeCheck && !options?.typeCheck(parsed))
-      throw new ParseError(text);
-    return options?.map ? options.map(parsed) : parsed;
+      (accValue, replacer) => replacer(key, accValue),
+      value
+    )
+  );
+};
+var composeJSONRevivers = (...revivers) => {
+  const filteredRevivers = revivers.filter((r) => r !== void 0);
+  if (filteredRevivers.length === 0) return void 0;
+  return (key, value, context) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredRevivers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, reviver) => reviver(key, accValue, context),
+      value
+    )
+  );
+};
+var JSONReplacer = (opts) => composeJSONReplacers(
+  opts?.replacer,
+  opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0,
+  opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0
+);
+var JSONReviver = (opts) => composeJSONRevivers(
+  opts?.reviver,
+  opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0,
+  opts?.parseDates === true ? JSONRevivers.date : void 0
+);
+var JSONReplacers = {
+  bigInt: bigIntReplacer,
+  date: dateReplacer
+};
+var JSONRevivers = {
+  bigInt: bigIntReviver,
+  date: dateReviver
+};
+var jsonSerializer = (options) => {
+  const defaultReplacer = JSONReplacer(options);
+  const defaultReviver = JSONReviver(options);
+  return {
+    serialize: (object, serializerOptions) => JSON.stringify(
+      object,
+      serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer
+    ),
+    deserialize: (payload, deserializerOptions) => JSON.parse(
+      payload,
+      deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver
+    )
+  };
+};
+var JSONSerializer = Object.assign(jsonSerializer(), {
+  from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer)
+});
+var NoRetries = { retries: 0 };
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return retry(
+    async (bail) => {
+      try {
+        const result = await fn();
+        if (opts?.shouldRetryResult && opts.shouldRetryResult(result)) {
+          throw new EmmettError(
+            `Retrying because of result: ${JSONSerializer.serialize(result)}`
+          );
+        }
+        return result;
+      } catch (error) {
+        if (opts?.shouldRetryError && !opts.shouldRetryError(error)) {
+          bail(error);
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    opts ?? { retries: 0 }
+  );
+};
+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}:${uuid3()}`;
+var getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
+var reactor = (options) => {
+  const {
+    checkpoints,
+    processorId,
+    processorInstanceId: instanceId = getProcessorInstanceId(processorId),
+    type = MessageProcessorType.REACTOR,
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition,
+    hooks = {},
+    processingScope = defaultProcessingMessageProcessingScope,
+    startFrom,
+    canHandle,
+    stopAfter
+  } = options;
+  const eachMessage = "eachMessage" in options && options.eachMessage ? options.eachMessage : () => Promise.resolve();
+  let isInitiated = false;
+  let isActive = false;
+  let lastCheckpoint = null;
+  let closeSignal = null;
+  const init = async (initOptions) => {
+    if (isInitiated) return;
+    if (hooks.onInit === void 0) {
+      isInitiated = true;
+      return;
+    }
+    return await processingScope(async (context) => {
+      await hooks.onInit(context);
+      isInitiated = true;
+    }, initOptions);
+  };
+  const close = async (closeOptions) => {
+    isActive = false;
+    if (closeSignal) {
+      closeSignal();
+      closeSignal = null;
+    }
+    if (hooks.onClose) {
+      await processingScope(hooks.onClose, closeOptions);
+    }
+  };
+  return {
+    // TODO: Consider whether not make it optional or add URN prefix
+    id: processorId,
+    instanceId,
+    type,
+    canHandle,
+    init,
+    start: async (startOptions) => {
+      if (isActive) return;
+      await init(startOptions);
+      isActive = true;
+      closeSignal = onShutdown(() => close(startOptions));
+      if (lastCheckpoint !== null)
+        return {
+          lastCheckpoint
+        };
+      return await processingScope(async (context) => {
+        if (hooks.onStart) {
+          await hooks.onStart(context);
+        }
+        if (startFrom && startFrom !== "CURRENT") return startFrom;
+        if (checkpoints) {
+          const readResult = await checkpoints?.read(
+            {
+              processorId,
+              partition
+            },
+            { ...startOptions, ...context }
+          );
+          lastCheckpoint = readResult.lastCheckpoint;
+        }
+        if (lastCheckpoint === null) return "BEGINNING";
+        return {
+          lastCheckpoint
+        };
+      }, startOptions);
+    },
+    close,
+    get isActive() {
+      return isActive;
+    },
+    handle: async (messages, partialContext) => {
+      if (!isActive) return Promise.resolve();
+      return await processingScope(async (context) => {
+        let result = void 0;
+        for (const message2 of messages) {
+          if (wasMessageHandled(message2, lastCheckpoint)) continue;
+          const upcasted = upcastRecordedMessage(
+            // TODO: Make it smarter
+            message2,
+            options.messageOptions?.schema?.versioning
+          );
+          if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
+            continue;
+          const messageProcessingResult = await eachMessage(upcasted, context);
+          if (checkpoints) {
+            const storeCheckpointResult = await checkpoints.store(
+              {
+                processorId,
+                version,
+                message: upcasted,
+                lastCheckpoint,
+                partition
+              },
+              context
+            );
+            if (storeCheckpointResult.success) {
+              lastCheckpoint = storeCheckpointResult.newCheckpoint;
+            }
+          }
+          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
+            isActive = false;
+            result = messageProcessingResult;
+            break;
+          }
+          if (stopAfter && stopAfter(upcasted)) {
+            isActive = false;
+            result = { type: "STOP", reason: "Stop condition reached" };
+            break;
+          }
+          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
+            continue;
+        }
+        return result;
+      }, partialContext);
+    }
+  };
+};
+var projector = (options) => {
+  const {
+    projection: projection2,
+    processorId = getProjectorId({
+      projectionName: projection2.name ?? "unknown"
+    }),
+    ...rest
+  } = options;
+  return reactor({
+    ...rest,
+    type: MessageProcessorType.PROJECTOR,
+    canHandle: projection2.canHandle,
+    processorId,
+    messageOptions: options.projection.eventsOptions,
+    hooks: {
+      onInit: options.hooks?.onInit,
+      onStart: options.truncateOnStart && options.projection.truncate || options.hooks?.onStart ? async (context) => {
+        if (options.truncateOnStart && options.projection.truncate)
+          await options.projection.truncate(context);
+        if (options.hooks?.onStart) await options.hooks?.onStart(context);
+      } : void 0,
+      onClose: options.hooks?.onClose
+    },
+    eachMessage: async (event2, context) => projection2.handle([event2], context)
+  });
+};
 var AssertionError = class extends Error {
   constructor(message2) {
     super(message2);
@@ -314,7 +760,7 @@ var isSubset = (superObj, subObj) => {
   assertOk(sup);
   assertOk(sub);
   return Object.keys(sub).every((ele) => {
-    if (typeof sub[ele] == "object") {
+    if (sub[ele] !== null && typeof sub[ele] == "object") {
       return isSubset(sup[ele], sub[ele]);
     }
     return sub[ele] === sup[ele];
@@ -323,6 +769,15 @@ var isSubset = (superObj, subObj) => {
 var assertFails = (message2) => {
   throw new AssertionError(message2 ?? "That should not ever happened, right?");
 };
+var assertDeepEqual = (actual, expected, message2) => {
+  if (!deepEquals(actual, expected))
+    throw new AssertionError(
+      message2 ?? `subObj:
+${JSONSerializer.serialize(expected)}
+is not equal to
+${JSONSerializer.serialize(actual)}`
+    );
+};
 function assertTrue(condition, message2) {
   if (condition !== true)
     throw new AssertionError(message2 ?? `Condition is false`);
@@ -334,22 +789,29 @@ function assertEqual(expected, actual, message2) {
   if (expected !== actual)
     throw new AssertionError(
       `${message2 ?? "Objects are not equal"}:
-Expected: ${JSONParser.stringify(expected)}
-Actual: ${JSONParser.stringify(actual)}`
+Expected: ${JSONSerializer.serialize(expected)}
+Actual: ${JSONSerializer.serialize(actual)}`
     );
 }
 function assertNotEqual(obj, other, message2) {
   if (obj === other)
     throw new AssertionError(
-      message2 ?? `Objects are equal: ${JSONParser.stringify(obj)}`
+      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 ${JSONParser.stringify(array)}`
+      `Array is not empty ${JSONSerializer.serialize(array)}`
     ),
     isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
     hasSize: (length) => assertEqual(array.length, length),
@@ -448,56 +910,467 @@ var upcastRecordedMessage = (recordedMessage, options) => {
     } : {}
   };
 };
-var getCheckpoint = (message2) => {
-  return "checkpoint" in message2.metadata ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.checkpoint
-  ) : "globalPosition" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  isBigint(message2.metadata.globalPosition) ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.globalPosition
-  ) : "streamPosition" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  isBigint(message2.metadata.streamPosition) ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.streamPosition
-  ) : null;
-};
 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
+});
+var createInputMetadata = (originalMessageId, action) => ({
+  originalMessageId,
+  input: true,
+  action
+});
+var tagOutputMessage = (msg, action) => {
+  const existingMetadata = "metadata" in msg && msg.metadata ? msg.metadata : {};
+  return {
+    ...msg,
+    metadata: {
+      ...existingMetadata,
+      action
+    }
+  };
+};
+var createWrappedInitialState = (initialState) => {
+  return () => ({
+    userState: initialState(),
+    processedInputIds: /* @__PURE__ */ new Set()
+  });
+};
+var createWrappedEvolve = (evolve, workflowName, separateInputInboxFromProcessing) => {
+  return (state, event2) => {
+    const metadata = event2.metadata;
+    let processedInputIds = state.processedInputIds;
+    if (metadata?.input === true && typeof metadata?.originalMessageId === "string") {
+      processedInputIds = new Set(state.processedInputIds);
+      processedInputIds.add(metadata.originalMessageId);
+    }
+    if (separateInputInboxFromProcessing && metadata?.input === true) {
+      return {
+        userState: state.userState,
+        processedInputIds
+      };
+    }
+    const eventType = event2.type;
+    const eventForEvolve = eventType.startsWith(`${workflowName}:`) ? {
+      ...event2,
+      type: eventType.replace(`${workflowName}:`, "")
+    } : event2;
+    return {
+      userState: evolve(state.userState, eventForEvolve),
+      processedInputIds
+    };
+  };
+};
+var workflowStreamName = ({
+  workflowName,
+  workflowId
+}) => `emt:workflow:${workflowName}:${workflowId}`;
+var WorkflowHandler = (options) => async (store, message2, handleOptions) => asyncRetry(
+  async () => {
+    const result = await withSession2(store, async ({ eventStore }) => {
+      const {
+        workflow: { evolve, initialState, decide, name: workflowName },
+        getWorkflowId: getWorkflowId2
+      } = options;
+      const inputMessageId = (
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        ("metadata" in message2 && message2.metadata?.messageId ? (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          message2.metadata.messageId
+        ) : void 0) ?? uuid6()
+      );
+      const messageWithMetadata = {
+        ...message2,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        metadata: {
+          messageId: inputMessageId,
+          ...message2.metadata
+        }
+      };
+      const workflowId = getWorkflowId2(messageWithMetadata);
+      if (!workflowId) {
+        return emptyHandlerResult();
+      }
+      const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({ workflowName, workflowId });
+      const messageType = messageWithMetadata.type;
+      const hasWorkflowPrefix = messageType.startsWith(`${workflowName}:`);
+      if (options.separateInputInboxFromProcessing && !hasWorkflowPrefix) {
+        const inputMetadata2 = createInputMetadata(
+          inputMessageId,
+          "InitiatedBy"
+        );
+        const inputToStore2 = {
+          type: `${workflowName}:${messageWithMetadata.type}`,
+          data: messageWithMetadata.data,
+          kind: messageWithMetadata.kind,
+          metadata: inputMetadata2
+        };
+        const appendResult2 = await eventStore.appendToStream(
+          streamName,
+          [inputToStore2],
+          {
+            ...handleOptions,
+            expectedStreamVersion: handleOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+          }
+        );
+        return {
+          ...appendResult2,
+          newMessages: []
+        };
+      }
+      const wrappedInitialState = createWrappedInitialState(initialState);
+      const wrappedEvolve = createWrappedEvolve(
+        evolve,
+        workflowName,
+        options.separateInputInboxFromProcessing ?? false
+      );
+      const aggregationResult = await eventStore.aggregateStream(streamName, {
+        evolve: wrappedEvolve,
+        initialState: wrappedInitialState,
+        read: {
+          ...handleOptions,
+          // expected stream version is passed to fail fast
+          // if stream is in the wrong state
+          expectedStreamVersion: handleOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+        }
+      });
+      const { currentStreamVersion } = aggregationResult;
+      const { userState: state, processedInputIds } = aggregationResult.state;
+      if (processedInputIds.has(inputMessageId)) {
+        return emptyHandlerResult(currentStreamVersion);
+      }
+      const messageForDecide = hasWorkflowPrefix ? {
+        ...messageWithMetadata,
+        type: messageType.replace(`${workflowName}:`, "")
+      } : messageWithMetadata;
+      const result2 = decide(messageForDecide, state);
+      const inputMetadata = createInputMetadata(
+        inputMessageId,
+        aggregationResult.streamExists ? "Received" : "InitiatedBy"
+      );
+      const inputToStore = {
+        type: `${workflowName}:${messageWithMetadata.type}`,
+        data: messageWithMetadata.data,
+        kind: messageWithMetadata.kind,
+        metadata: inputMetadata
+      };
+      const outputMessages = (Array.isArray(result2) ? result2 : [result2]).filter((msg) => msg !== void 0 && msg !== null);
+      const outputCommandTypes = options.outputs?.commands ?? [];
+      const taggedOutputMessages = outputMessages.map((msg) => {
+        const action = outputCommandTypes.includes(
+          msg.type
+        ) ? "Sent" : "Published";
+        return tagOutputMessage(msg, action);
+      });
+      const messagesToAppend = options.separateInputInboxFromProcessing && hasWorkflowPrefix ? [...taggedOutputMessages] : [inputToStore, ...taggedOutputMessages];
+      if (messagesToAppend.length === 0) {
+        return emptyHandlerResult(currentStreamVersion);
+      }
+      const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST);
+      const appendResult = await eventStore.appendToStream(
+        streamName,
+        // TODO: Fix this cast
+        messagesToAppend,
+        {
+          ...handleOptions,
+          expectedStreamVersion
+        }
+      );
+      return {
+        ...appendResult,
+        newMessages: outputMessages
+      };
+    });
+    return result;
+  },
+  fromWorkflowHandlerRetryOptions(
+    handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry
+  )
+);
+var withSession2 = (eventStore, callback) => {
+  const sessionFactory = canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore);
+  return sessionFactory.withSession(callback);
+};
+var getWorkflowId = (options) => `emt:processor:workflow:${options.workflowName}`;
+var workflowProcessor = (options) => {
+  const { workflow, ...rest } = options;
+  const inputs = [...options.inputs.commands, ...options.inputs.events];
+  let canHandle = inputs;
+  if (options.separateInputInboxFromProcessing)
+    canHandle = [
+      ...canHandle,
+      ...options.inputs.commands.map((t) => `${workflow.name}:${t}`),
+      ...options.inputs.events.map((t) => `${workflow.name}:${t}`)
+    ];
+  if (options.outputHandler)
+    canHandle = [...canHandle, ...options.outputHandler.canHandle];
+  const handle = WorkflowHandler(options);
+  return reactor({
+    ...rest,
+    processorId: options.processorId ?? getWorkflowId({ workflowName: workflow.name }),
+    canHandle,
+    type: MessageProcessorType.PROJECTOR,
+    eachMessage: async (message2, context) => {
+      const messageType = message2.type;
+      const metadata = message2.metadata;
+      const isInput = metadata?.input === true;
+      if (isInput || inputs.includes(messageType)) {
+        const result = await handle(
+          context.connection.messageStore,
+          message2,
+          context
+        );
+        if (options.stopAfter && result.newMessages.length > 0) {
+          for (const outputMessage of result.newMessages) {
+            if (options.stopAfter(
+              outputMessage
+            )) {
+              return { type: "STOP", reason: "Stop condition reached" };
+            }
+          }
+        }
+        return;
+      }
+      if (options.outputHandler?.canHandle.includes(messageType) === true) {
+        const handledOutputMessages = await options.outputHandler.handle(
+          message2,
+          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/pongoProjectionSpec.ts
+import {
+  pongoClient as pongoClient2
+} from "@event-driven-io/pongo";
+var withCollection = async (handle, options) => {
+  const { connection, inDatabase, inCollection } = options;
+  const driver = await pongoDriverRegistry.tryResolve(
+    connection.driverType
+  );
+  const pongo = pongoClient2({
+    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 } = 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
+      connection,
+      execute,
+      driverType
     });
   }
 };
 var sqliteProjection = (definition) => projection(definition);
 var 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);
-    for (const sql of sqls) await context.connection.execute.command(sql);
+    await context.execute.batchCommand(sqls);
   },
   init: async (initOptions) => {
-    if (options.init) {
-      await options.init(initOptions);
-    }
-    if (options.initSQL) {
-      const initSQLs = Array.isArray(options.initSQL) ? options.initSQL : [options.initSQL];
-      for (const sql of initSQLs)
-        await initOptions.context.connection.execute.command(sql);
+    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);
+      }
     }
   }
 });
 var sqliteRawSQLProjection = (options) => {
-  const { evolve, ...rest } = options;
+  const { evolve, kind, ...rest } = options;
   return sqliteRawBatchSQLProjection({
+    kind: kind ?? "emt:projections:sqlite:raw:_sql:single",
     ...rest,
     evolve: async (events, context) => {
       const sqls = [];
@@ -515,20 +1388,154 @@ var sqliteRawSQLProjection = (options) => {
 };
 
 // src/eventStore/projections/sqliteProjectionSpec.ts
-import {
-  dumbo as dumbo3
-} from "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/sqlite";
-import { v4 as uuid6 } from "uuid";
+import { dumbo } from "@event-driven-io/dumbo";
+import { v4 as uuid7 } from "uuid";
+var SQLiteProjectionSpec = {
+  for: (options) => {
+    {
+      const driverType = options.driver.driverType;
+      const pool = options.pool ?? dumbo({
+        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 = options2?.numberOfTimes ?? 1;
+              for (const event of [
+                ...givenEvents,
+                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
+              ]) {
+                const metadata = {
+                  checkpoint: bigIntProcessorCheckpoint(++globalPosition),
+                  globalPosition,
+                  streamPosition: globalPosition,
+                  streamName: `test-${uuid7()}`,
+                  messageId: uuid7()
+                };
+                allEvents.push({
+                  ...event,
+                  kind: "Event",
+                  metadata: {
+                    ...metadata,
+                    ..."metadata" in event ? event.metadata ?? {} : {}
+                  }
+                });
+              }
+              if (!wasInitialized && projection2.init) {
+                await projection2.init({
+                  registrationType: "async",
+                  status: "active",
+                  context: {
+                    execute: connection.execute,
+                    connection,
+                    driverType
+                  },
+                  version: 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(
+                    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: ${error?.toString()}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${error?.toString()}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${error?.toString()}`
+                    );
+                  }
+                }
+              })
+            };
+          }
+        };
+      };
+    }
+  }
+};
+var eventInStream = (streamName, event) => {
+  return {
+    ...event,
+    metadata: {
+      ...event.metadata ?? {},
+      streamName: event.metadata?.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/SQLiteEventStore.ts
+// src/eventStore/schema/appendToStream.ts
 import {
-  dumbo as dumbo2
+  BatchCommandNoChangesError,
+  DumboError,
+  singleOrNull,
+  SQL,
+  UniqueConstraintError
 } from "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/sqlite";
-
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-import { SQL, singleOrNull } from "@event-driven-io/dumbo";
+import { v4 as uuid8 } from "uuid";
 
 // src/eventStore/schema/typing.ts
 var emmettPrefix2 = "emt";
@@ -565,154 +1572,8 @@ var projectionsTable = {
   name: `${emmettPrefix2}_projections`
 };
 
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-var { identifier } = SQL;
-var readLastMessageGlobalPosition = async (execute, options) => {
-  const result = await singleOrNull(
-    execute.query(
-      SQL`
-         SELECT global_position
-         FROM ${identifier(messagesTable.name)}
-         WHERE partition = ${options?.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
-import { SQL as SQL2 } from "@event-driven-io/dumbo";
-var { identifier: identifier2 } = SQL2;
-var readMessagesBatch = async (execute, options) => {
-  const from = "from" in options ? options.from : "after" in options ? options.after + 1n : 0n;
-  const batchSize = options && "batchSize" in options ? options.batchSize : options.to - options.from;
-  const fromCondition = from !== -0n ? SQL2`AND global_position >= ${from}` : "";
-  const toCondition = "to" in options ? SQL2`AND global_position <= ${options.to}` : SQL2.EMPTY;
-  const limitCondition = "batchSize" in options ? SQL2`LIMIT ${options.batchSize}` : SQL2.EMPTY;
-  const events = (await execute.query(
-    SQL2`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-           FROM ${identifier2(messagesTable.name)}
-           WHERE partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE ${fromCondition} ${toCondition}
-           ORDER BY global_position
-           ${limitCondition}`
-  )).rows.map((row) => {
-    const rawEvent = {
-      type: row.message_type,
-      data: JSONParser.parse(row.message_data),
-      metadata: JSONParser.parse(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)
-    };
-    return {
-      ...rawEvent,
-      kind: "Event",
-      metadata
-    };
-  });
-  return events.length > 0 ? {
-    currentGlobalPosition: events[events.length - 1].metadata.globalPosition,
-    messages: events,
-    areEventsLeft: events.length === batchSize
-  } : {
-    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
-    messages: [],
-    areEventsLeft: false
-  };
-};
-
-// src/eventStore/consumers/messageBatchProcessing/index.ts
-var DefaultSQLiteEventStoreProcessorBatchSize = 100;
-var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
-var sqliteEventStoreMessageBatchPuller = ({
-  pool,
-  batchSize,
-  eachBatch,
-  pullingFrequencyInMs
-}) => {
-  let isRunning = false;
-  let start;
-  const pullMessages = async (options) => {
-    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await pool.withConnection(
-      async ({ execute }) => readLastMessageGlobalPosition(execute)
-    )).currentGlobalPosition ?? 0n : options.startFrom.globalPosition;
-    const readMessagesOptions = {
-      after,
-      batchSize
-    };
-    let waitTime = 100;
-    do {
-      const { messages, currentGlobalPosition, areEventsLeft } = await pool.withConnection(
-        ({ execute }) => readMessagesBatch(execute, 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 (!areEventsLeft) {
-        waitTime = Math.min(waitTime * 2, 1e3);
-      } else {
-        waitTime = pullingFrequencyInMs;
-      }
-    } while (isRunning);
-  };
-  return {
-    get isRunning() {
-      return isRunning;
-    },
-    start: (options) => {
-      if (isRunning) return start;
-      start = (async () => {
-        isRunning = true;
-        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
-import {
-  dumbo
-} from "@event-driven-io/dumbo";
-
-// src/eventStore/consumers/sqliteProcessor.ts
-import "@event-driven-io/dumbo/sqlite";
-
 // src/eventStore/schema/appendToStream.ts
-import {
-  BatchCommandNoChangesError,
-  DumboError,
-  singleOrNull as singleOrNull2,
-  SQL as SQL3,
-  UniqueConstraintError
-} from "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/sqlite";
-import { v4 as uuid5 } from "uuid";
-var { identifier: identifier3, merge } = SQL3;
+var { identifier, merge } = SQL;
 var appendToStream = async (connection, streamName, streamType, messages, options) => {
   if (messages.length === 0) return { success: false };
   const expectedStreamVersion = toExpectedVersion(
@@ -724,7 +1585,7 @@ var appendToStream = async (connection, streamName, streamType, messages, option
       kind: m.kind ?? "Event",
       metadata: {
         streamName,
-        messageId: uuid5(),
+        messageId: uuid8(),
         streamPosition: BigInt(i + 1),
         ..."metadata" in m ? m.metadata ?? {} : {}
       }
@@ -782,7 +1643,7 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
       expectedStreamVersion
     );
   }
-  const streamSQL = expectedStreamVersion === 0n ? SQL3`INSERT INTO ${identifier3(streamsTable.name)}
+  const streamSQL = expectedStreamVersion === 0n ? SQL`INSERT INTO ${identifier(streamsTable.name)}
             (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
             VALUES  (
                 ${streamId},
@@ -793,7 +1654,7 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
                 false
             )
             RETURNING stream_position;
-          ` : SQL3`UPDATE ${identifier3(streamsTable.name)}
+          ` : SQL`UPDATE ${identifier(streamsTable.name)}
             SET stream_position = stream_position + ${messages.length}
             WHERE stream_id = ${streamId}
             AND stream_position = ${expectedStreamVersion}
@@ -821,9 +1682,9 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
   };
 };
 async function getLastStreamPosition(execute, streamId, expectedStreamVersion) {
-  const result = await singleOrNull2(
+  const result = await singleOrNull(
     execute.query(
-      SQL3`SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${identifier3(streamsTable.name)} WHERE stream_id = ${streamId}`
+      SQL`SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${identifier(streamsTable.name)} WHERE stream_id = ${streamId}`
     )
   );
   if (result?.stream_position == null) {
@@ -839,10 +1700,10 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
       throw new Error("Stream position is required");
     }
     const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
-    return SQL3`(${streamId},${streamPosition ?? 0n},${partition ?? defaultTag2},${message.kind === "Event" ? "E" : "C"},${message.data},${message.metadata},${expectedStreamVersion ?? 0n},${message.type},${message.metadata.messageId},${false})`;
+    return SQL`(${streamId},${streamPosition ?? 0n},${partition ?? defaultTag2},${message.kind === "Event" ? "E" : "C"},${message.data},${message.metadata},${expectedStreamVersion ?? 0n},${message.type},${message.metadata.messageId},${false})`;
   });
-  return SQL3`
-      INSERT INTO ${identifier3(messagesTable.name)} (
+  return SQL`
+      INSERT INTO ${identifier(messagesTable.name)} (
           stream_id, 
           stream_position, 
           partition, 
@@ -861,9 +1722,9 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
 };
 
 // src/eventStore/schema/migrations/0_41_0/0_41_0.snapshot.ts
-import { SQL as SQL4 } from "@event-driven-io/dumbo";
+import { SQL as SQL2 } from "@event-driven-io/dumbo";
 var schema_0_41_0 = [
-  SQL4`CREATE TABLE IF NOT EXISTS emt_streams(
+  SQL2`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',
@@ -873,7 +1734,7 @@ var schema_0_41_0 = [
     PRIMARY KEY (stream_id, partition, is_archived),
     UNIQUE (stream_id, partition, is_archived)
 )`,
-  SQL4`CREATE TABLE IF NOT EXISTS emt_messages(
+  SQL2`CREATE TABLE IF NOT EXISTS emt_messages(
     stream_id              TEXT                      NOT NULL,
     stream_position        BIGINT                    NOT NULL,
     partition              TEXT                      NOT NULL DEFAULT 'global',
@@ -888,7 +1749,7 @@ var schema_0_41_0 = [
     created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
     UNIQUE (stream_id, stream_position, partition, is_archived)
 )`,
-  SQL4`CREATE TABLE IF NOT EXISTS emt_subscriptions(
+  SQL2`CREATE TABLE IF NOT EXISTS emt_subscriptions(
     subscription_id                 TEXT                   NOT NULL,
     version                         INTEGER                NOT NULL DEFAULT 1,
     partition                       TEXT                   NOT NULL DEFAULT 'global',
@@ -898,10 +1759,10 @@ var schema_0_41_0 = [
 ];
 
 // src/eventStore/schema/migrations/0_42_0/0_42_0.migration.ts
-import { singleOrNull as singleOrNull3, SQL as SQL5 } from "@event-driven-io/dumbo";
-var { identifier: identifier4, plain } = SQL5;
+import { singleOrNull as singleOrNull2, SQL as SQL3 } from "@event-driven-io/dumbo";
+var { identifier: identifier2, plain } = SQL3;
 var migration_0_42_0_SQLs = [
-  SQL5`CREATE TABLE IF NOT EXISTS ${identifier4(processorsTable.name)}(
+  SQL3`CREATE TABLE IF NOT EXISTS ${identifier2(processorsTable.name)}(
     processor_id                 TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT '${plain(globalTag)}',
@@ -910,7 +1771,7 @@ var migration_0_42_0_SQLs = [
     processor_instance_id        TEXT                  DEFAULT 'emt:unknown',
     PRIMARY KEY (processor_id, partition, version)
 )`,
-  SQL5`CREATE TABLE IF NOT EXISTS ${identifier4(projectionsTable.name)}(
+  SQL3`CREATE TABLE IF NOT EXISTS ${identifier2(projectionsTable.name)}(
     name                         TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT '${plain(globalTag)}',
@@ -920,7 +1781,7 @@ var migration_0_42_0_SQLs = [
     definition                   JSONB                 NOT NULL DEFAULT '{}',
     PRIMARY KEY (name, partition, version)
 )`,
-  SQL5`INSERT INTO ${identifier4(processorsTable.name)}
+  SQL3`INSERT INTO ${identifier2(processorsTable.name)}
     (processor_id, version, partition, status, last_processed_checkpoint, processor_instance_id)
   SELECT
     subscription_id,
@@ -930,12 +1791,12 @@ var migration_0_42_0_SQLs = [
     printf('%019d', last_processed_position),
     'emt:unknown'
   FROM emt_subscriptions`,
-  SQL5`DROP TABLE emt_subscriptions`
+  SQL3`DROP TABLE emt_subscriptions`
 ];
 var migration_0_42_0_FromSubscriptionsToProcessors = async (execute) => {
-  const tableExists = await singleOrNull3(
+  const tableExists = await singleOrNull2(
     execute.query(
-      SQL5`SELECT name FROM sqlite_master WHERE type='table' AND name='emt_subscriptions'`
+      SQL3`SELECT name FROM sqlite_master WHERE type='table' AND name='emt_subscriptions'`
     )
   );
   if (!tableExists) {
@@ -945,9 +1806,9 @@ var migration_0_42_0_FromSubscriptionsToProcessors = async (execute) => {
 };
 
 // src/eventStore/schema/migrations/0_42_0/0_42_0.snapshot.ts
-import { SQL as SQL6 } from "@event-driven-io/dumbo";
+import { SQL as SQL4 } from "@event-driven-io/dumbo";
 var schema_0_42_0 = [
-  SQL6`CREATE TABLE IF NOT EXISTS emt_streams(
+  SQL4`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',
@@ -957,7 +1818,7 @@ var schema_0_42_0 = [
     PRIMARY KEY (stream_id, partition, is_archived),
     UNIQUE (stream_id, partition, is_archived)
 )`,
-  SQL6`CREATE TABLE IF NOT EXISTS emt_messages(
+  SQL4`CREATE TABLE IF NOT EXISTS emt_messages(
     stream_id              TEXT                      NOT NULL,
     stream_position        BIGINT                    NOT NULL,
     partition              TEXT                      NOT NULL DEFAULT 'global',
@@ -972,7 +1833,7 @@ var schema_0_42_0 = [
     created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
     UNIQUE (stream_id, stream_position, partition, is_archived)
 )`,
-  SQL6`CREATE TABLE IF NOT EXISTS emt_processors(
+  SQL4`CREATE TABLE IF NOT EXISTS emt_processors(
     processor_id                 TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT 'global',
@@ -981,7 +1842,7 @@ var schema_0_42_0 = [
     processor_instance_id        TEXT                  DEFAULT 'emt:unknown',
     PRIMARY KEY (processor_id, partition, version)
 )`,
-  SQL6`CREATE TABLE IF NOT EXISTS emt_projections(
+  SQL4`CREATE TABLE IF NOT EXISTS emt_projections(
     name                         TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT 'global',
@@ -993,337 +1854,332 @@ var schema_0_42_0 = [
 )`
 ];
 
-// src/eventStore/schema/readProcessorCheckpoint.ts
-import { SQL as SQL7, singleOrNull as singleOrNull4 } from "@event-driven-io/dumbo";
-var { identifier: identifier5 } = SQL7;
-var readProcessorCheckpoint = async (execute, options) => {
-  const result = await singleOrNull4(
+// src/eventStore/schema/readLastMessageGlobalPosition.ts
+import { SQL as SQL5, singleOrNull as singleOrNull3 } from "@event-driven-io/dumbo";
+var { identifier: identifier3 } = SQL5;
+var readLastMessageGlobalPosition = async (execute, options) => {
+  const result = await singleOrNull3(
     execute.query(
-      SQL7`SELECT last_processed_checkpoint
-           FROM ${identifier5(processorsTable.name)}
-           WHERE partition = ${options?.partition ?? defaultTag2} AND processor_id = ${options.processorId}
-           LIMIT 1`
+      SQL5`
+         SELECT global_position
+         FROM ${identifier3(messagesTable.name)}
+         WHERE partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE
+         ORDER BY global_position
+         LIMIT 1`
     )
   );
   return {
-    lastProcessedPosition: result !== null ? BigInt(result.last_processed_checkpoint) : null
+    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
   };
 };
 
-// src/eventStore/schema/readStream.ts
-import { SQL as SQL8 } from "@event-driven-io/dumbo";
-var { identifier: identifier6 } = SQL8;
-var readStream = async (execute, streamId, options) => {
-  const fromCondition = options?.from ? SQL8`AND stream_position >= ${options.from}` : SQL8.EMPTY;
-  const to = Number(
-    options?.to ?? (options?.maxCount ? (options.from ?? 0n) + options.maxCount : NaN)
-  );
-  const toCondition = !isNaN(to) ? SQL8`AND stream_position <= ${to}` : SQL8.EMPTY;
-  const { rows: results } = await execute.query(
-    SQL8`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 = ${options?.partition ?? defaultTag2} AND is_archived = FALSE ${fromCondition} ${toCondition}
-        ORDER BY stream_position ASC`
+// src/eventStore/schema/readMessagesBatch.ts
+import { mapRows, SQL as SQL6 } from "@event-driven-io/dumbo";
+var { identifier: identifier4 } = SQL6;
+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 ? SQL6`AND global_position >= ${from}` : after !== void 0 ? SQL6`AND global_position > ${after}` : SQL6.EMPTY;
+  const toCondition = "to" in options ? SQL6`AND global_position <= ${options.to}` : SQL6.EMPTY;
+  const limitCondition = "batchSize" in options ? SQL6`LIMIT ${options.batchSize}` : SQL6.EMPTY;
+  const messages = await mapRows(
+    execute.query(
+      SQL6`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+           FROM ${identifier4(messagesTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag2} 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 ? 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
+      };
+    }
   );
-  const messages = results.map((row) => {
-    const rawEvent = {
-      type: row.message_type,
-      data: JSONParser.parse(row.message_data),
-      metadata: JSONParser.parse(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)
-    };
-    const event = {
-      ...rawEvent,
-      kind: "Event",
-      metadata
-    };
-    return upcastRecordedMessage(event, options?.schema?.versioning);
-  });
   return messages.length > 0 ? {
-    currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
-    events: messages,
-    streamExists: true
+    currentGlobalPosition: messages[messages.length - 1].metadata.globalPosition,
+    messages,
+    areMessagesLeft: messages.length === batchSize
   } : {
-    currentStreamVersion: SQLiteEventStoreDefaultStreamVersion,
-    events: [],
-    streamExists: false
+    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
+    messages: [],
+    areMessagesLeft: false
   };
 };
 
-// src/eventStore/schema/storeProcessorCheckpoint.ts
-import {
-  DumboError as DumboError2,
-  singleOrNull as singleOrNull5,
-  SQL as SQL9,
-  UniqueConstraintError as UniqueConstraintError2
-} from "@event-driven-io/dumbo";
-var { identifier: identifier7 } = SQL9;
-async function storeSubscriptionCheckpointSQLite(execute, processorId, version, position, checkPosition, partition, processorInstanceId) {
-  processorInstanceId ??= unknownTag2;
-  if (checkPosition !== null) {
-    const updateResult = await execute.command(
-      SQL9`
-          UPDATE ${identifier7(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 singleOrNull5(
-      execute.query(
-        SQL9`
-          SELECT last_processed_checkpoint FROM ${identifier7(processorsTable.name)} 
-               WHERE processor_id = ${processorId} AND partition = ${partition}`
-      )
-    );
-    const currentPosition = current_position && current_position?.last_processed_checkpoint !== null ? BigInt(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(
-        SQL9`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 (!DumboError2.isInstanceOf(err, {
-        errorType: UniqueConstraintError2.ErrorType
-      })) {
-        throw err;
+// src/eventStore/schema/readProcessorCheckpoint.ts
+import { SQL as SQL7, singleOrNull as singleOrNull4 } from "@event-driven-io/dumbo";
+var { identifier: identifier5 } = SQL7;
+var readProcessorCheckpoint = async (execute, options) => {
+  const result = await singleOrNull4(
+    execute.query(
+      SQL7`SELECT last_processed_checkpoint
+           FROM ${identifier5(processorsTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag2} AND processor_id = ${options.processorId}
+           LIMIT 1`
+    )
+  );
+  return {
+    lastProcessedCheckpoint: result !== null ? result.last_processed_checkpoint : null
+  };
+};
+
+// src/eventStore/schema/readStream.ts
+import { SQL as SQL8 } from "@event-driven-io/dumbo";
+
+// src/eventStore/SQLiteEventStore.ts
+import { dumbo as dumbo3 } from "@event-driven-io/dumbo";
+
+// 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 readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 0n : parseBigIntProcessorCheckpoint(options.startFrom.lastCheckpoint);
+    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;
+        }
       }
-      const current = await singleOrNull5(
-        execute.query(
-          SQL9`
-            SELECT last_processed_checkpoint FROM ${identifier7(processorsTable.name)} 
-            WHERE processor_id = ${processorId} AND partition = ${partition}`
-        )
-      );
-      const currentPosition = current && current?.last_processed_checkpoint !== null ? BigInt(current.last_processed_checkpoint) : null;
-      if (currentPosition === position) {
-        return 0;
+      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 {
-        return 2;
+        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
+import { dumbo as dumbo2 } from "@event-driven-io/dumbo";
+import { v7 as uuid9 } from "uuid";
+
+// src/eventStore/consumers/sqliteCheckpointer.ts
+var sqliteCheckpointer = () => ({
+  read: async (options, context) => {
+    const result = await readProcessorCheckpoint(context.execute, options);
+    return { lastCheckpoint: result?.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;
   }
-}
-async function storeProcessorCheckpoint(execute, options) {
-  try {
-    const result = await storeSubscriptionCheckpointSQLite(
-      execute,
-      options.processorId,
-      options.version ?? 1,
-      options.newPosition,
-      options.lastProcessedPosition,
-      options.partition ?? defaultTag2
-    );
-    return result === 1 ? { success: true, newPosition: options.newPosition } : { success: false, reason: result === 0 ? "IGNORED" : "MISMATCH" };
-  } catch (error) {
-    console.log(error);
-    throw error;
-  }
-}
+});
 
-// src/eventStore/schema/streamExists.ts
-import { exists, SQL as SQL10 } from "@event-driven-io/dumbo";
-var streamExists = (execute, streamId, options) => exists(
-  execute.query(
-    SQL10`SELECT EXISTS (
-        SELECT 1
-        from ${SQL10.identifier(streamsTable.name)}
-        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE) as exists
-      `
-  )
-);
-
-// src/eventStore/schema/tables.ts
-import { SQL as SQL11 } from "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/sqlite";
-var { identifier: identifier8, plain: plain2 } = SQL11;
-var streamsTableSQL = SQL11`CREATE TABLE IF NOT EXISTS ${identifier8(streamsTable.name)}(
-      stream_id         TEXT                      NOT NULL,
-      stream_position   BIGINT                    NOT NULL DEFAULT 0,
-      partition         TEXT                      NOT NULL DEFAULT '${plain2(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 = SQL11`CREATE TABLE IF NOT EXISTS ${identifier8(messagesTable.name)}(
-      stream_id              TEXT                      NOT NULL,
-      stream_position        BIGINT                    NOT NULL,
-      partition              TEXT                      NOT NULL DEFAULT '${plain2(globalTag)}',
-      message_kind           CHAR(1)                   NOT NULL DEFAULT 'E',
-      message_data           JSONB                     NOT NULL,
-      message_metadata       JSONB                     NOT NULL,
-      message_schema_version TEXT                      NOT NULL,
-      message_type           TEXT                      NOT NULL,
-      message_id             TEXT                      NOT NULL,
-      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
-      global_position        INTEGER                   PRIMARY KEY,
-      created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
-      UNIQUE (stream_id, stream_position, partition, is_archived)
-  ); 
-`;
-var processorsTableSQL = SQL11`
-  CREATE TABLE IF NOT EXISTS ${SQL11.identifier(processorsTable.name)}(
-      processor_id                 TEXT                  NOT NULL,
-      version                      INTEGER               NOT NULL DEFAULT 1,
-      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
-      status                       TEXT                  NOT NULL DEFAULT 'stopped',
-      last_processed_checkpoint    TEXT                  NOT NULL,
-      processor_instance_id        TEXT                  DEFAULT '${plain2(unknownTag2)}',
-      PRIMARY KEY (processor_id, partition, version)
-  );
-`;
-var projectionsTableSQL = SQL11`
-  CREATE TABLE IF NOT EXISTS ${SQL11.identifier(projectionsTable.name)}(
-      name                         TEXT                  NOT NULL,
-      version                      INTEGER               NOT NULL DEFAULT 1,
-      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
-      type                         CHAR(1)               NOT NULL,
-      kind                         TEXT                  NOT NULL,
-      status                       TEXT                  NOT NULL,
-      definition                   JSONB                 NOT NULL DEFAULT '{}',
-      PRIMARY KEY (name, partition, version)
-  );
-`;
-var schemaSQL = [
-  streamsTableSQL,
-  messagesTableSQL,
-  processorsTableSQL,
-  projectionsTableSQL
-];
-var 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();
-    }
-  });
-};
-
-// src/eventStore/consumers/sqliteProcessor.ts
-var genericSQLiteProcessor = (options) => {
-  const { eachMessage } = options;
-  let isActive = true;
-  const mapToContext = (context) => {
-    const connection = context.connection ?? options.connectionOptions?.connection;
-    if (!connection)
-      throw new Error("Connection is required in context or options");
-    return { connection };
-  };
-  return {
-    id: options.processorId,
-    start: async ({
-      execute
-    }) => {
-      isActive = true;
-      if (options.startFrom !== "CURRENT") return options.startFrom;
-      const { lastProcessedPosition } = await readProcessorCheckpoint(execute, {
-        processorId: options.processorId,
-        partition: options.partition
-      });
-      if (lastProcessedPosition === null) return "BEGINNING";
-      return { globalPosition: lastProcessedPosition };
-    },
-    get isActive() {
-      return isActive;
-    },
-    handle: async ({ messages }, context) => {
-      if (!isActive) return;
-      const { connection } = mapToContext(context);
-      return connection.withTransaction(async (tx) => {
-        let result = void 0;
-        let lastProcessedPosition = null;
-        for (const message of messages) {
-          const typedMessage = message;
-          const messageProcessingResult = await eachMessage(typedMessage, {
-            connection: tx.connection
-          });
-          const newPosition = getCheckpoint(typedMessage);
-          await storeProcessorCheckpoint(tx.execute, {
-            processorId: options.processorId,
-            version: options.version,
-            lastProcessedPosition,
-            newPosition,
-            partition: options.partition
-          });
-          lastProcessedPosition = typedMessage.metadata.globalPosition;
-          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
-            isActive = false;
-            result = messageProcessingResult;
-            break;
-          }
-          if (options.stopAfter && options.stopAfter(typedMessage)) {
-            isActive = false;
-            result = { type: "STOP", reason: "Stop condition reached" };
-            break;
-          }
-          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
-            continue;
-        }
-        return result;
-      });
-    }
-  };
-};
-var sqliteProjectionProcessor = (options) => {
-  const projection2 = options.projection;
-  return genericSQLiteProcessor({
-    processorId: options.processorId ?? `projection:${projection2.name}`,
-    eachMessage: async (event, context) => {
-      if (!projection2.canHandle.includes(event.type)) return;
-      await projection2.handle([event], { connection: context.connection });
-    },
-    ...options
-  });
-};
-var sqliteProcessor = (options) => {
-  if ("projection" in options) {
-    return sqliteProjectionProcessor(options);
-  }
-  return genericSQLiteProcessor(options);
-};
+// src/eventStore/consumers/sqliteProcessor.ts
+var sqliteProcessingScope = () => {
+  const processingScope = async (handler, partialContext) => {
+    const connection = partialContext?.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 = partialContext?.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 = options.processorId ?? getWorkflowId({
+      workflowName: options.workflow.name ?? "unknown"
+    }),
+    processorInstanceId = getProcessorInstanceId(processorId),
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition
+  } = options;
+  const hooks = {
+    ...options.hooks ?? {},
+    onClose: options.hooks?.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: options.projection.name ?? "unknown"
+    }),
+    processorInstanceId = getProcessorInstanceId(processorId),
+    version = defaultProcessorVersion,
+    partition = 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
+  };
+  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 = options.processors ?? [];
+  let abortController = null;
   let start;
-  let currentMessagePuller;
-  const pool = options.pool ?? dumbo({
+  let messagePuller;
+  const pool = options.pool ?? dumbo2({
+    serialization: options.serialization,
     transactionOptions: {
       allowNestedTransactions: true,
       mode: "session_based"
     },
-    ...options
+    ...options.driver.mapToDumboOptions(options)
   });
   const eachBatch = (messagesBatch) => pool.withConnection(async (connection) => {
     const activeProcessors = processors.filter((s) => s.isActive);
@@ -1333,9 +2189,10 @@ var sqliteEventStoreConsumer = (options) => {
         reason: "No active processors"
       };
     const result = await Promise.allSettled(
-      activeProcessors.map((s) => {
-        return s.handle(messagesBatch, {
-          connection
+      activeProcessors.map(async (s) => {
+        return await s.handle(messagesBatch, {
+          connection,
+          execute: connection.execute
         });
       })
     );
@@ -1345,47 +2202,115 @@ var sqliteEventStoreConsumer = (options) => {
       type: "STOP"
     };
   });
-  const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
-    pool,
-    eachBatch,
-    batchSize: pulling?.batchSize ?? DefaultSQLiteEventStoreProcessorBatchSize,
-    pullingFrequencyInMs: pulling?.pullingFrequencyInMs ?? DefaultSQLiteEventStoreProcessorPullingFrequencyInMs
-  });
+  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 (currentMessagePuller) {
-      await currentMessagePuller.stop();
-      currentMessagePuller = void 0;
+    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 {
-    processors,
+    consumerId: options.consumerId ?? uuid9(),
     get isRunning() {
       return isRunning;
     },
-    processor: (options2) => {
-      const processor = sqliteProcessor(options2);
-      processors.push(processor);
+    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: pulling?.batchSize ?? DefaultSQLiteEventStoreProcessorBatchSize,
+        pullingFrequencyInMs: pulling?.pullingFrequencyInMs ?? DefaultSQLiteEventStoreProcessorPullingFrequencyInMs,
+        signal: abortController.signal
+      });
       start = (async () => {
-        if (processors.length === 0)
-          return Promise.reject(
-            new EmmettError(
-              "Cannot start consumer without at least a single processor"
+        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;
+              })
             )
-          );
-        isRunning = true;
-        const startFrom = zipSQLiteEventStoreMessageBatchPullerStartFrom(
-          await pool.withConnection(
-            (connection) => Promise.all(processors.map((o) => o.start(connection)))
           )
         );
-        return messagePooler.start({ startFrom });
+        await messagePuller.start({ startFrom });
+        await stopProcessors();
+        isRunning = false;
       })();
       return start;
     },
@@ -1393,7 +2318,6 @@ var sqliteEventStoreConsumer = (options) => {
     close: async () => {
       await stop();
       await pool.close();
-      await new Promise((resolve) => setTimeout(resolve, 250));
     }
   };
 };
@@ -1402,20 +2326,18 @@ var sqliteEventStoreConsumer = (options) => {
 var SQLiteEventStoreDefaultStreamVersion = 0n;
 var getSQLiteEventStore = (options) => {
   let autoGenerateSchema = false;
-  const pool = options.pool ?? dumbo2({
+  const serializer = JSONSerializer.from(options);
+  const pool = options.pool ?? dumbo3({
+    serialization: options.serialization,
     transactionOptions: {
       allowNestedTransactions: true,
       mode: "session_based"
     },
-    ...options
+    ...options.driver.mapToDumboOptions(options)
   });
   let migrateSchema = void 0;
   const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
   const onBeforeCommitHook = options.hooks?.onBeforeCommit;
-  const withConnection = async (handler) => pool.withConnection(async (connection) => {
-    await ensureSchemaExists(connection);
-    return await handler(connection);
-  });
   if (options) {
     autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
   }
@@ -1429,7 +2351,11 @@ var getSQLiteEventStore = (options) => {
                 version: projection2.version ?? 1,
                 registrationType: "async",
                 status: "active",
-                context
+                context: {
+                  execute: context.connection.execute,
+                  connection: context.connection,
+                  driverType: options.driver.driverType
+                }
               });
             }
           }
@@ -1442,20 +2368,23 @@ var getSQLiteEventStore = (options) => {
     }
     return migrateSchema;
   };
-  const ensureSchemaExists = (connection) => {
+  const ensureSchemaExists = () => {
     if (!autoGenerateSchema) return Promise.resolve();
-    return migrate(connection);
+    return pool.withConnection((connection) => migrate(connection));
   };
   return {
     async aggregateStream(streamName, options2) {
+      await ensureSchemaExists();
       const { evolve, initialState, read } = options2;
       const expectedStreamVersion = read?.expectedStreamVersion;
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
       }
-      const result = await withConnection(
-        ({ execute }) => readStream(execute, streamName, read)
+      const result = await readStream(
+        pool.execute,
+        streamName,
+        { ...read, serializer: read?.serialization?.serializer ?? serializer }
       );
       const currentStreamVersion = result.currentStreamVersion;
       assertExpectedVersionMatchesCurrent(
@@ -1473,31 +2402,40 @@ var getSQLiteEventStore = (options) => {
         streamExists: result.streamExists
       };
     },
-    readStream: async (streamName, options2) => withConnection(
-      ({ execute }) => readStream(execute, streamName, options2)
-    ),
-    appendToStream: async (streamName, events, options2) => {
+    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 : unknownTag2;
-      const appendResult = await withConnection(
+      const appendResult = await pool.withConnection(
         (connection) => appendToStream(connection, streamName, streamType, events, {
-          ...options2,
+          ...appendOptions,
           onBeforeCommit: async (messages, context) => {
             if (inlineProjections.length > 0)
               await handleProjections({
                 projections: inlineProjections,
                 events: messages,
-                ...context
+                execute: context.connection.execute,
+                connection: context.connection,
+                driverType: options.driver.driverType
               });
-            if (onBeforeCommitHook) await onBeforeCommitHook(messages, context);
+            if (onBeforeCommitHook)
+              await onBeforeCommitHook(messages, context);
           }
-        })
+        }),
+        { readonly: false }
       );
       if (!appendResult.success)
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          options2?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+          appendOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -1505,16 +2443,41 @@ var getSQLiteEventStore = (options) => {
         createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
       };
     },
-    streamExists(streamName, options2) {
-      return withConnection(
-        ({ execute }) => streamExists(execute, streamName, options2)
-      );
+    async streamExists(streamName, options2) {
+      await ensureSchemaExists();
+      return streamExists(pool.execute, streamName, options2);
     },
     consumer: (consumerOptions) => sqliteEventStoreConsumer({
       ...options ?? {},
       ...consumerOptions ?? {},
       pool
     }),
+    async withSession(callback) {
+      return await pool.withConnection(async (connection) => {
+        const sessionStore = getSQLiteEventStore({
+          ...options,
+          pool: dumbo3({
+            ...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(""),
@@ -1524,133 +2487,222 @@ var getSQLiteEventStore = (options) => {
   };
 };
 
-// src/eventStore/projections/sqliteProjectionSpec.ts
-var SQLiteProjectionSpec = {
-  for: (options) => {
-    {
-      const pool = options.pool ?? dumbo3({
-        transactionOptions: {
-          allowNestedTransactions: true,
-          mode: "session_based"
-        },
-        ...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 = options2?.numberOfTimes ?? 1;
-              for (const event of [
-                ...givenEvents,
-                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
-              ]) {
-                const metadata = {
-                  globalPosition: ++globalPosition,
-                  streamPosition: globalPosition,
-                  streamName: `test-${uuid6()}`,
-                  messageId: uuid6()
-                };
-                allEvents.push({
-                  ...event,
-                  kind: "Event",
-                  metadata: {
-                    ...metadata,
-                    ..."metadata" in event ? event.metadata ?? {} : {}
-                  }
-                });
-              }
-              if (!wasInitialized && projection2.init) {
-                await projection2.init({
-                  registrationType: "async",
-                  status: "active",
-                  context: { connection },
-                  version: projection2.version ?? 1
-                });
-                wasInitialized = true;
-              }
-              await connection.withTransaction(
-                () => handleProjections({
-                  events: allEvents,
-                  projections: [projection2],
-                  connection
-                })
-              );
-            };
-            return {
-              then: (assert, message) => pool.withConnection(async (connection) => {
-                await run(connection);
-                const succeeded = await assert({
-                  connection
-                });
-                if (succeeded !== void 0 && succeeded === false)
-                  assertFails(
-                    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: ${error?.toString()}`
-                    );
-                    return;
-                  }
-                  assertTrue(
-                    error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${error?.toString()}`
-                  );
-                  if (args[1]) {
-                    assertTrue(
-                      args[1](error),
-                      `Error didn't match the error condition: ${error?.toString()}`
-                    );
-                  }
-                }
-              })
-            };
-          }
-        };
-      };
+// src/eventStore/schema/readStream.ts
+var { identifier: identifier6 } = SQL8;
+var readStream = async (execute, streamId, options) => {
+  const { serializer } = options;
+  const fromCondition = options.from ? SQL8`AND stream_position >= ${options.from}` : SQL8.EMPTY;
+  const to = Number(
+    options?.to ?? (options?.maxCount ? (options.from ?? 0n) + options.maxCount : NaN)
+  );
+  const toCondition = !isNaN(to) ? SQL8`AND stream_position <= ${to}` : SQL8.EMPTY;
+  const { rows: results } = await execute.query(
+    SQL8`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 = ${options?.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 ? 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, options?.schema?.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
+import {
+  DumboError as DumboError2,
+  singleOrNull as singleOrNull5,
+  SQL as SQL9,
+  UniqueConstraintError as UniqueConstraintError2
+} from "@event-driven-io/dumbo";
+var { identifier: identifier7 } = SQL9;
+async function storeSubscriptionCheckpointSQLite(execute, processorId, version, position, checkPosition, partition, processorInstanceId) {
+  processorInstanceId ??= unknownTag2;
+  if (checkPosition !== null) {
+    const updateResult = await execute.command(
+      SQL9`
+          UPDATE ${identifier7(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 singleOrNull5(
+      execute.query(
+        SQL9`
+          SELECT last_processed_checkpoint FROM ${identifier7(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(
+        SQL9`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 (!DumboError2.isInstanceOf(err, {
+        errorType: UniqueConstraintError2.ErrorType
+      })) {
+        throw err;
+      }
+      const current = await singleOrNull5(
+        execute.query(
+          SQL9`
+            SELECT last_processed_checkpoint FROM ${identifier7(processorsTable.name)} 
+            WHERE processor_id = ${processorId} AND partition = ${partition}`
+        )
+      );
+      const currentPosition = current && current?.last_processed_checkpoint !== null ? BigInt(current.last_processed_checkpoint) : null;
+      if (currentPosition === position) {
+        return 0;
+      } else {
+        return 2;
+      }
     }
   }
-};
-var eventInStream = (streamName, event) => {
-  return {
-    ...event,
-    metadata: {
-      ...event.metadata ?? {},
-      streamName: event.metadata?.streamName ?? streamName
+}
+async function storeProcessorCheckpoint(execute, options) {
+  try {
+    const result = await storeSubscriptionCheckpointSQLite(
+      execute,
+      options.processorId,
+      options.version ?? 1,
+      options.newCheckpoint,
+      options.lastProcessedCheckpoint,
+      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;
+  }
+}
+
+// src/eventStore/schema/streamExists.ts
+import { exists, SQL as SQL10 } from "@event-driven-io/dumbo";
+var streamExists = (execute, streamId, options) => exists(
+  execute.query(
+    SQL10`SELECT EXISTS (
+        SELECT 1
+        from ${SQL10.identifier(streamsTable.name)}
+        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE) as exists
+      `
+  )
+);
+
+// src/eventStore/schema/tables.ts
+import { SQL as SQL11 } from "@event-driven-io/dumbo";
+var { identifier: identifier8, plain: plain2 } = SQL11;
+var streamsTableSQL = SQL11`CREATE TABLE IF NOT EXISTS ${identifier8(streamsTable.name)}(
+      stream_id         TEXT                      NOT NULL,
+      stream_position   BIGINT                    NOT NULL DEFAULT 0,
+      partition         TEXT                      NOT NULL DEFAULT '${plain2(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 = SQL11`CREATE TABLE IF NOT EXISTS ${identifier8(messagesTable.name)}(
+      stream_id              TEXT                      NOT NULL,
+      stream_position        BIGINT                    NOT NULL,
+      partition              TEXT                      NOT NULL DEFAULT '${plain2(globalTag)}',
+      message_kind           CHAR(1)                   NOT NULL DEFAULT 'E',
+      message_data           JSONB                     NOT NULL,
+      message_metadata       JSONB                     NOT NULL,
+      message_schema_version TEXT                      NOT NULL,
+      message_type           TEXT                      NOT NULL,
+      message_id             TEXT                      NOT NULL,
+      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
+      global_position        INTEGER                   PRIMARY KEY,
+      created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE (stream_id, stream_position, partition, is_archived)
+  ); 
+`;
+var processorsTableSQL = SQL11`
+  CREATE TABLE IF NOT EXISTS ${SQL11.identifier(processorsTable.name)}(
+      processor_id                 TEXT                  NOT NULL,
+      version                      INTEGER               NOT NULL DEFAULT 1,
+      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
+      status                       TEXT                  NOT NULL DEFAULT 'stopped',
+      last_processed_checkpoint    TEXT                  NOT NULL,
+      processor_instance_id        TEXT                  DEFAULT '${plain2(unknownTag2)}',
+      PRIMARY KEY (processor_id, partition, version)
+  );
+`;
+var projectionsTableSQL = SQL11`
+  CREATE TABLE IF NOT EXISTS ${SQL11.identifier(projectionsTable.name)}(
+      name                         TEXT                  NOT NULL,
+      version                      INTEGER               NOT NULL DEFAULT 1,
+      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
+      type                         CHAR(1)               NOT NULL,
+      kind                         TEXT                  NOT NULL,
+      status                       TEXT                  NOT NULL,
+      definition                   JSONB                 NOT NULL DEFAULT '{}',
+      PRIMARY KEY (name, partition, version)
+  );
+`;
+var schemaSQL = [
+  streamsTableSQL,
+  messagesTableSQL,
+  processorsTableSQL,
+  projectionsTableSQL
+];
+var 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
+      });
     }
-  };
-};
-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)
+    await tx.execute.batchCommand(schemaSQL);
+    if (hooks?.onAfterSchemaCreated) {
+      await hooks.onAfterSchemaCreated();
     }
-  })
+  });
 };
 export {
   SQLiteEventStoreDefaultStreamVersion,
@@ -1659,9 +2711,15 @@ export {
   assertSQLQueryResultMatches,
   createEventStoreSchema,
   defaultTag2 as defaultTag,
+  documentDoesNotExist,
+  documentExists,
+  documentMatchingExists,
+  documentsAreTheSame,
+  documentsMatchingHaveCount,
   emmettPrefix2 as emmettPrefix,
   eventInStream,
   eventsInStream,
+  expectPongoDocuments,
   expectSQL,
   getSQLiteEventStore,
   globalNames,
@@ -1672,6 +2730,9 @@ export {
   migration_0_42_0_FromSubscriptionsToProcessors,
   migration_0_42_0_SQLs,
   newEventsInStream,
+  pongoMultiStreamProjection,
+  pongoProjection,
+  pongoSingleStreamProjection,
   processorsTable,
   processorsTableSQL,
   projectionsTable,