@relaybus/postgres 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -189,6 +189,26 @@ var DEFAULT_SCHEMA = "public";
 var MAXIMUM_CHANNEL_LENGTH = 63;
 var DEFAULT_TABLE_PREFIX = "relaybus_";
 var TABLE_PREFIX_PATTERN = /^[a-z0-9_]*$/;
+function indexNames(index) {
+  return {
+    deliveryEventHandler: index("deliveries_event_handler_unique"),
+    deliveryLaneDue: index("deliveries_lane_due_idx"),
+    deliveryKeyPending: index("deliveries_key_pending_idx"),
+    eventCreated: index("events_created_idx"),
+    deliveryCompleted: index("deliveries_completed_idx"),
+    deliveryDead: index("deliveries_dead_idx"),
+    completionCompleted: index("completed_deliveries_completed_idx"),
+    eventCompletionsCompleted: index("event_completions_completed_idx"),
+    obsolete: [
+      index("deliveries_due_idx"),
+      index("deliveries_due_unkeyed_idx"),
+      index("deliveries_handler_created_idx"),
+      index("deliveries_key_unfinished_idx"),
+      index("deliveries_key_processing_idx"),
+      index("deliveries_status_created_idx")
+    ]
+  };
+}
 function resolvePostgresNames(options = {}) {
   const schema = options.schema ?? DEFAULT_SCHEMA;
   const tablePrefix = options.tablePrefix ?? DEFAULT_TABLE_PREFIX;
@@ -218,24 +238,7 @@ function resolvePostgresNames(options = {}) {
     completions: table("completed_deliveries"),
     completionHistory: options.completionHistory ?? false,
     notificationChannel: channelName(`${schema}.${tablePrefix}deliveries`),
-    indexes: {
-      deliveryEventHandler: index("deliveries_event_handler_unique"),
-      deliveryLaneDue: index("deliveries_lane_due_idx"),
-      deliveryKeyPending: index("deliveries_key_pending_idx"),
-      eventCreated: index("events_created_idx"),
-      deliveryCompleted: index("deliveries_completed_idx"),
-      deliveryDead: index("deliveries_dead_idx"),
-      completionCompleted: index("completed_deliveries_completed_idx"),
-      eventCompletionsCompleted: index("event_completions_completed_idx"),
-      obsolete: [
-        index("deliveries_due_idx"),
-        index("deliveries_due_unkeyed_idx"),
-        index("deliveries_handler_created_idx"),
-        index("deliveries_key_unfinished_idx"),
-        index("deliveries_key_processing_idx"),
-        index("deliveries_status_created_idx")
-      ]
-    }
+    indexes: indexNames(index)
   };
 }
 var CHANNEL_HASH_DIGITS = 32;
@@ -266,6 +269,9 @@ function createPostgresSchemaStatements(options = {}) {
   return statements;
 }
 function eventAndDeliveryStatements(names) {
+  return [...eventAndKeySequenceStatements(names), ...deliveryStatements(names)];
+}
+function eventAndKeySequenceStatements(names) {
   return [
     `CREATE TABLE IF NOT EXISTS ${names.events} (
   id text PRIMARY KEY,
@@ -285,7 +291,11 @@ function eventAndDeliveryStatements(names) {
     `CREATE TABLE IF NOT EXISTS ${names.keySequences} (
   key text PRIMARY KEY,
   sequence bigint NOT NULL
-)`,
+)`
+  ];
+}
+function deliveryStatements(names) {
+  return [
     `CREATE TABLE IF NOT EXISTS ${names.deliveries} (
   id text COLLATE "C" PRIMARY KEY,
   event_id text NOT NULL REFERENCES ${names.events} (id) ON DELETE CASCADE,
@@ -377,6 +387,16 @@ function createPostgresSchemaSql(options = {}) {
 `;
 }
 var RECONNECT_DELAY_MS = 1e3;
+function endOnce(connection, ended) {
+  let ending = Promise.resolve();
+  return () => {
+    if (!ended.value) {
+      ended.value = true;
+      ending = connection.end().catch(() => void 0);
+    }
+    return ending;
+  };
+}
 var NotificationListener = class {
   #connect;
   #channel;
@@ -395,15 +415,8 @@ var NotificationListener = class {
   /** Connects and listens. Rejects when that fails; a connection lost later is replaced. */
   async start() {
     const connection = await this.#connect();
-    let ended = false;
-    let ending = Promise.resolve();
-    const end = () => {
-      if (!ended) {
-        ended = true;
-        ending = connection.end().catch(() => void 0);
-      }
-      return ending;
-    };
+    const ended = { value: false };
+    const end = endOnce(connection, ended);
     if (this.#closed) {
       await end();
       return;
@@ -411,7 +424,7 @@ var NotificationListener = class {
     this.#drop = end;
     let listening = false;
     const onLost = (error) => {
-      if (!listening || ended) {
+      if (!listening || ended.value) {
         return;
       }
       void end();
@@ -427,14 +440,8 @@ var NotificationListener = class {
     try {
       await connection.query(`LISTEN "${this.#channel}"`);
     } catch (error) {
-      if (this.#drop === end) {
-        this.#drop = void 0;
-      }
-      await end();
-      if (this.#closed) {
-        return;
-      }
-      throw error;
+      await this.#abandonFailedListen(end, error);
+      return;
     }
     if (this.#closed) {
       await end();
@@ -442,6 +449,17 @@ var NotificationListener = class {
     }
     listening = true;
   }
+  /** Forgets and ends a connection whose LISTEN failed; rethrows the failure unless closing caused it. */
+  async #abandonFailedListen(end, error) {
+    if (this.#drop === end) {
+      this.#drop = void 0;
+    }
+    await end();
+    if (this.#closed) {
+      return;
+    }
+    throw error;
+  }
   #scheduleReconnect() {
     this.#reconnectTimer = internal.schedule(core.systemClock, {
       run: () => {
@@ -476,7 +494,18 @@ var NotificationListener = class {
   }
 };
 
-// src/row-mapping.ts
+// src/root-pool-executor.ts
+function withRootPool(executor, root) {
+  return {
+    ...executor.sessionTimeouts === void 0 ? {} : { sessionTimeouts: executor.sessionTimeouts },
+    transaction: (work) => executor.transaction(work),
+    ...executor.transactionWithBudget === void 0 ? {} : {
+      transactionWithBudget: (work, timeoutMs) => executor.transactionWithBudget(work, timeoutMs)
+    },
+    // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature
+    query: (sql, parameters, transaction, options) => transaction === void 0 ? root.query(sql, parameters, void 0, options) : executor.query(sql, parameters, transaction, options)
+  };
+}
 function text(row, column) {
   return row[column];
 }
@@ -503,16 +532,16 @@ function mapEventEnvelope(row) {
     occurredAt: new Date(text(row, "event_occurred_at"))
   };
 }
+var LEASE_TOKENS = new internal.LaneLeaseTokenFormat({
+  laneCount: LANE_COUNT,
+  epochDigits: 18,
+  claimsDigits: 9
+});
 function formatLeaseToken(lane, { epoch, claims }) {
-  return `${lane}:${epoch}:${claims}`;
+  return LEASE_TOKENS.format(lane, { epoch, claims });
 }
-var LEASE_TOKEN_PATTERN = /^(\d{1,3}):(\d{1,18}):(\d{1,9})$/;
 function parseLeaseToken(token) {
-  const match = LEASE_TOKEN_PATTERN.exec(token);
-  if (match === null || Number(match[1]) >= LANE_COUNT) {
-    return void 0;
-  }
-  return { lane: Number(match[1]), epoch: match[2], claims: Number(match[3]) };
+  return LEASE_TOKENS.parse(token);
 }
 function mapClaimedDelivery(row, leaseExpiresAt) {
   return {
@@ -564,22 +593,11 @@ var PostgresAppend = class {
     const createdAt = now.toISOString();
     const wakeAt = this.#wakeAt(plan.deliveries, { now, transaction });
     const handlersByEvent = handlersByEventOf(plan.deliveries);
-    const keyCounts = keyCountsOf(plan.events);
-    const fresh = await this.#state.query({
-      sql: this.#state.statements.append.insertFreshEvents,
-      parameters: [
-        JSON.stringify(
-          plan.events.map((event, ordinal) => ({
-            ordinal,
-            ...toEventRow(event, { sequence: null, handlers: handlersByEvent.get(event.id) ?? [] })
-          }))
-        ),
-        createdAt,
-        JSON.stringify(plan.deliveries),
-        JSON.stringify([...keyCounts].map(([key, count]) => ({ key, count }))),
-        wakeAt
-      ],
-      transaction
+    const fresh = await this.#insertFreshEvents(transaction, {
+      plan,
+      handlersByEvent,
+      createdAt,
+      wakeAt
     });
     const insertedEventIds = new Set(
       fresh.filter((row) => row["inserted"] === true).map((row) => row["id"])
@@ -601,6 +619,40 @@ var PostgresAppend = class {
     }
     return { ...splitOutcomes(plan, insertedEventIds), appendedDeliveryCount };
   }
+  /** Runs the publishing statement that inserts the events not stored yet, with their deliveries. */
+  async #insertFreshEvents(transaction, {
+    plan,
+    handlersByEvent,
+    createdAt,
+    wakeAt
+  }) {
+    const keyCounts = keyCountsOf(plan.events);
+    return this.#state.query({
+      sql: this.#state.statements.append.insertFreshEvents,
+      parameters: [
+        JSON.stringify(
+          plan.events.map((event, ordinal) => ({
+            ordinal,
+            ...toEventRow(event, { sequence: null, handlers: handlersByEvent.get(event.id) ?? [] })
+          }))
+        ),
+        createdAt,
+        JSON.stringify(plan.deliveries),
+        JSON.stringify([...keyCounts].map(([key, count]) => ({ key, count }))),
+        wakeAt
+      ],
+      transaction
+    });
+  }
+  /** Locks the given events and returns the ids of those that still exist. */
+  async #lockExistingEvents(transaction, existing) {
+    const locked = await this.#state.query({
+      sql: this.#state.statements.append.lockExistingEvents,
+      parameters: [JSON.stringify(existing.map((row) => row.id).sort())],
+      transaction
+    });
+    return new Set(locked.map((row) => row["id"]));
+  }
   /**
    * The time the publishing statements notify the dispatchers for (deliveries due by then wake them),
    * or `null` for no notification. An append in a transaction of the caller's always notifies, at its
@@ -668,13 +720,7 @@ var PostgresAppend = class {
       })
     );
     while (existing.length > 0) {
-      const locked = new Set(
-        (await this.#state.query({
-          sql: this.#state.statements.append.lockExistingEvents,
-          parameters: [JSON.stringify(existing.map((row) => row.id).sort())],
-          transaction
-        })).map((row) => row["id"])
-      );
+      const locked = await this.#lockExistingEvents(transaction, existing);
       const gone = existing.filter((row) => !locked.has(row.id));
       if (gone.length > 0) {
         const inserted2 = await this.#state.query({
@@ -711,7 +757,7 @@ function planAppend(entries) {
       events.push(event);
     }
     for (const delivery of newDeliveries) {
-      const identity = `${event.id}\0${delivery.handler}`;
+      const identity = internal.CompositeKey.of(event.id, delivery.handler);
       if (!seenDeliveries.has(identity)) {
         seenDeliveries.add(identity);
         deliveries.push({
@@ -776,49 +822,46 @@ var ReconcileFailedError = class extends core.RelayBusError {
   name = "ReconcileFailedError";
   code = "RELAYBUS_POSTGRES_RECONCILE_FAILED";
 };
-
-// src/postgres-store-state.ts
-function handedOutKey(deliveryId, leaseToken) {
-  return `${deliveryId}\0${leaseToken}`;
+function leftWorkBehind(row) {
+  return row["takeover_waiting"] === true || row["unexamined_free_lanes"] === true || row["stale"] === true;
+}
+function keepKeyHeads(picked, limit) {
+  const seenKeys = /* @__PURE__ */ new Set();
+  const kept = [...picked].sort((left, right) => compareSequence(left, right)).filter((row) => {
+    if (row["delivery_key"] === null) {
+      return true;
+    }
+    const group = internal.CompositeKey.of(row["handler"], row["delivery_key"]);
+    return !seenKeys.has(group) && Boolean(seenKeys.add(group));
+  });
+  kept.sort(compareDue);
+  return kept.slice(0, limit);
+}
+function compareSequence(left, right) {
+  const first = sequenceOf(left);
+  const second = sequenceOf(right);
+  return Number(first > second) - Number(first < second);
+}
+function sequenceOf(row) {
+  return BigInt(row["sequence"] ?? 0);
+}
+function compareDue(left, right) {
+  return compareText(left["due_at"], right["due_at"]) || compareText(left["delivery_id"], right["delivery_id"]);
+}
+function compareText(left, right) {
+  return Number(left > right) - Number(left < right);
 }
 
 // src/postgres-claim.ts
 var INITIAL_LANES_PER_ROUND = 4;
 var MAXIMUM_STALE_CLAIM_ATTEMPTS = 3;
-var PostgresClaims = class {
+var PostgresClaims = class extends internal.OwnerSerializedClaims {
   #state;
   constructor(state) {
+    super();
     this.#state = state;
   }
-  /** Implements {@link PostgresEventStore.claim}. */
-  claim(request) {
-    if (request.handlers.length === 0 || !(request.limit > 0)) {
-      return Promise.resolve([]);
-    }
-    return this.#serialized(request.leaseOwner, () => this.#claim(request));
-  }
-  /**
-   * Runs `work` after the earlier claims of the same owner on this store settled. The
-   * bookkeeping of what was handed out and the reconciliation of a failed claim need
-   * one claim at a time per owner (the dispatcher claims one batch at a time anyway;
-   * `runOnce` next to a running dispatcher is what this guards against).
-   */
-  #serialized(owner, work) {
-    const previous = this.#state.ownerQueues.get(owner) ?? Promise.resolve();
-    const run = previous.then(work, work);
-    const tail = run.then(
-      () => void 0,
-      () => void 0
-    );
-    this.#state.ownerQueues.set(owner, tail);
-    void tail.then(() => {
-      if (this.#state.ownerQueues.get(owner) === tail) {
-        this.#state.ownerQueues.delete(owner);
-      }
-    });
-    return run;
-  }
-  async #claim(request) {
+  async claimInTurn(request) {
     await this.#assertReconciled(request.leaseOwner);
     const heldFirst = this.#state.drainingOwners.has(request.leaseOwner);
     let rows = await this.#claimFirst(request, heldFirst);
@@ -990,7 +1033,7 @@ var PostgresClaims = class {
   #handOut(rows, leaseOwner) {
     for (const row of rows) {
       const claim = mapClaimedDelivery(row, /* @__PURE__ */ new Date(0));
-      this.#state.handedOut.set(handedOutKey(claim.deliveryId, claim.leaseToken), {
+      this.#state.handedOut.register(claim, {
         owner: leaseOwner,
         deliveryId: claim.deliveryId,
         ...parseLeaseToken(claim.leaseToken)
@@ -1011,11 +1054,9 @@ var PostgresClaims = class {
       ...JSON.parse(row["running_ids"]),
       ...claimed.map((picked) => picked["delivery_id"])
     ]);
-    for (const [key, entry] of this.#state.handedOut) {
-      if (entry.owner === leaseOwner && heldLanes.has(entry.lane) && !running.has(entry.deliveryId)) {
-        this.#state.handedOut.delete(key);
-      }
-    }
+    this.#state.handedOut.forgetWhere(
+      (entry) => entry.owner === leaseOwner && heldLanes.has(entry.lane) && !running.has(entry.deliveryId)
+    );
   }
   /**
    * After a claim failed, possibly after the database recorded its batch: gives back the recorded
@@ -1025,7 +1066,7 @@ var PostgresClaims = class {
    */
   async #reconcile(leaseOwner) {
     const generation = this.#generation(leaseOwner, true);
-    const handedOut = [...this.#state.handedOut.values()].filter((entry) => entry.owner === leaseOwner).map(({ deliveryId, lane, epoch, claims }) => ({ id: deliveryId, lane, epoch, claims }));
+    const handedOut = this.#state.handedOut.entriesOf(leaseOwner).map(({ deliveryId, lane, epoch, claims }) => ({ id: deliveryId, lane, epoch, claims }));
     try {
       await this.#state.query({
         sql: this.#state.statements.claim.reconcileClaims,
@@ -1062,16 +1103,7 @@ var PostgresClaims = class {
           (row) => row["delivery_id"] !== null && !pickedIds.has(row["delivery_id"])
         )
       );
-      const seenKeys = /* @__PURE__ */ new Set();
-      const kept = [...picked].sort((left, right) => compareSequence(left, right)).filter((row) => {
-        if (row["delivery_key"] === null) {
-          return true;
-        }
-        const group = `${row["handler"]}\0${row["delivery_key"]}`;
-        return !seenKeys.has(group) && Boolean(seenKeys.add(group));
-      });
-      kept.sort(compareDue);
-      return kept.slice(0, limit);
+      return keepKeyHeads(picked, limit);
     }
     return picked;
   }
@@ -1103,43 +1135,12 @@ var PostgresClaims = class {
   }
 };
 var GENERATION_STEP = 1n;
-function leftWorkBehind(row) {
-  return row["takeover_waiting"] === true || row["unexamined_free_lanes"] === true || row["stale"] === true;
-}
-function compareSequence(left, right) {
-  const first = sequenceOf(left);
-  const second = sequenceOf(right);
-  return Number(first > second) - Number(first < second);
-}
-function sequenceOf(row) {
-  return BigInt(row["sequence"] ?? 0);
-}
-function compareDue(left, right) {
-  return compareText(left["due_at"], right["due_at"]) || compareText(left["delivery_id"], right["delivery_id"]);
-}
-function compareText(left, right) {
-  return Number(left > right) - Number(left < right);
-}
-
-// src/postgres-completion.ts
-var PostgresCompletion = class {
+var PostgresCompletion = class extends internal.LeaseSettlement {
   #state;
   constructor(state) {
+    super();
     this.#state = state;
   }
-  /** Implements {@link PostgresEventStore.extendLease}. */
-  extendLease(lease, leaseExpiresAt) {
-    return this.#whenIssued(
-      lease,
-      (held) => this.#changed(this.#state.statements.completion.extendLease, [
-        lease.deliveryId,
-        held.lane,
-        held.epoch,
-        held.claims,
-        leaseExpiresAt.toISOString()
-      ])
-    );
-  }
   /** Implements {@link PostgresEventStore.complete}. */
   async complete(lease, { now, transaction }) {
     return (await this.#completeLeases([lease], { now, transaction }))[0];
@@ -1148,76 +1149,44 @@ var PostgresCompletion = class {
   completeMany(leases, now) {
     return this.#completeLeases(leases, { now, transaction: void 0 });
   }
-  /** Implements {@link PostgresEventStore.reschedule}. */
-  reschedule(lease, {
-    availableAt,
-    error,
-    now
-  }) {
-    return this.#settled(
-      lease,
-      this.#whenIssued(
-        lease,
-        (held) => this.#changed(this.#state.statements.completion.reschedule, [
-          lease.deliveryId,
-          held.lane,
-          held.epoch,
-          held.claims,
-          availableAt.toISOString(),
-          JSON.stringify(error),
-          now.toISOString()
-        ])
-      )
-    );
+  /** A lease this store issued; any other token cannot be held. */
+  findHeld(lease) {
+    return parseLeaseToken(lease.leaseToken);
   }
-  /** Implements {@link PostgresEventStore.bury}. */
-  bury(lease, { error, now }) {
-    return this.#settled(
-      lease,
-      this.#whenIssued(
-        lease,
-        (held) => this.#changed(this.#state.statements.completion.bury, [
-          lease.deliveryId,
-          held.lane,
-          held.epoch,
-          held.claims,
-          JSON.stringify(error),
-          now.toISOString()
-        ])
-      )
-    );
+  writeExtension(held, { lease, leaseExpiresAt }) {
+    return this.#changed(this.#state.statements.completion.extendLease, [
+      ...fenceOf(lease, held),
+      leaseExpiresAt.toISOString()
+    ]);
   }
-  /** Implements {@link PostgresEventStore.release}. */
-  release(lease, now) {
-    return this.#settled(
-      lease,
-      this.#whenIssued(
-        lease,
-        (held) => this.#changed(this.#state.statements.completion.release, [
-          lease.deliveryId,
-          held.lane,
-          held.epoch,
-          held.claims,
-          now.toISOString()
-        ])
-      )
-    );
+  writeChange(held, { lease, change }) {
+    const { completion } = this.#state.statements;
+    const fence = fenceOf(lease, held);
+    if (change.kind === "reschedule") {
+      return this.#changed(completion.reschedule, [
+        ...fence,
+        change.availableAt.toISOString(),
+        JSON.stringify(change.error),
+        change.now.toISOString()
+      ]);
+    }
+    if (change.kind === "bury") {
+      return this.#changed(completion.bury, [
+        ...fence,
+        JSON.stringify(change.error),
+        change.now.toISOString()
+      ]);
+    }
+    return this.#changed(completion.release, [...fence, change.now.toISOString()]);
   }
   /** Forgets a handed-out lease once the store answered about it (any answer: the claim is over or fenced out). */
-  async #settled(lease, work) {
-    const result = await work;
-    this.#state.handedOut.delete(handedOutKey(lease.deliveryId, lease.leaseToken));
-    return result;
+  forgetHandedOut(lease) {
+    this.#state.handedOut.forget(lease);
   }
   async #changed(sql, parameters) {
     const rows = await this.#state.query({ sql, parameters });
     return readCount(rows[0], "count") > 0;
   }
-  /** Runs `operation` for a lease this store issued; any other token cannot be held. */
-  async #whenIssued(lease, operation) {
-    const held = parseLeaseToken(lease.leaseToken);
-    return held !== void 0 && await operation(held);
-  }
   /**
    * Deletes the delivery of every lease that is still the current claim of its
    * delivery. Returns one flag per lease, in order. Results are matched to leases
@@ -1225,16 +1194,7 @@ var PostgresCompletion = class {
    * their own answers; a lease listed twice completes once, at its first position.
    */
   async #completeLeases(leases, { now, transaction }) {
-    const issued = [];
-    const seen = /* @__PURE__ */ new Set();
-    leases.forEach((lease, ord) => {
-      const held = parseLeaseToken(lease.leaseToken);
-      const identity = `${lease.deliveryId}\0${lease.leaseToken}`;
-      if (held !== void 0 && !seen.has(identity)) {
-        seen.add(identity);
-        issued.push({ ord, id: lease.deliveryId, ...held });
-      }
-    });
+    const issued = issuedLeases(leases);
     const completed = /* @__PURE__ */ new Set();
     if (issued.length > 0) {
       const rows = await this.#state.query({
@@ -1248,12 +1208,28 @@ var PostgresCompletion = class {
     }
     if (transaction === void 0) {
       for (const lease of leases) {
-        this.#state.handedOut.delete(handedOutKey(lease.deliveryId, lease.leaseToken));
+        this.#state.handedOut.forget(lease);
       }
     }
     return leases.map((_, ord) => completed.has(ord));
   }
 };
+function fenceOf(lease, held) {
+  return [lease.deliveryId, held.lane, held.epoch, held.claims];
+}
+function issuedLeases(leases) {
+  const issued = [];
+  const seen = /* @__PURE__ */ new Set();
+  leases.forEach((lease, ord) => {
+    const held = parseLeaseToken(lease.leaseToken);
+    const identity = internal.DeliveryLeaseIdentity.of(lease.deliveryId, lease.leaseToken);
+    if (held !== void 0 && !seen.has(identity)) {
+      seen.add(identity);
+      issued.push({ ord, id: lease.deliveryId, ...held });
+    }
+  });
+  return issued;
+}
 var OwnedConnections = class {
   #clients = /* @__PURE__ */ new Set();
   /**
@@ -1352,6 +1328,24 @@ var PostgresMaintenance = class {
   /** Implements {@link PostgresEventStore.purge}. */
   async purge(request) {
     const total = { deletedDeliveries: 0, deletedEvents: 0 };
+    const batches = this.#purgeBatchPlan(request);
+    for (const [sql, cutoff, deleteOrphans] of batches) {
+      if (cutoff === void 0) {
+        continue;
+      }
+      let deletedInBatch = this.#state.purgeBatchSize;
+      while (deletedInBatch === this.#state.purgeBatchSize) {
+        const batch = await this.#purgeBatch(sql, { cutoff, deleteOrphans });
+        deletedInBatch = batch.deletedDeliveries;
+        total.deletedDeliveries += batch.deletedDeliveries;
+        total.deletedEvents += batch.deletedEvents;
+      }
+    }
+    total.deletedEvents += await this.#purgeAllOrphanEvents(request);
+    return total;
+  }
+  /** The purge statements to run in order: SQL, cutoff (undefined skips it) and the orphan-event delete. */
+  #purgeBatchPlan(request) {
     const batches = [
       [
         this.#state.statements.purge.purgeCompletedBatch(),
@@ -1371,21 +1365,14 @@ var PostgresMaintenance = class {
         this.#state.statements.purge.deleteOrphanEventsWithoutCompletion
       ]);
     }
-    for (const [sql, cutoff, deleteOrphans] of batches) {
-      if (cutoff === void 0) {
-        continue;
-      }
-      let deletedInBatch = this.#state.purgeBatchSize;
-      while (deletedInBatch === this.#state.purgeBatchSize) {
-        const batch = await this.#purgeBatch(sql, { cutoff, deleteOrphans });
-        deletedInBatch = batch.deletedDeliveries;
-        total.deletedDeliveries += batch.deletedDeliveries;
-        total.deletedEvents += batch.deletedEvents;
-      }
-    }
+    return batches;
+  }
+  /** Removes the events left without deliveries, in two passes; returns how many events were deleted. */
+  async #purgeAllOrphanEvents(request) {
+    let deletedEvents = 0;
     const orphanCutoff = [request.completedBefore, request.deadBefore].filter((cutoff) => cutoff !== void 0).sort((first, second) => first.getTime() - second.getTime())[0];
     if (orphanCutoff !== void 0) {
-      total.deletedEvents += await this.#purgeOrphanEvents(
+      deletedEvents += await this.#purgeOrphanEvents(
         this.#state.statements.purge.lockOrphanEventsBatch,
         {
           deleteStatement: this.#state.statements.purge.deleteOrphanEventsWithoutCompletion,
@@ -1395,7 +1382,7 @@ var PostgresMaintenance = class {
       );
     }
     if (request.completedBefore !== void 0) {
-      total.deletedEvents += await this.#purgeOrphanEvents(
+      deletedEvents += await this.#purgeOrphanEvents(
         this.#state.statements.purge.lockCompletedOrphanEventsBatch,
         {
           deleteStatement: this.#state.statements.purge.deleteExpiredCompletedOrphanEvents,
@@ -1404,7 +1391,7 @@ var PostgresMaintenance = class {
         }
       );
     }
-    return total;
+    return deletedEvents;
   }
   async #purgeOrphanEvents(lockStatement, {
     deleteStatement,
@@ -1459,6 +1446,37 @@ var PostgresMaintenance = class {
     });
   }
 };
+var WAKE_UPS = ["notify", "poll"];
+var DEFAULT_PURGE_BATCH_SIZE = 1e3;
+function resolveStoreSettings(options) {
+  const sources = [options.executor ?? options.pool, options.connectionString].filter(
+    (source) => source !== void 0
+  );
+  if (sources.length !== 1) {
+    throw new core.ConfigurationError(
+      "PostgresEventStore needs exactly one of pool, connectionString or executor"
+    );
+  }
+  const purgeBatchSize = internal.PositiveInteger.of(
+    options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE,
+    "purgeBatchSize"
+  );
+  const wakeUp = options.wakeUp ?? "notify";
+  if (!WAKE_UPS.includes(wakeUp)) {
+    throw new core.ConfigurationError(`wakeUp must be 'notify' or 'poll', received ${String(wakeUp)}`);
+  }
+  const preparedStatements = options.preparedStatements ?? true;
+  if (typeof preparedStatements !== "boolean") {
+    throw new core.ConfigurationError(
+      `preparedStatements must be a boolean, received ${String(preparedStatements)}`
+    );
+  }
+  return {
+    purgeBatchSize,
+    wakeUp,
+    queryOptions: preparedStatements ? { prepare: true } : void 0
+  };
+}
 
 // src/statements-append.ts
 var AppendStatements = class {
@@ -1476,15 +1494,27 @@ var AppendStatements = class {
    * inserted. Deliveries of events that already existed are left to {@link insertDeliveries}.
    */
   get insertFreshEvents() {
-    const events = this.#names.events;
-    return `WITH reserved AS (
+    return `WITH ${this.#reservedSequences()}, ${this.#incomingEvents()}, ${this.#insertedEvents()}, ${this.#insertedDeliveries()}, ${this.#wakeUp("inserted_deliveries", "$5")}
+SELECT incoming.id, incoming.sequence::text AS sequence,
+  incoming.id IN (SELECT inserted_events.id FROM inserted_events) AS inserted,
+  (SELECT count(*) FROM inserted_deliveries)::int AS deliveries
+FROM incoming
+WHERE (SELECT count(*) FROM woken) >= 0`;
+  }
+  /** The CTE `reserved` of {@link insertFreshEvents}: the sequences the keys of `$4` reserve. */
+  #reservedSequences() {
+    return `reserved AS (
   INSERT INTO ${this.#names.keySequences} AS reserved (key, sequence)
   SELECT requested.key, requested.count
   FROM jsonb_to_recordset($4::jsonb) AS requested (key text, count bigint)
   ORDER BY requested.key
   ON CONFLICT (key) DO UPDATE SET sequence = reserved.sequence + EXCLUDED.sequence
   RETURNING reserved.key AS key, reserved.sequence AS sequence
-), incoming AS (
+)`;
+  }
+  /** The CTE `incoming` of {@link insertFreshEvents}: the events of `$1` with their key sequences. */
+  #incomingEvents() {
+    return `incoming AS (
   SELECT incoming.*,
     CASE WHEN incoming.key IS NULL THEN NULL ELSE
       reserved.sequence - count(*) OVER (PARTITION BY incoming.key)
@@ -1494,8 +1524,12 @@ var AppendStatements = class {
     ordinal int, id text, type text, source text, key text, payload jsonb, headers jsonb,
     correlation_id text, causation_id text, occurred_at timestamptz, handlers text[])
   LEFT JOIN reserved ON reserved.key = incoming.key
-), inserted_events AS (
-  INSERT INTO ${events}
+)`;
+  }
+  /** The CTE `inserted_events` of {@link insertFreshEvents}: the events of `$1` that do not exist yet. */
+  #insertedEvents() {
+    return `inserted_events AS (
+  INSERT INTO ${this.#names.events}
     (id, type, source, key, sequence, payload, headers, correlation_id, causation_id, occurred_at, created_at, handlers)
   SELECT incoming.id, incoming.type, incoming.source, incoming.key, incoming.sequence,
     COALESCE(incoming.payload, 'null'::jsonb), COALESCE(incoming.headers, '{}'::jsonb),
@@ -1505,7 +1539,11 @@ var AppendStatements = class {
   ORDER BY incoming.id
   ON CONFLICT (id) DO NOTHING
   RETURNING id, key, sequence
-), inserted_deliveries AS (
+)`;
+  }
+  /** The CTE `inserted_deliveries` of {@link insertFreshEvents}: the deliveries of `$3` of the inserted events. */
+  #insertedDeliveries() {
+    return `inserted_deliveries AS (
   INSERT INTO ${this.#names.deliveries}
     (id, event_id, handler, lane, status, attempts, available_at, key, sequence, created_at, updated_at)
   SELECT delivery.id, delivery.event_id, delivery.handler, ${laneExpression("event.key", "event.id")}, 'pending', 0,
@@ -1515,16 +1553,15 @@ var AppendStatements = class {
   ORDER BY delivery.event_id, delivery.handler
   ON CONFLICT (event_id, handler) DO NOTHING
   RETURNING available_at
-), ${this.#wakeUp("inserted_deliveries", "$5")}
-SELECT incoming.id, incoming.sequence::text AS sequence,
-  incoming.id IN (SELECT inserted_events.id FROM inserted_events) AS inserted,
-  (SELECT count(*) FROM inserted_deliveries)::int AS deliveries
-FROM incoming
-WHERE (SELECT count(*) FROM woken) >= 0`;
+)`;
   }
-  /** One wake-up notification on {@link PostgresNames.notificationChannel}, outside any publishing transaction. */
+  /**
+   * One wake-up notification on {@link PostgresNames.notificationChannel}, outside any publishing
+   * transaction. Returns a boolean column rather than the `void` of `pg_notify`, which some libraries
+   * cannot read (Prisma's raw queries reject a `void` column).
+   */
   get notify() {
-    return `SELECT pg_notify('${this.#names.notificationChannel}', '')`;
+    return `SELECT true AS notified FROM pg_notify('${this.#names.notificationChannel}', '')`;
   }
   /**
    * A CTE `woken` that sends one notification on {@link PostgresNames.notificationChannel} when a row of
@@ -2047,11 +2084,146 @@ SELECT count(*)::int AS count FROM changed`;
   }
 };
 
-// src/statements-lanes.ts
-var FREE_LANE_SURPLUS = 16;
+// src/statements-candidates.ts
 function notRunning(running, alias) {
   return running === null ? "true" : `NOT EXISTS (SELECT 1 FROM ${running} AS running WHERE running.handler = ${alias}.handler AND running.key = ${alias}.key)`;
 }
+var CandidateStatements = class {
+  #names;
+  constructor(names) {
+    this.#names = names;
+  }
+  /**
+   * CTEs that pick up to `limit` claimable deliveries from the lanes of the CTE `scope` (columns `lane`,
+   * `epoch`, `in_flight`), named after `prefix`; the result is `<prefix>_candidates (id, lane, available_at)`.
+   * The rules are those of `ClaimStatements.claim`. The fast window reads the first {@link LANE_SCAN_WINDOW} due
+   * deliveries of each lane (at most {@link CLAIM_SCAN_WINDOW} together); of a key, only the lowest sequence
+   * in the window can be its head, so only that one is checked for an earlier pending delivery. Only when
+   * that yields fewer than `limit` are the lanes whose window filled up looked at again with a loose index
+   * scan over the heads of all their keys. `running` names the CTE of the keyed deliveries running in the
+   * lanes, or is null when nothing runs there.
+   */
+  candidates(prefix, {
+    scope,
+    running,
+    limit
+  }) {
+    const spec = { prefix, scope, running, limit };
+    return this.#fastCandidates(spec) + this.#slowCandidates(spec);
+  }
+  /** The fast window of each lane and the claimable deliveries in it (`<prefix>_window`, `<prefix>_fast`). */
+  #fastCandidates({ prefix, scope, running, limit }) {
+    const deliveries = this.#names.deliveries;
+    return `${prefix}_window AS MATERIALIZED (
+  SELECT recent.id, recent.lane, recent.available_at, recent.handler, recent.key, recent.sequence
+  FROM ${scope}
+  CROSS JOIN LATERAL (
+    SELECT delivery.id, delivery.lane, delivery.available_at, delivery.handler, delivery.key, delivery.sequence
+    FROM ${deliveries} AS delivery
+    WHERE delivery.lane = ${scope}.lane AND delivery.status = 'pending'
+      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
+      AND delivery.id <> ALL (${scope}.in_flight)
+    ORDER BY delivery.available_at, delivery.id
+    LIMIT ${LANE_SCAN_WINDOW}
+  ) AS recent
+  ORDER BY recent.available_at, recent.id
+  LIMIT ${CLAIM_SCAN_WINDOW}
+), ${prefix}_fast AS MATERIALIZED (
+  SELECT picked.id, picked.lane, picked.available_at FROM (
+    SELECT unkeyed.id, unkeyed.lane, unkeyed.available_at FROM ${prefix}_window AS unkeyed WHERE unkeyed.key IS NULL
+    UNION ALL
+    SELECT head.id, head.lane, head.available_at
+    FROM (
+      SELECT DISTINCT ON (keyed.handler, keyed.key) keyed.id, keyed.lane, keyed.available_at, keyed.handler, keyed.key, keyed.sequence
+      FROM ${prefix}_window AS keyed
+      WHERE keyed.key IS NOT NULL
+      ORDER BY keyed.handler, keyed.key, keyed.sequence
+    ) AS head
+    WHERE NOT EXISTS (
+        SELECT 1 FROM ${deliveries} AS earlier
+        WHERE earlier.lane = head.lane AND earlier.handler = head.handler AND earlier.key = head.key
+          AND earlier.status = 'pending' AND earlier.key IS NOT NULL AND earlier.sequence < head.sequence
+      ) AND ${notRunning(running, "head")}
+  ) AS picked
+  ORDER BY picked.available_at, picked.id
+  LIMIT ${limit}
+`;
+  }
+  /**
+   * For lanes whose window filled up while the fast pick came up short: the heads of all their keys and
+   * their unkeyed deliveries, then the union with the fast pick (`<prefix>_candidates`).
+   */
+  #slowCandidates(spec) {
+    return this.#saturatedLanes(spec) + this.#keyHeads(spec) + this.#keyedHeads(spec) + this.#unkeyedRecent(spec) + this.#unionCandidates(spec);
+  }
+  /** `<prefix>_saturated`: the lanes whose window filled up while the fast pick came up short. */
+  #saturatedLanes({ prefix, scope, limit }) {
+    return `), ${prefix}_saturated AS MATERIALIZED (
+  SELECT ${scope}.lane, ${scope}.in_flight FROM ${scope}
+  WHERE (SELECT count(*) FROM ${prefix}_fast) < ${limit}
+    AND ((SELECT count(*) FROM ${prefix}_window) >= ${CLAIM_SCAN_WINDOW}
+      OR ${scope}.lane IN (
+        SELECT full_lane.lane FROM ${prefix}_window AS full_lane
+        GROUP BY full_lane.lane HAVING count(*) >= ${LANE_SCAN_WINDOW}
+      ))
+`;
+  }
+  /** `<prefix>_heads`: the head of every key of the saturated lanes. */
+  #keyHeads({ prefix }) {
+    return `), ${prefix}_heads AS MATERIALIZED (
+  SELECT head.id, head.lane, head.available_at, head.handler, head.key
+  FROM ${prefix}_saturated AS scope
+  CROSS JOIN LATERAL (${keyHeads(this.#names, "scope")}) AS head
+`;
+  }
+  /** `<prefix>_keyed`: the due heads that are not in flight and whose key runs nowhere. */
+  #keyedHeads({ prefix, running, limit }) {
+    return `), ${prefix}_keyed AS MATERIALIZED (
+  SELECT heads.id, heads.lane, heads.available_at
+  FROM ${prefix}_heads AS heads
+  JOIN ${prefix}_saturated AS scope ON scope.lane = heads.lane
+  WHERE heads.available_at <= $1::timestamptz AND heads.id <> ALL (scope.in_flight) AND ${notRunning(running, "heads")}
+  ORDER BY heads.available_at, heads.id
+  LIMIT ${limit}
+`;
+  }
+  /** `<prefix>_unkeyed`: the due unkeyed deliveries of the saturated lanes that are not in flight. */
+  #unkeyedRecent({ prefix, limit }) {
+    const deliveries = this.#names.deliveries;
+    return `), ${prefix}_unkeyed AS MATERIALIZED (
+  SELECT recent.id, recent.lane, recent.available_at
+  FROM ${prefix}_saturated AS scope
+  CROSS JOIN LATERAL (
+    SELECT delivery.id, delivery.lane, delivery.available_at
+    FROM ${deliveries} AS delivery
+    WHERE delivery.lane = scope.lane AND delivery.key IS NULL AND delivery.status = 'pending'
+      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
+      AND delivery.id <> ALL (scope.in_flight)
+    ORDER BY delivery.available_at, delivery.id
+    LIMIT ${limit}
+  ) AS recent
+  ORDER BY recent.available_at, recent.id
+  LIMIT ${limit}
+`;
+  }
+  /** `<prefix>_candidates`: the union of the fast pick and the slow picks, oldest first, at most `limit`. */
+  #unionCandidates({ prefix, limit }) {
+    return `), ${prefix}_candidates AS MATERIALIZED (
+  SELECT chosen.id, chosen.lane, chosen.available_at FROM (
+    SELECT fast.id, fast.lane, fast.available_at FROM ${prefix}_fast AS fast
+    UNION
+    SELECT keyed.id, keyed.lane, keyed.available_at FROM ${prefix}_keyed AS keyed
+    UNION
+    SELECT unkeyed.id, unkeyed.lane, unkeyed.available_at FROM ${prefix}_unkeyed AS unkeyed
+  ) AS chosen
+  ORDER BY chosen.available_at, chosen.id
+  LIMIT ${limit}
+)`;
+  }
+};
+
+// src/statements-lanes.ts
+var FREE_LANE_SURPLUS = 16;
 var freeLane = (alias) => `(${alias}.lease_expires_at IS NULL OR ${alias}.lease_expires_at <= $1::timestamptz
       OR (${alias}.lease_owner = $4::text AND ${alias}.claim_floor < $6::bigint))`;
 var NO_FREE_LANES = `), free_lanes AS (
@@ -2063,8 +2235,10 @@ var NO_FREE_LANES = `), free_lanes AS (
 )`;
 var LaneStatements = class {
   #names;
+  #candidateStatements;
   constructor(names) {
     this.#names = names;
+    this.#candidateStatements = new CandidateStatements(names);
   }
   /**
    * A claim in one statement, the only one in the common case. Parameters:
@@ -2139,7 +2313,7 @@ var LaneStatements = class {
   CROSS JOIN LATERAL unnest(held_scope.in_flight) AS flying (id)
   JOIN ${deliveries} AS delivery ON delivery.id = flying.id
   WHERE delivery.status = 'pending' AND delivery.key IS NOT NULL
-), ${this.#candidates("held", { scope: "held_scope", running: "held_running", limit: "$3::int" })}, wanted AS MATERIALIZED (
+), ${this.#candidateStatements.candidates("held", { scope: "held_scope", running: "held_running", limit: "$3::int" })}, wanted AS MATERIALIZED (
   SELECT CASE WHEN (SELECT value FROM stale) THEN 0
     ELSE $3::int - (SELECT count(*) FROM held_candidates)::int END AS count
 `;
@@ -2228,7 +2402,7 @@ var LaneStatements = class {
   WHERE locked.epoch = seen.epoch AND locked.in_flight = seen.in_flight
     AND locked.lease_owner IS NOT DISTINCT FROM seen.lease_owner
     AND locked.lease_expires_at IS NOT DISTINCT FROM seen.lease_expires_at
-), ${this.#candidates("free", { scope: "free_scope", running: null, limit: "(SELECT count FROM wanted)" })}`;
+), ${this.#candidateStatements.candidates("free", { scope: "free_scope", running: null, limit: "(SELECT count FROM wanted)" })}`;
   }
   /** The picked deliveries of held and taken lanes with their events, and the picks per lane. */
   #claimPicks() {
@@ -2317,113 +2491,6 @@ SELECT (SELECT value FROM stale) AS stale,
 FROM (SELECT 1) AS anchor
 LEFT JOIN picked_rows AS picked ON true
 ORDER BY picked.due_at, picked.delivery_id`;
-  }
-  /**
-   * CTEs that pick up to `limit` claimable deliveries from the lanes of the CTE `scope` (columns `lane`,
-   * `epoch`, `in_flight`), named after `prefix`; the result is `<prefix>_candidates (id, lane, available_at)`.
-   * The rules are those of `ClaimStatements.claim`. The fast window reads the first {@link LANE_SCAN_WINDOW} due
-   * deliveries of each lane (at most {@link CLAIM_SCAN_WINDOW} together); of a key, only the lowest sequence
-   * in the window can be its head, so only that one is checked for an earlier pending delivery. Only when
-   * that yields fewer than `limit` are the lanes whose window filled up looked at again with a loose index
-   * scan over the heads of all their keys. `running` names the CTE of the keyed deliveries running in the
-   * lanes, or is null when nothing runs there.
-   */
-  #candidates(prefix, {
-    scope,
-    running,
-    limit
-  }) {
-    const spec = { prefix, scope, running, limit };
-    return this.#fastCandidates(spec) + this.#slowCandidates(spec);
-  }
-  /** The fast window of each lane and the claimable deliveries in it (`<prefix>_window`, `<prefix>_fast`). */
-  #fastCandidates({ prefix, scope, running, limit }) {
-    const deliveries = this.#names.deliveries;
-    return `${prefix}_window AS MATERIALIZED (
-  SELECT recent.id, recent.lane, recent.available_at, recent.handler, recent.key, recent.sequence
-  FROM ${scope}
-  CROSS JOIN LATERAL (
-    SELECT delivery.id, delivery.lane, delivery.available_at, delivery.handler, delivery.key, delivery.sequence
-    FROM ${deliveries} AS delivery
-    WHERE delivery.lane = ${scope}.lane AND delivery.status = 'pending'
-      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
-      AND delivery.id <> ALL (${scope}.in_flight)
-    ORDER BY delivery.available_at, delivery.id
-    LIMIT ${LANE_SCAN_WINDOW}
-  ) AS recent
-  ORDER BY recent.available_at, recent.id
-  LIMIT ${CLAIM_SCAN_WINDOW}
-), ${prefix}_fast AS MATERIALIZED (
-  SELECT picked.id, picked.lane, picked.available_at FROM (
-    SELECT unkeyed.id, unkeyed.lane, unkeyed.available_at FROM ${prefix}_window AS unkeyed WHERE unkeyed.key IS NULL
-    UNION ALL
-    SELECT head.id, head.lane, head.available_at
-    FROM (
-      SELECT DISTINCT ON (keyed.handler, keyed.key) keyed.id, keyed.lane, keyed.available_at, keyed.handler, keyed.key, keyed.sequence
-      FROM ${prefix}_window AS keyed
-      WHERE keyed.key IS NOT NULL
-      ORDER BY keyed.handler, keyed.key, keyed.sequence
-    ) AS head
-    WHERE NOT EXISTS (
-        SELECT 1 FROM ${deliveries} AS earlier
-        WHERE earlier.lane = head.lane AND earlier.handler = head.handler AND earlier.key = head.key
-          AND earlier.status = 'pending' AND earlier.key IS NOT NULL AND earlier.sequence < head.sequence
-      ) AND ${notRunning(running, "head")}
-  ) AS picked
-  ORDER BY picked.available_at, picked.id
-  LIMIT ${limit}
-`;
-  }
-  /**
-   * For lanes whose window filled up while the fast pick came up short: the heads of all their keys and
-   * their unkeyed deliveries, then the union with the fast pick (`<prefix>_candidates`).
-   */
-  #slowCandidates({ prefix, scope, running, limit }) {
-    const deliveries = this.#names.deliveries;
-    return `), ${prefix}_saturated AS MATERIALIZED (
-  SELECT ${scope}.lane, ${scope}.in_flight FROM ${scope}
-  WHERE (SELECT count(*) FROM ${prefix}_fast) < ${limit}
-    AND ((SELECT count(*) FROM ${prefix}_window) >= ${CLAIM_SCAN_WINDOW}
-      OR ${scope}.lane IN (
-        SELECT full_lane.lane FROM ${prefix}_window AS full_lane
-        GROUP BY full_lane.lane HAVING count(*) >= ${LANE_SCAN_WINDOW}
-      ))
-), ${prefix}_heads AS MATERIALIZED (
-  SELECT head.id, head.lane, head.available_at, head.handler, head.key
-  FROM ${prefix}_saturated AS scope
-  CROSS JOIN LATERAL (${keyHeads(this.#names, "scope")}) AS head
-), ${prefix}_keyed AS MATERIALIZED (
-  SELECT heads.id, heads.lane, heads.available_at
-  FROM ${prefix}_heads AS heads
-  JOIN ${prefix}_saturated AS scope ON scope.lane = heads.lane
-  WHERE heads.available_at <= $1::timestamptz AND heads.id <> ALL (scope.in_flight) AND ${notRunning(running, "heads")}
-  ORDER BY heads.available_at, heads.id
-  LIMIT ${limit}
-), ${prefix}_unkeyed AS MATERIALIZED (
-  SELECT recent.id, recent.lane, recent.available_at
-  FROM ${prefix}_saturated AS scope
-  CROSS JOIN LATERAL (
-    SELECT delivery.id, delivery.lane, delivery.available_at
-    FROM ${deliveries} AS delivery
-    WHERE delivery.lane = scope.lane AND delivery.key IS NULL AND delivery.status = 'pending'
-      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
-      AND delivery.id <> ALL (scope.in_flight)
-    ORDER BY delivery.available_at, delivery.id
-    LIMIT ${limit}
-  ) AS recent
-  ORDER BY recent.available_at, recent.id
-  LIMIT ${limit}
-), ${prefix}_candidates AS MATERIALIZED (
-  SELECT chosen.id, chosen.lane, chosen.available_at FROM (
-    SELECT fast.id, fast.lane, fast.available_at FROM ${prefix}_fast AS fast
-    UNION
-    SELECT keyed.id, keyed.lane, keyed.available_at FROM ${prefix}_keyed AS keyed
-    UNION
-    SELECT unkeyed.id, unkeyed.lane, unkeyed.available_at FROM ${prefix}_unkeyed AS unkeyed
-  ) AS chosen
-  ORDER BY chosen.available_at, chosen.id
-  LIMIT ${limit}
-)`;
   }
   /**
    * Takes up to `$3` free lanes (no lease, or an expired one) that have a due
@@ -2784,8 +2851,12 @@ var SetupStatements = class {
   WHERE n.nspname = '${this.#names.schema}' AND c.relname = '${this.#names.lanesTableName}' AND d.description = $1::text
 ) AS current`;
   }
+  /**
+   * Takes the setup lock. Returns a boolean column rather than the `void` of the lock function, which
+   * some libraries cannot read (Prisma's raw queries reject a `void` column).
+   */
   get setupLock() {
-    return "SELECT pg_advisory_xact_lock(hashtextextended($1::text, 0))";
+    return "SELECT true AS locked FROM pg_advisory_xact_lock(hashtextextended($1::text, 0))";
   }
 };
 
@@ -2810,8 +2881,6 @@ var PostgresStatements = class {
 };
 
 // src/postgres-event-store.ts
-var WAKE_UPS = ["notify", "poll"];
-var DEFAULT_PURGE_BATCH_SIZE = 1e3;
 var PostgresEventStore = class {
   #state;
   #appender;
@@ -2838,10 +2907,9 @@ var PostgresEventStore = class {
       queryOptions,
       notifies: wakeUp === "notify",
       query: ({ sql, parameters, transaction }) => executor.query(sql, parameters, transaction, queryOptions),
-      handedOut: /* @__PURE__ */ new Map(),
+      handedOut: new internal.HandedOutLedger(),
       unreconciled: /* @__PURE__ */ new Set(),
       generations: /* @__PURE__ */ new Map(),
-      ownerQueues: /* @__PURE__ */ new Map(),
       drainingOwners: /* @__PURE__ */ new Set(),
       ownedPool,
       pool,
@@ -2948,7 +3016,7 @@ var PostgresEventStore = class {
     return this.#claims.claim(request);
   }
   extendLease(lease, leaseExpiresAt) {
-    return this.#completion.extendLease(lease, leaseExpiresAt);
+    return Promise.resolve(this.#completion.extendLease({ lease, leaseExpiresAt }));
   }
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   complete(lease, now, transaction) {
@@ -2959,15 +3027,24 @@ var PostgresEventStore = class {
   }
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   reschedule(lease, availableAt, error, now) {
-    return this.#completion.reschedule(lease, { availableAt, error, now });
+    return Promise.resolve(
+      this.#completion.changeClaim({
+        lease,
+        change: { kind: "reschedule", availableAt, error, now }
+      })
+    );
   }
   // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   bury(lease, error, now) {
-    return this.#completion.bury(lease, { error, now });
+    return Promise.resolve(
+      this.#completion.changeClaim({ lease, change: { kind: "bury", error, now } })
+    );
   }
   /** Returns a leased delivery to pending, due now, without counting the attempt. */
   release(lease, now) {
-    return this.#completion.release(lease, now);
+    return Promise.resolve(
+      this.#completion.changeClaim({ lease, change: { kind: "release", now } })
+    );
   }
   /**
    * Calls `listener` soon after a transaction that published deliveries due at once commits, in any
@@ -3046,38 +3123,14 @@ var PostgresEventStore = class {
     }
   }
 };
-function resolveStoreSettings(options) {
-  const sources = [options.pool, options.connectionString, options.executor].filter(
-    (source) => source !== void 0
-  );
-  if (sources.length !== 1) {
-    throw new core.ConfigurationError(
-      "PostgresEventStore needs exactly one of pool, connectionString or executor"
-    );
-  }
-  const purgeBatchSize = internal.assertPositiveInteger(
-    options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE,
-    "purgeBatchSize"
-  );
-  const wakeUp = options.wakeUp ?? "notify";
-  if (!WAKE_UPS.includes(wakeUp)) {
-    throw new core.ConfigurationError(`wakeUp must be 'notify' or 'poll', received ${String(wakeUp)}`);
-  }
-  const preparedStatements = options.preparedStatements ?? true;
-  if (typeof preparedStatements !== "boolean") {
-    throw new core.ConfigurationError(
-      `preparedStatements must be a boolean, received ${String(preparedStatements)}`
-    );
-  }
-  return {
-    purgeBatchSize,
-    wakeUp,
-    queryOptions: preparedStatements ? { prepare: true } : void 0
-  };
-}
 function connect(options, { logger, owned }) {
   if (options.executor !== void 0) {
-    return { executor: options.executor, pool: void 0, ownedPool: void 0 };
+    const { executor: executor2, pool: pool2 } = options;
+    return {
+      executor: pool2 === void 0 ? executor2 : withRootPool(executor2, new PgExecutor(pool2, { logger })),
+      pool: pool2,
+      ownedPool: void 0
+    };
   }
   const pool = options.pool ?? new pg.Pool({
     ...options.poolConfig,