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

package/dist/index.js

@@ -1,64 +1,3 @@
-// src/eventStore/consumers/messageBatchProcessing/index.ts
-import "@event-driven-io/dumbo";
-
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-import { singleOrNull, SQL } from "@event-driven-io/dumbo";
-
-// src/eventStore/schema/typing.ts
-var emmettPrefix = "emt";
-var globalTag = "global";
-var defaultTag = `${emmettPrefix}:default`;
-var unknownTag = `${emmettPrefix}:unknown`;
-var globalNames = {
-  module: `${emmettPrefix}:module:${globalTag}`,
-  tenant: `${emmettPrefix}:tenant:${globalTag}`
-};
-var columns = {
-  partition: {
-    name: "partition"
-  },
-  isArchived: { name: "is_archived" }
-};
-var streamsTable = {
-  name: `${emmettPrefix}_streams`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-var messagesTable = {
-  name: `${emmettPrefix}_messages`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-var processorsTable = {
-  name: `${emmettPrefix}_processors`
-};
-var projectionsTable = {
-  name: `${emmettPrefix}_projections`
-};
-
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-var readLastMessageGlobalPosition = async (execute, options) => {
-  const result = await singleOrNull(
-    execute.query(
-      SQL`SELECT global_position
-           FROM ${SQL.identifier(messagesTable.name)}
-           WHERE partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
-           ORDER BY transaction_id, global_position
-           LIMIT 1`
-    )
-  );
-  return {
-    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
-  };
-};
-
-// src/eventStore/schema/readMessagesBatch.ts
-import { mapRows, SQL as SQL2 } from "@event-driven-io/dumbo";
-
 // ../emmett/dist/chunk-AZDDB5SF.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isBigint = (val) => typeof val === "bigint" && val === val;
@@ -109,14 +48,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";
-var emmettPrefix2 = "emt";
-var defaultTag2 = `${emmettPrefix2}:default`;
-var unknownTag2 = `${emmettPrefix2}:unknown`;
+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";
@@ -137,6 +88,10 @@ var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends C
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
+var isExpectedVersionConflictError = (error) => error instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
+  error,
+  ExpectedVersionConflictError.Codes.ConcurrencyError
+);
 var isPrimitive = (value) => {
   const type = typeof value;
   return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
@@ -342,27 +297,110 @@ var toNormalizedString = (value) => value.toString().padStart(19, "0");
 var bigInt = {
   toNormalizedString
 };
-var ParseError = class extends Error {
-  constructor(text) {
-    super(`Cannot parse! ${text}`);
+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 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
-      // 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;
+var dateReviver = (_key, value) => {
+  if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
   }
+  return value;
+};
+var composeJSONReplacers = (...replacers) => {
+  const filteredReplacers = replacers.filter((r) => r !== void 0);
+  if (filteredReplacers.length === 0) return void 0;
+  return (key, value) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredReplacers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, replacer) => replacer(key, accValue),
+      value
+    )
+  );
+};
+var composeJSONRevivers = (...revivers) => {
+  const filteredRevivers = revivers.filter((r) => r !== void 0);
+  if (filteredRevivers.length === 0) return void 0;
+  return (key, value, context) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredRevivers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, reviver) => reviver(key, accValue, context),
+      value
+    )
+  );
+};
+var JSONReplacer = (opts) => composeJSONReplacers(
+  opts?.replacer,
+  opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0,
+  opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0
+);
+var JSONReviver = (opts) => composeJSONRevivers(
+  opts?.reviver,
+  opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0,
+  opts?.parseDates === true ? JSONRevivers.date : void 0
+);
+var JSONReplacers = {
+  bigInt: bigIntReplacer,
+  date: dateReplacer
+};
+var JSONRevivers = {
+  bigInt: bigIntReviver,
+  date: dateReviver
+};
+var jsonSerializer = (options) => {
+  const defaultReplacer = JSONReplacer(options);
+  const defaultReviver = JSONReviver(options);
+  return {
+    serialize: (object, serializerOptions) => JSON.stringify(
+      object,
+      serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer
+    ),
+    deserialize: (payload, deserializerOptions) => JSON.parse(
+      payload,
+      deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver
+    )
+  };
 };
+var JSONSerializer = Object.assign(jsonSerializer(), {
+  from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer)
+});
+var NoRetries = { retries: 0 };
 var asyncRetry = async (fn, opts) => {
   if (opts === void 0 || opts.retries === 0) return fn();
   return retry(
@@ -371,16 +409,16 @@ var asyncRetry = async (fn, opts) => {
         const result = await fn();
         if (opts?.shouldRetryResult && opts.shouldRetryResult(result)) {
           throw new EmmettError(
-            `Retrying because of result: ${JSONParser.stringify(result)}`
+            `Retrying because of result: ${JSONSerializer.serialize(result)}`
           );
         }
         return result;
-      } catch (error2) {
-        if (opts?.shouldRetryError && !opts.shouldRetryError(error2)) {
-          bail(error2);
+      } catch (error) {
+        if (opts?.shouldRetryError && !opts.shouldRetryError(error)) {
+          bail(error);
           return void 0;
         }
-        throw error2;
+        throw error;
       }
     },
     opts ?? { retries: 0 }
@@ -421,191 +459,23 @@ var hashText = async (text) => {
   const view = new BigInt64Array(hashBuffer, 0, 1);
   return view[0];
 };
-var AssertionError = class extends Error {
-  constructor(message2) {
-    super(message2);
-  }
-};
-var isSubset = (superObj, subObj) => {
-  const sup = superObj;
-  const sub = subObj;
-  assertOk(sup);
-  assertOk(sub);
-  return Object.keys(sub).every((ele) => {
-    if (typeof sub[ele] == "object") {
-      return isSubset(sup[ele], sub[ele]);
-    }
-    return sub[ele] === sup[ele];
-  });
-};
-var assertFails = (message2) => {
-  throw new AssertionError(message2 ?? "That should not ever happened, right?");
-};
-var assertDeepEqual = (actual, expected, message2) => {
-  if (!deepEquals(actual, expected))
-    throw new AssertionError(
-      message2 ?? `subObj:
-${JSONParser.stringify(expected)}
-is not equal to
-${JSONParser.stringify(actual)}`
-    );
-};
-function assertTrue(condition, message2) {
-  if (condition !== true)
-    throw new AssertionError(message2 ?? `Condition is false`);
-}
-function assertOk(obj, message2) {
-  if (!obj) throw new AssertionError(message2 ?? `Condition is not truthy`);
-}
-function assertEqual(expected, actual, message2) {
-  if (expected !== actual)
-    throw new AssertionError(
-      `${message2 ?? "Objects are not equal"}:
-Expected: ${JSONParser.stringify(expected)}
-Actual: ${JSONParser.stringify(actual)}`
-    );
-}
-function assertNotEqual(obj, other, message2) {
-  if (obj === other)
-    throw new AssertionError(
-      message2 ?? `Objects are equal: ${JSONParser.stringify(obj)}`
-    );
-}
-function assertIsNotNull(result) {
-  assertNotEqual(result, null);
-  assertOk(result);
-}
-var assertThatArray = (array) => {
-  return {
-    isEmpty: () => assertEqual(
-      array.length,
-      0,
-      `Array is not empty ${JSONParser.stringify(array)}`
-    ),
-    isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
-    hasSize: (length) => assertEqual(array.length, length),
-    containsElements: (other) => {
-      assertTrue(other.every((ts) => array.some((o) => deepEquals(ts, o))));
-    },
-    containsElementsMatching: (other) => {
-      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
-    },
-    containsOnlyElementsMatching: (other) => {
-      assertEqual(array.length, other.length, `Arrays lengths don't match`);
-      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
-    },
-    containsExactlyInAnyOrder: (other) => {
-      assertEqual(array.length, other.length);
-      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
-    },
-    containsExactlyInAnyOrderElementsOf: (other) => {
-      assertEqual(array.length, other.length);
-      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
-    },
-    containsExactlyElementsOf: (other) => {
-      assertEqual(array.length, other.length);
-      for (let i = 0; i < array.length; i++) {
-        assertTrue(deepEquals(array[i], other[i]));
-      }
-    },
-    containsExactly: (elem) => {
-      assertEqual(array.length, 1);
-      assertTrue(deepEquals(array[0], elem));
-    },
-    contains: (elem) => {
-      assertTrue(array.some((a) => deepEquals(a, elem)));
-    },
-    containsOnlyOnceElementsOf: (other) => {
-      assertTrue(
-        other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
-      );
-    },
-    containsAnyOf: (other) => {
-      assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
-    },
-    allMatch: (matches) => {
-      assertTrue(array.every(matches));
-    },
-    anyMatches: (matches) => {
-      assertTrue(array.some(matches));
-    },
-    allMatchAsync: async (matches) => {
-      for (const item of array) {
-        assertTrue(await matches(item));
-      }
-    }
-  };
-};
-var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!options?.downcast)
-    return recordedMessage;
-  const downcasted = options.downcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: downcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in downcasted ? downcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!options?.downcast)
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
-  );
-};
-var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!options?.upcast)
-    return recordedMessage;
-  const upcasted = options.upcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: upcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in upcasted ? upcasted.metadata : {}
-      }
-    } : {}
-  };
-};
 var 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;
+  return message2.metadata.checkpoint;
 };
 var wasMessageHandled = (message2, checkpoint) => {
   const messageCheckpoint = getCheckpoint(message2);
-  const checkpointBigint = checkpoint;
-  return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpointBigint !== null && checkpointBigint !== void 0 && messageCheckpoint <= checkpointBigint;
+  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 = defaultTag2;
-var getProcessorInstanceId = (processorId) => `${processorId}:${uuid4()}`;
+var defaultProcessorPartition = defaultTag;
+var getProcessorInstanceId = (processorId) => `${processorId}:${uuid3()}`;
 var getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
 var reactor = (options) => {
   const {
@@ -652,12 +522,13 @@ var reactor = (options) => {
     id: processorId,
     instanceId,
     type,
+    canHandle,
     init,
     start: async (startOptions) => {
       if (isActive) return;
       await init(startOptions);
       isActive = true;
-      closeSignal = onShutdown(() => close({}));
+      closeSignal = onShutdown(() => close(startOptions));
       if (lastCheckpoint !== null)
         return {
           lastCheckpoint
@@ -760,138 +631,638 @@ var projector = (options) => {
     eachMessage: async (event2, context) => projection2.handle([event2], context)
   });
 };
-var projection = (definition) => definition;
-
-// src/eventStore/schema/readMessagesBatch.ts
-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 ? `AND global_position >= ${from}` : "";
-  const toCondition = "to" in options ? `AND global_position <= ${options.to}` : "";
-  const limitCondition = "batchSize" in options ? `LIMIT ${options.batchSize}` : "";
-  const messages = await mapRows(
-    execute.query(
-      SQL2`
-          SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-           FROM ${SQL2.identifier(messagesTable.name)}
-           WHERE partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${SQL2.plain(fromCondition)} ${SQL2.plain(toCondition)}
-           ORDER BY transaction_id, global_position
-           ${SQL2.plain(limitCondition)}`
+var AssertionError = class extends Error {
+  constructor(message2) {
+    super(message2);
+  }
+};
+var isSubset = (superObj, subObj) => {
+  const sup = superObj;
+  const sub = subObj;
+  assertOk(sup);
+  assertOk(sub);
+  return Object.keys(sub).every((ele) => {
+    if (sub[ele] !== null && typeof sub[ele] == "object") {
+      return isSubset(sup[ele], sub[ele]);
+    }
+    return sub[ele] === sup[ele];
+  });
+};
+var assertFails = (message2) => {
+  throw new AssertionError(message2 ?? "That should not ever happened, right?");
+};
+var 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`);
+}
+function assertOk(obj, message2) {
+  if (!obj) throw new AssertionError(message2 ?? `Condition is not truthy`);
+}
+function assertEqual(expected, actual, message2) {
+  if (expected !== actual)
+    throw new AssertionError(
+      `${message2 ?? "Objects are not equal"}:
+Expected: ${JSONSerializer.serialize(expected)}
+Actual: ${JSONSerializer.serialize(actual)}`
+    );
+}
+function assertNotEqual(obj, other, message2) {
+  if (obj === other)
+    throw new AssertionError(
+      message2 ?? `Objects are equal: ${JSONSerializer.serialize(obj)}`
+    );
+}
+function assertIsNotNull(result) {
+  assertNotEqual(result, null);
+  assertOk(result);
+}
+function assertIsNull(result) {
+  assertEqual(result, null);
+}
+var assertThatArray = (array) => {
+  return {
+    isEmpty: () => assertEqual(
+      array.length,
+      0,
+      `Array is not empty ${JSONSerializer.serialize(array)}`
     ),
-    (row) => {
-      const rawEvent = {
-        type: row.message_type,
-        data: row.message_data,
-        metadata: 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
-      };
+    isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
+    hasSize: (length) => assertEqual(array.length, length),
+    containsElements: (other) => {
+      assertTrue(other.every((ts) => array.some((o) => deepEquals(ts, o))));
+    },
+    containsElementsMatching: (other) => {
+      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
+    },
+    containsOnlyElementsMatching: (other) => {
+      assertEqual(array.length, other.length, `Arrays lengths don't match`);
+      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
+    },
+    containsExactlyInAnyOrder: (other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrderElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      for (let i = 0; i < array.length; i++) {
+        assertTrue(deepEquals(array[i], other[i]));
+      }
+    },
+    containsExactly: (elem) => {
+      assertEqual(array.length, 1);
+      assertTrue(deepEquals(array[0], elem));
+    },
+    contains: (elem) => {
+      assertTrue(array.some((a) => deepEquals(a, elem)));
+    },
+    containsOnlyOnceElementsOf: (other) => {
+      assertTrue(
+        other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
+      );
+    },
+    containsAnyOf: (other) => {
+      assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
+    },
+    allMatch: (matches) => {
+      assertTrue(array.every(matches));
+    },
+    anyMatches: (matches) => {
+      assertTrue(array.some(matches));
+    },
+    allMatchAsync: async (matches) => {
+      for (const item of array) {
+        assertTrue(await matches(item));
+      }
     }
-  );
-  return messages.length > 0 ? {
-    currentGlobalPosition: messages[messages.length - 1].metadata.globalPosition,
-    messages,
-    areMessagesLeft: messages.length === batchSize
-  } : {
-    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
-    messages: [],
-    areMessagesLeft: false
   };
 };
-
-// src/eventStore/consumers/messageBatchProcessing/index.ts
-var DefaultPostgreSQLEventStoreProcessorBatchSize = 100;
-var DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = 50;
-var postgreSQLEventStoreMessageBatchPuller = ({
-  executor,
-  batchSize,
-  eachBatch,
-  pullingFrequencyInMs,
-  stopWhen,
-  signal
-}) => {
-  let isRunning = false;
-  let start;
-  const pullMessages = async (options) => {
-    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 0n : options.startFrom.lastCheckpoint;
-    const readMessagesOptions = {
-      after,
-      batchSize
-    };
-    let waitTime = 100;
-    while (isRunning && !signal?.aborted) {
-      const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
-      if (messages.length > 0) {
-        const result = await eachBatch(messages);
-        if (result && result.type === "STOP") {
-          isRunning = false;
-          break;
-        }
-      }
-      readMessagesOptions.after = currentGlobalPosition;
-      await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (stopWhen?.noMessagesLeft === true && !areMessagesLeft) {
-        isRunning = false;
-        break;
+var downcastRecordedMessage = (recordedMessage, options) => {
+  if (!options?.downcast)
+    return recordedMessage;
+  const downcasted = options.downcast(
+    recordedMessage
+  );
+  return {
+    ...recordedMessage,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: downcasted.data,
+    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
+      metadata: {
+        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+        ..."metadata" in downcasted ? downcasted.metadata : {}
       }
-      if (!areMessagesLeft) {
-        waitTime = Math.min(waitTime * 2, 1e3);
-      } else {
-        waitTime = pullingFrequencyInMs;
+    } : {}
+  };
+};
+var downcastRecordedMessages = (recordedMessages, options) => {
+  if (!options?.downcast)
+    return recordedMessages;
+  return recordedMessages.map(
+    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
+  );
+};
+var upcastRecordedMessage = (recordedMessage, options) => {
+  if (!options?.upcast)
+    return recordedMessage;
+  const upcasted = options.upcast(
+    recordedMessage
+  );
+  return {
+    ...recordedMessage,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: upcasted.data,
+    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
+      metadata: {
+        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+        ..."metadata" in upcasted ? upcasted.metadata : {}
       }
-    }
+    } : {}
   };
+};
+var 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 {
-    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;
+    ...msg,
+    metadata: {
+      ...existingMetadata,
+      action
     }
   };
 };
-var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (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];
+var createWrappedInitialState = (initialState) => {
+  return () => ({
+    userState: initialState(),
+    processedInputIds: /* @__PURE__ */ new Set()
+  });
 };
-
-// src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
-import { dumbo as dumbo6 } from "@event-driven-io/dumbo";
-import { v7 as uuid7 } from "uuid";
-
-// src/eventStore/consumers/postgreSQLProcessor.ts
-import { dumbo as dumbo5 } from "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/pg";
-import "pg";
-
-// src/eventStore/projections/locks/tryAcquireProcessorLock.ts
-import { single } from "@event-driven-io/dumbo";
-
-// src/eventStore/schema/processors/processorsLocks.ts
-import { SQL as SQL4 } from "@event-driven-io/dumbo";
-
+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/schema/readLastMessageGlobalPosition.ts
+import { singleOrNull, SQL } from "@event-driven-io/dumbo";
+
+// src/eventStore/schema/typing.ts
+var emmettPrefix2 = "emt";
+var globalTag = "global";
+var defaultTag2 = `${emmettPrefix2}:default`;
+var unknownTag2 = `${emmettPrefix2}:unknown`;
+var globalNames = {
+  module: `${emmettPrefix2}:module:${globalTag}`,
+  tenant: `${emmettPrefix2}:tenant:${globalTag}`
+};
+var columns = {
+  partition: {
+    name: "partition"
+  },
+  isArchived: { name: "is_archived" }
+};
+var streamsTable = {
+  name: `${emmettPrefix2}_streams`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
+  }
+};
+var messagesTable = {
+  name: `${emmettPrefix2}_messages`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
+  }
+};
+var processorsTable = {
+  name: `${emmettPrefix2}_processors`
+};
+var projectionsTable = {
+  name: `${emmettPrefix2}_projections`
+};
+
+// src/eventStore/schema/readLastMessageGlobalPosition.ts
+var readLastMessageGlobalPosition = async (execute, options) => {
+  const result = await singleOrNull(
+    execute.query(
+      SQL`SELECT global_position
+           FROM ${SQL.identifier(messagesTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+           ORDER BY transaction_id, global_position
+           LIMIT 1`
+    )
+  );
+  return {
+    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
+  };
+};
+
+// src/eventStore/schema/readMessagesBatch.ts
+import { mapRows, SQL as SQL2 } from "@event-driven-io/dumbo";
+var readMessagesBatch = async (execute, 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 ? SQL2`AND global_position >= ${from}` : after !== void 0 ? SQL2`AND global_position > ${after}` : SQL2.EMPTY;
+  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 messages = await mapRows(
+    execute.query(
+      SQL2`
+          SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+           FROM ${SQL2.identifier(messagesTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${fromCondition} ${toCondition}
+           ORDER BY transaction_id, global_position
+           ${limitCondition}`
+    ),
+    (row) => {
+      const rawEvent = {
+        type: row.message_type,
+        data: row.message_data,
+        metadata: 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
+      };
+    }
+  );
+  return messages.length > 0 ? {
+    currentGlobalPosition: messages[messages.length - 1].metadata.globalPosition,
+    messages,
+    areMessagesLeft: messages.length === batchSize
+  } : {
+    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
+    messages: [],
+    areMessagesLeft: false
+  };
+};
+
+// src/eventStore/consumers/messageBatchProcessing/index.ts
+var DefaultPostgreSQLEventStoreProcessorBatchSize = 100;
+var DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = 50;
+var postgreSQLEventStoreMessageBatchPuller = ({
+  executor,
+  batchSize,
+  eachBatch,
+  pullingFrequencyInMs,
+  stopWhen,
+  signal
+}) => {
+  let isRunning = false;
+  let start;
+  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
+    };
+    let waitTime = 100;
+    while (isRunning && !signal?.aborted) {
+      const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
+      if (messages.length > 0) {
+        const result = await eachBatch(messages);
+        if (result && result.type === "STOP") {
+          isRunning = false;
+          break;
+        }
+      }
+      readMessagesOptions.after = currentGlobalPosition;
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+      if (stopWhen?.noMessagesLeft === true && !areMessagesLeft) {
+        isRunning = false;
+        break;
+      }
+      if (!areMessagesLeft) {
+        waitTime = Math.min(waitTime * 2, 1e3);
+      } else {
+        waitTime = pullingFrequencyInMs;
+      }
+    }
+  };
+  return {
+    get isRunning() {
+      return isRunning;
+    },
+    start: (options) => {
+      if (isRunning) return start;
+      isRunning = true;
+      start = (async () => {
+        return pullMessages(options);
+      })();
+      return start;
+    },
+    stop: async () => {
+      if (!isRunning) return;
+      isRunning = false;
+      await start;
+    }
+  };
+};
+var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (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/postgreSQLEventStoreConsumer.ts
+import { dumbo as dumbo6 } from "@event-driven-io/dumbo";
+import { v7 as uuid9 } from "uuid";
+
+// src/eventStore/consumers/postgreSQLProcessor.ts
+import { dumbo as dumbo5 } from "@event-driven-io/dumbo";
+
+// src/eventStore/postgreSQLEventStore.ts
+import {
+  dumbo as dumbo4,
+  fromDatabaseDriverType,
+  getFormatter,
+  SQL as SQL20
+} from "@event-driven-io/dumbo";
+
+// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
+import { single } from "@event-driven-io/dumbo";
+
+// src/eventStore/schema/projections/projectionsLocks.ts
+import { SQL as SQL4 } from "@event-driven-io/dumbo";
+
 // src/eventStore/schema/createFunctionIfDoesNotExist.ts
 import { SQL as SQL3 } from "@event-driven-io/dumbo";
 var createFunctionIfDoesNotExistSQL = (functionName, functionDefinition) => SQL3`
@@ -903,31 +1274,115 @@ END IF;
 END $$;
 `;
 
-// src/eventStore/schema/processors/processorsLocks.ts
-var tryAcquireProcessorLockSQL = createFunctionIfDoesNotExistSQL(
-  "emt_try_acquire_processor_lock",
+// src/eventStore/schema/projections/projectionsLocks.ts
+var tryAcquireProjectionLockSQL = createFunctionIfDoesNotExistSQL(
+  "emt_try_acquire_projection_lock",
   SQL4`
-CREATE OR REPLACE FUNCTION emt_try_acquire_processor_lock(
-    p_lock_key               BIGINT,
-    p_processor_id           TEXT,
-    p_version                INT,
-    p_partition              TEXT       DEFAULT '${SQL4.plain(defaultTag)}',
-    p_processor_instance_id  TEXT       DEFAULT '${SQL4.plain(unknownTag)}',
-    p_projection_name        TEXT       DEFAULT NULL,
-    p_projection_type        VARCHAR(1) DEFAULT NULL,
-    p_projection_kind        TEXT       DEFAULT NULL,
-    p_lock_timeout_seconds   INT        DEFAULT 300
+CREATE OR REPLACE FUNCTION emt_try_acquire_projection_lock(
+    p_lock_key   BIGINT,
+    p_partition  TEXT,
+    p_name       TEXT,
+    p_version    INT
 )
-RETURNS TABLE (acquired BOOLEAN, checkpoint TEXT)
+RETURNS TABLE (acquired BOOLEAN, is_active BOOLEAN)
 LANGUAGE plpgsql
-AS $emt_try_acquire_processor_lock$
+AS $emt_try_acquire_projection_lock$
+BEGIN
+    RETURN QUERY
+    WITH lock_check AS (
+        SELECT pg_try_advisory_xact_lock_shared(p_lock_key) AS acquired
+    ),
+    status_check AS (
+        SELECT status = 'active' AS is_active
+        FROM ${SQL4.plain(projectionsTable.name)}
+        WHERE partition = p_partition AND name = p_name AND version = p_version
+    )
+    SELECT
+        COALESCE((SELECT lc.acquired FROM lock_check lc), false),
+        COALESCE((SELECT sc.is_active FROM status_check sc), true);
+END;
+$emt_try_acquire_projection_lock$;
+`
+);
+var callTryAcquireProjectionLock = (params) => SQL4`SELECT * FROM emt_try_acquire_projection_lock(${params.lockKey}, ${params.partition}, ${params.name}, ${params.version});`;
+
+// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
+var tryAcquireProjectionLock = async (execute, {
+  lockKey,
+  projectionName,
+  partition,
+  version
+}) => {
+  const lockKeyBigInt = isBigint(lockKey) ? lockKey : await hashText(lockKey);
+  const { acquired, is_active } = await single(
+    execute.query(
+      callTryAcquireProjectionLock({
+        lockKey: lockKeyBigInt.toString(),
+        partition,
+        name: projectionName,
+        version
+      })
+    )
+  );
+  return acquired === true && is_active === true;
+};
+
+// src/eventStore/projections/locks/postgreSQLProjectionLock.ts
+var postgreSQLProjectionLock = (options) => {
+  let acquired = false;
+  const lockKey = options.lockKey ?? toProjectionLockKey(options);
+  return {
+    tryAcquire: async (context) => {
+      if (acquired) {
+        return true;
+      }
+      acquired = await tryAcquireProjectionLock(context.execute, {
+        ...options,
+        lockKey
+      });
+      return acquired;
+    },
+    release: (_context) => {
+      if (!acquired) return;
+      acquired = false;
+    }
+  };
+};
+var toProjectionLockKey = ({
+  projectionName,
+  partition,
+  version
+}) => `${partition}:${projectionName}:${version}`;
+
+// src/eventStore/projections/locks/tryAcquireProcessorLock.ts
+import { single as single2 } from "@event-driven-io/dumbo";
+
+// src/eventStore/schema/processors/processorsLocks.ts
+import { SQL as SQL5 } from "@event-driven-io/dumbo";
+var tryAcquireProcessorLockSQL = createFunctionIfDoesNotExistSQL(
+  "emt_try_acquire_processor_lock",
+  SQL5`
+CREATE OR REPLACE FUNCTION emt_try_acquire_processor_lock(
+    p_lock_key               BIGINT,
+    p_processor_id           TEXT,
+    p_version                INT,
+    p_partition              TEXT       DEFAULT '${SQL5.plain(defaultTag2)}',
+    p_processor_instance_id  TEXT       DEFAULT '${SQL5.plain(unknownTag2)}',
+    p_projection_name        TEXT       DEFAULT NULL,
+    p_projection_type        VARCHAR(1) DEFAULT NULL,
+    p_projection_kind        TEXT       DEFAULT NULL,
+    p_lock_timeout_seconds   INT        DEFAULT 300
+)
+RETURNS TABLE (acquired BOOLEAN, checkpoint TEXT)
+LANGUAGE plpgsql
+AS $emt_try_acquire_processor_lock$
 BEGIN
     RETURN QUERY
     WITH lock_check AS (
         SELECT pg_try_advisory_xact_lock(p_lock_key) AS lock_acquired
     ),
     ownership_check AS (
-        INSERT INTO ${SQL4.plain(processorsTable.name)} (
+        INSERT INTO ${SQL5.plain(processorsTable.name)} (
             processor_id,
             partition,
             version,
@@ -938,20 +1393,20 @@ BEGIN
             created_at,
             last_updated
         )
-        SELECT p_processor_id, p_partition, p_version, p_processor_instance_id, 'running', '${SQL4.plain(bigInt.toNormalizedString(0n))}', '0'::xid8, now(), now()
+        SELECT p_processor_id, p_partition, p_version, p_processor_instance_id, 'running', '${SQL5.plain(bigInt.toNormalizedString(0n))}', '0'::xid8, now(), now()
         WHERE (SELECT lock_acquired FROM lock_check) = true
         ON CONFLICT (processor_id, partition, version) DO UPDATE
         SET processor_instance_id = p_processor_instance_id,
             status = 'running',
             last_updated = now()
-        WHERE ${SQL4.plain(processorsTable.name)}.processor_instance_id = p_processor_instance_id
-           OR ${SQL4.plain(processorsTable.name)}.processor_instance_id = '${SQL4.plain(unknownTag)}'
-           OR ${SQL4.plain(processorsTable.name)}.status = 'stopped'
-           OR ${SQL4.plain(processorsTable.name)}.last_updated < now() - (p_lock_timeout_seconds || ' seconds')::interval
+        WHERE ${SQL5.plain(processorsTable.name)}.processor_instance_id = p_processor_instance_id
+           OR ${SQL5.plain(processorsTable.name)}.processor_instance_id = '${SQL5.plain(unknownTag2)}'
+           OR ${SQL5.plain(processorsTable.name)}.status = 'stopped'
+           OR ${SQL5.plain(processorsTable.name)}.last_updated < now() - (p_lock_timeout_seconds || ' seconds')::interval
         RETURNING last_processed_checkpoint
     ),
     projection_status AS (
-        INSERT INTO ${SQL4.plain(projectionsTable.name)} (
+        INSERT INTO ${SQL5.plain(projectionsTable.name)} (
             name,
             partition,
             version,
@@ -976,13 +1431,13 @@ $emt_try_acquire_processor_lock$;
 );
 var releaseProcessorLockSQL = createFunctionIfDoesNotExistSQL(
   "emt_release_processor_lock",
-  SQL4`
+  SQL5`
 CREATE OR REPLACE FUNCTION emt_release_processor_lock(
     p_lock_key              BIGINT,
     p_processor_id          TEXT,
     p_partition             TEXT,
     p_version               INT,
-    p_processor_instance_id TEXT DEFAULT '${SQL4.plain(unknownTag)}',
+    p_processor_instance_id TEXT DEFAULT '${SQL5.plain(unknownTag2)}',
     p_projection_name       TEXT DEFAULT NULL
 )
 RETURNS BOOLEAN
@@ -992,7 +1447,7 @@ DECLARE
     v_rows_updated INT;
 BEGIN
     IF p_projection_name IS NOT NULL THEN
-        UPDATE ${SQL4.plain(projectionsTable.name)}
+        UPDATE ${SQL5.plain(projectionsTable.name)}
         SET status = 'active',
             last_updated = now()
         WHERE partition = p_partition
@@ -1000,9 +1455,9 @@ BEGIN
           AND version = p_version;
     END IF;
 
-    UPDATE ${SQL4.plain(processorsTable.name)}
+    UPDATE ${SQL5.plain(processorsTable.name)}
     SET status = 'stopped',
-        processor_instance_id = '${SQL4.plain(unknownTag)}',
+        processor_instance_id = '${SQL5.plain(unknownTag2)}',
         last_updated = now()
     WHERE processor_id = p_processor_id
       AND partition = p_partition
@@ -1018,7 +1473,7 @@ END;
 $emt_release_processor_lock$;
 `
 );
-var callTryAcquireProcessorLock = (params) => SQL4`
+var callTryAcquireProcessorLock = (params) => SQL5`
     SELECT * FROM emt_try_acquire_processor_lock(
       ${params.lockKey}, 
       ${params.processorId}, 
@@ -1031,7 +1486,7 @@ var callTryAcquireProcessorLock = (params) => SQL4`
       ${params.lockTimeoutSeconds}
     );
   `;
-var callReleaseProcessorLock = (params) => SQL4`SELECT emt_release_processor_lock(
+var callReleaseProcessorLock = (params) => SQL5`SELECT emt_release_processor_lock(
     ${params.lockKey}, 
     ${params.processorId}, 
     ${params.partition}, 
@@ -1044,7 +1499,7 @@ var callReleaseProcessorLock = (params) => SQL4`SELECT emt_release_processor_loc
 var PROCESSOR_LOCK_DEFAULT_TIMEOUT_SECONDS = 300;
 var tryAcquireProcessorLock = async (execute, options) => {
   const lockKeyBigInt = isBigint(options.lockKey) ? options.lockKey : await hashText(options.lockKey);
-  const { acquired, checkpoint } = await single(
+  const { acquired, checkpoint } = await single2(
     execute.command(
       callTryAcquireProcessorLock({
         lockKey: lockKeyBigInt.toString(),
@@ -1062,7 +1517,7 @@ var tryAcquireProcessorLock = async (execute, options) => {
   return acquired ? { acquired: true, checkpoint } : { acquired: false };
 };
 var tryAcquireProcessorLockWithRetry = async (execute, options) => {
-  const policy = options.lockPolicy ?? DefaultPostgreSQLProcessorLockPolicy;
+  const policy = options.lockAcquisitionPolicy ?? DefaultPostgreSQLProcessorLockPolicy;
   if (policy.type === "retry") {
     return asyncRetry(() => tryAcquireProcessorLock(execute, options), {
       retries: policy.retries - 1,
@@ -1075,7 +1530,7 @@ var tryAcquireProcessorLockWithRetry = async (execute, options) => {
 };
 var releaseProcessorLock = async (execute, options) => {
   const lockKeyBigInt = isBigint(options.lockKey) ? options.lockKey : await hashText(options.lockKey);
-  const { result } = await single(
+  const { result } = await single2(
     execute.command(
       callReleaseProcessorLock({
         lockKey: lockKeyBigInt.toString(),
@@ -1090,90 +1545,6 @@ var releaseProcessorLock = async (execute, options) => {
   return result;
 };
 
-// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
-import { single as single2 } from "@event-driven-io/dumbo";
-
-// src/eventStore/schema/projections/projectionsLocks.ts
-import { SQL as SQL5 } from "@event-driven-io/dumbo";
-var tryAcquireProjectionLockSQL = createFunctionIfDoesNotExistSQL(
-  "emt_try_acquire_projection_lock",
-  SQL5`
-CREATE OR REPLACE FUNCTION emt_try_acquire_projection_lock(
-    p_lock_key   BIGINT,
-    p_partition  TEXT,
-    p_name       TEXT,
-    p_version    INT
-)
-RETURNS TABLE (acquired BOOLEAN, is_active BOOLEAN)
-LANGUAGE plpgsql
-AS $emt_try_acquire_projection_lock$
-BEGIN
-    RETURN QUERY
-    WITH lock_check AS (
-        SELECT pg_try_advisory_xact_lock_shared(p_lock_key) AS acquired
-    ),
-    status_check AS (
-        SELECT status = 'active' AS is_active
-        FROM ${SQL5.plain(projectionsTable.name)}
-        WHERE partition = p_partition AND name = p_name AND version = p_version
-    )
-    SELECT
-        COALESCE((SELECT lc.acquired FROM lock_check lc), false),
-        COALESCE((SELECT sc.is_active FROM status_check sc), true);
-END;
-$emt_try_acquire_projection_lock$;
-`
-);
-var callTryAcquireProjectionLock = (params) => SQL5`SELECT * FROM emt_try_acquire_projection_lock(${params.lockKey}, ${params.partition}, ${params.name}, ${params.version});`;
-
-// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
-var tryAcquireProjectionLock = async (execute, {
-  lockKey,
-  projectionName,
-  partition,
-  version
-}) => {
-  const lockKeyBigInt = isBigint(lockKey) ? lockKey : await hashText(lockKey);
-  const { acquired, is_active } = await single2(
-    execute.query(
-      callTryAcquireProjectionLock({
-        lockKey: lockKeyBigInt.toString(),
-        partition,
-        name: projectionName,
-        version
-      })
-    )
-  );
-  return acquired === true && is_active === true;
-};
-
-// src/eventStore/projections/locks/postgreSQLProjectionLock.ts
-var postgreSQLProjectionLock = (options) => {
-  let acquired = false;
-  const lockKey = options.lockKey ?? toProjectionLockKey(options);
-  return {
-    tryAcquire: async (context) => {
-      if (acquired) {
-        return true;
-      }
-      acquired = await tryAcquireProjectionLock(context.execute, {
-        ...options,
-        lockKey
-      });
-      return acquired;
-    },
-    release: (_context) => {
-      if (!acquired) return;
-      acquired = false;
-    }
-  };
-};
-var toProjectionLockKey = ({
-  projectionName,
-  partition,
-  version
-}) => `${partition}:${projectionName}:${version}`;
-
 // src/eventStore/projections/locks/postgreSQLProcessorLock.ts
 var DefaultPostgreSQLProcessorLockPolicy = {
   type: "fail"
@@ -1190,7 +1561,7 @@ var postgreSQLProcessorLock = (options) => {
         ...options,
         lockKey
       });
-      if (!result.acquired && options.lockPolicy?.type !== "skip") {
+      if (!result.acquired && options.lockAcquisitionPolicy?.type !== "skip") {
         throw new EmmettError(
           `Failed to acquire lock for processor '${options.processorId}'`
         );
@@ -1223,7 +1594,7 @@ var toProcessorLockKey = ({
 
 // src/eventStore/projections/management/projectionManagement.ts
 import {
-  JSONSerializer,
+  JSONSerializer as JSONSerializer2,
   single as single3,
   singleOrNull as singleOrNull2,
   SQL as SQL7
@@ -1354,7 +1725,7 @@ var registerProjection = async (execute, options) => {
   const name = registration.projection.name;
   const version = registration.projection.version ?? 1;
   const kind = registration.projection.kind ?? registration.type;
-  const definition = JSONSerializer.serialize(registration.projection);
+  const definition = JSONSerializer2.serialize(registration.projection);
   const lockKey = toProjectionLockKey({
     projectionName: name,
     partition,
@@ -1575,7 +1946,6 @@ var pongoSingleStreamProjection = (options) => {
 };
 
 // src/eventStore/projections/pongo/pongoProjectionSpec.ts
-import "@event-driven-io/dumbo";
 import {
   pongoClient as pongoClient2
 } from "@event-driven-io/pongo";
@@ -1666,7 +2036,7 @@ var documentDoesNotExist = (options) => (assertOptions) => withCollection(
     const result = await collection.findOne(
       "withId" in options ? { _id: options.withId } : options.matchingFilter
     );
-    assertIsNotNull(result);
+    assertIsNull(result);
   },
   { ...options, ...assertOptions }
 );
@@ -1715,100 +2085,338 @@ var expectPongoDocuments = {
 
 // src/eventStore/projections/postgresProjectionSpec.ts
 import {
-  dumbo as dumbo4
-} from "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/pg";
-import { v4 as uuid6 } from "uuid";
-
-// src/eventStore/postgreSQLEventStore.ts
-import {
-  dumbo as dumbo3,
-  fromDatabaseDriverType,
-  getFormatter,
-  SQL as SQL20
-} from "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/pg";
-import "pg";
-
-// src/eventStore/schema/index.ts
-import {
-  dumbo as dumbo2,
-  runSQLMigrations,
-  sqlMigration as sqlMigration4
-} from "@event-driven-io/dumbo";
-
-// src/eventStore/schema/appendToStream.ts
-import {
-  DumboError,
-  single as single4,
-  SQL as SQL8,
-  UniqueConstraintError
+  dumbo
 } from "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/pg";
-import { v4 as uuid5 } from "uuid";
-var appendToStreamSQL = createFunctionIfDoesNotExistSQL(
-  "emt_append_to_stream",
-  SQL8`CREATE OR REPLACE FUNCTION emt_append_to_stream(
-      v_message_ids text[],
-      v_messages_data jsonb[],
-      v_messages_metadata jsonb[],
-      v_message_schema_versions text[],
-      v_message_types text[],
-      v_message_kinds text[],
-      v_stream_id text,
-      v_stream_type text,
-      v_expected_stream_position bigint DEFAULT NULL,
-      v_partition text DEFAULT emt_sanitize_name('default_partition')
-  ) RETURNS TABLE (
-      success boolean,
-      next_stream_position bigint,
-      global_positions bigint[],
-      transaction_id xid8
-  ) LANGUAGE plpgsql
-  AS $emt_append_to_stream$
-  DECLARE
-      v_next_stream_position bigint;
-      v_position bigint;
-      v_updated_rows int;
-      v_transaction_id xid8;
-      v_global_positions bigint[];
-  BEGIN
-      v_transaction_id := pg_current_xact_id();
-
-      IF v_expected_stream_position IS NULL THEN
-          SELECT COALESCE(
-            (SELECT stream_position 
-            FROM ${SQL8.identifier(streamsTable.name)}
-            WHERE stream_id = v_stream_id 
-              AND partition = v_partition 
-              AND is_archived = FALSE
-            LIMIT 1), 
-            0
-        ) INTO v_expected_stream_position;
-      END IF;
-
-      v_next_stream_position := v_expected_stream_position + array_upper(v_messages_data, 1);
-
-      IF v_expected_stream_position = 0 THEN
-          INSERT INTO ${SQL8.identifier(streamsTable.name)}
-              (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
-          VALUES
-              (v_stream_id, v_next_stream_position, v_partition, v_stream_type, '{}', FALSE);
-      ELSE
-          UPDATE ${SQL8.identifier(streamsTable.name)} as s              
-          SET stream_position = v_next_stream_position
-          WHERE stream_id = v_stream_id AND stream_position = v_expected_stream_position AND partition = v_partition AND is_archived = FALSE;
-
-          get diagnostics v_updated_rows = row_count;
-
-          IF v_updated_rows = 0 THEN
-              RETURN QUERY SELECT FALSE, NULL::bigint, NULL::bigint[], NULL::xid8;
-              RETURN;
-          END IF;
-      END IF;
-
-      WITH ev AS (
-          SELECT row_number() OVER () + v_expected_stream_position AS stream_position, 
+import { v4 as uuid7 } from "uuid";
+var PostgreSQLProjectionSpec = {
+  for: (options) => {
+    {
+      const { projection: projection2, ...restOptions } = options;
+      const dumboOptions = {
+        ...restOptions,
+        serialization: projection2.serialization
+      };
+      const { connectionString } = dumboOptions;
+      let wasInitialised = false;
+      const initialize = async (pool) => {
+        const eventStore = getPostgreSQLEventStore(connectionString, {
+          // TODO: This will need to change when we support other drivers
+          connectionOptions: { dumbo: pool }
+        });
+        if (wasInitialised) return;
+        wasInitialised = true;
+        await eventStore.schema.migrate();
+        if (projection2.init)
+          await pool.withTransaction(async (transaction) => {
+            await projection2.init({
+              registrationType: "async",
+              version: projection2.version ?? 1,
+              status: "active",
+              context: await transactionToPostgreSQLProjectionHandlerContext(
+                connectionString,
+                pool,
+                transaction
+              )
+            });
+          });
+      };
+      return (givenEvents) => {
+        return {
+          when: (events, options2) => {
+            const allEvents = [];
+            const run = async (pool) => {
+              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 ?? {} : {}
+                  }
+                });
+              }
+              await initialize(pool);
+              await pool.withTransaction(async (transaction) => {
+                await handleProjections({
+                  events: allEvents,
+                  projections: [projection2],
+                  ...await transactionToPostgreSQLProjectionHandlerContext(
+                    connectionString,
+                    pool,
+                    transaction
+                  )
+                });
+              });
+            };
+            return {
+              then: async (assert, message) => {
+                const pool = dumbo(dumboOptions);
+                try {
+                  await run(pool);
+                  const succeeded = await assert({ pool, connectionString });
+                  if (succeeded !== void 0 && succeeded === false)
+                    assertFails(
+                      message ?? "Projection specification didn't match the criteria"
+                    );
+                } finally {
+                  await pool.close();
+                }
+              },
+              thenThrows: async (...args) => {
+                const pool = dumbo(dumboOptions);
+                try {
+                  await run(pool);
+                  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()}`
+                    );
+                  }
+                } finally {
+                  await pool.close();
+                }
+              }
+            };
+          }
+        };
+      };
+    }
+  }
+};
+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 ({ pool: { execute } }) => {
+  const result = await execute.query(sql);
+  assertThatArray(rows).containsExactlyInAnyOrder(result.rows);
+};
+var expectSQL = {
+  query: (sql) => ({
+    resultRows: {
+      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows)
+    }
+  })
+};
+
+// src/eventStore/projections/postgreSQLProjection.ts
+var transactionToPostgreSQLProjectionHandlerContext = async (connectionString, pool, transaction) => ({
+  execute: transaction.execute,
+  connection: {
+    connectionString,
+    client: await transaction.connection.open(),
+    transaction,
+    pool
+  }
+});
+var handleProjections = async (options) => {
+  const {
+    projections: allProjections,
+    events,
+    connection: { pool, transaction, connectionString },
+    partition = defaultTag2
+  } = options;
+  const eventTypes = events.map((e) => e.type);
+  const projections = allProjections.filter(
+    (p) => p.canHandle.some((type) => eventTypes.includes(type))
+  );
+  const client = await transaction.connection.open();
+  for (const projection2 of projections) {
+    if (projection2.name) {
+      const lockAcquired = await postgreSQLProjectionLock({
+        projectionName: projection2.name,
+        partition,
+        version: projection2.version ?? 1
+      }).tryAcquire({ execute: transaction.execute });
+      if (!lockAcquired) {
+        continue;
+      }
+    }
+    await projection2.handle(events, {
+      connection: {
+        connectionString,
+        pool,
+        client,
+        transaction
+      },
+      execute: transaction.execute
+    });
+  }
+};
+var postgreSQLProjection = (definition) => projection({
+  ...definition,
+  init: async (options) => {
+    await registerProjection(options.context.execute, {
+      // TODO: pass partition from options
+      partition: defaultTag2,
+      status: "active",
+      registration: {
+        type: "async",
+        // TODO: fix this
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+        projection: definition
+      }
+    });
+    if (definition.init) {
+      await definition.init(options);
+    }
+  }
+});
+var postgreSQLRawBatchSQLProjection = (options) => postgreSQLProjection({
+  name: options.name,
+  kind: options.kind ?? "emt:projections:postgresql:raw_sql:batch",
+  version: options.version,
+  canHandle: options.canHandle,
+  eventsOptions: options.eventsOptions,
+  handle: async (events, context) => {
+    const sqls = await options.evolve(events, context);
+    await context.execute.batchCommand(sqls);
+  },
+  init: async (initOptions) => {
+    const initSQL = options.init ? await options.init(initOptions) : void 0;
+    if (initSQL) {
+      if (Array.isArray(initSQL)) {
+        await initOptions.context.execute.batchCommand(initSQL);
+      } else {
+        await initOptions.context.execute.command(initSQL);
+      }
+    }
+  }
+});
+var postgreSQLRawSQLProjection = (options) => {
+  const { evolve, kind, ...rest } = options;
+  return postgreSQLRawBatchSQLProjection({
+    kind: kind ?? "emt:projections:postgresql:raw:_sql:single",
+    ...rest,
+    evolve: async (events, context) => {
+      const sqls = [];
+      for (const event of events) {
+        const pendingSqls = await evolve(event, context);
+        if (Array.isArray(pendingSqls)) {
+          sqls.push(...pendingSqls);
+        } else {
+          sqls.push(pendingSqls);
+        }
+      }
+      return sqls;
+    }
+  });
+};
+
+// src/eventStore/schema/index.ts
+import {
+  dumbo as dumbo3,
+  runSQLMigrations,
+  sqlMigration as sqlMigration4
+} from "@event-driven-io/dumbo";
+
+// src/eventStore/schema/appendToStream.ts
+import {
+  DumboError,
+  single as single4,
+  SQL as SQL8,
+  UniqueConstraintError
+} from "@event-driven-io/dumbo";
+import { v4 as uuid8 } from "uuid";
+var appendToStreamSQL = createFunctionIfDoesNotExistSQL(
+  "emt_append_to_stream",
+  SQL8`CREATE OR REPLACE FUNCTION emt_append_to_stream(
+      v_message_ids text[],
+      v_messages_data jsonb[],
+      v_messages_metadata jsonb[],
+      v_message_schema_versions text[],
+      v_message_types text[],
+      v_message_kinds text[],
+      v_stream_id text,
+      v_stream_type text,
+      v_expected_stream_position bigint DEFAULT NULL,
+      v_partition text DEFAULT emt_sanitize_name('default_partition')
+  ) RETURNS TABLE (
+      success boolean,
+      next_stream_position bigint,
+      global_positions bigint[],
+      transaction_id xid8
+  ) LANGUAGE plpgsql
+  AS $emt_append_to_stream$
+  DECLARE
+      v_next_stream_position bigint;
+      v_position bigint;
+      v_updated_rows int;
+      v_transaction_id xid8;
+      v_global_positions bigint[];
+  BEGIN
+      v_transaction_id := pg_current_xact_id();
+
+      IF v_expected_stream_position IS NULL THEN
+          SELECT COALESCE(
+            (SELECT stream_position 
+            FROM ${SQL8.identifier(streamsTable.name)}
+            WHERE stream_id = v_stream_id 
+              AND partition = v_partition 
+              AND is_archived = FALSE
+            LIMIT 1), 
+            0
+        ) INTO v_expected_stream_position;
+      END IF;
+
+      v_next_stream_position := v_expected_stream_position + array_upper(v_messages_data, 1);
+
+      IF v_expected_stream_position = 0 THEN
+          INSERT INTO ${SQL8.identifier(streamsTable.name)}
+              (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
+          VALUES
+              (v_stream_id, v_next_stream_position, v_partition, v_stream_type, '{}', FALSE);
+      ELSE
+          UPDATE ${SQL8.identifier(streamsTable.name)} as s              
+          SET stream_position = v_next_stream_position
+          WHERE stream_id = v_stream_id AND stream_position = v_expected_stream_position AND partition = v_partition AND is_archived = FALSE;
+
+          get diagnostics v_updated_rows = row_count;
+
+          IF v_updated_rows = 0 THEN
+              RETURN QUERY SELECT FALSE, NULL::bigint, NULL::bigint[], NULL::xid8;
+              RETURN;
+          END IF;
+      END IF;
+
+      WITH ev AS (
+          SELECT row_number() OVER () + v_expected_stream_position AS stream_position, 
                 message_data, 
                 message_metadata, 
                 schema_version, 
@@ -1864,7 +2472,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
       ...e,
       kind: e.kind ?? "Event",
       metadata: {
-        messageId: uuid5(),
+        messageId: uuid8(),
         ..."metadata" in e ? e.metadata ?? {} : {}
       }
     }));
@@ -1942,7 +2550,7 @@ var appendEventsRaw = (execute, streamId, streamType, messages, options) => sing
       streamId,
       streamType,
       expectedStreamPosition: options?.expectedStreamVersion ?? null,
-      partition: options?.partition ?? defaultTag
+      partition: options?.partition ?? defaultTag2
     })
   )
 );
@@ -2437,7 +3045,7 @@ BEGIN
         END;
         $fnpar$ LANGUAGE plpgsql;
 
-        PERFORM emt_add_partition('${SQL11.plain(defaultTag)}');
+        PERFORM emt_add_partition('${SQL11.plain(defaultTag2)}');
 
         -- 3. Copy data from old table to new table
         INSERT INTO "emt_processors"
@@ -2553,7 +3161,7 @@ BEGIN
           p_position               TEXT,
           p_check_position         TEXT,
           p_transaction_id         xid8,
-          p_partition              TEXT DEFAULT '${SQL11.plain(defaultTag)}',
+          p_partition              TEXT DEFAULT '${SQL11.plain(defaultTag2)}',
           p_processor_instance_id  TEXT DEFAULT 'emt:unknown'
         ) RETURNS INT AS $fn2$
         DECLARE
@@ -2688,7 +3296,7 @@ CREATE OR REPLACE FUNCTION emt_try_acquire_processor_lock(
     p_lock_key               BIGINT,
     p_processor_id           TEXT,
     p_version                INT,
-    p_partition              TEXT       DEFAULT '${SQL11.plain(defaultTag)}',
+    p_partition              TEXT       DEFAULT '${SQL11.plain(defaultTag2)}',
     p_processor_instance_id  TEXT       DEFAULT 'emt:unknown',
     p_projection_name        TEXT       DEFAULT NULL,
     p_projection_type        VARCHAR(1) DEFAULT NULL,
@@ -3467,8 +4075,8 @@ CREATE OR REPLACE FUNCTION store_processor_checkpoint(
   p_position               TEXT,
   p_check_position         TEXT,
   p_transaction_id         xid8,
-  p_partition              TEXT DEFAULT '${SQL13.plain(defaultTag)}',
-  p_processor_instance_id  TEXT DEFAULT '${SQL13.plain(unknownTag)}'
+  p_partition              TEXT DEFAULT '${SQL13.plain(defaultTag2)}',
+  p_processor_instance_id  TEXT DEFAULT '${SQL13.plain(unknownTag2)}'
 ) RETURNS INT AS $spc$
 DECLARE
   current_position TEXT;
@@ -3500,1083 +4108,838 @@ BEGIN
       -- Return appropriate codes based on current position
       IF current_position = p_position THEN
           RETURN 0;  -- Idempotent check: position already set
-      ELSIF current_position > p_position THEN
-          RETURN 3;  -- Current ahead: another process has progressed further
-      ELSE
-          RETURN 2;  -- Mismatch: check position doesn't match current
-      END IF;
-  END IF;
-
-  -- Handle the case when p_check_position is NULL: Insert if not exists
-  BEGIN
-      INSERT INTO "${SQL13.plain(processorsTable.name)}"("processor_id", "version", "last_processed_checkpoint", "partition", "last_processed_transaction_id", "created_at", "last_updated")
-      VALUES (p_processor_id, p_version, p_position, p_partition, p_transaction_id, now(), now());
-      RETURN 1;  -- Successfully inserted
-  EXCEPTION WHEN unique_violation THEN
-      -- If insertion failed, it means the row already exists
-      SELECT "last_processed_checkpoint" INTO current_position
-      FROM "${SQL13.plain(processorsTable.name)}"
-      WHERE "processor_id" = p_processor_id 
-        AND "partition" = p_partition 
-        AND "version" = p_version;
-
-      IF current_position = p_position THEN
-          RETURN 0;  -- Idempotent check: position already set
-      ELSIF current_position > p_position THEN
-          RETURN 3;  -- Current ahead: another process has progressed further
-      ELSE
-          RETURN 2;  -- Insertion failed, row already exists with different position
-      END IF;
-  END;
-END;
-$spc$ LANGUAGE plpgsql;
-`
-);
-var callStoreProcessorCheckpoint = (params) => SQL13`
-    SELECT store_processor_checkpoint(
-      ${params.processorId}, 
-      ${params.version}, 
-      ${params.position}, 
-      ${params.checkPosition}, 
-      pg_current_xact_id(), 
-      ${params.partition}, 
-      ${params.processorInstanceId}
-    ) as result;`;
-var storeProcessorCheckpoint = async (execute, options) => {
-  try {
-    const { result } = await single5(
-      execute.command(
-        callStoreProcessorCheckpoint({
-          processorId: options.processorId,
-          version: options.version ?? 1,
-          position: options.newCheckpoint !== null ? bigInt.toNormalizedString(options.newCheckpoint) : null,
-          checkPosition: options.lastProcessedCheckpoint !== null ? bigInt.toNormalizedString(options.lastProcessedCheckpoint) : null,
-          partition: options.partition ?? defaultTag,
-          processorInstanceId: options.processorInstanceId ?? unknownTag
-        })
-      )
-    );
-    return result === 1 ? { success: true, newCheckpoint: options.newCheckpoint } : {
-      success: false,
-      reason: result === 0 ? "IGNORED" : result === 3 ? "CURRENT_AHEAD" : "MISMATCH"
-    };
-  } catch (error) {
-    console.log(error);
-    throw error;
-  }
-};
-
-// src/eventStore/schema/tables.ts
-import { SQL as SQL15 } from "@event-driven-io/dumbo";
-
-// src/eventStore/schema/migrations/0_43_0/index.ts
-import {
-  dumbo,
-  SQL as SQL14,
-  sqlMigration as sqlMigration3
-} from "@event-driven-io/dumbo";
-var migration_0_43_0_cleanupLegacySubscriptionSQL = SQL14`
-DO $$
-BEGIN
-IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'emt_subscriptions') THEN
-    -- Restore clean emt_add_partition (remove creation of emt_subscriptions partitions)
-    CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $fnpar$
-    BEGIN                
-        PERFORM emt_add_table_partition('${SQL14.plain(messagesTable.name)}', partition_name);
-        PERFORM emt_add_table_partition('${SQL14.plain(streamsTable.name)}', partition_name);
-    
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-            FOR VALUES IN (%L);',
-            emt_sanitize_name('${SQL14.plain(processorsTable.name)}' || '_' || partition_name), '${SQL14.plain(processorsTable.name)}', partition_name
-        );
-    
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-            FOR VALUES IN (%L);',
-            emt_sanitize_name('${SQL14.plain(projectionsTable.name)}' || '_' || partition_name), '${SQL14.plain(projectionsTable.name)}', partition_name
-        );
-    END;
-    $fnpar$ LANGUAGE plpgsql;
-
-    -- Drop old subscriptions table if it exists
-    DROP TABLE IF EXISTS emt_subscriptions CASCADE;
-
-    -- Drop old function if it exists
-    DROP FUNCTION IF EXISTS store_subscription_checkpoint(character varying, bigint, bigint, bigint, xid8, text);
-    
-    -- Restore clean store_processor_checkpoint (remove dual-write logic)
-    CREATE OR REPLACE FUNCTION store_processor_checkpoint(
-      p_processor_id           TEXT,
-      p_version                BIGINT,
-      p_position               TEXT,
-      p_check_position         TEXT,
-      p_transaction_id         xid8,
-      p_partition              TEXT DEFAULT '${SQL14.plain(defaultTag)}',
-      p_processor_instance_id  TEXT DEFAULT 'emt:unknown'
-    ) RETURNS INT AS $fn$
-    DECLARE
-      current_position TEXT;
-    BEGIN
-      IF p_check_position IS NOT NULL THEN
-          UPDATE "emt_processors"
-          SET
-            "last_processed_checkpoint" = p_position,
-            "last_processed_transaction_id" = p_transaction_id,
-            "last_updated" = now()
-          WHERE "processor_id" = p_processor_id
-            AND "last_processed_checkpoint" = p_check_position
-            AND "partition" = p_partition            
-            AND "version" = p_version;
-
-          IF FOUND THEN
-              RETURN 1;
-          END IF;
-
-          SELECT "last_processed_checkpoint" INTO current_position
-          FROM "emt_processors"
-          WHERE "processor_id" = p_processor_id 
-            AND "partition" = p_partition            
-            AND "version" = p_version ;
-
-          IF current_position = p_position THEN
-              RETURN 0;
-          ELSIF current_position > p_position THEN
-              RETURN 3;
-          ELSE
-              RETURN 2;
-          END IF;
-      END IF;
-
-      BEGIN
-          INSERT INTO "emt_processors"("processor_id", "version", "last_processed_checkpoint", "partition", "last_processed_transaction_id", "created_at", "last_updated")
-          VALUES (p_processor_id, p_version, p_position, p_partition, p_transaction_id, now(), now());
-          RETURN 1;
-      EXCEPTION WHEN unique_violation THEN
-          SELECT "last_processed_checkpoint" INTO current_position
-          FROM "emt_processors"
-          WHERE "processor_id" = p_processor_id 
-            AND "partition" = p_partition
-            AND "version" = p_version;
-
-          IF current_position = p_position THEN
-              RETURN 0;
-          ELSE
-              RETURN 2;
-          END IF;
-      END;
-    END;
-    $fn$ LANGUAGE plpgsql;
-END IF;
-END $$;
-`;
-var migration_0_43_0_cleanupLegacySubscription = sqlMigration3("emt:postgresql:eventstore:0.43.0:cleanup-legacy-subscription", [
-  migration_0_43_0_cleanupLegacySubscriptionSQL
-]);
-var cleanupLegacySubscriptionTables = async (connectionString) => {
-  const pool = dumbo({ connectionString });
-  try {
-    await pool.withTransaction(async ({ execute }) => {
-      await execute.command(migration_0_43_0_cleanupLegacySubscriptionSQL);
-    });
-  } finally {
-    await pool.close();
-  }
-};
-
-// src/eventStore/schema/tables.ts
-var streamsTableSQL = SQL15`
-  CREATE TABLE IF NOT EXISTS ${SQL15.identifier(streamsTable.name)}(
-      stream_id         TEXT                      NOT NULL,
-      stream_position   BIGINT                    NOT NULL,
-      partition         TEXT                      NOT NULL DEFAULT '${SQL15.plain(defaultTag)}',
-      stream_type       TEXT                      NOT NULL,
-      stream_metadata   JSONB                     NOT NULL,
-      is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
-      PRIMARY KEY (stream_id, partition, is_archived)
-  ) PARTITION BY LIST (partition);
-   
-  CREATE UNIQUE INDEX IF NOT EXISTS idx_streams_unique 
-  ON ${SQL15.identifier(streamsTable.name)}(stream_id, partition, is_archived) 
-  INCLUDE (stream_position);`;
-var messagesTableSQL = SQL15`
-  CREATE SEQUENCE IF NOT EXISTS emt_global_message_position;
-
-  CREATE TABLE IF NOT EXISTS ${SQL15.identifier(messagesTable.name)}(
-      stream_position        BIGINT                    NOT NULL,
-      global_position        BIGINT                    DEFAULT nextval('emt_global_message_position'),
-      transaction_id         XID8                      NOT NULL,
-      created                TIMESTAMPTZ               NOT NULL DEFAULT now(),
-      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
-      message_kind           VARCHAR(1)                NOT NULL DEFAULT 'E',
-      stream_id              TEXT                      NOT NULL,
-      partition              TEXT                      NOT NULL DEFAULT '${SQL15.plain(defaultTag)}',
-      message_schema_version TEXT                      NOT NULL,
-      message_id             TEXT                      NOT NULL,
-      message_type           TEXT                      NOT NULL,
-      message_data           JSONB                     NOT NULL,
-      message_metadata       JSONB                     NOT NULL,
-      PRIMARY KEY (stream_id, stream_position, partition, is_archived)
-  ) PARTITION BY LIST (partition);`;
-var processorsTableSQL = SQL15`
-  CREATE TABLE IF NOT EXISTS ${SQL15.identifier(processorsTable.name)}(
-      last_processed_transaction_id XID8                   NOT NULL,
-      version                       INT                    NOT NULL DEFAULT 1,
-      processor_id                  TEXT                   NOT NULL,
-      partition                     TEXT                   NOT NULL DEFAULT '${SQL15.plain(defaultTag)}',
-      status                        TEXT                   NOT NULL DEFAULT 'stopped',
-      last_processed_checkpoint     TEXT                   NOT NULL,
-      processor_instance_id         TEXT                   DEFAULT '${SQL15.plain(unknownTag)}',
-      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      PRIMARY KEY (processor_id, partition, version)
-  ) PARTITION BY LIST (partition);
-`;
-var projectionsTableSQL = SQL15`
-  CREATE TABLE IF NOT EXISTS ${SQL15.identifier(projectionsTable.name)}(
-      version                       INT                    NOT NULL DEFAULT 1,
-      type                          VARCHAR(1)             NOT NULL,
-      name                          TEXT                   NOT NULL,
-      partition                     TEXT                   NOT NULL DEFAULT '${SQL15.plain(defaultTag)}',
-      kind                          TEXT                   NOT NULL,
-      status                        TEXT                   NOT NULL,
-      definition                    JSONB                  NOT NULL DEFAULT '{}'::jsonb,
-      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      PRIMARY KEY (name, partition, version)
-  ) PARTITION BY LIST (partition);
-`;
-var sanitizeNameSQL = createFunctionIfDoesNotExistSQL(
-  "emt_sanitize_name",
-  SQL15`CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $emt_sanitize_name$
-    BEGIN
-        RETURN REGEXP_REPLACE(input_name, '[^a-zA-Z0-9_]', '_', 'g');
-    END;
-    $emt_sanitize_name$ LANGUAGE plpgsql;`
-);
-var addTablePartitions = createFunctionIfDoesNotExistSQL(
-  "emt_add_table_partition",
-  SQL15`
-  CREATE OR REPLACE FUNCTION emt_add_table_partition(tableName TEXT, partition_name TEXT) RETURNS void AS $emt_add_table_partition$
-  DECLARE
-    v_main_partiton_name     TEXT;
-    v_active_partiton_name   TEXT;
-    v_archived_partiton_name TEXT;
-  BEGIN                
-      v_main_partiton_name     := emt_sanitize_name(tableName || '_' || partition_name);
-      v_active_partiton_name   := emt_sanitize_name(v_main_partiton_name   || '_active');
-      v_archived_partiton_name := emt_sanitize_name(v_main_partiton_name   || '_archived');
+      ELSIF current_position > p_position THEN
+          RETURN 3;  -- Current ahead: another process has progressed further
+      ELSE
+          RETURN 2;  -- Mismatch: check position doesn't match current
+      END IF;
+  END IF;
 
+  -- Handle the case when p_check_position is NULL: Insert if not exists
+  BEGIN
+      INSERT INTO "${SQL13.plain(processorsTable.name)}"("processor_id", "version", "last_processed_checkpoint", "partition", "last_processed_transaction_id", "created_at", "last_updated")
+      VALUES (p_processor_id, p_version, p_position, p_partition, p_transaction_id, now(), now());
+      RETURN 1;  -- Successfully inserted
+  EXCEPTION WHEN unique_violation THEN
+      -- If insertion failed, it means the row already exists
+      SELECT "last_processed_checkpoint" INTO current_position
+      FROM "${SQL13.plain(processorsTable.name)}"
+      WHERE "processor_id" = p_processor_id 
+        AND "partition" = p_partition 
+        AND "version" = p_version;
 
-      -- create default partition
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (%L) PARTITION BY LIST (is_archived);',
-          v_main_partiton_name, tableName, partition_name
-      );
-  
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (FALSE);',
-          v_active_partiton_name, v_main_partiton_name
-      );
-  
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (TRUE);',
-          v_archived_partiton_name, v_main_partiton_name
-      );
+      IF current_position = p_position THEN
+          RETURN 0;  -- Idempotent check: position already set
+      ELSIF current_position > p_position THEN
+          RETURN 3;  -- Current ahead: another process has progressed further
+      ELSE
+          RETURN 2;  -- Insertion failed, row already exists with different position
+      END IF;
   END;
-  $emt_add_table_partition$ LANGUAGE plpgsql;`
+END;
+$spc$ LANGUAGE plpgsql;
+`
 );
-var addPartitionSQL = createFunctionIfDoesNotExistSQL(
-  "emt_add_partition",
-  SQL15`
-  CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $emt_add_partition$
-  BEGIN                
-      PERFORM emt_add_table_partition('${SQL15.plain(messagesTable.name)}', partition_name);
-      PERFORM emt_add_table_partition('${SQL15.plain(streamsTable.name)}', partition_name);
+var callStoreProcessorCheckpoint = (params) => SQL13`
+    SELECT store_processor_checkpoint(
+      ${params.processorId}, 
+      ${params.version}, 
+      ${params.position}, 
+      ${params.checkPosition}, 
+      pg_current_xact_id(), 
+      ${params.partition}, 
+      ${params.processorInstanceId}
+    ) as result;`;
+var storeProcessorCheckpoint = async (execute, options) => {
+  try {
+    const { result } = await single5(
+      execute.command(
+        callStoreProcessorCheckpoint({
+          processorId: options.processorId,
+          version: options.version ?? 1,
+          position: options.newCheckpoint !== null ? options.newCheckpoint : null,
+          checkPosition: options.lastProcessedCheckpoint !== null ? options.lastProcessedCheckpoint : null,
+          partition: options.partition ?? defaultTag2,
+          processorInstanceId: options.processorInstanceId ?? unknownTag2
+        })
+      )
+    );
+    return result === 1 ? { success: true, newCheckpoint: options.newCheckpoint } : {
+      success: false,
+      reason: result === 0 ? "IGNORED" : result === 3 ? "CURRENT_AHEAD" : "MISMATCH"
+    };
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+};
 
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (%L);',
-          emt_sanitize_name('${SQL15.plain(processorsTable.name)}' || '_' || partition_name), '${SQL15.plain(processorsTable.name)}', partition_name
-      );
+// src/eventStore/schema/tables.ts
+import { SQL as SQL15 } from "@event-driven-io/dumbo";
 
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (%L);',
-          emt_sanitize_name('${SQL15.plain(projectionsTable.name)}' || '_' || partition_name), '${SQL15.plain(projectionsTable.name)}', partition_name
-      );
-  END;
-  $emt_add_partition$ LANGUAGE plpgsql;`
-);
-var addModuleSQL = SQL15`
-      CREATE OR REPLACE FUNCTION add_module(new_module TEXT) RETURNS void AS $$
-      BEGIN
-          -- For ${SQL15.plain(messagesTable.name)} table
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-              FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
-              emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}'), '${SQL15.plain(messagesTable.name)}', new_module, '${SQL15.plain(globalTag)}'
-          );
-  
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-              FOR VALUES IN (FALSE);',
-              emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}' || '_active'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}')
-          );
-  
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-              FOR VALUES IN (TRUE);',
-              emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}' || '_archived'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}')
-          );
-  
-          -- For ${SQL15.plain(streamsTable.name)} table
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-              FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
-              emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}'), '${SQL15.plain(streamsTable.name)}', new_module, '${SQL15.plain(globalTag)}'
-          );
-  
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-              FOR VALUES IN (FALSE);',
-              emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}' || '_active'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}')
-          );
-  
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-              FOR VALUES IN (TRUE);',
-              emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}' || '_archived'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}')
-          );
-      END;
-      $$ LANGUAGE plpgsql;
-    `;
-var addTenantSQL = SQL15`
-    CREATE OR REPLACE FUNCTION add_tenant(new_module TEXT, new_tenant TEXT) RETURNS void AS $$
-    BEGIN
-        -- For ${SQL15.plain(messagesTable.name)} table
+// src/eventStore/schema/migrations/0_43_0/index.ts
+import {
+  dumbo as dumbo2,
+  SQL as SQL14,
+  sqlMigration as sqlMigration3
+} from "@event-driven-io/dumbo";
+var migration_0_43_0_cleanupLegacySubscriptionSQL = SQL14`
+DO $$
+BEGIN
+IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'emt_subscriptions') THEN
+    -- Restore clean emt_add_partition (remove creation of emt_subscriptions partitions)
+    CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $fnpar$
+    BEGIN                
+        PERFORM emt_add_table_partition('${SQL14.plain(messagesTable.name)}', partition_name);
+        PERFORM emt_add_table_partition('${SQL14.plain(streamsTable.name)}', partition_name);
+    
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-            FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-            emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant), '${SQL15.plain(messagesTable.name)}', new_module, new_tenant
-        );
-  
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-            FOR VALUES IN (FALSE);',
-            emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant)
-        );
-  
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-            FOR VALUES IN (TRUE);',
-            emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant)
+            FOR VALUES IN (%L);',
+            emt_sanitize_name('${SQL14.plain(processorsTable.name)}' || '_' || partition_name), '${SQL14.plain(processorsTable.name)}', partition_name
         );
-  
-        -- For ${SQL15.plain(streamsTable.name)} table
+    
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-            FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-            emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant), '${SQL15.plain(streamsTable.name)}', new_module, new_tenant
-        );
-  
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-            FOR VALUES IN (FALSE);',
-            emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant)
-        );
-  
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-            FOR VALUES IN (TRUE);',
-            emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant)
+            FOR VALUES IN (%L);',
+            emt_sanitize_name('${SQL14.plain(projectionsTable.name)}' || '_' || partition_name), '${SQL14.plain(projectionsTable.name)}', partition_name
         );
     END;
-    $$ LANGUAGE plpgsql;
-  `;
-var addModuleForAllTenantsSQL = SQL15`
-    CREATE OR REPLACE FUNCTION add_module_for_all_tenants(new_module TEXT) RETURNS void AS $$
-    DECLARE
-        tenant_record RECORD;
-    BEGIN
-        PERFORM add_module(new_module);
-  
-        FOR tenant_record IN SELECT DISTINCT tenant FROM ${SQL15.plain(messagesTable.name)}
-        LOOP
-            -- For ${SQL15.plain(messagesTable.name)} table
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant), '${SQL15.plain(messagesTable.name)}', new_module, tenant_record.tenant
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-                FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant)
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-                FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant)
-            );
-  
-            -- For ${SQL15.plain(streamsTable.name)} table
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant), '${SQL15.plain(streamsTable.name)}', new_module, tenant_record.tenant
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-                FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant)
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-                FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant)
-            );
-        END LOOP;
-    END;
-    $$ LANGUAGE plpgsql;
-  `;
-var addTenantForAllModulesSQL = SQL15`
-    CREATE OR REPLACE FUNCTION add_tenant_for_all_modules(new_tenant TEXT) RETURNS void AS $$
+    $fnpar$ LANGUAGE plpgsql;
+
+    -- Drop old subscriptions table if it exists
+    DROP TABLE IF EXISTS emt_subscriptions CASCADE;
+
+    -- Drop old function if it exists
+    DROP FUNCTION IF EXISTS store_subscription_checkpoint(character varying, bigint, bigint, bigint, xid8, text);
+    
+    -- Restore clean store_processor_checkpoint (remove dual-write logic)
+    CREATE OR REPLACE FUNCTION store_processor_checkpoint(
+      p_processor_id           TEXT,
+      p_version                BIGINT,
+      p_position               TEXT,
+      p_check_position         TEXT,
+      p_transaction_id         xid8,
+      p_partition              TEXT DEFAULT '${SQL14.plain(defaultTag2)}',
+      p_processor_instance_id  TEXT DEFAULT 'emt:unknown'
+    ) RETURNS INT AS $fn$
     DECLARE
-        module_record RECORD;
+      current_position TEXT;
     BEGIN
-        FOR module_record IN SELECT DISTINCT partitionname FROM pg_partman.part_config WHERE parent_table = '${SQL15.plain(messagesTable.name)}'
-        LOOP
-            -- For ${SQL15.plain(messagesTable.name)} table
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant), '${SQL15.plain(messagesTable.name)}', module_record.partitionname, new_tenant
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-                FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant)
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-                FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant)
-            );
-  
-            -- For ${SQL15.plain(streamsTable.name)} table
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant), '${SQL15.plain(streamsTable.name)}', module_record.partitionname, new_tenant
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-                FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant)
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-                FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant)
-            );
-        END LOOP;
-    END;
-    $$ LANGUAGE plpgsql;
-  `;
-var addDefaultPartitionSQL = SQL15`SELECT emt_add_partition('${SQL15.plain(defaultTag)}');`;
+      IF p_check_position IS NOT NULL THEN
+          UPDATE "emt_processors"
+          SET
+            "last_processed_checkpoint" = p_position,
+            "last_processed_transaction_id" = p_transaction_id,
+            "last_updated" = now()
+          WHERE "processor_id" = p_processor_id
+            AND "last_processed_checkpoint" = p_check_position
+            AND "partition" = p_partition            
+            AND "version" = p_version;
 
-// src/eventStore/schema/readProcessorCheckpoint.ts
-import { singleOrNull as singleOrNull3, SQL as SQL16 } from "@event-driven-io/dumbo";
-var readProcessorCheckpoint = async (execute, options) => {
-  const result = await singleOrNull3(
-    execute.query(
-      SQL16`SELECT last_processed_checkpoint
-           FROM ${SQL16.identifier(processorsTable.name)}
-           WHERE partition = ${options?.partition ?? defaultTag} AND processor_id = ${options.processorId} AND version = ${options.version ?? 1}
-           LIMIT 1`
-    )
-  );
-  return {
-    lastProcessedCheckpoint: result !== null ? BigInt(result.last_processed_checkpoint) : null
-  };
-};
+          IF FOUND THEN
+              RETURN 1;
+          END IF;
 
-// src/eventStore/schema/readStream.ts
-import { mapRows as mapRows2, SQL as SQL17 } from "@event-driven-io/dumbo";
-var readStream = async (execute, streamId, options) => {
-  const fromCondition = options?.from ? `AND stream_position >= ${options.from}` : "";
-  const to = Number(
-    options?.to ?? (options?.maxCount ? (options.from ?? 0n) + options.maxCount : NaN)
-  );
-  const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
-  const events = await mapRows2(
-    execute.query(
-      SQL17`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-           FROM ${SQL17.identifier(messagesTable.name)}
-           WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE ${SQL17.plain(fromCondition)} ${SQL17.plain(toCondition)}
-           ORDER BY stream_position ASC`
-    ),
-    (row) => {
-      const rawEvent = {
-        type: row.message_type,
-        data: row.message_data,
-        metadata: 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 events.length > 0 ? {
-    currentStreamVersion: events[events.length - 1].metadata.streamPosition,
-    events,
-    streamExists: true
-  } : {
-    currentStreamVersion: PostgreSQLEventStoreDefaultStreamVersion,
-    events: [],
-    streamExists: false
-  };
-};
+          SELECT "last_processed_checkpoint" INTO current_position
+          FROM "emt_processors"
+          WHERE "processor_id" = p_processor_id 
+            AND "partition" = p_partition            
+            AND "version" = p_version ;
 
-// src/eventStore/schema/streamExists.ts
-import { SQL as SQL18 } from "@event-driven-io/dumbo";
-var streamExists = async (execute, streamId, options) => {
-  const queryResult = await execute.query(
-    SQL18`SELECT EXISTS (
-        SELECT 1
-        from ${SQL18.identifier(streamsTable.name)}
-        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE)
-      `
-  );
-  return queryResult.rows[0]?.exists ?? false;
+          IF current_position = p_position THEN
+              RETURN 0;
+          ELSIF current_position > p_position THEN
+              RETURN 3;
+          ELSE
+              RETURN 2;
+          END IF;
+      END IF;
+
+      BEGIN
+          INSERT INTO "emt_processors"("processor_id", "version", "last_processed_checkpoint", "partition", "last_processed_transaction_id", "created_at", "last_updated")
+          VALUES (p_processor_id, p_version, p_position, p_partition, p_transaction_id, now(), now());
+          RETURN 1;
+      EXCEPTION WHEN unique_violation THEN
+          SELECT "last_processed_checkpoint" INTO current_position
+          FROM "emt_processors"
+          WHERE "processor_id" = p_processor_id 
+            AND "partition" = p_partition
+            AND "version" = p_version;
+
+          IF current_position = p_position THEN
+              RETURN 0;
+          ELSE
+              RETURN 2;
+          END IF;
+      END;
+    END;
+    $fn$ LANGUAGE plpgsql;
+END IF;
+END $$;
+`;
+var migration_0_43_0_cleanupLegacySubscription = sqlMigration3("emt:postgresql:eventstore:0.43.0:cleanup-legacy-subscription", [
+  migration_0_43_0_cleanupLegacySubscriptionSQL
+]);
+var cleanupLegacySubscriptionTables = async (connectionString) => {
+  const pool = dumbo2({ connectionString });
+  try {
+    await pool.withTransaction(async ({ execute }) => {
+      await execute.command(migration_0_43_0_cleanupLegacySubscriptionSQL);
+    });
+  } finally {
+    await pool.close();
+  }
 };
 
-// src/eventStore/schema/index.ts
-var schemaSQL = [
-  streamsTableSQL,
-  messagesTableSQL,
-  projectionsTableSQL,
-  processorsTableSQL,
-  sanitizeNameSQL,
-  addTablePartitions,
-  addPartitionSQL,
-  appendToStreamSQL,
-  addDefaultPartitionSQL,
-  storeSubscriptionCheckpointSQL,
-  tryAcquireProcessorLockSQL,
-  releaseProcessorLockSQL,
-  registerProjectionSQL,
-  activateProjectionSQL,
-  deactivateProjectionSQL
-];
-var schemaMigration = sqlMigration4(
-  "emt:postgresql:eventstore:initial",
-  schemaSQL
+// src/eventStore/schema/tables.ts
+var streamsTableSQL = SQL15`
+  CREATE TABLE IF NOT EXISTS ${SQL15.identifier(streamsTable.name)}(
+      stream_id         TEXT                      NOT NULL,
+      stream_position   BIGINT                    NOT NULL,
+      partition         TEXT                      NOT NULL DEFAULT '${SQL15.plain(defaultTag2)}',
+      stream_type       TEXT                      NOT NULL,
+      stream_metadata   JSONB                     NOT NULL,
+      is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
+      PRIMARY KEY (stream_id, partition, is_archived)
+  ) PARTITION BY LIST (partition);
+   
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_streams_unique 
+  ON ${SQL15.identifier(streamsTable.name)}(stream_id, partition, is_archived) 
+  INCLUDE (stream_position);`;
+var messagesTableSQL = SQL15`
+  CREATE SEQUENCE IF NOT EXISTS emt_global_message_position;
+
+  CREATE TABLE IF NOT EXISTS ${SQL15.identifier(messagesTable.name)}(
+      stream_position        BIGINT                    NOT NULL,
+      global_position        BIGINT                    DEFAULT nextval('emt_global_message_position'),
+      transaction_id         XID8                      NOT NULL,
+      created                TIMESTAMPTZ               NOT NULL DEFAULT now(),
+      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
+      message_kind           VARCHAR(1)                NOT NULL DEFAULT 'E',
+      stream_id              TEXT                      NOT NULL,
+      partition              TEXT                      NOT NULL DEFAULT '${SQL15.plain(defaultTag2)}',
+      message_schema_version TEXT                      NOT NULL,
+      message_id             TEXT                      NOT NULL,
+      message_type           TEXT                      NOT NULL,
+      message_data           JSONB                     NOT NULL,
+      message_metadata       JSONB                     NOT NULL,
+      PRIMARY KEY (stream_id, stream_position, partition, is_archived)
+  ) PARTITION BY LIST (partition);`;
+var processorsTableSQL = SQL15`
+  CREATE TABLE IF NOT EXISTS ${SQL15.identifier(processorsTable.name)}(
+      last_processed_transaction_id XID8                   NOT NULL,
+      version                       INT                    NOT NULL DEFAULT 1,
+      processor_id                  TEXT                   NOT NULL,
+      partition                     TEXT                   NOT NULL DEFAULT '${SQL15.plain(defaultTag2)}',
+      status                        TEXT                   NOT NULL DEFAULT 'stopped',
+      last_processed_checkpoint     TEXT                   NOT NULL,
+      processor_instance_id         TEXT                   DEFAULT '${SQL15.plain(unknownTag2)}',
+      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
+      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
+      PRIMARY KEY (processor_id, partition, version)
+  ) PARTITION BY LIST (partition);
+`;
+var projectionsTableSQL = SQL15`
+  CREATE TABLE IF NOT EXISTS ${SQL15.identifier(projectionsTable.name)}(
+      version                       INT                    NOT NULL DEFAULT 1,
+      type                          VARCHAR(1)             NOT NULL,
+      name                          TEXT                   NOT NULL,
+      partition                     TEXT                   NOT NULL DEFAULT '${SQL15.plain(defaultTag2)}',
+      kind                          TEXT                   NOT NULL,
+      status                        TEXT                   NOT NULL,
+      definition                    JSONB                  NOT NULL DEFAULT '{}'::jsonb,
+      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
+      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
+      PRIMARY KEY (name, partition, version)
+  ) PARTITION BY LIST (partition);
+`;
+var sanitizeNameSQL = createFunctionIfDoesNotExistSQL(
+  "emt_sanitize_name",
+  SQL15`CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $emt_sanitize_name$
+    BEGIN
+        RETURN REGEXP_REPLACE(input_name, '[^a-zA-Z0-9_]', '_', 'g');
+    END;
+    $emt_sanitize_name$ LANGUAGE plpgsql;`
 );
-var eventStoreSchemaMigrations = [
-  migration_0_38_7_and_older,
-  migration_0_42_0_FromSubscriptionsToProcessors,
-  migration_0_42_0_2_AddProcessorProjectionFunctions,
-  schemaMigration
-];
-var createEventStoreSchema = (connectionString, pool, hooks, options) => {
-  return pool.withTransaction(async (tx) => {
-    const context = await transactionToPostgreSQLProjectionHandlerContext(
-      connectionString,
-      pool,
-      tx
-    );
-    const nestedPool = dumbo2({ connectionString, connection: tx.connection });
-    try {
-      if (hooks?.onBeforeSchemaCreated) {
-        await hooks.onBeforeSchemaCreated(context);
-      }
-      const result = await runSQLMigrations(
-        nestedPool,
-        eventStoreSchemaMigrations,
-        options
-      );
-      if (hooks?.onAfterSchemaCreated) {
-        await hooks.onAfterSchemaCreated(context);
-      }
-      return result;
-    } finally {
-      await nestedPool.close();
-    }
-  });
-};
+var addTablePartitions = createFunctionIfDoesNotExistSQL(
+  "emt_add_table_partition",
+  SQL15`
+  CREATE OR REPLACE FUNCTION emt_add_table_partition(tableName TEXT, partition_name TEXT) RETURNS void AS $emt_add_table_partition$
+  DECLARE
+    v_main_partiton_name     TEXT;
+    v_active_partiton_name   TEXT;
+    v_archived_partiton_name TEXT;
+  BEGIN                
+      v_main_partiton_name     := emt_sanitize_name(tableName || '_' || partition_name);
+      v_active_partiton_name   := emt_sanitize_name(v_main_partiton_name   || '_active');
+      v_archived_partiton_name := emt_sanitize_name(v_main_partiton_name   || '_archived');
 
-// src/eventStore/schema/truncateTables.ts
-import { SQL as SQL19 } from "@event-driven-io/dumbo";
-var truncateTables = async (execute, options) => {
-  await execute.command(
-    SQL19`TRUNCATE TABLE 
-        ${SQL19.identifier(streamsTable.name)}, 
-        ${SQL19.identifier(messagesTable.name)}, 
-        ${SQL19.identifier(processorsTable.name)}, 
-        ${SQL19.identifier(projectionsTable.name)} 
-        CASCADE${SQL19.plain(options?.resetSequences ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : "")};`
-  );
-};
 
-// src/eventStore/postgreSQLEventStore.ts
-var defaultPostgreSQLOptions = {
-  projections: [],
-  schema: { autoMigration: "CreateOrUpdate" }
-};
-var PostgreSQLEventStoreDefaultStreamVersion = 0n;
-var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOptions) => {
-  const poolOptions = {
-    connectionString,
-    ...options.connectionOptions ? options.connectionOptions : {}
-  };
-  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : dumbo3(poolOptions);
-  let migrateSchema = void 0;
-  const autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
-  const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const migrate = async (migrationOptions) => {
-    if (!migrateSchema) {
-      migrateSchema = createEventStoreSchema(
-        connectionString,
-        pool,
-        {
-          onBeforeSchemaCreated: async (context) => {
-            if (options.hooks?.onBeforeSchemaCreated) {
-              await options.hooks.onBeforeSchemaCreated(context);
-            }
-          },
-          onAfterSchemaCreated: async (context) => {
-            for (const projection2 of inlineProjections) {
-              if (projection2.init) {
-                await projection2.init({
-                  version: projection2.version ?? 1,
-                  status: "active",
-                  registrationType: "inline",
-                  context: { ...context, migrationOptions }
-                });
-              }
-            }
-            if (options.hooks?.onAfterSchemaCreated) {
-              await options.hooks.onAfterSchemaCreated(context);
-            }
-          }
-        },
-        migrationOptions
+      -- create default partition
+      EXECUTE format('
+          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+          FOR VALUES IN (%L) PARTITION BY LIST (is_archived);',
+          v_main_partiton_name, tableName, partition_name
       );
-    }
-    return migrateSchema;
-  };
-  const ensureSchemaExists = () => {
-    if (!autoGenerateSchema) return Promise.resolve();
-    return migrate();
-  };
-  const beforeCommitHook = inlineProjections.length > 0 ? async (events, { transaction }) => handleProjections({
-    projections: inlineProjections,
-    // TODO: Add proper handling of global data
-    // Currently it's not available as append doesn't return array of global position but just the last one
-    events,
-    ...await transactionToPostgreSQLProjectionHandlerContext(
-      connectionString,
-      pool,
-      transaction
-    )
-  }) : void 0;
-  return {
-    schema: {
-      sql: () => SQL20.describe(
-        schemaSQL,
-        getFormatter(fromDatabaseDriverType(pool.driverType).databaseType)
-      ),
-      print: () => console.log(
-        SQL20.describe(
-          schemaSQL,
-          getFormatter(fromDatabaseDriverType(pool.driverType).databaseType)
-        )
-      ),
-      migrate,
-      dangerous: {
-        truncate: (truncateOptions) => pool.withTransaction(async (transaction) => {
-          await ensureSchemaExists();
-          await truncateTables(transaction.execute, truncateOptions);
-          if (truncateOptions?.truncateProjections) {
-            const projectionContext = await transactionToPostgreSQLProjectionHandlerContext(
-              connectionString,
-              pool,
-              transaction
-            );
-            for (const projection2 of options?.projections ?? []) {
-              if (projection2.projection.truncate)
-                await projection2.projection.truncate(projectionContext);
-            }
-          }
-        })
-      }
-    },
-    async aggregateStream(streamName, options2) {
-      const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = read?.expectedStreamVersion;
-      let state = initialState();
-      const result = await this.readStream(
-        streamName,
-        read
+  
+      EXECUTE format('
+          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+          FOR VALUES IN (FALSE);',
+          v_active_partiton_name, v_main_partiton_name
       );
-      const currentStreamVersion = result.currentStreamVersion;
-      assertExpectedVersionMatchesCurrent(
-        currentStreamVersion,
-        expectedStreamVersion,
-        PostgreSQLEventStoreDefaultStreamVersion
+  
+      EXECUTE format('
+          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+          FOR VALUES IN (TRUE);',
+          v_archived_partiton_name, v_main_partiton_name
       );
-      for (const event of result.events) {
-        if (!event) continue;
-        state = evolve(state, event);
-      }
-      return {
-        currentStreamVersion,
-        state,
-        streamExists: result.streamExists
-      };
-    },
-    readStream: async (streamName, options2) => {
-      await ensureSchemaExists();
-      return readStream(
-        pool.execute,
-        streamName,
-        options2
+  END;
+  $emt_add_table_partition$ LANGUAGE plpgsql;`
+);
+var addPartitionSQL = createFunctionIfDoesNotExistSQL(
+  "emt_add_partition",
+  SQL15`
+  CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $emt_add_partition$
+  BEGIN                
+      PERFORM emt_add_table_partition('${SQL15.plain(messagesTable.name)}', partition_name);
+      PERFORM emt_add_table_partition('${SQL15.plain(streamsTable.name)}', partition_name);
+
+      EXECUTE format('
+          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+          FOR VALUES IN (%L);',
+          emt_sanitize_name('${SQL15.plain(processorsTable.name)}' || '_' || partition_name), '${SQL15.plain(processorsTable.name)}', partition_name
       );
-    },
-    appendToStream: async (streamName, events, options2) => {
-      await ensureSchemaExists();
-      const [firstPart, ...rest] = streamName.split("-");
-      const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag;
-      const appendResult = await appendToStream(
-        // TODO: Fix this when introducing more drivers
-        pool,
-        streamName,
-        streamType,
-        downcastRecordedMessages(events, options2?.schema?.versioning),
-        {
-          ...options2,
-          beforeCommitHook
-        }
+
+      EXECUTE format('
+          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+          FOR VALUES IN (%L);',
+          emt_sanitize_name('${SQL15.plain(projectionsTable.name)}' || '_' || partition_name), '${SQL15.plain(projectionsTable.name)}', partition_name
       );
-      if (!appendResult.success)
-        throw new ExpectedVersionConflictError(
-          -1n,
-          //TODO: Return actual version in case of error
-          options2?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+  END;
+  $emt_add_partition$ LANGUAGE plpgsql;`
+);
+var addModuleSQL = SQL15`
+      CREATE OR REPLACE FUNCTION add_module(new_module TEXT) RETURNS void AS $$
+      BEGIN
+          -- For ${SQL15.plain(messagesTable.name)} table
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+              FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
+              emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}'), '${SQL15.plain(messagesTable.name)}', new_module, '${SQL15.plain(globalTag)}'
+          );
+  
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+              FOR VALUES IN (FALSE);',
+              emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}' || '_active'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}')
+          );
+  
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+              FOR VALUES IN (TRUE);',
+              emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}' || '_archived'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}')
+          );
+  
+          -- For ${SQL15.plain(streamsTable.name)} table
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+              FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
+              emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}'), '${SQL15.plain(streamsTable.name)}', new_module, '${SQL15.plain(globalTag)}'
+          );
+  
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+              FOR VALUES IN (FALSE);',
+              emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}' || '_active'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}')
+          );
+  
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+              FOR VALUES IN (TRUE);',
+              emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}' || '_archived'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || '${SQL15.plain(globalTag)}')
+          );
+      END;
+      $$ LANGUAGE plpgsql;
+    `;
+var addTenantSQL = SQL15`
+    CREATE OR REPLACE FUNCTION add_tenant(new_module TEXT, new_tenant TEXT) RETURNS void AS $$
+    BEGIN
+        -- For ${SQL15.plain(messagesTable.name)} table
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+            FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+            emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant), '${SQL15.plain(messagesTable.name)}', new_module, new_tenant
         );
-      return {
-        nextExpectedStreamVersion: appendResult.nextStreamPosition,
-        lastEventGlobalPosition: appendResult.globalPositions[appendResult.globalPositions.length - 1],
-        createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
-      };
-    },
-    streamExists: async (streamName, options2) => {
-      await ensureSchemaExists();
-      return streamExists(pool.execute, streamName, options2);
-    },
-    consumer: (options2) => postgreSQLEventStoreConsumer({
-      ...options2 ?? {},
-      pool,
-      connectionString
-    }),
-    close: () => pool.close(),
-    async withSession(callback) {
-      return await pool.withConnection(async (connection) => {
-        const storeOptions = {
-          ...options,
-          connectionOptions: {
-            connection
-          },
-          schema: {
-            ...options.schema ?? {},
-            autoMigration: "None"
-          }
-        };
-        const eventStore = getPostgreSQLEventStore(
-          connectionString,
-          storeOptions
+  
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+            FOR VALUES IN (FALSE);',
+            emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant)
         );
-        return ensureSchemaExists().then(
-          () => callback({
-            eventStore,
-            close: () => Promise.resolve()
-          })
+  
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+            FOR VALUES IN (TRUE);',
+            emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || new_tenant)
         );
-      });
-    }
+  
+        -- For ${SQL15.plain(streamsTable.name)} table
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+            FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+            emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant), '${SQL15.plain(streamsTable.name)}', new_module, new_tenant
+        );
+  
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+            FOR VALUES IN (FALSE);',
+            emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant)
+        );
+  
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+            FOR VALUES IN (TRUE);',
+            emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || new_tenant)
+        );
+    END;
+    $$ LANGUAGE plpgsql;
+  `;
+var addModuleForAllTenantsSQL = SQL15`
+    CREATE OR REPLACE FUNCTION add_module_for_all_tenants(new_module TEXT) RETURNS void AS $$
+    DECLARE
+        tenant_record RECORD;
+    BEGIN
+        PERFORM add_module(new_module);
+  
+        FOR tenant_record IN SELECT DISTINCT tenant FROM ${SQL15.plain(messagesTable.name)}
+        LOOP
+            -- For ${SQL15.plain(messagesTable.name)} table
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant), '${SQL15.plain(messagesTable.name)}', new_module, tenant_record.tenant
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+                FOR VALUES IN (FALSE);',
+                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant)
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+                FOR VALUES IN (TRUE);',
+                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant)
+            );
+  
+            -- For ${SQL15.plain(streamsTable.name)} table
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant), '${SQL15.plain(streamsTable.name)}', new_module, tenant_record.tenant
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+                FOR VALUES IN (FALSE);',
+                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant)
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+                FOR VALUES IN (TRUE);',
+                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant)
+            );
+        END LOOP;
+    END;
+    $$ LANGUAGE plpgsql;
+  `;
+var addTenantForAllModulesSQL = SQL15`
+    CREATE OR REPLACE FUNCTION add_tenant_for_all_modules(new_tenant TEXT) RETURNS void AS $$
+    DECLARE
+        module_record RECORD;
+    BEGIN
+        FOR module_record IN SELECT DISTINCT partitionname FROM pg_partman.part_config WHERE parent_table = '${SQL15.plain(messagesTable.name)}'
+        LOOP
+            -- For ${SQL15.plain(messagesTable.name)} table
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant), '${SQL15.plain(messagesTable.name)}', module_record.partitionname, new_tenant
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+                FOR VALUES IN (FALSE);',
+                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant)
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+                FOR VALUES IN (TRUE);',
+                emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL15.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant)
+            );
+  
+            -- For ${SQL15.plain(streamsTable.name)} table
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant), '${SQL15.plain(streamsTable.name)}', module_record.partitionname, new_tenant
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+                FOR VALUES IN (FALSE);',
+                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant)
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+                FOR VALUES IN (TRUE);',
+                emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL15.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant)
+            );
+        END LOOP;
+    END;
+    $$ LANGUAGE plpgsql;
+  `;
+var addDefaultPartitionSQL = SQL15`SELECT emt_add_partition('${SQL15.plain(defaultTag2)}');`;
+
+// src/eventStore/schema/readProcessorCheckpoint.ts
+import { singleOrNull as singleOrNull3, SQL as SQL16 } from "@event-driven-io/dumbo";
+var readProcessorCheckpoint = async (execute, options) => {
+  const result = await singleOrNull3(
+    execute.query(
+      SQL16`SELECT last_processed_checkpoint
+           FROM ${SQL16.identifier(processorsTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag2} AND processor_id = ${options.processorId} AND version = ${options.version ?? 1}
+           LIMIT 1`
+    )
+  );
+  return {
+    lastProcessedCheckpoint: result !== null ? result.last_processed_checkpoint : null
   };
 };
 
-// src/eventStore/projections/postgresProjectionSpec.ts
-var PostgreSQLProjectionSpec = {
-  for: (options) => {
-    {
-      const { projection: projection2, ...dumoOptions } = options;
-      const { connectionString } = dumoOptions;
-      let wasInitialised = false;
-      const initialize = async (pool) => {
-        const eventStore = getPostgreSQLEventStore(connectionString, {
-          // TODO: This will need to change when we support other drivers
-          connectionOptions: { dumbo: pool }
-        });
-        if (wasInitialised) return;
-        wasInitialised = true;
-        await eventStore.schema.migrate();
-        if (projection2.init)
-          await pool.withTransaction(async (transaction) => {
-            await projection2.init({
-              registrationType: "async",
-              version: projection2.version ?? 1,
-              status: "active",
-              context: await transactionToPostgreSQLProjectionHandlerContext(
-                connectionString,
-                pool,
-                transaction
-              )
-            });
-          });
+// src/eventStore/schema/readStream.ts
+import { mapRows as mapRows2, SQL as SQL17 } from "@event-driven-io/dumbo";
+var readStream = async (execute, streamId, options) => {
+  const fromCondition = options?.from ? `AND stream_position >= ${options.from}` : "";
+  const to = Number(
+    options?.to ?? (options?.maxCount ? (options.from ?? 0n) + options.maxCount : NaN)
+  );
+  const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
+  const events = await mapRows2(
+    execute.query(
+      SQL17`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+           FROM ${SQL17.identifier(messagesTable.name)}
+           WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE ${SQL17.plain(fromCondition)} ${SQL17.plain(toCondition)}
+           ORDER BY stream_position ASC`
+    ),
+    (row) => {
+      const rawEvent = {
+        type: row.message_type,
+        data: row.message_data,
+        metadata: 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))
       };
-      return (givenEvents) => {
-        return {
-          when: (events, options2) => {
-            const allEvents = [];
-            const run = async (pool) => {
-              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 ?? {} : {}
-                  }
-                });
-              }
-              await initialize(pool);
-              await pool.withTransaction(async (transaction) => {
-                await handleProjections({
-                  events: allEvents,
-                  projections: [projection2],
-                  ...await transactionToPostgreSQLProjectionHandlerContext(
-                    connectionString,
-                    pool,
-                    transaction
-                  )
-                });
-              });
-            };
-            return {
-              then: async (assert, message) => {
-                const pool = dumbo4(dumoOptions);
-                try {
-                  await run(pool);
-                  const succeeded = await assert({ pool, connectionString });
-                  if (succeeded !== void 0 && succeeded === false)
-                    assertFails(
-                      message ?? "Projection specification didn't match the criteria"
-                    );
-                } finally {
-                  await pool.close();
-                }
-              },
-              thenThrows: async (...args) => {
-                const pool = dumbo4(dumoOptions);
-                try {
-                  await run(pool);
-                  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()}`
-                    );
-                  }
-                } finally {
-                  await pool.close();
-                }
-              }
-            };
-          }
-        };
+      const event = {
+        ...rawEvent,
+        kind: "Event",
+        metadata
       };
+      return upcastRecordedMessage(event, options?.schema?.versioning);
     }
-  }
-};
-var eventInStream = (streamName, event) => {
-  return {
-    ...event,
-    metadata: {
-      ...event.metadata ?? {},
-      streamName: event.metadata?.streamName ?? streamName
-    }
+  );
+  return events.length > 0 ? {
+    currentStreamVersion: events[events.length - 1].metadata.streamPosition,
+    events,
+    streamExists: true
+  } : {
+    currentStreamVersion: PostgreSQLEventStoreDefaultStreamVersion,
+    events: [],
+    streamExists: false
   };
 };
-var eventsInStream = (streamName, events) => {
-  return events.map((e) => eventInStream(streamName, e));
-};
-var newEventsInStream = eventsInStream;
-var assertSQLQueryResultMatches = (sql, rows) => async ({ pool: { execute } }) => {
-  const result = await execute.query(sql);
-  assertThatArray(rows).containsExactlyInAnyOrder(result.rows);
+
+// src/eventStore/schema/streamExists.ts
+import { SQL as SQL18 } from "@event-driven-io/dumbo";
+var streamExists = async (execute, streamId, options) => {
+  const queryResult = await execute.query(
+    SQL18`SELECT EXISTS (
+        SELECT 1
+        from ${SQL18.identifier(streamsTable.name)}
+        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE)
+      `
+  );
+  return queryResult.rows[0]?.exists ?? false;
 };
-var expectSQL = {
-  query: (sql) => ({
-    resultRows: {
-      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows)
+
+// src/eventStore/schema/index.ts
+var schemaSQL = [
+  streamsTableSQL,
+  messagesTableSQL,
+  projectionsTableSQL,
+  processorsTableSQL,
+  sanitizeNameSQL,
+  addTablePartitions,
+  addPartitionSQL,
+  appendToStreamSQL,
+  addDefaultPartitionSQL,
+  storeSubscriptionCheckpointSQL,
+  tryAcquireProcessorLockSQL,
+  releaseProcessorLockSQL,
+  registerProjectionSQL,
+  activateProjectionSQL,
+  deactivateProjectionSQL
+];
+var schemaMigration = sqlMigration4(
+  "emt:postgresql:eventstore:initial",
+  schemaSQL
+);
+var eventStoreSchemaMigrations = [
+  migration_0_38_7_and_older,
+  migration_0_42_0_FromSubscriptionsToProcessors,
+  migration_0_42_0_2_AddProcessorProjectionFunctions,
+  schemaMigration
+];
+var createEventStoreSchema = (connectionString, pool, hooks, options) => {
+  return pool.withTransaction(async (tx) => {
+    const context = await transactionToPostgreSQLProjectionHandlerContext(
+      connectionString,
+      pool,
+      tx
+    );
+    const nestedPool = dumbo3({
+      connectionString,
+      connection: tx.connection,
+      serialization: options?.serialization
+    });
+    try {
+      if (hooks?.onBeforeSchemaCreated) {
+        await hooks.onBeforeSchemaCreated(context);
+      }
+      const result = await runSQLMigrations(
+        nestedPool,
+        eventStoreSchemaMigrations,
+        options
+      );
+      if (hooks?.onAfterSchemaCreated) {
+        await hooks.onAfterSchemaCreated(context);
+      }
+      return result;
+    } finally {
+      await nestedPool.close();
     }
-  })
+  });
 };
 
-// src/eventStore/projections/postgreSQLProjection.ts
-import "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/pg";
-var transactionToPostgreSQLProjectionHandlerContext = async (connectionString, pool, transaction) => ({
-  execute: transaction.execute,
-  connection: {
-    connectionString,
-    client: await transaction.connection.open(),
-    transaction,
-    pool
-  }
-});
-var handleProjections = async (options) => {
-  const {
-    projections: allProjections,
-    events,
-    connection: { pool, transaction, connectionString },
-    partition = defaultTag
-  } = options;
-  const eventTypes = events.map((e) => e.type);
-  const projections = allProjections.filter(
-    (p) => p.canHandle.some((type) => eventTypes.includes(type))
+// src/eventStore/schema/truncateTables.ts
+import { SQL as SQL19 } from "@event-driven-io/dumbo";
+var truncateTables = async (execute, options) => {
+  await execute.command(
+    SQL19`TRUNCATE TABLE 
+        ${SQL19.identifier(streamsTable.name)}, 
+        ${SQL19.identifier(messagesTable.name)}, 
+        ${SQL19.identifier(processorsTable.name)}, 
+        ${SQL19.identifier(projectionsTable.name)} 
+        CASCADE${SQL19.plain(options?.resetSequences ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : "")};`
   );
-  const client = await transaction.connection.open();
-  for (const projection2 of projections) {
-    if (projection2.name) {
-      const lockAcquired = await postgreSQLProjectionLock({
-        projectionName: projection2.name,
-        partition,
-        version: projection2.version ?? 1
-      }).tryAcquire({ execute: transaction.execute });
-      if (!lockAcquired) {
-        continue;
-      }
+};
+
+// src/eventStore/postgreSQLEventStore.ts
+var defaultPostgreSQLOptions = {
+  projections: [],
+  schema: { autoMigration: "CreateOrUpdate" }
+};
+var PostgreSQLEventStoreDefaultStreamVersion = 0n;
+var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOptions) => {
+  const poolOptions = {
+    connectionString,
+    ...options.connectionOptions ? options.connectionOptions : {}
+  };
+  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : dumbo4({ ...poolOptions, serialization: options.serialization });
+  let migrateSchema = void 0;
+  const autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
+  const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
+  const migrate = async (migrationOptions) => {
+    if (!migrateSchema) {
+      migrateSchema = createEventStoreSchema(
+        connectionString,
+        pool,
+        {
+          onBeforeSchemaCreated: async (context) => {
+            if (options.hooks?.onBeforeSchemaCreated) {
+              await options.hooks.onBeforeSchemaCreated(context);
+            }
+          },
+          onAfterSchemaCreated: async (context) => {
+            for (const projection2 of inlineProjections) {
+              if (projection2.init) {
+                await projection2.init({
+                  version: projection2.version ?? 1,
+                  status: "active",
+                  registrationType: "inline",
+                  context: { ...context, migrationOptions }
+                });
+              }
+            }
+            if (options.hooks?.onAfterSchemaCreated) {
+              await options.hooks.onAfterSchemaCreated(context);
+            }
+          }
+        },
+        migrationOptions
+      );
     }
-    await projection2.handle(events, {
-      connection: {
-        connectionString,
-        pool,
-        client,
-        transaction
-      },
-      execute: transaction.execute
-    });
-  }
-};
-var postgreSQLProjection = (definition) => projection({
-  ...definition,
-  init: async (options) => {
-    await registerProjection(options.context.execute, {
-      // TODO: pass partition from options
-      partition: defaultTag,
-      status: "active",
-      registration: {
-        type: "async",
-        // TODO: fix this
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
-        projection: definition
+    return migrateSchema;
+  };
+  const ensureSchemaExists = () => {
+    if (!autoGenerateSchema) return Promise.resolve();
+    return migrate();
+  };
+  const beforeCommitHook = inlineProjections.length > 0 ? async (events, { transaction }) => handleProjections({
+    projections: inlineProjections,
+    // TODO: Add proper handling of global data
+    // Currently it's not available as append doesn't return array of global position but just the last one
+    events,
+    ...await transactionToPostgreSQLProjectionHandlerContext(
+      connectionString,
+      pool,
+      transaction
+    )
+  }) : void 0;
+  return {
+    schema: {
+      sql: () => SQL20.describe(
+        schemaSQL,
+        getFormatter(fromDatabaseDriverType(pool.driverType).databaseType)
+      ),
+      print: () => console.log(
+        SQL20.describe(
+          schemaSQL,
+          getFormatter(fromDatabaseDriverType(pool.driverType).databaseType)
+        )
+      ),
+      migrate,
+      dangerous: {
+        truncate: (truncateOptions) => pool.withTransaction(async (transaction) => {
+          await ensureSchemaExists();
+          await truncateTables(transaction.execute, truncateOptions);
+          if (truncateOptions?.truncateProjections) {
+            const projectionContext = await transactionToPostgreSQLProjectionHandlerContext(
+              connectionString,
+              pool,
+              transaction
+            );
+            for (const projection2 of options?.projections ?? []) {
+              if (projection2.projection.truncate)
+                await projection2.projection.truncate(projectionContext);
+            }
+          }
+        })
       }
-    });
-    if (definition.init) {
-      await definition.init(options);
-    }
-  }
-});
-var postgreSQLRawBatchSQLProjection = (options) => postgreSQLProjection({
-  name: options.name,
-  kind: options.kind ?? "emt:projections:postgresql:raw_sql:batch",
-  version: options.version,
-  canHandle: options.canHandle,
-  eventsOptions: options.eventsOptions,
-  handle: async (events, context) => {
-    const sqls = await options.evolve(events, context);
-    await context.execute.batchCommand(sqls);
-  },
-  init: async (initOptions) => {
-    const initSQL = options.init ? await options.init(initOptions) : void 0;
-    if (initSQL) {
-      if (Array.isArray(initSQL)) {
-        await initOptions.context.execute.batchCommand(initSQL);
-      } else {
-        await initOptions.context.execute.command(initSQL);
+    },
+    async aggregateStream(streamName, options2) {
+      const { evolve, initialState, read } = options2;
+      const expectedStreamVersion = read?.expectedStreamVersion;
+      let state = initialState();
+      const result = await this.readStream(
+        streamName,
+        read
+      );
+      const currentStreamVersion = result.currentStreamVersion;
+      assertExpectedVersionMatchesCurrent(
+        currentStreamVersion,
+        expectedStreamVersion,
+        PostgreSQLEventStoreDefaultStreamVersion
+      );
+      for (const event of result.events) {
+        if (!event) continue;
+        state = evolve(state, event);
       }
-    }
-  }
-});
-var postgreSQLRawSQLProjection = (options) => {
-  const { evolve, kind, ...rest } = options;
-  return postgreSQLRawBatchSQLProjection({
-    kind: kind ?? "emt:projections:postgresql:raw:_sql:single",
-    ...rest,
-    evolve: async (events, context) => {
-      const sqls = [];
-      for (const event of events) {
-        const pendingSqls = await evolve(event, context);
-        if (Array.isArray(pendingSqls)) {
-          sqls.push(...pendingSqls);
-        } else {
-          sqls.push(pendingSqls);
+      return {
+        currentStreamVersion,
+        state,
+        streamExists: result.streamExists
+      };
+    },
+    readStream: async (streamName, readOptions) => {
+      await ensureSchemaExists();
+      return readStream(pool.execute, streamName, {
+        ...readOptions,
+        serialization: options.serialization ?? readOptions?.serialization
+      });
+    },
+    appendToStream: async (streamName, events, appendOptions) => {
+      await ensureSchemaExists();
+      const [firstPart, ...rest] = streamName.split("-");
+      const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag2;
+      const appendResult = await appendToStream(
+        // TODO: Fix this when introducing more drivers
+        pool,
+        streamName,
+        streamType,
+        downcastRecordedMessages(events, appendOptions?.schema?.versioning),
+        {
+          ...appendOptions,
+          beforeCommitHook
         }
-      }
-      return sqls;
+      );
+      if (!appendResult.success)
+        throw new ExpectedVersionConflictError(
+          -1n,
+          //TODO: Return actual version in case of error
+          appendOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+        );
+      return {
+        nextExpectedStreamVersion: appendResult.nextStreamPosition,
+        lastEventGlobalPosition: appendResult.globalPositions[appendResult.globalPositions.length - 1],
+        createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
+      };
+    },
+    streamExists: async (streamName, options2) => {
+      await ensureSchemaExists();
+      return streamExists(pool.execute, streamName, options2);
+    },
+    consumer: (options2) => postgreSQLEventStoreConsumer({
+      ...options2 ?? {},
+      pool,
+      connectionString
+    }),
+    close: () => pool.close(),
+    async withSession(callback) {
+      return await pool.withConnection(async (connection) => {
+        const storeOptions = {
+          ...options,
+          connectionOptions: {
+            connection
+          },
+          schema: {
+            ...options.schema ?? {},
+            autoMigration: "None"
+          }
+        };
+        const eventStore = getPostgreSQLEventStore(
+          connectionString,
+          storeOptions
+        );
+        return ensureSchemaExists().then(
+          () => callback({
+            eventStore,
+            close: () => Promise.resolve()
+          })
+        );
+      });
     }
-  });
+  };
 };
 
 // src/eventStore/consumers/postgreSQLProcessor.ts
@@ -4586,10 +4949,10 @@ var postgreSQLCheckpointer = () => ({
     return { lastCheckpoint: result?.lastProcessedCheckpoint };
   },
   store: async (options, context) => {
-    const newPosition = getCheckpoint(options.message);
+    const newCheckpoint = getCheckpoint(options.message);
     const result = await storeProcessorCheckpoint(context.execute, {
       lastProcessedCheckpoint: options.lastCheckpoint,
-      newCheckpoint: newPosition,
+      newCheckpoint,
       processorId: options.processorId,
       partition: options.partition,
       version: options.version
@@ -4622,7 +4985,10 @@ var postgreSQLProcessingScope = (options) => {
           connectionString,
           pool,
           client,
-          transaction
+          transaction,
+          messageStore: getPostgreSQLEventStore(connectionString, {
+            connectionOptions: { client }
+          })
         }
       });
     });
@@ -4636,7 +5002,8 @@ var getProcessorPool = (options) => {
   const processorConnectionString = "connectionString" in poolOptions ? poolOptions.connectionString ?? null : null;
   const processorPool = "dumbo" in poolOptions ? poolOptions.dumbo : processorConnectionString ? dumbo5({
     connectionString: processorConnectionString,
-    ...poolOptions
+    ...poolOptions,
+    serialization: options.serialization
   }) : null;
   return {
     pool: processorPool,
@@ -4663,8 +5030,7 @@ var postgreSQLProjector = (options) => {
     processorInstanceId = getProcessorInstanceId(processorId),
     version = defaultProcessorVersion,
     partition = defaultProcessorPartition,
-    lockPolicy = DefaultPostgreSQLProcessorLockPolicy,
-    lockTimeoutSeconds
+    lock
   } = options;
   const { pool, connectionString, close } = getProcessorPool(options);
   const processorLock = postgreSQLProcessorLock({
@@ -4673,13 +5039,13 @@ var postgreSQLProjector = (options) => {
     partition,
     processorInstanceId,
     projection: options.projection ? {
-      name: options.projection.name ?? unknownTag2,
-      kind: options.projection.kind ?? unknownTag2,
+      name: options.projection.name ?? unknownTag,
+      kind: options.projection.kind ?? unknownTag,
       version: options.projection.version ?? version,
       handlingType: "async"
     } : void 0,
-    lockPolicy,
-    lockTimeoutSeconds
+    lockAcquisitionPolicy: lock?.acquisitionPolicy ?? DefaultPostgreSQLProcessorLockPolicy,
+    lockTimeoutSeconds: lock?.timeoutSeconds
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
@@ -4725,13 +5091,60 @@ var postgreSQLProjector = (options) => {
   });
   return processor;
 };
+var postgreSQLWorkflowProcessor = (options) => {
+  const {
+    processorId = options.processorId ?? getWorkflowId({
+      workflowName: options.workflow.name ?? "unknown"
+    }),
+    processorInstanceId = getProcessorInstanceId(processorId),
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition,
+    lock
+  } = options;
+  const { pool, connectionString, close } = getProcessorPool(options);
+  const processorLock = postgreSQLProcessorLock({
+    processorId,
+    version,
+    partition,
+    processorInstanceId,
+    projection: void 0,
+    lockAcquisitionPolicy: lock?.acquisitionPolicy ?? DefaultPostgreSQLProcessorLockPolicy,
+    lockTimeoutSeconds: lock?.timeoutSeconds
+  });
+  const hooks = wrapHooksWithProcessorLocks(
+    {
+      ...options.hooks ?? {},
+      onClose: close ? async (context) => {
+        if (options.hooks?.onClose)
+          await options.hooks?.onClose(context);
+        if (close) await close();
+      } : options.hooks?.onClose
+    },
+    processorLock
+  );
+  return workflowProcessor({
+    ...options,
+    processorId,
+    processorInstanceId,
+    version,
+    partition,
+    hooks,
+    processingScope: postgreSQLProcessingScope({
+      pool,
+      connectionString,
+      processorId,
+      partition
+    }),
+    checkpoints: postgreSQLCheckpointer()
+  });
+};
 var postgreSQLReactor = (options) => {
   const {
     processorId = options.processorId,
     processorInstanceId = getProcessorInstanceId(processorId),
     version = defaultProcessorVersion,
     partition = defaultProcessorPartition,
-    lockPolicy = DefaultPostgreSQLProcessorLockPolicy
+    lock
   } = options;
   const { pool, connectionString, close } = getProcessorPool(options);
   const processorLock = postgreSQLProcessorLock({
@@ -4740,7 +5153,8 @@ var postgreSQLReactor = (options) => {
     partition,
     processorInstanceId,
     projection: void 0,
-    lockPolicy
+    lockAcquisitionPolicy: lock?.acquisitionPolicy ?? DefaultPostgreSQLProcessorLockPolicy,
+    lockTimeoutSeconds: lock?.timeoutSeconds
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
@@ -4768,14 +5182,6 @@ var postgreSQLReactor = (options) => {
     checkpoints: postgreSQLCheckpointer()
   });
 };
-var postgreSQLMessageProcessor = (options) => {
-  if ("projection" in options) {
-    return postgreSQLProjector(
-      options
-    );
-  }
-  return postgreSQLReactor(options);
-};
 
 // src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
 var postgreSQLEventStoreConsumer = (options) => {
@@ -4786,7 +5192,10 @@ var postgreSQLEventStoreConsumer = (options) => {
   let abortController = null;
   let start;
   let messagePuller;
-  const pool = options.pool ? options.pool : dumbo6({ connectionString: options.connectionString });
+  const pool = options.pool ? options.pool : dumbo6({
+    connectionString: options.connectionString,
+    serialization: options.serialization
+  });
   const eachBatch = async (messagesBatch) => {
     const activeProcessors = processors.filter((s) => s.isActive);
     if (activeProcessors.length === 0)
@@ -4816,7 +5225,8 @@ var postgreSQLEventStoreConsumer = (options) => {
       connectionString: options.connectionString,
       pool,
       client: void 0,
-      transaction: void 0
+      transaction: void 0,
+      messageStore: void 0
     }
   };
   const stopProcessors = () => Promise.all(processors.map((p) => p.close(processorContext)));
@@ -4826,10 +5236,10 @@ var postgreSQLEventStoreConsumer = (options) => {
     if (messagePuller) {
       abortController?.abort();
       await messagePuller.stop();
-      messagePuller = void 0;
-      abortController = null;
     }
     await start;
+    messagePuller = void 0;
+    abortController = null;
     await stopProcessors();
   };
   const init = async () => {
@@ -4843,7 +5253,7 @@ var postgreSQLEventStoreConsumer = (options) => {
     isInitialized = true;
   };
   return {
-    consumerId: options.consumerId ?? uuid7(),
+    consumerId: options.consumerId ?? uuid9(),
     get isRunning() {
       return isRunning;
     },
@@ -4865,6 +5275,14 @@ var postgreSQLEventStoreConsumer = (options) => {
       );
       return processor;
     },
+    workflowProcessor: (options2) => {
+      const processor = postgreSQLWorkflowProcessor(options2);
+      processors.push(
+        // TODO: change that
+        processor
+      );
+      return processor;
+    },
     start: () => {
       if (isRunning) return start;
       if (processors.length === 0)
@@ -4926,27 +5344,27 @@ var rebuildPostgreSQLProjections = (options) => {
     ...options,
     stopWhen: { noMessagesLeft: true }
   });
+  const lock = { acquisitionPolicy: defaultRebuildLockPolicy, ...options.lock };
   const projections = "projections" in options ? options.projections.map(
     (p) => "projection" in p ? {
-      lockPolicy: defaultRebuildLockPolicy,
       truncateOnStart: true,
       processorId: getProjectorId({
-        projectionName: p.projection.name ?? unknownTag2
+        projectionName: p.projection.name ?? unknownTag
       }),
       ...p
     } : {
       projection: p,
       processorId: getProjectorId({
-        projectionName: p.name ?? unknownTag2
+        projectionName: p.name ?? unknownTag
       }),
-      truncateOnStart: true,
-      lockPolicy: defaultRebuildLockPolicy
+      truncateOnStart: true
     }
   ) : [options];
   for (const projectionDefinition of projections) {
     consumer.projector({
       ...projectionDefinition,
-      truncateOnStart: projectionDefinition.truncateOnStart ?? true
+      truncateOnStart: projectionDefinition.truncateOnStart ?? true,
+      lock
     });
   }
   return consumer;
@@ -4982,13 +5400,13 @@ export {
   deactivateProjection,
   deactivateProjectionSQL,
   defaultPostgreSQLOptions,
-  defaultTag,
+  defaultTag2 as defaultTag,
   documentDoesNotExist,
   documentExists,
   documentMatchingExists,
   documentsAreTheSame,
   documentsMatchingHaveCount,
-  emmettPrefix,
+  emmettPrefix2 as emmettPrefix,
   eventInStream,
   eventStoreSchemaMigrations,
   eventsInStream,
@@ -5007,7 +5425,6 @@ export {
   postgreSQLCheckpointer,
   postgreSQLEventStoreConsumer,
   postgreSQLEventStoreMessageBatchPuller,
-  postgreSQLMessageProcessor,
   postgreSQLProcessorLock,
   postgreSQLProjection,
   postgreSQLProjectionLock,
@@ -5015,6 +5432,7 @@ export {
   postgreSQLRawBatchSQLProjection,
   postgreSQLRawSQLProjection,
   postgreSQLReactor,
+  postgreSQLWorkflowProcessor,
   processorsTable,
   processorsTableSQL,
   projectionsTable,
@@ -5041,7 +5459,7 @@ export {
   transactionToPostgreSQLProjectionHandlerContext,
   tryAcquireProcessorLockSQL,
   tryAcquireProjectionLockSQL,
-  unknownTag,
+  unknownTag2 as unknownTag,
   zipPostgreSQLEventStoreMessageBatchPullerStartFrom
 };
 //# sourceMappingURL=index.js.map