@relaybus/postgres 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,31 +1,130 @@
 import { createHash } from 'crypto';
-import { ConfigurationError } from '@relaybus/core';
-import { Pool, Client } from 'pg';
+import { ConfigurationError, RelayBusError, systemClock } from '@relaybus/core';
+import { LaneLeaseTokenFormat, HandedOutLedger, PositiveInteger, schedule, OwnerSerializedClaims, LeaseSettlement, CompositeKey, DeliveryLeaseIdentity } from '@relaybus/core/internal';
+import { Client, Pool } from 'pg';
+
+// src/pg-executor.ts
+
+// src/transaction-timeouts.ts
+function budgetSettingsSql({ value, sessionTimeouts, scope }) {
+  const local = scope === "transaction";
+  const statementTimeout = `SELECT set_config('statement_timeout', ${value}, ${local})`;
+  if (!sessionTimeouts) {
+    return statementTimeout;
+  }
+  return `${statementTimeout}, set_config('idle_in_transaction_session_timeout', ${value}, ${local}), CASE WHEN current_setting('server_version_num')::int >= 170000 THEN set_config('transaction_timeout', ${value}, ${local}) END`;
+}
+var SESSION_DEFAULTS_SQL = "SELECT set_config(name, reset_val, false) FROM pg_settings WHERE name IN ('statement_timeout', 'idle_in_transaction_session_timeout', 'transaction_timeout')";
+function budgetValue(timeoutMs) {
+  return `${Math.ceil(timeoutMs)}ms`;
+}
+function inBudgetedTransaction(state, {
+  work,
+  timeoutMs
+}) {
+  const { executor } = state;
+  if (executor.transactionWithBudget !== void 0) {
+    return executor.transactionWithBudget(work, timeoutMs);
+  }
+  const sql = budgetSettingsSql({
+    value: "$1",
+    sessionTimeouts: executor.sessionTimeouts === true,
+    scope: "transaction"
+  });
+  return executor.transaction(async (transaction) => {
+    await state.query({ sql, parameters: [budgetValue(timeoutMs)], transaction });
+    return work(transaction);
+  });
+}
 
 // src/pg-executor.ts
 var FOREIGN_SESSION_ERRORS = /* @__PURE__ */ new Set(["26000", "42P05"]);
+var STATEMENT_NAME_DIGITS = 24;
 var PgExecutor = class {
   #pool;
   #logger;
   #names = /* @__PURE__ */ new Map();
   #preparing = true;
+  #sessionBudget;
+  /** The budget each connection keeps at session level (`sessionBudget`); absent for the defaults. */
+  #sessionValues = /* @__PURE__ */ new WeakMap();
   constructor(pool, options = {}) {
     this.#pool = pool;
     this.#logger = options.logger ?? console;
+    this.#sessionBudget = options.sessionBudget === true;
+  }
+  /** The connection listens for `error` during the transaction, so a server-ended session fails the transaction instead of the process. */
+  sessionTimeouts = true;
+  transaction(work) {
+    return this.#transaction(
+      work,
+      (client) => this.#sessionBudget && (!this.#preparing || this.#sessionValues.has(client)) ? { begin: `BEGIN; ${SESSION_DEFAULTS_SQL}`, sessionValue: null } : { begin: "BEGIN" }
+    );
+  }
+  /**
+   * Sends `BEGIN` and the budget settings as one simple query (the value as a literal: the simple
+   * query protocol has no parameters), so the budget costs no round trip. With `sessionBudget` a
+   * connection that already keeps this budget only gets `BEGIN`.
+   */
+  transactionWithBudget(work, timeoutMs) {
+    const value = budgetValue(timeoutMs);
+    const settings = (scope) => budgetSettingsSql({ value: `'${value}'`, sessionTimeouts: true, scope });
+    return this.#transaction(work, (client) => {
+      if (!this.#keepsSessionBudget()) {
+        return { begin: `BEGIN; ${settings("transaction")}` };
+      }
+      return this.#sessionValues.get(client) === value ? { begin: "BEGIN" } : { begin: `BEGIN; ${settings("session")}`, sessionValue: value };
+    });
   }
-  async transaction(work) {
+  #recordSession(client, sessionValue) {
+    if (sessionValue === null) {
+      this.#sessionValues.delete(client);
+    } else if (sessionValue !== void 0) {
+      this.#sessionValues.set(client, sessionValue);
+    }
+  }
+  /** A pooler that hands out other server sessions (noticed by prepared statements) shares session settings. */
+  #keepsSessionBudget() {
+    return this.#sessionBudget && this.#preparing;
+  }
+  async #transaction(work, start) {
     const client = await this.#pool.connect();
+    let released = false;
+    const release = (destroy) => {
+      if (released) {
+        return;
+      }
+      released = true;
+      client.removeListener("error", onSessionEnded);
+      if (destroy) {
+        client.release(true);
+      } else {
+        client.release();
+      }
+    };
+    const onSessionEnded = (error) => {
+      this.#logger.warn(
+        `[PgExecutor](transaction) The server ended the session of an open transaction, the transaction fails | error=${error.message}`
+      );
+      release(true);
+    };
+    client.on("error", onSessionEnded);
+    const { begin, sessionValue } = start(client);
     try {
-      await client.query("BEGIN");
+      await client.query(begin);
       const result = await work(client);
-      await client.query("COMMIT");
-      client.release();
+      const { command } = await client.query("COMMIT");
+      if (command === "COMMIT") {
+        this.#recordSession(client, sessionValue);
+      }
+      release(false);
       return result;
     } catch (error) {
-      await this.#rollbackAndRelease(client);
+      await this.#rollbackAndRelease(client, release);
       throw error;
     }
   }
+  // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature
   async query(sql, parameters, transaction, options) {
     const queryable = transaction ?? this.#pool;
     const values = [...parameters];
@@ -54,18 +153,18 @@ var PgExecutor = class {
   #nameOf(sql) {
     let name = this.#names.get(sql);
     if (name === void 0) {
-      name = `relaybus_${createHash("sha256").update(sql).digest("hex").slice(0, 24)}`;
+      name = `relaybus_${createHash("sha256").update(sql).digest("hex").slice(0, STATEMENT_NAME_DIGITS)}`;
       this.#names.set(sql, name);
     }
     return name;
   }
   /** A client whose rollback fails is in an unknown state, so it is destroyed instead of reused. */
-  async #rollbackAndRelease(client) {
+  async #rollbackAndRelease(client, release) {
     try {
       await client.query("ROLLBACK");
-      client.release();
+      release(false);
     } catch {
-      client.release(true);
+      release(true);
     }
   }
 };
@@ -88,6 +187,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;
@@ -117,28 +236,12 @@ 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;
 function channelName(readable) {
-  return readable.length <= MAXIMUM_CHANNEL_LENGTH ? readable : `relaybus_${createHash("sha256").update(readable).digest("hex").slice(0, 32)}`;
+  return readable.length <= MAXIMUM_CHANNEL_LENGTH ? readable : `relaybus_${createHash("sha256").update(readable).digest("hex").slice(0, CHANNEL_HASH_DIGITS)}`;
 }
 
 // src/sql-fragments.ts
@@ -150,9 +253,24 @@ function laneExpression(keyExpression, eventIdExpression) {
 }
 
 // src/schema.ts
+var SCHEMA_MARKER_DIGITS = 32;
 function createPostgresSchemaStatements(options = {}) {
   const names = resolvePostgresNames(options);
-  const statements = [
+  const statements = [...eventAndDeliveryStatements(names), ...laneAndCompletionStatements(names)];
+  if (names.completionHistory) {
+    statements.push(...completionHistoryStatements(names));
+  }
+  if (names.schema !== "public") {
+    statements.unshift(`CREATE SCHEMA IF NOT EXISTS ${names.quotedSchema}`);
+  }
+  statements.push(`COMMENT ON TABLE ${names.lanes} IS '${postgresSchemaMarker(statements)}'`);
+  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,
   type text NOT NULL,
@@ -171,7 +289,11 @@ function createPostgresSchemaStatements(options = {}) {
     `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,
@@ -196,7 +318,11 @@ function createPostgresSchemaStatements(options = {}) {
     `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryLaneDue} ON ${names.deliveries} (lane, available_at, id) WHERE status = 'pending'`,
     `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryKeyPending} ON ${names.deliveries} (lane, handler, key, sequence) WHERE key IS NOT NULL AND status = 'pending'`,
     `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryCompleted} ON ${names.deliveries} (completed_at, id) WHERE status = 'completed'`,
-    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryDead} ON ${names.deliveries} (updated_at, id) WHERE status = 'dead'`,
+    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryDead} ON ${names.deliveries} (updated_at, id) WHERE status = 'dead'`
+  ];
+}
+function laneAndCompletionStatements(names) {
+  return [
     `CREATE TABLE IF NOT EXISTS ${names.lanes} (
   lane smallint PRIMARY KEY CHECK (lane >= 0 AND lane < ${LANE_COUNT}),
   epoch bigint NOT NULL DEFAULT 0,
@@ -213,9 +339,10 @@ function createPostgresSchemaStatements(options = {}) {
     `CREATE INDEX IF NOT EXISTS ${names.indexes.eventCompletionsCompleted} ON ${names.eventCompletions} (completed_at, event_id)`,
     `INSERT INTO ${names.lanes} (lane) SELECT generate_series(0, ${LANE_COUNT - 1})::smallint ON CONFLICT (lane) DO NOTHING`
   ];
-  if (names.completionHistory) {
-    statements.push(
-      `CREATE TABLE IF NOT EXISTS ${names.completions} (
+}
+function completionHistoryStatements(names) {
+  return [
+    `CREATE TABLE IF NOT EXISTS ${names.completions} (
   id text COLLATE "C" PRIMARY KEY,
   event_id text NOT NULL REFERENCES ${names.events} (id) ON DELETE CASCADE,
   handler text NOT NULL,
@@ -224,17 +351,11 @@ function createPostgresSchemaStatements(options = {}) {
   created_at timestamptz NOT NULL,
   completed_at timestamptz NOT NULL
 )`,
-      `CREATE INDEX IF NOT EXISTS ${names.indexes.completionCompleted} ON ${names.completions} (completed_at, id)`
-    );
-  }
-  if (names.schema !== "public") {
-    statements.unshift(`CREATE SCHEMA IF NOT EXISTS ${names.quotedSchema}`);
-  }
-  statements.push(`COMMENT ON TABLE ${names.lanes} IS '${postgresSchemaMarker(statements)}'`);
-  return statements;
+    `CREATE INDEX IF NOT EXISTS ${names.indexes.completionCompleted} ON ${names.completions} (completed_at, id)`
+  ];
 }
 function postgresSchemaMarker(statements) {
-  return `relaybus schema ${createHash("sha256").update(statements.join(";")).digest("hex").slice(0, 32)}`;
+  return `relaybus schema ${createHash("sha256").update(statements.join(";")).digest("hex").slice(0, SCHEMA_MARKER_DIGITS)}`;
 }
 function upgradeFromVersion010(names) {
   return `DO $relaybus_upgrade$
@@ -263,9 +384,17 @@ function createPostgresSchemaSql(options = {}) {
   return `${createPostgresSchemaStatements(options).join(";\n\n")};
 `;
 }
-
-// src/notification-listener.ts
 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;
@@ -275,8 +404,8 @@ var NotificationListener = class {
   #drop;
   #reconnectTimer;
   #closed = false;
-  constructor(connect, channel, listener, logger) {
-    this.#connect = connect;
+  constructor(connect2, channel, listener, logger) {
+    this.#connect = connect2;
     this.#channel = channel;
     this.#listener = listener;
     this.#logger = logger;
@@ -284,15 +413,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;
@@ -300,7 +422,7 @@ var NotificationListener = class {
     this.#drop = end;
     let listening = false;
     const onLost = (error) => {
-      if (!listening || ended) {
+      if (!listening || ended.value) {
         return;
       }
       void end();
@@ -316,14 +438,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();
@@ -331,38 +447,50 @@ 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 = setTimeout(() => {
-      this.#reconnectTimer = void 0;
-      this.start().then(
-        () => {
-          if (!this.#closed) {
-            this.#listener();
-          }
-        },
-        (error) => {
-          this.#logger.warn(
-            `[NotificationListener](scheduleReconnect) Listening again failed, retrying | channel=${this.#channel} | error=${error instanceof Error ? error.message : String(error)}`
-          );
-          if (!this.#closed) {
-            this.#scheduleReconnect();
+    this.#reconnectTimer = schedule(systemClock, {
+      run: () => {
+        this.#reconnectTimer = void 0;
+        this.start().then(
+          () => {
+            if (!this.#closed) {
+              this.#listener();
+            }
+          },
+          (error) => {
+            this.#logger.warn(
+              `[NotificationListener](scheduleReconnect) Listening again failed, retrying | channel=${this.#channel} | error=${error instanceof Error ? error.message : String(error)}`
+            );
+            if (!this.#closed) {
+              this.#scheduleReconnect();
+            }
           }
-        }
-      );
-    }, RECONNECT_DELAY_MS);
-    this.#reconnectTimer.unref();
+        );
+      },
+      delayMs: RECONNECT_DELAY_MS,
+      unref: true
+    });
   }
   /** Stops listening for good and ends the connection. */
   async close() {
     this.#closed = true;
-    clearTimeout(this.#reconnectTimer);
+    this.#reconnectTimer?.();
     const drop = this.#drop;
     this.#drop = void 0;
     await drop?.();
   }
 };
-
-// src/row-mapping.ts
 function text(row, column) {
   return row[column];
 }
@@ -389,25 +517,24 @@ function mapEventEnvelope(row) {
     occurredAt: new Date(text(row, "event_occurred_at"))
   };
 }
-function formatLeaseToken(lane, epoch, claims) {
-  return `${lane}:${epoch}:${claims}`;
+var LEASE_TOKENS = new LaneLeaseTokenFormat({
+  laneCount: LANE_COUNT,
+  epochDigits: 18,
+  claimsDigits: 9
+});
+function formatLeaseToken(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 {
     deliveryId: text(row, "delivery_id"),
-    leaseToken: formatLeaseToken(
-      readCount(row, "lane"),
-      text(row, "epoch"),
-      readCount(row, "claims")
-    ),
+    leaseToken: formatLeaseToken(readCount(row, "lane"), {
+      epoch: text(row, "epoch"),
+      claims: readCount(row, "claims")
+    }),
     handler: text(row, "handler"),
     attempt: readCount(row, "attempt"),
     leaseExpiresAt,
@@ -435,614 +562,1144 @@ function mapOldestDueAt(rows) {
   return nullableDate(rows[0], "oldest_due_at");
 }
 
-// src/statements.ts
-var DEFAULT_LIST_LIMIT = 100;
-function eventColumns(alias) {
-  return `${alias}.id AS event_id,
-    ${alias}.type AS event_type,
-    ${alias}.source AS event_source,
-    ${alias}.key AS event_key,
-    ${alias}.payload::text AS event_payload,
-    ${alias}.headers::text AS event_headers,
-    ${alias}.correlation_id AS event_correlation_id,
-    ${alias}.causation_id AS event_causation_id,
-    ${isoText(`${alias}.occurred_at`)} AS event_occurred_at`;
-}
-function countChanged(dml) {
-  return `WITH changed AS (${dml} RETURNING 1) SELECT count(*)::int AS count FROM changed`;
-}
-var CLAIM_SCAN_WINDOW = 256;
-var LANE_SCAN_WINDOW = 64;
-var LANE_DEPTH_CAP = 16;
-var INITIAL_FREE_LANES = 4;
-var FREE_LANE_SURPLUS = 16;
-var HANDLER_PREDICATE = `delivery.handler = ANY (ARRAY(SELECT jsonb_array_elements_text($2::jsonb)))`;
-var LANE_LIST = `ARRAY(SELECT jsonb_array_elements_text($4::jsonb)::smallint)`;
-var PostgresStatements = class {
-  #names;
-  constructor(names) {
-    this.#names = names;
-  }
-  /**
-   * Lock advisory key text for {@link setupLock}. It is derived from the schema
-   * name only, so stores with different table prefixes in one schema also
-   * serialize their `CREATE SCHEMA IF NOT EXISTS`, which is not race-free.
-   */
-  get setupLockKey() {
-    return `relaybus:${this.#names.schema}`;
+// src/postgres-append.ts
+var NOTIFICATION_INTERVAL_MS = 10;
+var PostgresAppend = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
   }
-  /**
-   * Whether the lane table carries `marker` as its comment, that is whether the schema statements
-   * that produce that marker already ran. Takes no table lock. Parameters: `[marker]`.
-   */
-  get schemaCurrent() {
-    return `SELECT EXISTS (
-  SELECT 1 FROM pg_catalog.pg_class AS c
-  JOIN pg_catalog.pg_namespace AS n ON n.oid = c.relnamespace
-  JOIN pg_catalog.pg_description AS d
-    ON d.objoid = c.oid AND d.classoid = 'pg_catalog.pg_class'::regclass AND d.objsubid = 0
-  WHERE n.nspname = '${this.#names.schema}' AND c.relname = '${this.#names.lanesTableName}' AND d.description = $1::text
-) AS current`;
+  /** Implements {@link PostgresEventStore.append}. */
+  async append(transaction, { entries, now }) {
+    const plan = planAppend(entries);
+    if (plan.events.length === 0) {
+      return { appendedEventIds: [], duplicateEventIds: [], appendedDeliveryCount: 0 };
+    }
+    const createdAt = now.toISOString();
+    const wakeAt = this.#wakeAt(plan.deliveries, { now, transaction });
+    const handlersByEvent = handlersByEventOf(plan.deliveries);
+    const fresh = await this.#insertFreshEvents(transaction, {
+      plan,
+      handlersByEvent,
+      createdAt,
+      wakeAt
+    });
+    const insertedEventIds = new Set(
+      fresh.filter((row) => row["inserted"] === true).map((row) => row["id"])
+    );
+    let appendedDeliveryCount = readCount(fresh[0], "deliveries");
+    const remaining = plan.deliveries.filter(
+      (delivery) => !insertedEventIds.has(delivery.event_id)
+    );
+    if (remaining.length > 0) {
+      appendedDeliveryCount += await this.#appendToExistingEvents(transaction, {
+        plan,
+        fresh,
+        deliveries: remaining,
+        handlersByEvent,
+        insertedEventIds,
+        createdAt,
+        wakeAt
+      });
+    }
+    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
+    });
   }
-  get setupLock() {
-    return "SELECT pg_advisory_xact_lock(hashtextextended($1::text, 0))";
+  /** 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"]));
   }
   /**
-   * Publishes in one statement: reserves the sequences of the keys (`[{ key, count }]` in `$4`, locked in
-   * key order: each row lock is held until the publishing transaction ends, which makes sequence order equal commit order for a key), numbers the keyed events in entry order (`ordinal`), inserts
-   * the events of `$1` that do not exist yet and the deliveries of `$3` that belong to them, and sends one
-   * wake-up notification when a delivery it inserted is due at `$5`. Parameters:
-   * `[eventsJson, createdAt, deliveriesJson, keyCountsJson, now]`. Returns one row per event of `$1`: its
-   * id, its sequence, whether this statement inserted it, and (on every row) how many deliveries it
-   * inserted. Deliveries of events that already existed are left to {@link insertDeliveries}.
+   * 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
+   * commit. In a transaction of this store, only the first append within {@link NOTIFICATION_INTERVAL_MS}
+   * does; the others leave the wake-up to {@link #wakeAfterCommit}, which runs once their transaction
+   * committed, so no committed delivery waits for the poll.
    */
-  get insertFreshEvents() {
-    const events = this.#names.events;
-    return `WITH 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 (
-  SELECT incoming.*,
-    CASE WHEN incoming.key IS NULL THEN NULL ELSE
-      reserved.sequence - count(*) OVER (PARTITION BY incoming.key)
-        + row_number() OVER (PARTITION BY incoming.key ORDER BY incoming.ordinal)
-    END AS sequence
-  FROM jsonb_to_recordset($1::jsonb) AS incoming (
-    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}
-    (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),
-    incoming.correlation_id, incoming.causation_id, incoming.occurred_at, $2::timestamptz,
-    COALESCE(incoming.handlers, '{}')
-  FROM incoming
-  ORDER BY incoming.id
-  ON CONFLICT (id) DO NOTHING
-  RETURNING id, key, sequence
-), 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,
-    delivery.available_at, event.key, event.sequence, $2::timestamptz, $2::timestamptz
-  FROM jsonb_to_recordset($3::jsonb) AS delivery (id text, event_id text, handler text, available_at timestamptz)
-  JOIN inserted_events AS event ON event.id = delivery.event_id
-  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. */
-  get notify() {
-    return `SELECT pg_notify('${this.#names.notificationChannel}', '')`;
+  #wakeAt(deliveries, { now, transaction }) {
+    if (!this.#state.notifies || !deliveries.some((delivery) => Date.parse(delivery.available_at) <= now.getTime())) {
+      return null;
+    }
+    const own = this.#state.ownTransactions.get(transaction);
+    if (own !== void 0 && Date.now() - this.#state.lastNotificationAt < NOTIFICATION_INTERVAL_MS) {
+      own.wake = true;
+      return null;
+    }
+    this.#state.lastNotificationAt = Date.now();
+    return now.toISOString();
   }
   /**
-   * A CTE `woken` that sends one notification on {@link PostgresNames.notificationChannel} when a row of
-   * `inserted` is due at `now`. PostgreSQL delivers it when the transaction commits, merges the same
-   * notification sent twice in one transaction, and drops it on rollback. The statement must reference
-   * `woken` for it to run.
+   * Wakes the dispatchers for a committed transaction whose appends sent no notification: at once when
+   * none was sent within {@link NOTIFICATION_INTERVAL_MS}, otherwise once when the interval ends. A
+   * wake-up already scheduled covers this transaction too, since it is sent after this commit. Nothing is
+   * sent once the store is closed or the `pg` pool behind it is ending: no dispatcher can be woken through
+   * it then, and the deliveries are found by polling.
    */
-  #wakeUp(inserted, now) {
-    return `woken AS (
-  SELECT pg_notify('${this.#names.notificationChannel}', '') FROM (
-    SELECT 1 FROM ${inserted} WHERE ${inserted}.available_at <= ${now}::timestamptz LIMIT 1
-  ) AS due
-)`;
+  wakeAfterCommit() {
+    if (this.#state.trailingNotification !== void 0 || this.#state.closed) {
+      return;
+    }
+    this.#state.trailingNotification = schedule(systemClock, {
+      run: () => {
+        this.#state.trailingNotification = void 0;
+        if (this.#state.pool?.ending === true) {
+          return;
+        }
+        this.#state.lastNotificationAt = Date.now();
+        this.#state.query({ sql: this.#state.statements.append.notify, parameters: [] }).catch((error) => {
+          this.#state.logger.error(
+            `[PostgresAppend](wakeAfterCommit) Waking the dispatchers failed, they find the deliveries when they poll | error=${error instanceof Error ? error.message : String(error)}`
+          );
+        });
+      },
+      delayMs: Math.max(0, this.#state.lastNotificationAt + NOTIFICATION_INTERVAL_MS - Date.now())
+    });
   }
   /**
-   * Parameters: `[eventsJson, createdAt]`. Returns the ids that were inserted.
-   * `handlers` is the list of handlers the event gets deliveries for: it
-   * outlives the deliveries, which are deleted when they complete.
-   */
-  get insertEvents() {
-    return `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),
-  incoming.correlation_id, incoming.causation_id, incoming.occurred_at, $2::timestamptz,
-  COALESCE(incoming.handlers, '{}')
-FROM jsonb_to_recordset($1::jsonb) AS incoming (
-  id text, type text, source text, key text, sequence bigint, payload jsonb, headers jsonb,
-  correlation_id text, causation_id text, occurred_at timestamptz, handlers text[])
-ORDER BY incoming.id
-ON CONFLICT (id) DO NOTHING
-RETURNING id`;
-  }
-  /**
-   * Locks events that were not inserted by the current append, in id order, so
-   * that appends adding handlers to the same event run one after the other.
-   * Parameters: `[eventIdsJson]`. `FOR NO KEY UPDATE` conflicts with itself and
-   * not with the foreign key checks of other inserts.
+   * Adds the deliveries of events the publishing statement found already stored. An event that already
+   * exists may be getting the same new handler from another transaction at this very moment. Whoever
+   * holds the event decides, so the freshness check of the insert sees what the other transaction
+   * committed, even if its delivery has completed since. An existing event that a purge removed
+   * meanwhile is inserted again (with the sequence reserved for it) instead of being skipped; its id is
+   * added to `insertedEventIds`. Returns how many deliveries were inserted.
    */
-  get lockExistingEvents() {
-    return `SELECT id FROM ${this.#names.events}
-WHERE id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb)))
-ORDER BY id
-FOR NO KEY UPDATE`;
+  async #appendToExistingEvents(transaction, input) {
+    const { plan, fresh, deliveries, handlersByEvent, insertedEventIds, createdAt, wakeAt } = input;
+    const sequences = new Map(
+      fresh.map((row) => [row["id"], row["sequence"]])
+    );
+    const reinserted = [];
+    let existing = plan.events.filter((event) => !insertedEventIds.has(event.id)).map(
+      (event) => toEventRow(event, {
+        sequence: sequences.get(event.id),
+        handlers: handlersByEvent.get(event.id) ?? []
+      })
+    );
+    while (existing.length > 0) {
+      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({
+          sql: this.#state.statements.append.insertEvents,
+          parameters: [JSON.stringify(gone), createdAt],
+          transaction
+        });
+        for (const row of inserted2) {
+          insertedEventIds.add(row["id"]);
+          reinserted.push(row["id"]);
+        }
+      }
+      existing = gone.filter((row) => !insertedEventIds.has(row.id));
+    }
+    const inserted = await this.#state.query({
+      sql: this.#state.statements.append.insertDeliveries,
+      parameters: [JSON.stringify(deliveries), createdAt, JSON.stringify(reinserted), wakeAt],
+      transaction
+    });
+    return inserted.length;
+  }
+};
+function planAppend(entries) {
+  const events = [];
+  const deliveries = [];
+  const outcomes = [];
+  const seenEventIds = /* @__PURE__ */ new Set();
+  const seenDeliveries = /* @__PURE__ */ new Set();
+  for (const { event, deliveries: newDeliveries } of entries) {
+    const repeated = seenEventIds.has(event.id);
+    seenEventIds.add(event.id);
+    outcomes.push({ eventId: event.id, repeated });
+    if (!repeated) {
+      events.push(event);
+    }
+    for (const delivery of newDeliveries) {
+      const identity = CompositeKey.of(event.id, delivery.handler);
+      if (!seenDeliveries.has(identity)) {
+        seenDeliveries.add(identity);
+        deliveries.push({
+          id: delivery.id,
+          event_id: event.id,
+          handler: delivery.handler,
+          available_at: delivery.availableAt.toISOString()
+        });
+      }
+    }
+  }
+  return { events, deliveries, outcomes };
+}
+function toEventRow(event, {
+  sequence,
+  handlers
+}) {
+  return {
+    id: event.id,
+    type: event.type,
+    source: event.source,
+    key: event.key,
+    sequence,
+    payload: event.payload,
+    headers: event.headers,
+    correlation_id: event.correlationId,
+    causation_id: event.causationId,
+    occurred_at: event.occurredAt.toISOString(),
+    handlers
+  };
+}
+function handlersByEventOf(deliveries) {
+  const handlersByEvent = /* @__PURE__ */ new Map();
+  for (const delivery of deliveries) {
+    handlersByEvent.set(delivery.event_id, [
+      ...handlersByEvent.get(delivery.event_id) ?? [],
+      delivery.handler
+    ]);
+  }
+  return handlersByEvent;
+}
+function keyCountsOf(events) {
+  const keyCounts = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.key !== null) {
+      keyCounts.set(event.key, (keyCounts.get(event.key) ?? 0) + 1);
+    }
+  }
+  return keyCounts;
+}
+function splitOutcomes(plan, insertedEventIds) {
+  const appendedEventIds = [];
+  const duplicateEventIds = [];
+  for (const { eventId, repeated } of plan.outcomes) {
+    (!repeated && insertedEventIds.has(eventId) ? appendedEventIds : duplicateEventIds).push(
+      eventId
+    );
+  }
+  return { appendedEventIds, duplicateEventIds };
+}
+var ReconcileFailedError = class extends RelayBusError {
+  name = "ReconcileFailedError";
+  code = "RELAYBUS_POSTGRES_RECONCILE_FAILED";
+};
+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 = 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 extends OwnerSerializedClaims {
+  #state;
+  constructor(state) {
+    super();
+    this.#state = state;
+  }
+  async claimInTurn(request) {
+    await this.#assertReconciled(request.leaseOwner);
+    const heldFirst = this.#state.drainingOwners.has(request.leaseOwner);
+    let rows = await this.#claimFirst(request, heldFirst);
+    const heldLanes = new Set(JSON.parse(rows[0]["examined_lanes"]));
+    const claimed = this.#takeClaimed(rows, request.leaseOwner);
+    if (heldFirst && claimed.length < request.limit && rows[0]["stale"] !== true) {
+      const freeRows = await this.#claimFreeLanesAfterHeld(request, claimed);
+      if (freeRows === void 0) {
+        return this.#handOutInDueOrder(claimed, { request, heldLanes });
+      }
+      rows = freeRows;
+    }
+    if (claimed.length < request.limit && leftWorkBehind(rows[0])) {
+      await this.#claimMoreLanes(request, claimed);
+    }
+    return this.#handOutInDueOrder(claimed, { request, heldLanes });
+  }
+  /** Reconciles first when an earlier reconciliation of `owner` failed; refuses to claim while it still fails. */
+  async #assertReconciled(owner) {
+    if (this.#state.unreconciled.has(owner) && !await this.#reconcile(owner)) {
+      throw new ReconcileFailedError(
+        `[PostgresEventStore](claim) Giving back unreturned deliveries still fails, so no claim is made | owner=${owner}`
+      );
+    }
+  }
+  /** The first claim statement: from the held lanes only when `heldFirst`, else from held and free lanes. */
+  async #claimFirst(request, heldFirst) {
+    try {
+      return await this.#claimInOneStatement(
+        request,
+        heldFirst ? this.#state.statements.lanes.claimHeldLanes : this.#state.statements.lanes.claimLanes
+      );
+    } catch (error) {
+      await this.#reconcile(request.leaseOwner);
+      throw error;
+    }
   }
   /**
-   * Parameters: `[deliveriesJson, createdAt, insertedEventIdsJson, now]`. Key and
-   * sequence are copied from the stored event, so a delivery added later to an
-   * existing event keeps the event's position in its key and lands in the same
-   * lane. Returns the ids that were inserted.
-   *
-   * The deliveries of events this call just inserted are all new. For an event
-   * that already existed, a handler gets a delivery only if the event does not
-   * list it yet: a completed delivery is deleted, but its handler stays listed,
-   * so a redelivered or republished event never runs a handler twice. The
-   * handlers added to an existing event are appended to its list.
+   * After a held-lanes claim came up short: claims the rest from held and free lanes and adds it to
+   * `claimed`. Returns the statement's rows, or undefined when it failed after something was claimed
+   * already, which is then handed out as it is.
    */
-  get insertDeliveries() {
-    const events = this.#names.events;
-    const insertedEvents = `ARRAY(SELECT jsonb_array_elements_text($3::jsonb))`;
-    return `WITH incoming AS (
-  SELECT incoming.id, incoming.event_id, incoming.handler, incoming.available_at
-  FROM jsonb_to_recordset($1::jsonb) AS incoming (id text, event_id text, handler text, available_at timestamptz)
-), fresh AS (
-  SELECT incoming.*, event.key, event.sequence, ${laneExpression("event.key", "event.id")} AS lane
-  FROM incoming
-  JOIN ${events} AS event ON event.id = incoming.event_id
-  WHERE event.id = ANY (${insertedEvents}) OR NOT incoming.handler = ANY (event.handlers)
-), inserted AS (
-  INSERT INTO ${this.#names.deliveries}
-    (id, event_id, handler, lane, status, attempts, available_at, key, sequence, created_at, updated_at)
-  SELECT fresh.id, fresh.event_id, fresh.handler, fresh.lane, 'pending', 0, fresh.available_at,
-    fresh.key, fresh.sequence, $2::timestamptz, $2::timestamptz
-  FROM fresh
-  ORDER BY fresh.event_id, fresh.handler
-  ON CONFLICT (event_id, handler) DO NOTHING
-  RETURNING id, event_id, handler, available_at
-), extended AS (
-  UPDATE ${events} AS event SET handlers = event.handlers || added.handlers
-  FROM (
-    SELECT inserted.event_id, array_agg(inserted.handler) AS handlers FROM inserted
-    WHERE inserted.event_id <> ALL (${insertedEvents}) GROUP BY inserted.event_id
-  ) AS added
-  WHERE event.id = added.event_id
-  RETURNING event.id
-), ${this.#wakeUp("inserted", "$4")}
-SELECT id FROM inserted WHERE (SELECT count(*) FROM woken) >= 0`;
+  async #claimFreeLanesAfterHeld(request, claimed) {
+    let rows;
+    try {
+      rows = await this.#claimInOneStatement(
+        { ...request, limit: request.limit - claimed.length },
+        this.#state.statements.lanes.claimLanes
+      );
+    } catch (error) {
+      await this.#reconcile(request.leaseOwner);
+      if (claimed.length === 0) {
+        this.#state.drainingOwners.delete(request.leaseOwner);
+        throw error;
+      }
+      this.#state.logger.error(
+        `[PostgresClaims](claimFreeLanesAfterHeld) Claiming from free lanes failed, returning the deliveries already claimed | claimed=${claimed.length} | error=${error instanceof Error ? error.message : String(error)}`
+      );
+      return void 0;
+    }
+    claimed.push(...this.#takeClaimed(rows, request.leaseOwner));
+    return rows;
+  }
+  /** Takes more lanes round by round and adds what they give to `claimed`; keeps what was claimed when that fails. */
+  async #claimMoreLanes(request, claimed) {
+    try {
+      const more = await this.#claimMore(request, claimed.length);
+      this.#handOut(more, request.leaseOwner);
+      claimed.push(...more);
+    } catch (error) {
+      await this.#reconcile(request.leaseOwner);
+      if (claimed.length === 0) {
+        throw error;
+      }
+      this.#state.logger.error(
+        `[PostgresClaims](claimMoreLanes) Taking more lanes failed, returning the deliveries already claimed | claimed=${claimed.length} | error=${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /** The deliveries a claim statement picked, registered as handed out to `leaseOwner`. */
+  #takeClaimed(rows, leaseOwner) {
+    const claimed = rows.filter((row) => row["delivery_id"] !== null);
+    this.#forgetFinished(rows[0], { leaseOwner, claimed });
+    this.#handOut(claimed, leaseOwner);
+    return claimed;
+  }
+  #handOutInDueOrder(claimed, {
+    request,
+    heldLanes
+  }) {
+    if (claimed.length >= request.limit && claimed.every((row) => heldLanes.has(readCount(row, "lane")))) {
+      this.#state.drainingOwners.add(request.leaseOwner);
+    } else {
+      this.#state.drainingOwners.delete(request.leaseOwner);
+    }
+    claimed.sort(compareDue);
+    return claimed.map((row) => mapClaimedDelivery(row, request.leaseExpiresAt));
   }
   /**
-   * A claim in one statement, the only one in the common case. Parameters:
-   * `[now, handlersJson, limit, leaseOwner, leaseExpiresAt, generation]`.
-   *
-   * 1. **Held lanes.** The lanes this owner holds under a live lease whose `claim_floor` is exactly the
-   *    generation are locked `FOR NO KEY UPDATE` in lane order. A lane above it was raised by a
-   *    reconciliation, so a statement of a claim whose caller gave up (a client timeout does not cancel
-   *    the statement on the server) and that reaches the server late records nothing; a lane below it was
-   *    taken by such a late statement after the reconciliation, and its listed deliveries were never
-   *    handed out. A lane that another transaction of this owner is changing makes the statement wait;
-   *    the statement then reports `stale` and does nothing (see the `stale` CTE).
-   * 2. **Free lanes**, only when the held lanes yield fewer than `limit`: the free lanes with a due
-   *    delivery (one index probe per free lane) are ranked by their oldest due delivery; the first
-   *    {@link INITIAL_FREE_LANES} that can give something now, and further ones until what they can give
-   *    (estimated from their first {@link LANE_DEPTH_CAP} due deliveries) covers what is still wanted, are locked
-   *    `FOR UPDATE SKIP LOCKED`, so a lane another claimer has is skipped, never waited
-   *    for. A lane that still runs deliveries of an expired lease is left to the transaction of
-   *    {@link takeFreeLanes}, which charges their lost attempts (`takeover_waiting`); so is any lane whose
-   *    locked row differs from what the statement's snapshot saw. A lane that runs nothing and did not
-   *    change cannot have had a delivery written since the snapshot, so its deliveries can be read here.
-   * 3. **Picks** follow the rules of {@link claim}: the fast window of each lane, and for lanes whose
-   *    window filled up while the batch is not full, the heads of all keys (a loose index scan per lane).
-   * 4. **Writes**: one update per lane. A held lane records its picks; a taken lane gets a new epoch, the
-   *    owner, the lease and its picks; a taken lane that yielded nothing is not written. Held lanes that
-   *    picked nothing, run nothing and have no full scan window are freed.
-   *
-   * Always returns one row per picked delivery, or one row whose `delivery_id` is null. `running_ids`
-   * (JSON text) lists the deliveries the held lanes still run, `examined_lanes` the held lanes.
+   * Runs `statement` (`LaneStatements.claimLanes` or its held-lane form), again when it reports that it waited for a lane lock and
+   * read deliveries with an older snapshot than the lane it got. A held lane is only locked by an
+   * operation of its own owner (another claim, a reschedule), so a few attempts are enough.
    */
-  get claimLanes() {
-    return this.#claimLanes(true);
+  async #claimInOneStatement(request, statement) {
+    const parameters = [
+      request.now.toISOString(),
+      JSON.stringify(request.handlers),
+      request.limit,
+      request.leaseOwner,
+      request.leaseExpiresAt.toISOString(),
+      this.#generation(request.leaseOwner).toString()
+    ];
+    let rows = await this.#state.query({ sql: statement, parameters });
+    for (let attempt = 1; attempt < MAXIMUM_STALE_CLAIM_ATTEMPTS && rows[0]["stale"] === true; attempt += 1) {
+      rows = await this.#state.query({ sql: statement, parameters });
+    }
+    return rows;
   }
   /**
-   * {@link claimLanes} limited to the lanes the owner holds: the same parameters, rows and writes, without
-   * looking at free lanes (`takeover_waiting` and `unexamined_free_lanes` are false). A worker draining a
-   * backlog finds its batch in the lanes it holds; this statement is about half as costly to plan, and
-   * the caller runs {@link claimLanes} after it only when it came up short.
-   */
-  get claimHeldLanes() {
-    return this.#claimLanes(false);
+   * Second step of {@link PostgresEventStore.claim}, in one transaction: takes free lanes a few at a
+   * time, lanes to take over included (their lost attempts are charged first), and records the batch.
+   * `alreadyClaimed` deliveries of the first step are in flight, so they are not picked again.
+   */
+  async #claimMore(request, alreadyClaimed) {
+    const now = request.now.toISOString();
+    const leaseExpiresAt = request.leaseExpiresAt.toISOString();
+    const handlers = JSON.stringify(request.handlers);
+    const generation = this.#generation(request.leaseOwner).toString();
+    return this.#state.executor.transaction(async (transaction) => {
+      const claimed = [];
+      const remaining = () => request.limit - alreadyClaimed - claimed.length;
+      const takenLanes = /* @__PURE__ */ new Set();
+      for (let laneCount = INITIAL_LANES_PER_ROUND; remaining() > 0; ) {
+        const taken = await this.#state.query({
+          sql: this.#state.statements.lanes.takeFreeLanes,
+          parameters: [now, handlers, laneCount, request.leaseOwner, leaseExpiresAt, generation],
+          transaction
+        });
+        if (taken.length === 0) {
+          break;
+        }
+        const lanes = taken.map((row) => readCount(row, "lane"));
+        for (const lane of lanes) {
+          takenLanes.add(lane);
+        }
+        claimed.push(
+          ...await this.#pickDeliveries(
+            [now, handlers, remaining(), JSON.stringify(lanes)],
+            transaction
+          )
+        );
+        laneCount *= 2;
+      }
+      await this.#recordClaim(claimed, { lanes: takenLanes, request, transaction });
+      return claimed;
+    });
   }
-  #claimLanes(includeFreeLanes) {
-    const deliveries = this.#names.deliveries;
-    const lanes = this.#names.lanes;
-    const 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))`;
-    const free = includeFreeLanes ? `), free_lanes AS MATERIALIZED (
-  -- The oldest due delivery of each free lane: one index probe per free lane, bounded by the due time,
-  -- so deliveries scheduled for later are never read.
-  SELECT lane.lane, lane.epoch, lane.in_flight, lane.lease_owner, lane.lease_expires_at,
-    oldest.available_at, oldest.id, NOT ${this.#noRunningDelivery("lane")} AS running
-  FROM ${lanes} AS lane
-  CROSS JOIN LATERAL (
-    SELECT delivery.available_at, delivery.id
-    FROM ${deliveries} AS delivery
-    WHERE delivery.lane = lane.lane AND delivery.status = 'pending'
-      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
-    ORDER BY delivery.available_at, delivery.id
-    LIMIT 1
-  ) AS oldest
-  WHERE (SELECT count FROM wanted) > 0 AND ${freeLane("lane")}
-  ORDER BY oldest.available_at, oldest.id
-  LIMIT (SELECT count FROM wanted) + ${FREE_LANE_SURPLUS}
-), free_depth AS MATERIALIZED (
-  -- What each candidate lane can give now, from its first due deliveries: unkeyed ones, and of a key its
-  -- lowest one when nothing earlier of the key is pending. Lanes that can give nothing are passed over;
-  -- of the others, the first ${INITIAL_FREE_LANES} are taken, and further ones until they cover what is
-  -- still wanted, so the earliest due work of the free lanes comes first.
-  SELECT runnable.lane,
-    row_number() OVER (ORDER BY runnable.available_at, runnable.id) AS rank,
-    sum(runnable.count) OVER (ORDER BY runnable.available_at, runnable.id ROWS UNBOUNDED PRECEDING) - runnable.count AS due_before
-  FROM (
-    SELECT lane_candidate.lane, lane_candidate.available_at, lane_candidate.id, depth.count
-    FROM free_lanes AS lane_candidate
-    CROSS JOIN LATERAL (
-      -- A full window that shows nothing runnable may hide runnable work behind it: such a lane counts
-      -- once, and the claim looks behind its blocked deliveries.
-      SELECT GREATEST(count(*) FILTER (
-          WHERE due.key IS NULL OR (due.position = 1 AND NOT EXISTS (
-            SELECT 1 FROM ${deliveries} AS earlier
-            WHERE earlier.lane = due.lane AND earlier.handler = due.handler AND earlier.key = due.key
-              AND earlier.status = 'pending' AND earlier.key IS NOT NULL AND earlier.sequence < due.sequence
-          ))
-        ), CASE WHEN count(*) >= ${LANE_DEPTH_CAP} THEN 1 ELSE 0 END) AS count
-      FROM (
-        SELECT window_rows.*,
-          row_number() OVER (PARTITION BY window_rows.handler, window_rows.key ORDER BY window_rows.sequence) AS position
-        FROM (
-          SELECT delivery.lane, delivery.handler, delivery.key, delivery.sequence FROM ${deliveries} AS delivery
-          WHERE delivery.lane = lane_candidate.lane AND delivery.status = 'pending'
-            AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
-          ORDER BY delivery.available_at, delivery.id
-          LIMIT ${LANE_DEPTH_CAP}
-        ) AS window_rows
-      ) AS due
-    ) AS depth
-    WHERE NOT lane_candidate.running AND depth.count > 0
-  ) AS runnable
-), free_locked AS MATERIALIZED (
-  SELECT lane.lane, lane.epoch, lane.in_flight, lane.lease_owner, lane.lease_expires_at
-  FROM ${lanes} AS lane
-  WHERE lane.lane IN (
-      SELECT chosen.lane FROM free_depth AS chosen
-      WHERE chosen.rank <= ${INITIAL_FREE_LANES} OR chosen.due_before < (SELECT count FROM wanted)
-    )
-    AND ${freeLane("lane")}
-  ORDER BY lane.lane
-  FOR UPDATE SKIP LOCKED
-), free_scope AS MATERIALIZED (
-  -- A lane whose locked row is not the one the snapshot saw changed hands meanwhile: left for a later claim.
-  SELECT locked.lane, locked.epoch + 1 AS epoch, '{}'::text[] AS in_flight
-  FROM free_locked AS locked
-  JOIN free_lanes AS seen ON seen.lane = locked.lane
-  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", "free_scope", null, "(SELECT count FROM wanted)")}` : `), free_lanes AS (
-  SELECT NULL::smallint AS lane, NULL::bigint AS epoch, NULL::text[] AS in_flight, false AS running WHERE false
-), free_scope AS (
-  SELECT NULL::smallint AS lane, NULL::bigint AS epoch WHERE false
-), free_candidates AS (
-  SELECT NULL::text AS id, NULL::smallint AS lane, NULL::timestamptz AS available_at WHERE false
+  /**
+   * The generation of the owner's claim statements. It only grows, also across restarts (it starts at the
+   * clock), and a reconciliation moves it up, which fences off every earlier statement still in flight.
+   */
+  #generation(owner, advance = false) {
+    const current = this.#state.generations.get(owner) ?? BigInt(Date.now());
+    const next = advance ? current + GENERATION_STEP > BigInt(Date.now()) ? current + GENERATION_STEP : BigInt(Date.now()) : current;
+    this.#state.generations.set(owner, next);
+    return next;
+  }
+  /** Remembers the claims handed to the caller of `claim` until they are settled. */
+  #handOut(rows, leaseOwner) {
+    for (const row of rows) {
+      const claim = mapClaimedDelivery(row, /* @__PURE__ */ new Date(0));
+      this.#state.handedOut.register(claim, {
+        owner: leaseOwner,
+        deliveryId: claim.deliveryId,
+        ...parseLeaseToken(claim.leaseToken)
+      });
+    }
+  }
+  /**
+   * Drops the registrations of the owner's held lanes whose delivery no longer runs there
+   * (completed inside the caller's transaction, deleted, or listed no more). Registrations of
+   * lanes this claim did not see stay: their tokens may still be valid.
+   */
+  #forgetFinished(row, {
+    leaseOwner,
+    claimed
+  }) {
+    const heldLanes = new Set(JSON.parse(row["examined_lanes"]));
+    const running = /* @__PURE__ */ new Set([
+      ...JSON.parse(row["running_ids"]),
+      ...claimed.map((picked) => picked["delivery_id"])
+    ]);
+    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
+   * deliveries that were never handed out, keeping exactly the claims handed out and not settled.
+   * A failure is remembered and retried before the owner's next claim: other deliveries keep
+   * renewing the lane, so an unreturned one would otherwise never be recovered.
+   */
+  async #reconcile(leaseOwner) {
+    const generation = this.#generation(leaseOwner, true);
+    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,
+        parameters: [leaseOwner, JSON.stringify(handedOut), generation.toString()]
+      });
+      this.#state.unreconciled.delete(leaseOwner);
+      return true;
+    } catch (error) {
+      this.#state.unreconciled.add(leaseOwner);
+      this.#state.logger.error(
+        `[PostgresClaims](reconcile) Giving back unreturned deliveries failed, it is retried before the next claim | owner=${leaseOwner} | error=${error instanceof Error ? error.message : String(error)}`
+      );
+      return false;
+    }
+  }
+  /** Fast claim, then the slow one when the fast window was full of blocked followers. */
+  async #pickDeliveries(parameters, transaction) {
+    const limit = parameters[2];
+    const fastRows = await this.#state.query({
+      sql: this.#state.statements.claim.claim,
+      parameters,
+      transaction
+    });
+    const picked = fastRows.filter((row) => row["delivery_id"] !== null);
+    if (picked.length < limit && fastRows[0]["window_saturated"] === true) {
+      const slowRows = await this.#state.query({
+        sql: this.#state.statements.claim.claimBehindBlockedKeys,
+        parameters,
+        transaction
+      });
+      const pickedIds = new Set(picked.map((row) => row["delivery_id"]));
+      picked.push(
+        ...slowRows.filter(
+          (row) => row["delivery_id"] !== null && !pickedIds.has(row["delivery_id"])
+        )
+      );
+      return keepKeyHeads(picked, limit);
+    }
+    return picked;
+  }
+  /** Writes the picked ids into their lane rows and frees the lanes that picked nothing. */
+  async #recordClaim(claimed, {
+    lanes,
+    request,
+    transaction
+  }) {
+    const idsByLane = /* @__PURE__ */ new Map();
+    for (const row of claimed) {
+      const lane = readCount(row, "lane");
+      idsByLane.set(lane, [...idsByLane.get(lane) ?? [], row["delivery_id"]]);
+    }
+    const idleLanes = [...lanes].filter((lane) => !idsByLane.has(lane));
+    if (idsByLane.size === 0 && idleLanes.length === 0) {
+      return;
+    }
+    await this.#state.query({
+      sql: this.#state.statements.claim.recordClaim,
+      parameters: [
+        JSON.stringify([...idsByLane].map(([lane, ids]) => ({ lane, ids }))),
+        JSON.stringify(idleLanes),
+        request.leaseOwner,
+        request.leaseExpiresAt.toISOString()
+      ],
+      transaction
+    });
+  }
+};
+var GENERATION_STEP = 1n;
+var PostgresCompletion = class extends LeaseSettlement {
+  #state;
+  constructor(state) {
+    super();
+    this.#state = state;
+  }
+  /** Implements {@link PostgresEventStore.complete}. */
+  async complete(lease, { now, transaction }) {
+    return (await this.#completeLeases([lease], { now, transaction }))[0];
+  }
+  /** Implements {@link PostgresEventStore.completeMany}. */
+  completeMany(leases, now) {
+    return this.#completeLeases(leases, { now, transaction: void 0 });
+  }
+  /** A lease this store issued; any other token cannot be held. */
+  findHeld(lease) {
+    return parseLeaseToken(lease.leaseToken);
+  }
+  writeExtension(held, { lease, leaseExpiresAt }) {
+    return this.#changed(this.#state.statements.completion.extendLease, [
+      ...fenceOf(lease, held),
+      leaseExpiresAt.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). */
+  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;
+  }
+  /**
+   * 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
+   * by position, so two leases of one delivery (a stale and a current one) get
+   * their own answers; a lease listed twice completes once, at its first position.
+   */
+  async #completeLeases(leases, { now, transaction }) {
+    const issued = issuedLeases(leases);
+    const completed = /* @__PURE__ */ new Set();
+    if (issued.length > 0) {
+      const rows = await this.#state.query({
+        sql: this.#state.statements.completion.complete,
+        parameters: [JSON.stringify(issued), now.toISOString()],
+        transaction
+      });
+      for (const row of rows) {
+        completed.add(readCount(row, "ord"));
+      }
+    }
+    if (transaction === void 0) {
+      for (const lease of leases) {
+        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 = 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();
+  /**
+   * The `Client` class for a pool the store creates: every connection is tracked from the moment it
+   * is created, so one still connecting or authenticating is destroyed too.
+   */
+  clientClass() {
+    const owned = this;
+    return class OwnedClient extends Client {
+      constructor(config) {
+        super(config);
+        owned.track(this);
+      }
+    };
+  }
+  /** Tracks one connection until it ends. */
+  track(client) {
+    this.#clients.add(client);
+    client.once("end", () => this.#clients.delete(client));
+  }
+  /**
+   * Destroys the socket of every tracked connection. Its queries fail with "Connection terminated"
+   * and the pool drops it. The server ends the session when it next talks to the client.
+   */
+  destroyAll() {
+    for (const client of this.#clients) {
+      client.on("error", () => void 0);
+      client.connection.stream.destroy();
+    }
+    this.#clients.clear();
+  }
+};
+
+// src/postgres-maintenance.ts
+var PostgresMaintenance = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  /** Implements {@link PostgresEventStore.relinquish}. */
+  async relinquish(leaseOwner) {
+    await this.#state.query({
+      sql: this.#state.statements.claim.relinquish,
+      parameters: [leaseOwner]
+    });
+  }
+  /** Implements {@link PostgresEventStore.listDeliveries}. */
+  async listDeliveries(query) {
+    const statement = this.#state.statements.queries.listDeliveries(query);
+    const rows = await this.#state.executor.query(statement.sql, statement.parameters);
+    return rows.map(mapDeliveryRecord);
+  }
+  /** Implements {@link PostgresEventStore.requeue}. */
+  async requeue(deliveryIds, now) {
+    const rows = await this.#state.query({
+      sql: this.#state.statements.queries.requeue,
+      parameters: [JSON.stringify(deliveryIds), now.toISOString()]
+    });
+    return readCount(rows[0], "count");
+  }
+  /** Implements {@link PostgresEventStore.statistics}. */
+  async statistics(now) {
+    const stored = { pending: 0, dead: 0, completed: 0 };
+    for (const row of await this.#state.query({
+      sql: this.#state.statements.queries.countByStatus,
+      parameters: []
+    })) {
+      stored[row["status"]] = readCount(row, "count");
+    }
+    const [running] = await this.#state.query({
+      sql: this.#state.statements.queries.countRunning,
+      parameters: []
+    });
+    const processing = readCount(running, "count");
+    let completed = stored["completed"];
+    if (this.#state.completionHistory) {
+      const [history] = await this.#state.query({
+        sql: this.#state.statements.queries.countCompletionHistory,
+        parameters: []
+      });
+      completed += readCount(history, "count");
+    }
+    const oldestDue = await this.#state.query({
+      sql: this.#state.statements.queries.oldestDue,
+      parameters: [now.toISOString()]
+    });
+    return {
+      // The counts come from separate statements; a delivery that finishes in between must not make this negative.
+      pending: Math.max(0, stored["pending"] - processing),
+      processing,
+      completed,
+      dead: stored["dead"],
+      oldestDueAt: mapOldestDueAt(oldestDue)
+    };
+  }
+  /** 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(),
+        request.completedBefore,
+        this.#state.statements.purge.deleteOrphanEventsWithoutCompletion
+      ],
+      [
+        this.#state.statements.purge.purgeDeadBatch(),
+        request.deadBefore,
+        this.#state.statements.purge.deleteOrphanEventsWithoutCompletion
+      ]
+    ];
+    if (this.#state.completionHistory) {
+      batches.push([
+        this.#state.statements.purge.purgeCompletionHistoryBatch(),
+        request.completedBefore,
+        this.#state.statements.purge.deleteOrphanEventsWithoutCompletion
+      ]);
+    }
+    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) {
+      deletedEvents += await this.#purgeOrphanEvents(
+        this.#state.statements.purge.lockOrphanEventsBatch,
+        {
+          deleteStatement: this.#state.statements.purge.deleteOrphanEventsWithoutCompletion,
+          cutoff: orphanCutoff,
+          recheckCutoff: false
+        }
+      );
+    }
+    if (request.completedBefore !== void 0) {
+      deletedEvents += await this.#purgeOrphanEvents(
+        this.#state.statements.purge.lockCompletedOrphanEventsBatch,
+        {
+          deleteStatement: this.#state.statements.purge.deleteExpiredCompletedOrphanEvents,
+          cutoff: request.completedBefore,
+          recheckCutoff: true
+        }
+      );
+    }
+    return deletedEvents;
+  }
+  async #purgeOrphanEvents(lockStatement, {
+    deleteStatement,
+    cutoff,
+    recheckCutoff
+  }) {
+    let deletedEvents = 0;
+    let removedInBatch = this.#state.purgeBatchSize;
+    while (removedInBatch === this.#state.purgeBatchSize) {
+      removedInBatch = await this.#state.executor.transaction(async (transaction) => {
+        const locked = await this.#state.query({
+          sql: lockStatement,
+          parameters: [cutoff.toISOString(), this.#state.purgeBatchSize],
+          transaction
+        });
+        const ids = JSON.stringify(locked.map((row) => row["id"]));
+        const removed = await this.#state.query({
+          sql: deleteStatement,
+          parameters: recheckCutoff ? [ids, cutoff.toISOString()] : [ids],
+          transaction
+        });
+        return readCount(removed[0], "count");
+      });
+      deletedEvents += removedInBatch;
+    }
+    return deletedEvents;
+  }
+  async #purgeBatch(sql, { cutoff, deleteOrphans }) {
+    return this.#state.executor.transaction(async (transaction) => {
+      const deleted = await this.#state.query({
+        sql,
+        parameters: [cutoff.toISOString(), this.#state.purgeBatchSize],
+        transaction
+      });
+      if (deleted.length === 0) {
+        return { deletedDeliveries: 0, deletedEvents: 0 };
+      }
+      const eventIds = JSON.stringify([
+        ...new Set(deleted.map((row) => row["event_id"]))
+      ]);
+      const locked = await this.#state.query({
+        sql: this.#state.statements.purge.lockEvents,
+        parameters: [eventIds],
+        transaction
+      });
+      const removed = await this.#state.query({
+        sql: deleteOrphans,
+        parameters: [JSON.stringify(locked.map((row) => row["id"]))],
+        transaction
+      });
+      return { deletedDeliveries: deleted.length, deletedEvents: readCount(removed[0], "count") };
+    });
+  }
+};
+var WAKE_UPS = ["notify", "poll"];
+var DEFAULT_PURGE_BATCH_SIZE = 1e3;
+function resolveStoreSettings(options) {
+  const sources = [options.pool, options.connectionString, options.executor].filter(
+    (source) => source !== void 0
+  );
+  if (sources.length !== 1) {
+    throw new ConfigurationError(
+      "PostgresEventStore needs exactly one of pool, connectionString or executor"
+    );
+  }
+  const purgeBatchSize = PositiveInteger.of(
+    options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE,
+    "purgeBatchSize"
+  );
+  const wakeUp = options.wakeUp ?? "notify";
+  if (!WAKE_UPS.includes(wakeUp)) {
+    throw new ConfigurationError(`wakeUp must be 'notify' or 'poll', received ${String(wakeUp)}`);
+  }
+  const preparedStatements = options.preparedStatements ?? true;
+  if (typeof preparedStatements !== "boolean") {
+    throw new 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 {
+  #names;
+  constructor(names) {
+    this.#names = names;
+  }
+  /**
+   * Publishes in one statement: reserves the sequences of the keys (`[{ key, count }]` in `$4`, locked in
+   * key order: each row lock is held until the publishing transaction ends, which makes sequence order equal commit order for a key), numbers the keyed events in entry order (`ordinal`), inserts
+   * the events of `$1` that do not exist yet and the deliveries of `$3` that belong to them, and sends one
+   * wake-up notification when a delivery it inserted is due at `$5`. Parameters:
+   * `[eventsJson, createdAt, deliveriesJson, keyCountsJson, now]`. Returns one row per event of `$1`: its
+   * id, its sequence, whether this statement inserted it, and (on every row) how many deliveries it
+   * inserted. Deliveries of events that already existed are left to {@link insertDeliveries}.
+   */
+  get insertFreshEvents() {
+    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
 )`;
-    return `WITH held AS MATERIALIZED (
-  SELECT lane.lane, lane.epoch, lane.in_flight
-  FROM ${lanes} AS lane
-  WHERE lane.lease_owner = $4::text AND lane.lease_expires_at > $1::timestamptz
-    AND lane.claim_floor = $6::bigint
-  ORDER BY lane.lane
-  FOR NO KEY UPDATE
-), stale AS (
-  -- A claim that waited for a lane lock sees the new lane row but reads deliveries with the snapshot it took
-  -- before the wait: whatever changed the lane meanwhile (a reschedule, a release) may also have changed
-  -- deliveries it cannot see. The statement then does nothing and reports it, and the caller runs it again.
-  SELECT EXISTS (
-    SELECT 1 FROM held
-    JOIN ${lanes} AS before ON before.lane = held.lane
-    WHERE before.epoch <> held.epoch OR before.in_flight IS DISTINCT FROM held.in_flight
-  ) AS value
-), held_scope AS MATERIALIZED (
-  SELECT held.lane, held.epoch, held.in_flight FROM held WHERE NOT (SELECT value FROM stale)
-), held_running AS MATERIALIZED (
-  SELECT delivery.handler, delivery.key
-  FROM held_scope
-  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", "held_scope", "held_running", "$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
-${free}, claim_scope AS MATERIALIZED (
-  SELECT held_scope.lane, held_scope.epoch FROM held_scope
-  UNION ALL
-  SELECT free_scope.lane, free_scope.epoch FROM free_scope
-), picked_rows AS MATERIALIZED (
-  SELECT candidates.available_at AS due_at, delivery.id AS delivery_id, delivery.lane::int AS lane,
-    scope.epoch::text AS epoch, delivery.claims AS claims, delivery.handler, delivery.key AS delivery_key, delivery.sequence::text AS sequence, (delivery.attempts + 1)::int AS attempt,
-    ${eventColumns("event")}
-  FROM (
-    SELECT held_candidates.id, held_candidates.lane, held_candidates.available_at FROM held_candidates
-    UNION ALL
-    SELECT free_candidates.id, free_candidates.lane, free_candidates.available_at FROM free_candidates
-  ) AS candidates
-  JOIN claim_scope AS scope ON scope.lane = candidates.lane
-  JOIN ${deliveries} AS delivery ON delivery.id = candidates.id
-  JOIN ${this.#names.events} AS event ON event.id = delivery.event_id
-), by_lane AS (
-  SELECT picked_rows.lane, array_agg(picked_rows.delivery_id) AS ids FROM picked_rows GROUP BY picked_rows.lane
-), still_running AS (
-  -- The retained ids come from the locked \`held\` rows, not from the lane table: a claim that waited for the lock
-  -- must see the in-flight list the claim before it recorded, which the statement snapshot may not.
-  SELECT held.lane, array_agg(delivery.id) AS ids
-  FROM by_lane
-  JOIN held ON held.lane = by_lane.lane
-  CROSS JOIN LATERAL unnest(held.in_flight) AS flying (id)
-  JOIN ${deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'
-  GROUP BY held.lane
-), extended AS (
-  UPDATE ${lanes} AS lane
-  SET in_flight = COALESCE(still_running.ids, '{}') || by_lane.ids,
-      lease_expires_at = GREATEST(lane.lease_expires_at, $5::timestamptz)
-  FROM by_lane
-  JOIN held_scope ON held_scope.lane = by_lane.lane
-  LEFT JOIN still_running ON still_running.lane = by_lane.lane
-  WHERE lane.lane = by_lane.lane
-  RETURNING lane.lane
-), taken AS (
-  UPDATE ${lanes} AS lane
-  SET epoch = free_scope.epoch, lease_owner = $4::text, lease_expires_at = $5::timestamptz,
-      in_flight = by_lane.ids, claim_floor = $6::bigint
-  FROM free_scope
-  JOIN by_lane ON by_lane.lane = free_scope.lane
-  WHERE lane.lane = free_scope.lane
-  RETURNING lane.lane
-), saturated_lanes AS (
-  SELECT held_window.lane FROM held_window GROUP BY held_window.lane HAVING count(*) >= ${LANE_SCAN_WINDOW}
-), freed AS (
-  UPDATE ${lanes} AS lane
-  SET lease_owner = NULL, lease_expires_at = NULL, in_flight = '{}'
-  FROM held
-  WHERE lane.lane = held.lane
-    AND lane.lane NOT IN (SELECT lane FROM by_lane)
-    AND lane.lane NOT IN (SELECT lane FROM saturated_lanes)
-    AND (SELECT count(*) FROM held_window) < ${CLAIM_SCAN_WINDOW}
-    AND NOT (SELECT value FROM stale)
-    AND ${this.#noRunningDelivery("lane")}
-  RETURNING lane.lane
-)
-SELECT (SELECT value FROM stale) AS stale,
-  EXISTS (SELECT 1 FROM free_lanes WHERE free_lanes.running) AS takeover_waiting,
-  (SELECT count(*) FROM free_lanes) = (SELECT count FROM wanted) + ${FREE_LANE_SURPLUS} AS unexamined_free_lanes,
-  (
-    SELECT COALESCE(jsonb_agg(delivery.id), '[]'::jsonb)
-    FROM held
-    CROSS JOIN LATERAL unnest(held.in_flight) AS flying (id)
-    JOIN ${deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'
-  )::text AS running_ids,
-  (SELECT COALESCE(jsonb_agg(held.lane), '[]'::jsonb) FROM held)::text AS examined_lanes,
-  picked.*
-FROM (SELECT 1) AS anchor
-LEFT JOIN picked_rows AS picked ON true
-ORDER BY picked.due_at, picked.delivery_id`;
+  }
+  /** 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)
+        + row_number() OVER (PARTITION BY incoming.key ORDER BY incoming.ordinal)
+    END AS sequence
+  FROM jsonb_to_recordset($1::jsonb) AS incoming (
+    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
+)`;
+  }
+  /** 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),
+    incoming.correlation_id, incoming.causation_id, incoming.occurred_at, $2::timestamptz,
+    COALESCE(incoming.handlers, '{}')
+  FROM incoming
+  ORDER BY incoming.id
+  ON CONFLICT (id) DO NOTHING
+  RETURNING id, key, sequence
+)`;
+  }
+  /** 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,
+    delivery.available_at, event.key, event.sequence, $2::timestamptz, $2::timestamptz
+  FROM jsonb_to_recordset($3::jsonb) AS delivery (id text, event_id text, handler text, available_at timestamptz)
+  JOIN inserted_events AS event ON event.id = delivery.event_id
+  ORDER BY delivery.event_id, delivery.handler
+  ON CONFLICT (event_id, handler) DO NOTHING
+  RETURNING available_at
+)`;
+  }
+  /** One wake-up notification on {@link PostgresNames.notificationChannel}, outside any publishing transaction. */
+  get notify() {
+    return `SELECT pg_notify('${this.#names.notificationChannel}', '')`;
   }
   /**
-   * The head (lowest pending sequence) of every key of every wanted handler in the lane `scope.lane`,
-   * as a subquery returning `(id, lane, available_at, handler, key)`. A loose index scan on the
-   * pending-key index hops from key to key of a handler, and after its last key on to the first key of
-   * the next wanted handler, so the cost follows the number of keys, not the number of followers. The
-   * handlers are walked inside the recursion instead of joined to it: a join multiplied the planner's
-   * cost estimate by the handler count, which pushed the claim statements over `jit_above_cost`, and
-   * compiling them took longer than running them.
+   * A CTE `woken` that sends one notification on {@link PostgresNames.notificationChannel} when a row of
+   * `inserted` is due at `now`. PostgreSQL delivers it when the transaction commits, merges the same
+   * notification sent twice in one transaction, and drops it on rollback. The statement must reference
+   * `woken` for it to run.
    */
-  #keyHeads(scope) {
-    const deliveries = this.#names.deliveries;
-    const pending = `candidate.lane = ${scope}.lane AND candidate.status = 'pending'`;
-    const nextHandler = (after) => `(SELECT min(wanted.handler) FROM jsonb_array_elements_text($2::jsonb) AS wanted (handler)${after === "" ? "" : ` WHERE wanted.handler > ${after}`})`;
-    return `
-    WITH RECURSIVE hops (handler, key) AS (
-      SELECT ${nextHandler("")}, NULL::text
-      UNION ALL
-      SELECT CASE WHEN next.key IS NULL THEN ${nextHandler("hops.handler")} ELSE hops.handler END, next.key
-      FROM hops
-      CROSS JOIN LATERAL (
-        SELECT CASE WHEN hops.key IS NULL
-          THEN (SELECT candidate.key FROM ${deliveries} AS candidate
-                WHERE ${pending} AND candidate.handler = hops.handler AND candidate.key IS NOT NULL
-                ORDER BY candidate.key LIMIT 1)
-          ELSE (SELECT candidate.key FROM ${deliveries} AS candidate
-                WHERE ${pending} AND candidate.handler = hops.handler AND candidate.key > hops.key
-                ORDER BY candidate.key LIMIT 1)
-        END AS key
-        OFFSET 0
-      ) AS next
-      WHERE hops.handler IS NOT NULL
-    )
-    SELECT lowest.id, lowest.lane, lowest.available_at, lowest.handler, lowest.key
-    FROM hops
-    CROSS JOIN LATERAL (
-      SELECT candidate.id, candidate.lane, candidate.available_at, candidate.handler, candidate.key
-      FROM ${deliveries} AS candidate
-      WHERE ${pending} AND candidate.handler = hops.handler AND candidate.key = hops.key
-      ORDER BY candidate.sequence LIMIT 1
-    ) AS lowest
-    WHERE hops.key IS NOT NULL
-  `;
+  #wakeUp(inserted, now) {
+    return `woken AS (
+  SELECT pg_notify('${this.#names.notificationChannel}', '') FROM (
+    SELECT 1 FROM ${inserted} WHERE ${inserted}.available_at <= ${now}::timestamptz LIMIT 1
+  ) AS due
+)`;
   }
   /**
-   * 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 {@link 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.
+   * Parameters: `[eventsJson, createdAt]`. Returns the ids that were inserted.
+   * `handlers` is the list of handlers the event gets deliveries for: it
+   * outlives the deliveries, which are deleted when they complete.
    */
-  #candidates(prefix, scope, running, limit) {
-    const deliveries = this.#names.deliveries;
-    const notRunning = (alias) => running === null ? "true" : `NOT EXISTS (SELECT 1 FROM ${running} AS running WHERE running.handler = ${alias}.handler AND running.key = ${alias}.key)`;
-    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("head")}
-  ) AS picked
-  ORDER BY picked.available_at, picked.id
-  LIMIT ${limit}
-), ${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 (${this.#keyHeads("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("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}
-)`;
+  get insertEvents() {
+    return `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),
+  incoming.correlation_id, incoming.causation_id, incoming.occurred_at, $2::timestamptz,
+  COALESCE(incoming.handlers, '{}')
+FROM jsonb_to_recordset($1::jsonb) AS incoming (
+  id text, type text, source text, key text, sequence bigint, payload jsonb, headers jsonb,
+  correlation_id text, causation_id text, occurred_at timestamptz, handlers text[])
+ORDER BY incoming.id
+ON CONFLICT (id) DO NOTHING
+RETURNING id`;
   }
   /**
-   * Takes up to `$3` free lanes (no lease, or an expired one) that have a due
-   * delivery of the requested handlers, the ones with the oldest due delivery
-   * first. Parameters: `[now, handlersJson, laneCount, leaseOwner, leaseExpiresAt, generation]`.
-   * The lane gets the owner's `generation` as its `claim_floor`. A lane the owner itself holds under a live
-   * lease with a lower floor was taken by a claim statement that reached the server after its caller gave up
-   * and the owner reconciled (or by an earlier incarnation of the same owner): it is taken over like the lane of a
-   * crashed worker, so its listed deliveries are charged an attempt.
+   * Locks events that were not inserted by the current append, in id order, so
+   * that appends adding handlers to the same event run one after the other.
+   * Parameters: `[eventIdsJson]`. `FOR NO KEY UPDATE` conflicts with itself and
+   * not with the foreign key checks of other inserts.
+   */
+  get lockExistingEvents() {
+    return `SELECT id FROM ${this.#names.events}
+WHERE id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb)))
+ORDER BY id
+FOR NO KEY UPDATE`;
+  }
+  /**
+   * Parameters: `[deliveriesJson, createdAt, insertedEventIdsJson, now]`. Key and
+   * sequence are copied from the stored event, so a delivery added later to an
+   * existing event keeps the event's position in its key and lands in the same
+   * lane. Returns the ids that were inserted.
    *
-   * A taken lane gets a new epoch, which fences everything the previous owner
-   * still holds. Deliveries the previous owner had in flight are the ones whose
-   * attempt was never recorded (a claim writes no delivery row), so each of
-   * them is charged one attempt here: a worker that crashes with a poison
-   * message still runs it into the retry limit. Lanes another claimer has locked
-   * are skipped, never waited for.
+   * The deliveries of events this call just inserted are all new. For an event
+   * that already existed, a handler gets a delivery only if the event does not
+   * list it yet: a completed delivery is deleted, but its handler stays listed,
+   * so a redelivered or republished event never runs a handler twice. The
+   * handlers added to an existing event are appended to its list.
    */
-  get takeFreeLanes() {
-    const deliveries = this.#names.deliveries;
-    const lanes = this.#names.lanes;
-    return `WITH picked AS (
-  -- in_flight is read here, from the locked version of the lane: a settlement that committed after the
-  -- statement took its snapshot has taken its delivery out of the list already and must not be charged again.
-  SELECT free.lane, free.in_flight
-  FROM ${lanes} AS free
-  CROSS JOIN LATERAL (
-    SELECT delivery.available_at, delivery.id
-    FROM ${deliveries} AS delivery
-    WHERE delivery.lane = free.lane AND delivery.status = 'pending'
-      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
-    ORDER BY delivery.available_at, delivery.id
-    LIMIT 1
-  ) AS oldest
-  WHERE free.lease_expires_at IS NULL OR free.lease_expires_at <= $1::timestamptz
-    OR (free.lease_owner = $4::text AND free.claim_floor < $6::bigint)
-  ORDER BY oldest.available_at, oldest.id
-  LIMIT $3::int
-  FOR UPDATE OF free SKIP LOCKED
-), charged AS (
-  UPDATE ${deliveries} AS delivery SET attempts = delivery.attempts + 1, claims = delivery.claims + 1
+  get insertDeliveries() {
+    const events = this.#names.events;
+    const insertedEvents = `ARRAY(SELECT jsonb_array_elements_text($3::jsonb))`;
+    return `WITH incoming AS (
+  SELECT incoming.id, incoming.event_id, incoming.handler, incoming.available_at
+  FROM jsonb_to_recordset($1::jsonb) AS incoming (id text, event_id text, handler text, available_at timestamptz)
+), fresh AS (
+  SELECT incoming.*, event.key, event.sequence, ${laneExpression("event.key", "event.id")} AS lane
+  FROM incoming
+  JOIN ${events} AS event ON event.id = incoming.event_id
+  WHERE event.id = ANY (${insertedEvents}) OR NOT incoming.handler = ANY (event.handlers)
+), inserted AS (
+  INSERT INTO ${this.#names.deliveries}
+    (id, event_id, handler, lane, status, attempts, available_at, key, sequence, created_at, updated_at)
+  SELECT fresh.id, fresh.event_id, fresh.handler, fresh.lane, 'pending', 0, fresh.available_at,
+    fresh.key, fresh.sequence, $2::timestamptz, $2::timestamptz
+  FROM fresh
+  ORDER BY fresh.event_id, fresh.handler
+  ON CONFLICT (event_id, handler) DO NOTHING
+  RETURNING id, event_id, handler, available_at
+), extended AS (
+  UPDATE ${events} AS event SET handlers = event.handlers || added.handlers
   FROM (
-    SELECT unnest(picked.in_flight) AS id FROM picked
-  ) AS lost
-  WHERE delivery.id = lost.id AND delivery.status = 'pending'
-  RETURNING delivery.id
-), taken AS (
-  UPDATE ${lanes} AS lane
-  SET epoch = lane.epoch + 1, lease_owner = $4::text, lease_expires_at = $5::timestamptz, in_flight = '{}',
-      claim_floor = $6::bigint
-  FROM picked WHERE lane.lane = picked.lane
-  RETURNING lane.lane, lane.epoch
-)
-SELECT lane::int AS lane, epoch::text AS epoch FROM taken ORDER BY lane`;
+    SELECT inserted.event_id, array_agg(inserted.handler) AS handlers FROM inserted
+    WHERE inserted.event_id <> ALL (${insertedEvents}) GROUP BY inserted.event_id
+  ) AS added
+  WHERE event.id = added.event_id
+  RETURNING event.id
+), ${this.#wakeUp("inserted", "$4")}
+SELECT id FROM inserted WHERE (SELECT count(*) FROM woken) >= 0`;
+  }
+};
+
+// src/statement-fragments.ts
+var CLAIM_SCAN_WINDOW = 256;
+var LANE_SCAN_WINDOW = 64;
+var LANE_DEPTH_CAP = 16;
+var INITIAL_FREE_LANES = 4;
+var HANDLER_PREDICATE = `delivery.handler = ANY (ARRAY(SELECT jsonb_array_elements_text($2::jsonb)))`;
+function eventColumns(alias) {
+  return `${alias}.id AS event_id,
+    ${alias}.type AS event_type,
+    ${alias}.source AS event_source,
+    ${alias}.key AS event_key,
+    ${alias}.payload::text AS event_payload,
+    ${alias}.headers::text AS event_headers,
+    ${alias}.correlation_id AS event_correlation_id,
+    ${alias}.causation_id AS event_causation_id,
+    ${isoText(`${alias}.occurred_at`)} AS event_occurred_at`;
+}
+function countChanged(dml) {
+  return `WITH changed AS (${dml} RETURNING 1) SELECT count(*)::int AS count FROM changed`;
+}
+function keyHeads(names, scope) {
+  const deliveries = names.deliveries;
+  const pending = `candidate.lane = ${scope}.lane AND candidate.status = 'pending'`;
+  const nextHandler = (after) => `(SELECT min(wanted.handler) FROM jsonb_array_elements_text($2::jsonb) AS wanted (handler)${after === "" ? "" : ` WHERE wanted.handler > ${after}`})`;
+  return `
+    WITH RECURSIVE hops (handler, key) AS (
+      SELECT ${nextHandler("")}, NULL::text
+      UNION ALL
+      SELECT CASE WHEN next.key IS NULL THEN ${nextHandler("hops.handler")} ELSE hops.handler END, next.key
+      FROM hops
+      CROSS JOIN LATERAL (
+        SELECT CASE WHEN hops.key IS NULL
+          THEN (SELECT candidate.key FROM ${deliveries} AS candidate
+                WHERE ${pending} AND candidate.handler = hops.handler AND candidate.key IS NOT NULL
+                ORDER BY candidate.key LIMIT 1)
+          ELSE (SELECT candidate.key FROM ${deliveries} AS candidate
+                WHERE ${pending} AND candidate.handler = hops.handler AND candidate.key > hops.key
+                ORDER BY candidate.key LIMIT 1)
+        END AS key
+        OFFSET 0
+      ) AS next
+      WHERE hops.handler IS NOT NULL
+    )
+    SELECT lowest.id, lowest.lane, lowest.available_at, lowest.handler, lowest.key
+    FROM hops
+    CROSS JOIN LATERAL (
+      SELECT candidate.id, candidate.lane, candidate.available_at, candidate.handler, candidate.key
+      FROM ${deliveries} AS candidate
+      WHERE ${pending} AND candidate.handler = hops.handler AND candidate.key = hops.key
+      ORDER BY candidate.sequence LIMIT 1
+    ) AS lowest
+    WHERE hops.key IS NOT NULL
+  `;
+}
+function noRunningDelivery(names, laneAlias) {
+  return `NOT EXISTS (
+      SELECT 1 FROM unnest(${laneAlias}.in_flight) AS flying (id)
+      JOIN ${names.deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'
+    )`;
+}
+
+// src/statements-claim.ts
+var LANE_LIST = `ARRAY(SELECT jsonb_array_elements_text($4::jsonb)::smallint)`;
+var ClaimStatements = class {
+  #names;
+  constructor(names) {
+    this.#names = names;
   }
   /**
    * Fast claim: picks from the first {@link CLAIM_SCAN_WINDOW} due deliveries of
@@ -1114,7 +1771,7 @@ ${this.#pickedRows(`((SELECT count(*) FROM due_window) >= ${CLAIM_SCAN_WINDOW} O
 heads AS MATERIALIZED (
   SELECT head.id, head.lane, head.available_at, head.handler, head.key
   FROM scope
-  CROSS JOIN LATERAL (${this.#keyHeads("scope")}) AS head
+  CROSS JOIN LATERAL (${keyHeads(this.#names, "scope")}) AS head
 ), keyed AS MATERIALIZED (
   SELECT heads.id, heads.lane, heads.available_at
   FROM heads
@@ -1233,18 +1890,11 @@ ORDER BY picked.due_at, picked.delivery_id`;
   SET lease_owner = NULL, lease_expires_at = NULL, in_flight = '{}'
   WHERE lane.lane = ANY (ARRAY(SELECT jsonb_array_elements_text($2::jsonb)::smallint))
     AND lane.lease_owner = $3::text
-    AND ${this.#noRunningDelivery("lane")}
+    AND ${noRunningDelivery(this.#names, "lane")}
   RETURNING lane.lane
 )
 SELECT (SELECT count(*) FROM extended)::int AS extended, (SELECT count(*) FROM freed)::int AS freed`;
   }
-  /** True when none of the lane's listed deliveries exists as a pending row. */
-  #noRunningDelivery(laneAlias) {
-    return `NOT EXISTS (
-      SELECT 1 FROM unnest(${laneAlias}.in_flight) AS flying (id)
-      JOIN ${this.#names.deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'
-    )`;
-  }
   /**
    * Keeps in the in-flight lists of the lanes `$1` holds only the claims in `$2`
    * (`[{ id, lane, epoch, claims }]`, the ones this store handed out and nobody
@@ -1287,7 +1937,15 @@ WHERE lane.lane = owned.lane AND lane.lease_owner = $1::text AND lane.claim_floo
 UPDATE ${this.#names.lanes} AS lane
 SET lease_owner = NULL, lease_expires_at = NULL, in_flight = '{}'
 FROM owned
-WHERE lane.lane = owned.lane AND lane.lease_owner = $1::text AND ${this.#noRunningDelivery("lane")}`;
+WHERE lane.lane = owned.lane AND lane.lease_owner = $1::text AND ${noRunningDelivery(this.#names, "lane")}`;
+  }
+};
+
+// src/statements-completion.ts
+var CompletionStatements = class {
+  #names;
+  constructor(names) {
+    this.#names = names;
   }
   /**
    * Extends the lease of the lane a running delivery belongs to; the lane lease
@@ -1388,158 +2046,493 @@ SELECT ord FROM completed`;
    */
   #leaveFlight(assignments) {
     const lanes = this.#names.lanes;
-    return `WITH fence AS MATERIALIZED (
-  SELECT lane.lane FROM ${lanes} AS lane
-  WHERE lane.lane = $2::smallint AND lane.epoch = $3::bigint AND $1::text = ANY (lane.in_flight)
-  FOR NO KEY UPDATE
-), changed AS (
-  UPDATE ${this.#names.deliveries} AS delivery ${assignments}
-  FROM fence
-  WHERE delivery.id = $1::text AND delivery.lane = fence.lane AND delivery.status = 'pending'
-    AND delivery.claims = $4::int
-  RETURNING delivery.id
-), trimmed AS (
-  UPDATE ${lanes} AS lane SET in_flight = array_remove(lane.in_flight, $1::text)
-  FROM changed WHERE lane.lane = $2::smallint
-  RETURNING lane.lane
-)
-SELECT count(*)::int AS count FROM changed`;
+    return `WITH fence AS MATERIALIZED (
+  SELECT lane.lane FROM ${lanes} AS lane
+  WHERE lane.lane = $2::smallint AND lane.epoch = $3::bigint AND $1::text = ANY (lane.in_flight)
+  FOR NO KEY UPDATE
+), changed AS (
+  UPDATE ${this.#names.deliveries} AS delivery ${assignments}
+  FROM fence
+  WHERE delivery.id = $1::text AND delivery.lane = fence.lane AND delivery.status = 'pending'
+    AND delivery.claims = $4::int
+  RETURNING delivery.id
+), trimmed AS (
+  UPDATE ${lanes} AS lane SET in_flight = array_remove(lane.in_flight, $1::text)
+  FROM changed WHERE lane.lane = $2::smallint
+  RETURNING lane.lane
+)
+SELECT count(*)::int AS count FROM changed`;
+  }
+};
+
+// 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 (
+  SELECT NULL::smallint AS lane, NULL::bigint AS epoch, NULL::text[] AS in_flight, false AS running WHERE false
+), free_scope AS (
+  SELECT NULL::smallint AS lane, NULL::bigint AS epoch WHERE false
+), free_candidates AS (
+  SELECT NULL::text AS id, NULL::smallint AS lane, NULL::timestamptz AS available_at WHERE false
+)`;
+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:
+   * `[now, handlersJson, limit, leaseOwner, leaseExpiresAt, generation]`.
+   *
+   * 1. **Held lanes.** The lanes this owner holds under a live lease whose `claim_floor` is exactly the
+   *    generation are locked `FOR NO KEY UPDATE` in lane order. A lane above it was raised by a
+   *    reconciliation, so a statement of a claim whose caller gave up (a client timeout does not cancel
+   *    the statement on the server) and that reaches the server late records nothing; a lane below it was
+   *    taken by such a late statement after the reconciliation, and its listed deliveries were never
+   *    handed out. A lane that another transaction of this owner is changing makes the statement wait;
+   *    the statement then reports `stale` and does nothing (see the `stale` CTE).
+   * 2. **Free lanes**, only when the held lanes yield fewer than `limit`: the free lanes with a due
+   *    delivery (one index probe per free lane) are ranked by their oldest due delivery; the first
+   *    {@link INITIAL_FREE_LANES} that can give something now, and further ones until what they can give
+   *    (estimated from their first {@link LANE_DEPTH_CAP} due deliveries) covers what is still wanted, are locked
+   *    `FOR UPDATE SKIP LOCKED`, so a lane another claimer has is skipped, never waited
+   *    for. A lane that still runs deliveries of an expired lease is left to the transaction of
+   *    {@link takeFreeLanes}, which charges their lost attempts (`takeover_waiting`); so is any lane whose
+   *    locked row differs from what the statement's snapshot saw. A lane that runs nothing and did not
+   *    change cannot have had a delivery written since the snapshot, so its deliveries can be read here.
+   * 3. **Picks** follow the rules of `ClaimStatements.claim`: the fast window of each lane, and for lanes whose
+   *    window filled up while the batch is not full, the heads of all keys (a loose index scan per lane).
+   * 4. **Writes**: one update per lane. A held lane records its picks; a taken lane gets a new epoch, the
+   *    owner, the lease and its picks; a taken lane that yielded nothing is not written. Held lanes that
+   *    picked nothing, run nothing and have no full scan window are freed.
+   *
+   * Always returns one row per picked delivery, or one row whose `delivery_id` is null. `running_ids`
+   * (JSON text) lists the deliveries the held lanes still run, `examined_lanes` the held lanes.
+   */
+  get claimLanes() {
+    return this.#claimLanes(true);
+  }
+  /**
+   * {@link claimLanes} limited to the lanes the owner holds: the same parameters, rows and writes, without
+   * looking at free lanes (`takeover_waiting` and `unexamined_free_lanes` are false). A worker draining a
+   * backlog finds its batch in the lanes it holds; this statement is about half as costly to plan, and
+   * the caller runs {@link claimLanes} after it only when it came up short.
+   */
+  get claimHeldLanes() {
+    return this.#claimLanes(false);
+  }
+  #claimLanes(includeFreeLanes) {
+    const free = includeFreeLanes ? this.#freeLaneChoice() + this.#freeLaneDepth() + this.#freeLaneTake() : NO_FREE_LANES;
+    return this.#heldLanes() + free + this.#claimPicks() + this.#claimRecord() + this.#claimRelease();
+  }
+  /** Locks the held lanes, detects a stale snapshot and picks from the held lanes; ends with `wanted`. */
+  #heldLanes() {
+    const deliveries = this.#names.deliveries;
+    const lanes = this.#names.lanes;
+    return `WITH held AS MATERIALIZED (
+  SELECT lane.lane, lane.epoch, lane.in_flight
+  FROM ${lanes} AS lane
+  WHERE lane.lease_owner = $4::text AND lane.lease_expires_at > $1::timestamptz
+    AND lane.claim_floor = $6::bigint
+  ORDER BY lane.lane
+  FOR NO KEY UPDATE
+), stale AS (
+  -- A claim that waited for a lane lock sees the new lane row but reads deliveries with the snapshot it took
+  -- before the wait: whatever changed the lane meanwhile (a reschedule, a release) may also have changed
+  -- deliveries it cannot see. The statement then does nothing and reports it, and the caller runs it again.
+  SELECT EXISTS (
+    SELECT 1 FROM held
+    JOIN ${lanes} AS before ON before.lane = held.lane
+    WHERE before.epoch <> held.epoch OR before.in_flight IS DISTINCT FROM held.in_flight
+  ) AS value
+), held_scope AS MATERIALIZED (
+  SELECT held.lane, held.epoch, held.in_flight FROM held WHERE NOT (SELECT value FROM stale)
+), held_running AS MATERIALIZED (
+  SELECT delivery.handler, delivery.key
+  FROM held_scope
+  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.#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
+`;
+  }
+  /** The oldest due delivery of each free lane, at most the number still wanted plus a surplus. */
+  #freeLaneChoice() {
+    const deliveries = this.#names.deliveries;
+    const lanes = this.#names.lanes;
+    return `), free_lanes AS MATERIALIZED (
+  -- The oldest due delivery of each free lane: one index probe per free lane, bounded by the due time,
+  -- so deliveries scheduled for later are never read.
+  SELECT lane.lane, lane.epoch, lane.in_flight, lane.lease_owner, lane.lease_expires_at,
+    oldest.available_at, oldest.id, NOT ${noRunningDelivery(this.#names, "lane")} AS running
+  FROM ${lanes} AS lane
+  CROSS JOIN LATERAL (
+    SELECT delivery.available_at, delivery.id
+    FROM ${deliveries} AS delivery
+    WHERE delivery.lane = lane.lane AND delivery.status = 'pending'
+      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
+    ORDER BY delivery.available_at, delivery.id
+    LIMIT 1
+  ) AS oldest
+  WHERE (SELECT count FROM wanted) > 0 AND ${freeLane("lane")}
+  ORDER BY oldest.available_at, oldest.id
+  LIMIT (SELECT count FROM wanted) + ${FREE_LANE_SURPLUS}
+`;
   }
-  /** Parameters: `[deliveryIdsJson, now]`. The dead rows are locked in id order first. */
-  get requeue() {
+  /** What each free candidate lane can give now, and their order. */
+  #freeLaneDepth() {
     const deliveries = this.#names.deliveries;
-    return countChanged(`WITH dead AS MATERIALIZED (
-  SELECT delivery.id FROM ${deliveries} AS delivery
-  WHERE delivery.id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb))) AND delivery.status = 'dead'
-  ORDER BY delivery.id
-  FOR NO KEY UPDATE
-)
-UPDATE ${deliveries} AS delivery
-SET status = 'pending', attempts = 0, available_at = $2::timestamptz, updated_at = $2::timestamptz
-FROM dead
-WHERE delivery.id = dead.id AND delivery.status = 'dead'`);
+    return `), free_depth AS MATERIALIZED (
+  -- What each candidate lane can give now, from its first due deliveries: unkeyed ones, and of a key its
+  -- lowest one when nothing earlier of the key is pending. Lanes that can give nothing are passed over;
+  -- of the others, the first ${INITIAL_FREE_LANES} are taken, and further ones until they cover what is
+  -- still wanted, so the earliest due work of the free lanes comes first.
+  SELECT runnable.lane,
+    row_number() OVER (ORDER BY runnable.available_at, runnable.id) AS rank,
+    sum(runnable.count) OVER (ORDER BY runnable.available_at, runnable.id ROWS UNBOUNDED PRECEDING) - runnable.count AS due_before
+  FROM (
+    SELECT lane_candidate.lane, lane_candidate.available_at, lane_candidate.id, depth.count
+    FROM free_lanes AS lane_candidate
+    CROSS JOIN LATERAL (
+      -- A full window that shows nothing runnable may hide runnable work behind it: such a lane counts
+      -- once, and the claim looks behind its blocked deliveries.
+      SELECT GREATEST(count(*) FILTER (
+          WHERE due.key IS NULL OR (due.position = 1 AND NOT EXISTS (
+            SELECT 1 FROM ${deliveries} AS earlier
+            WHERE earlier.lane = due.lane AND earlier.handler = due.handler AND earlier.key = due.key
+              AND earlier.status = 'pending' AND earlier.key IS NOT NULL AND earlier.sequence < due.sequence
+          ))
+        ), CASE WHEN count(*) >= ${LANE_DEPTH_CAP} THEN 1 ELSE 0 END) AS count
+      FROM (
+        SELECT window_rows.*,
+          row_number() OVER (PARTITION BY window_rows.handler, window_rows.key ORDER BY window_rows.sequence) AS position
+        FROM (
+          SELECT delivery.lane, delivery.handler, delivery.key, delivery.sequence FROM ${deliveries} AS delivery
+          WHERE delivery.lane = lane_candidate.lane AND delivery.status = 'pending'
+            AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
+          ORDER BY delivery.available_at, delivery.id
+          LIMIT ${LANE_DEPTH_CAP}
+        ) AS window_rows
+      ) AS due
+    ) AS depth
+    WHERE NOT lane_candidate.running AND depth.count > 0
+  ) AS runnable
+`;
   }
-  /**
-   * Builds the filtered, creation-ordered listing. A delivery is `processing`
-   * while its row exists as `pending` and its lane lists its id; its attempt
-   * count, lease owner and lease expiry then come from the claim and the lane.
-   * Records of the completion history (when kept) are listed as `completed`.
-   */
-  listDeliveries(query) {
-    const parameters = [];
-    const bind = (value) => {
-      parameters.push(value);
-      return `$${parameters.length}::${typeof value === "number" ? "int" : "text"}`;
-    };
-    const filters = {
-      handler: query.handler === void 0 ? void 0 : bind(query.handler),
-      eventType: query.eventType === void 0 ? void 0 : bind(query.eventType),
-      eventId: query.eventId === void 0 ? void 0 : bind(query.eventId),
-      status: query.status === void 0 ? void 0 : bind(query.status)
-    };
-    const limit = bind(query.limit ?? DEFAULT_LIST_LIMIT);
-    const common = (alias) => [
-      ...filters.handler === void 0 ? [] : [`${alias}.handler = ${filters.handler}`],
-      ...filters.eventType === void 0 ? [] : [`event.type = ${filters.eventType}`],
-      ...filters.eventId === void 0 ? [] : [`${alias}.event_id = ${filters.eventId}`]
-    ];
-    const inFlight = `(delivery.status = 'pending' AND delivery.id = ANY (lane.in_flight))`;
-    const whereCurrent = [
-      ...common("delivery"),
-      ...filters.status === void 0 ? [] : [
-        `(CASE WHEN ${inFlight} THEN 'processing' ELSE delivery.status END) = ${filters.status}`
-      ]
-    ];
-    const current = `SELECT delivery.id AS delivery_id, delivery.handler,
-  CASE WHEN ${inFlight} THEN 'processing' ELSE delivery.status END AS status,
-  (delivery.attempts + CASE WHEN ${inFlight} THEN 1 ELSE 0 END)::int AS attempts,
-  ${isoText("delivery.available_at")} AS available_at,
-  CASE WHEN ${inFlight} THEN lane.lease_owner END AS lease_owner,
-  CASE WHEN ${inFlight} THEN ${isoText("lane.lease_expires_at")} END AS lease_expires_at,
-  delivery.last_error::text AS last_error,
-  ${isoText("delivery.created_at")} AS created_at,
-  ${isoText("delivery.updated_at")} AS updated_at,
-  ${isoText("delivery.completed_at")} AS completed_at,
-  ${eventColumns("event")}
-FROM ${this.#names.deliveries} AS delivery
-JOIN ${this.#names.lanes} AS lane ON lane.lane = delivery.lane
-JOIN ${this.#names.events} AS event ON event.id = delivery.event_id
-${whereCurrent.length === 0 ? "" : `WHERE ${whereCurrent.join(" AND ")}`}`;
-    const includeHistory = this.#names.completionHistory && (query.status === void 0 || query.status === "completed");
-    if (!includeHistory) {
-      return {
-        sql: `${current}
-ORDER BY delivery.created_at, delivery.id
-LIMIT ${limit}`,
-        parameters
-      };
-    }
-    const history = `SELECT done.id AS delivery_id, done.handler, 'completed' AS status, done.attempts,
-  ${isoText("done.available_at")} AS available_at,
-  NULL AS lease_owner,
-  NULL AS lease_expires_at,
-  NULL AS last_error,
-  ${isoText("done.created_at")} AS created_at,
-  ${isoText("done.completed_at")} AS updated_at,
-  ${isoText("done.completed_at")} AS completed_at,
-  ${eventColumns("event")}
-FROM ${this.#names.completions} AS done
-JOIN ${this.#names.events} AS event ON event.id = done.event_id
-${common("done").length === 0 ? "" : `WHERE ${common("done").join(" AND ")}`}`;
-    return {
-      sql: `SELECT * FROM (
-${current}
-UNION ALL
-${history}
-) AS listed
-ORDER BY created_at, delivery_id
-LIMIT ${limit}`,
-      parameters
-    };
+  /** Locks the chosen free lanes that did not change hands and picks from them. */
+  #freeLaneTake() {
+    const lanes = this.#names.lanes;
+    return `), free_locked AS MATERIALIZED (
+  SELECT lane.lane, lane.epoch, lane.in_flight, lane.lease_owner, lane.lease_expires_at
+  FROM ${lanes} AS lane
+  WHERE lane.lane IN (
+      SELECT chosen.lane FROM free_depth AS chosen
+      WHERE chosen.rank <= ${INITIAL_FREE_LANES} OR chosen.due_before < (SELECT count FROM wanted)
+    )
+    AND ${freeLane("lane")}
+  ORDER BY lane.lane
+  FOR UPDATE SKIP LOCKED
+), free_scope AS MATERIALIZED (
+  -- A lane whose locked row is not the one the snapshot saw changed hands meanwhile: left for a later claim.
+  SELECT locked.lane, locked.epoch + 1 AS epoch, '{}'::text[] AS in_flight
+  FROM free_locked AS locked
+  JOIN free_lanes AS seen ON seen.lane = locked.lane
+  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.#candidateStatements.candidates("free", { scope: "free_scope", running: null, limit: "(SELECT count FROM wanted)" })}`;
   }
-  /**
-   * Counts of rows by stored status (`pending` includes running deliveries;
-   * `completed` rows exist only after an upgrade from 0.1.0). Each count is
-   * answered from a partial index.
-   */
-  get countByStatus() {
+  /** The picked deliveries of held and taken lanes with their events, and the picks per lane. */
+  #claimPicks() {
     const deliveries = this.#names.deliveries;
-    return ["pending", "dead", "completed"].map(
-      (status) => `SELECT '${status}' AS status, count(*)::text AS count FROM ${deliveries} WHERE status = '${status}'`
-    ).join("\nUNION ALL\n");
+    return `, claim_scope AS MATERIALIZED (
+  SELECT held_scope.lane, held_scope.epoch FROM held_scope
+  UNION ALL
+  SELECT free_scope.lane, free_scope.epoch FROM free_scope
+), picked_rows AS MATERIALIZED (
+  SELECT candidates.available_at AS due_at, delivery.id AS delivery_id, delivery.lane::int AS lane,
+    scope.epoch::text AS epoch, delivery.claims AS claims, delivery.handler, delivery.key AS delivery_key, delivery.sequence::text AS sequence, (delivery.attempts + 1)::int AS attempt,
+    ${eventColumns("event")}
+  FROM (
+    SELECT held_candidates.id, held_candidates.lane, held_candidates.available_at FROM held_candidates
+    UNION ALL
+    SELECT free_candidates.id, free_candidates.lane, free_candidates.available_at FROM free_candidates
+  ) AS candidates
+  JOIN claim_scope AS scope ON scope.lane = candidates.lane
+  JOIN ${deliveries} AS delivery ON delivery.id = candidates.id
+  JOIN ${this.#names.events} AS event ON event.id = delivery.event_id
+), by_lane AS (
+  SELECT picked_rows.lane, array_agg(picked_rows.delivery_id) AS ids FROM picked_rows GROUP BY picked_rows.lane
+`;
   }
-  /** Deliveries that are running: listed by a lane and still pending as rows. */
-  get countRunning() {
-    return `SELECT count(*)::text AS count
-FROM ${this.#names.lanes} AS lane
-CROSS JOIN LATERAL unnest(lane.in_flight) AS flying (id)
-JOIN ${this.#names.deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'`;
+  /** Records the picks in the held lanes and takes the free lanes that yielded picks. */
+  #claimRecord() {
+    const deliveries = this.#names.deliveries;
+    const lanes = this.#names.lanes;
+    return `), still_running AS (
+  -- The retained ids come from the locked \`held\` rows, not from the lane table: a claim that waited for the lock
+  -- must see the in-flight list the claim before it recorded, which the statement snapshot may not.
+  SELECT held.lane, array_agg(delivery.id) AS ids
+  FROM by_lane
+  JOIN held ON held.lane = by_lane.lane
+  CROSS JOIN LATERAL unnest(held.in_flight) AS flying (id)
+  JOIN ${deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'
+  GROUP BY held.lane
+), extended AS (
+  UPDATE ${lanes} AS lane
+  SET in_flight = COALESCE(still_running.ids, '{}') || by_lane.ids,
+      lease_expires_at = GREATEST(lane.lease_expires_at, $5::timestamptz)
+  FROM by_lane
+  JOIN held_scope ON held_scope.lane = by_lane.lane
+  LEFT JOIN still_running ON still_running.lane = by_lane.lane
+  WHERE lane.lane = by_lane.lane
+  RETURNING lane.lane
+), taken AS (
+  UPDATE ${lanes} AS lane
+  SET epoch = free_scope.epoch, lease_owner = $4::text, lease_expires_at = $5::timestamptz,
+      in_flight = by_lane.ids, claim_floor = $6::bigint
+  FROM free_scope
+  JOIN by_lane ON by_lane.lane = free_scope.lane
+  WHERE lane.lane = free_scope.lane
+  RETURNING lane.lane
+`;
   }
-  get countCompletionHistory() {
-    return `SELECT count(*)::text AS count FROM ${this.#names.completions}`;
+  /** Frees the held lanes that yielded nothing and run nothing, and selects the result rows. */
+  #claimRelease() {
+    const deliveries = this.#names.deliveries;
+    const lanes = this.#names.lanes;
+    return `), saturated_lanes AS (
+  SELECT held_window.lane FROM held_window GROUP BY held_window.lane HAVING count(*) >= ${LANE_SCAN_WINDOW}
+), freed AS (
+  UPDATE ${lanes} AS lane
+  SET lease_owner = NULL, lease_expires_at = NULL, in_flight = '{}'
+  FROM held
+  WHERE lane.lane = held.lane
+    AND lane.lane NOT IN (SELECT lane FROM by_lane)
+    AND lane.lane NOT IN (SELECT lane FROM saturated_lanes)
+    AND (SELECT count(*) FROM held_window) < ${CLAIM_SCAN_WINDOW}
+    AND NOT (SELECT value FROM stale)
+    AND ${noRunningDelivery(this.#names, "lane")}
+  RETURNING lane.lane
+)
+SELECT (SELECT value FROM stale) AS stale,
+  EXISTS (SELECT 1 FROM free_lanes WHERE free_lanes.running) AS takeover_waiting,
+  (SELECT count(*) FROM free_lanes) = (SELECT count FROM wanted) + ${FREE_LANE_SURPLUS} AS unexamined_free_lanes,
+  (
+    SELECT COALESCE(jsonb_agg(delivery.id), '[]'::jsonb)
+    FROM held
+    CROSS JOIN LATERAL unnest(held.in_flight) AS flying (id)
+    JOIN ${deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'
+  )::text AS running_ids,
+  (SELECT COALESCE(jsonb_agg(held.lane), '[]'::jsonb) FROM held)::text AS examined_lanes,
+  picked.*
+FROM (SELECT 1) AS anchor
+LEFT JOIN picked_rows AS picked ON true
+ORDER BY picked.due_at, picked.delivery_id`;
   }
   /**
-   * Oldest instant at which a delivery became claimable: `available_at` of a
-   * pending delivery that nobody runs, or the lease expiry of a lane that runs
-   * deliveries. Parameters: `[now]`.
+   * Takes up to `$3` free lanes (no lease, or an expired one) that have a due
+   * delivery of the requested handlers, the ones with the oldest due delivery
+   * first. Parameters: `[now, handlersJson, laneCount, leaseOwner, leaseExpiresAt, generation]`.
+   * The lane gets the owner's `generation` as its `claim_floor`. A lane the owner itself holds under a live
+   * lease with a lower floor was taken by a claim statement that reached the server after its caller gave up
+   * and the owner reconciled (or by an earlier incarnation of the same owner): it is taken over like the lane of a
+   * crashed worker, so its listed deliveries are charged an attempt.
+   *
+   * A taken lane gets a new epoch, which fences everything the previous owner
+   * still holds. Deliveries the previous owner had in flight are the ones whose
+   * attempt was never recorded (a claim writes no delivery row), so each of
+   * them is charged one attempt here: a worker that crashes with a poison
+   * message still runs it into the retry limit. Lanes another claimer has locked
+   * are skipped, never waited for.
    */
-  get oldestDue() {
+  get takeFreeLanes() {
     const deliveries = this.#names.deliveries;
     const lanes = this.#names.lanes;
-    return `SELECT ${isoText("min(due.due_at)")} AS oldest_due_at FROM (
-  SELECT waiting.available_at AS due_at
-  FROM ${lanes} AS lane
+    return `WITH picked AS (
+  -- in_flight is read here, from the locked version of the lane: a settlement that committed after the
+  -- statement took its snapshot has taken its delivery out of the list already and must not be charged again.
+  SELECT free.lane, free.in_flight
+  FROM ${lanes} AS free
   CROSS JOIN LATERAL (
-    SELECT delivery.available_at FROM ${deliveries} AS delivery
-    WHERE delivery.lane = lane.lane AND delivery.status = 'pending'
-      AND delivery.available_at <= $1::timestamptz AND delivery.id <> ALL (lane.in_flight)
-    ORDER BY delivery.available_at LIMIT 1
-  ) AS waiting
-  UNION ALL
-  SELECT lane.lease_expires_at AS due_at
-  FROM ${lanes} AS lane
-  WHERE lane.lease_expires_at <= $1::timestamptz AND NOT ${this.#noRunningDelivery("lane")}
-) AS due`;
+    SELECT delivery.available_at, delivery.id
+    FROM ${deliveries} AS delivery
+    WHERE delivery.lane = free.lane AND delivery.status = 'pending'
+      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}
+    ORDER BY delivery.available_at, delivery.id
+    LIMIT 1
+  ) AS oldest
+  WHERE free.lease_expires_at IS NULL OR free.lease_expires_at <= $1::timestamptz
+    OR (free.lease_owner = $4::text AND free.claim_floor < $6::bigint)
+  ORDER BY oldest.available_at, oldest.id
+  LIMIT $3::int
+  FOR UPDATE OF free SKIP LOCKED
+), charged AS (
+  UPDATE ${deliveries} AS delivery SET attempts = delivery.attempts + 1, claims = delivery.claims + 1
+  FROM (
+    SELECT unnest(picked.in_flight) AS id FROM picked
+  ) AS lost
+  WHERE delivery.id = lost.id AND delivery.status = 'pending'
+  RETURNING delivery.id
+), taken AS (
+  UPDATE ${lanes} AS lane
+  SET epoch = lane.epoch + 1, lease_owner = $4::text, lease_expires_at = $5::timestamptz, in_flight = '{}',
+      claim_floor = $6::bigint
+  FROM picked WHERE lane.lane = picked.lane
+  RETURNING lane.lane, lane.epoch
+)
+SELECT lane::int AS lane, epoch::text AS epoch FROM taken ORDER BY lane`;
+  }
+};
+
+// src/statements-purge.ts
+var PurgeStatements = class {
+  #names;
+  constructor(names) {
+    this.#names = names;
   }
   /**
    * Deletes one bounded batch of purgeable deliveries (or of the completion
@@ -1548,25 +2541,22 @@ JOIN ${this.#names.deliveries} AS delivery ON delivery.id = flying.id AND delive
    * on, or being waited on by, anything.
    */
   purgeCompletedBatch() {
-    return this.#purgeBatch(
-      this.#names.deliveries,
-      `status = 'completed' AND completed_at < $1::timestamptz`,
-      "completed_at"
-    );
+    return this.#purgeBatch(this.#names.deliveries, {
+      condition: `status = 'completed' AND completed_at < $1::timestamptz`,
+      orderColumn: "completed_at"
+    });
   }
   purgeCompletionHistoryBatch() {
-    return this.#purgeBatch(
-      this.#names.completions,
-      `completed_at < $1::timestamptz`,
-      "completed_at"
-    );
+    return this.#purgeBatch(this.#names.completions, {
+      condition: `completed_at < $1::timestamptz`,
+      orderColumn: "completed_at"
+    });
   }
   purgeDeadBatch() {
-    return this.#purgeBatch(
-      this.#names.deliveries,
-      `status = 'dead' AND updated_at < $1::timestamptz`,
-      "updated_at"
-    );
+    return this.#purgeBatch(this.#names.deliveries, {
+      condition: `status = 'dead' AND updated_at < $1::timestamptz`,
+      orderColumn: "updated_at"
+    });
   }
   /**
    * Selects and locks one bounded batch of events created before the cutoff
@@ -1641,7 +2631,7 @@ WHERE event.id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb)))
     const history = this.#names.completionHistory ? ` AND NOT EXISTS (SELECT 1 FROM ${this.#names.completions} AS done WHERE done.event_id = ${eventAlias}.id)` : "";
     return `NOT EXISTS (SELECT 1 FROM ${this.#names.deliveries} AS delivery WHERE delivery.event_id = ${eventAlias}.id)${history}`;
   }
-  #purgeBatch(table, condition, orderColumn) {
+  #purgeBatch(table, { condition, orderColumn }) {
     return `WITH batch AS MATERIALIZED (
   SELECT id FROM ${table}
   WHERE ${condition}
@@ -1655,668 +2645,382 @@ SELECT event_id FROM deleted`;
   }
 };
 
-// src/postgres-event-store.ts
-var WAKE_UPS = ["notify", "poll"];
-var DEFAULT_PURGE_BATCH_SIZE = 1e3;
-var INITIAL_LANES_PER_ROUND = 4;
-var MAXIMUM_STALE_CLAIM_ATTEMPTS = 3;
-var NOTIFICATION_INTERVAL_MS = 10;
-function handedOutKey(deliveryId, leaseToken) {
-  return `${deliveryId}\0${leaseToken}`;
+// src/statements-queries.ts
+var DEFAULT_LIST_LIMIT = 100;
+function bindListFilters(query) {
+  const parameters = [];
+  const bind = (value) => {
+    parameters.push(value);
+    return `$${parameters.length}::${typeof value === "number" ? "int" : "text"}`;
+  };
+  const filters = {
+    handler: query.handler === void 0 ? void 0 : bind(query.handler),
+    eventType: query.eventType === void 0 ? void 0 : bind(query.eventType),
+    eventId: query.eventId === void 0 ? void 0 : bind(query.eventId),
+    status: query.status === void 0 ? void 0 : bind(query.status)
+  };
+  const limit = bind(query.limit ?? DEFAULT_LIST_LIMIT);
+  return { parameters, filters, limit };
 }
-var PostgresEventStore = class {
-  #executor;
-  #statements;
-  #schemaStatements;
-  #setupLockKey;
-  #schemaMarker;
-  #purgeBatchSize;
-  #completionHistory;
-  #logger;
-  /** Passed with every statement whose text is fixed: asks the executor to prepare it (`preparedStatements`). */
-  #queryOptions;
-  #notifies;
-  /** Every claim handed to a caller and not settled yet, by delivery id and exact lease token. */
-  #handedOut = /* @__PURE__ */ new Map();
-  #unreconciled = /* @__PURE__ */ new Set();
-  #generations = /* @__PURE__ */ new Map();
-  #ownerQueues = /* @__PURE__ */ new Map();
-  /** Owners whose last claim was filled from the lanes they held. */
-  #drainingOwners = /* @__PURE__ */ new Set();
-  #ownedPool;
-  /** The `pg` pool behind the store, when it has one: listening for notifications needs a connection of its own. */
-  #pool;
-  #notificationChannel;
-  #lastNotificationAt = Number.NEGATIVE_INFINITY;
-  #trailingNotification;
-  /** Set by `close()`: a transaction that commits afterwards schedules no wake-up. */
-  #closed = false;
-  /** The transactions `transaction` runs right now, and whether one of their appends left its wake-up for after the commit. */
-  #ownTransactions = /* @__PURE__ */ new Map();
-  constructor(options) {
-    const sources = [options.pool, options.connectionString, options.executor].filter(
-      (source) => source !== void 0
-    );
-    if (sources.length !== 1) {
-      throw new ConfigurationError(
-        "PostgresEventStore needs exactly one of pool, connectionString or executor"
-      );
-    }
-    const purgeBatchSize = options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE;
-    if (!Number.isInteger(purgeBatchSize) || purgeBatchSize < 1) {
-      throw new ConfigurationError(
-        `purgeBatchSize must be a positive integer, received ${String(purgeBatchSize)}`
-      );
-    }
-    const wakeUp = options.wakeUp ?? "notify";
-    if (!WAKE_UPS.includes(wakeUp)) {
-      throw new ConfigurationError(`wakeUp must be 'notify' or 'poll', received ${String(wakeUp)}`);
-    }
-    const preparedStatements = options.preparedStatements ?? true;
-    if (typeof preparedStatements !== "boolean") {
-      throw new ConfigurationError(
-        `preparedStatements must be a boolean, received ${String(preparedStatements)}`
-      );
-    }
-    this.#notifies = wakeUp === "notify";
-    this.#queryOptions = preparedStatements ? { prepare: true } : void 0;
-    const names = resolvePostgresNames(options);
-    this.#statements = new PostgresStatements(names);
-    this.#schemaStatements = createPostgresSchemaStatements(options);
-    this.#setupLockKey = this.#statements.setupLockKey;
-    this.#schemaMarker = postgresSchemaMarker(this.#schemaStatements.slice(0, -1));
-    this.#purgeBatchSize = purgeBatchSize;
-    this.#completionHistory = names.completionHistory;
-    this.#logger = options.logger ?? console;
-    this.#notificationChannel = names.notificationChannel;
-    if (options.executor !== void 0) {
-      this.#executor = options.executor;
-      this.#pool = void 0;
-    } else {
-      const pool = options.pool ?? new Pool({ ...options.poolConfig, connectionString: options.connectionString });
-      if (options.pool === void 0) {
-        const logger = options.logger ?? console;
-        pool.on("error", (error) => {
-          logger.error(
-            `[PostgresEventStore](constructor) Idle connection failed, the pool replaces it | error=${error.message}`
-          );
-        });
-        this.#ownedPool = pool;
-      }
-      this.#pool = pool;
-      this.#executor = new PgExecutor(pool, {
-        logger: this.#logger
-      });
-    }
-  }
-  /**
-   * Creates the schema, tables and indexes if they do not exist. Safe to call
-   * from many processes at once: a transaction-scoped advisory lock serializes
-   * the DDL, so racing `CREATE TABLE IF NOT EXISTS` statements cannot collide.
-   * When the lane table already carries the marker of the current statements
-   * ({@link postgresSchemaMarker}) nothing runs and no table is locked, so instances
-   * that start next to running dispatchers cannot deadlock with their claims.
-   * Skip it (`setupStore: false`) when a migration tool applies
-   * `createPostgresSchemaSql()` instead.
-   */
-  async setup() {
-    if (await this.#schemaIsCurrent()) {
-      return;
-    }
-    await this.#executor.transaction(async (transaction) => {
-      await this.#executor.query(this.#statements.setupLock, [this.#setupLockKey], transaction);
-      if (await this.#schemaIsCurrent(transaction)) {
-        return;
-      }
-      for (const statement of this.#schemaStatements) {
-        await this.#executor.query(statement, [], transaction);
-      }
-    });
-  }
-  async #schemaIsCurrent(transaction) {
-    const rows = await this.#executor.query(
-      this.#statements.schemaCurrent,
-      [this.#schemaMarker],
-      transaction
-    );
-    return rows[0]["current"] === true;
-  }
-  async transaction(work) {
-    const own = { wake: false };
-    const result = await this.#executor.transaction(async (transaction) => {
-      this.#ownTransactions.set(transaction, own);
-      try {
-        return await work(transaction);
-      } finally {
-        this.#ownTransactions.delete(transaction);
-      }
-    });
-    if (own.wake) {
-      this.#wakeAfterCommit();
-    }
-    return result;
-  }
-  /**
-   * Writes the entries in `transaction`, normally with one statement
-   * ({@link PostgresStatements.insertFreshEvents}): keyed events reserve their sequence numbers (locking
-   * the key rows in sorted order, so publishers cannot deadlock inside one call), then the new events and
-   * their deliveries are inserted, ordered by primary key, and one notification wakes the dispatchers
-   * when a delivery is due now. Events that already existed get their missing handlers' deliveries in
-   * two more statements. Two transactions that append keys in opposite order across several calls can
-   * still deadlock (40P01); the database rolls one back and the caller retries.
-   * A duplicate event id still consumes a sequence number; gaps are harmless
-   * because only the order of sequences matters.
-   */
-  async append(transaction, entries, now) {
-    const plan = planAppend(entries);
-    if (plan.events.length === 0) {
-      return { appendedEventIds: [], duplicateEventIds: [], appendedDeliveryCount: 0 };
-    }
-    const createdAt = now.toISOString();
-    const wakeAt = this.#wakeAt(plan.deliveries, now, transaction);
-    const handlersByEvent = /* @__PURE__ */ new Map();
-    for (const delivery of plan.deliveries) {
-      handlersByEvent.set(delivery.event_id, [
-        ...handlersByEvent.get(delivery.event_id) ?? [],
-        delivery.handler
-      ]);
-    }
-    const keyCounts = /* @__PURE__ */ new Map();
-    for (const event of plan.events) {
-      if (event.key !== null) {
-        keyCounts.set(event.key, (keyCounts.get(event.key) ?? 0) + 1);
-      }
-    }
-    const fresh = await this.#query(
-      this.#statements.insertFreshEvents,
-      [
-        JSON.stringify(
-          plan.events.map((event, ordinal) => ({
-            ordinal,
-            ...toEventRow(event, null, handlersByEvent.get(event.id) ?? [])
-          }))
-        ),
-        createdAt,
-        JSON.stringify(plan.deliveries),
-        JSON.stringify([...keyCounts].map(([key, count]) => ({ key, count }))),
-        wakeAt
-      ],
-      transaction
-    );
-    const insertedEventIds = new Set(
-      fresh.filter((row) => row["inserted"] === true).map((row) => row["id"])
-    );
-    let appendedDeliveryCount = readCount(fresh[0], "deliveries");
-    const remaining = plan.deliveries.filter(
-      (delivery) => !insertedEventIds.has(delivery.event_id)
-    );
-    if (remaining.length > 0) {
-      appendedDeliveryCount += await this.#appendToExistingEvents(
-        transaction,
-        plan,
-        fresh,
-        remaining,
-        handlersByEvent,
-        insertedEventIds,
-        createdAt,
-        wakeAt
-      );
-    }
-    const appendedEventIds = [];
-    const duplicateEventIds = [];
-    for (const { eventId, repeated } of plan.outcomes) {
-      (!repeated && insertedEventIds.has(eventId) ? appendedEventIds : duplicateEventIds).push(
-        eventId
-      );
-    }
-    return { appendedEventIds, duplicateEventIds, appendedDeliveryCount };
-  }
-  /**
-   * 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
-   * commit. In a transaction of this store, only the first append within {@link NOTIFICATION_INTERVAL_MS}
-   * does; the others leave the wake-up to {@link #wakeAfterCommit}, which runs once their transaction
-   * committed, so no committed delivery waits for the poll.
-   */
-  #wakeAt(deliveries, now, transaction) {
-    if (!this.#notifies || !deliveries.some((delivery) => Date.parse(delivery.available_at) <= now.getTime())) {
-      return null;
-    }
-    const own = this.#ownTransactions.get(transaction);
-    if (own !== void 0 && Date.now() - this.#lastNotificationAt < NOTIFICATION_INTERVAL_MS) {
-      own.wake = true;
-      return null;
-    }
-    this.#lastNotificationAt = Date.now();
-    return now.toISOString();
-  }
-  /**
-   * Wakes the dispatchers for a committed transaction whose appends sent no notification: at once when
-   * none was sent within {@link NOTIFICATION_INTERVAL_MS}, otherwise once when the interval ends. A
-   * wake-up already scheduled covers this transaction too, since it is sent after this commit. Nothing is
-   * sent once the store is closed or the `pg` pool behind it is ending: no dispatcher can be woken through
-   * it then, and the deliveries are found by polling.
-   */
-  #wakeAfterCommit() {
-    if (this.#trailingNotification !== void 0 || this.#closed) {
-      return;
-    }
-    this.#trailingNotification = setTimeout(
-      () => {
-        this.#trailingNotification = void 0;
-        if (this.#pool?.ending === true) {
-          return;
-        }
-        this.#lastNotificationAt = Date.now();
-        this.#query(this.#statements.notify, []).catch((error) => {
-          this.#logger.error(
-            `[PostgresEventStore](wakeAfterCommit) Waking the dispatchers failed, they find the deliveries when they poll | error=${error instanceof Error ? error.message : String(error)}`
-          );
-        });
-      },
-      Math.max(0, this.#lastNotificationAt + NOTIFICATION_INTERVAL_MS - Date.now())
-    );
+function listConditions(filters, alias) {
+  return [
+    ...filters.handler === void 0 ? [] : [`${alias}.handler = ${filters.handler}`],
+    ...filters.eventType === void 0 ? [] : [`event.type = ${filters.eventType}`],
+    ...filters.eventId === void 0 ? [] : [`${alias}.event_id = ${filters.eventId}`]
+  ];
+}
+var QueryStatements = class {
+  #names;
+  constructor(names) {
+    this.#names = names;
   }
-  /**
-   * Adds the deliveries of events the publishing statement found already stored. An event that already
-   * exists may be getting the same new handler from another transaction at this very moment. Whoever
-   * holds the event decides, so the freshness check of the insert sees what the other transaction
-   * committed, even if its delivery has completed since. An existing event that a purge removed
-   * meanwhile is inserted again (with the sequence reserved for it) instead of being skipped; its id is
-   * added to `insertedEventIds`. Returns how many deliveries were inserted.
-   */
-  async #appendToExistingEvents(transaction, plan, fresh, deliveries, handlersByEvent, insertedEventIds, createdAt, wakeAt) {
-    const sequences = new Map(
-      fresh.map((row) => [row["id"], row["sequence"]])
-    );
-    const reinserted = [];
-    let existing = plan.events.filter((event) => !insertedEventIds.has(event.id)).map(
-      (event) => toEventRow(event, sequences.get(event.id), handlersByEvent.get(event.id) ?? [])
-    );
-    while (existing.length > 0) {
-      const locked = new Set(
-        (await this.#query(
-          this.#statements.lockExistingEvents,
-          [JSON.stringify(existing.map((row) => row.id).sort())],
-          transaction
-        )).map((row) => row["id"])
-      );
-      const gone = existing.filter((row) => !locked.has(row.id));
-      if (gone.length > 0) {
-        const inserted2 = await this.#query(
-          this.#statements.insertEvents,
-          [JSON.stringify(gone), createdAt],
-          transaction
-        );
-        for (const row of inserted2) {
-          insertedEventIds.add(row["id"]);
-          reinserted.push(row["id"]);
-        }
-      }
-      existing = gone.filter((row) => !insertedEventIds.has(row.id));
-    }
-    const inserted = await this.#query(
-      this.#statements.insertDeliveries,
-      [JSON.stringify(deliveries), createdAt, JSON.stringify(reinserted), wakeAt],
-      transaction
-    );
-    return inserted.length;
+  /** Parameters: `[deliveryIdsJson, now]`. The dead rows are locked in id order first. */
+  get requeue() {
+    const deliveries = this.#names.deliveries;
+    return countChanged(`WITH dead AS MATERIALIZED (
+  SELECT delivery.id FROM ${deliveries} AS delivery
+  WHERE delivery.id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb))) AND delivery.status = 'dead'
+  ORDER BY delivery.id
+  FOR NO KEY UPDATE
+)
+UPDATE ${deliveries} AS delivery
+SET status = 'pending', attempts = 0, available_at = $2::timestamptz, updated_at = $2::timestamptz
+FROM dead
+WHERE delivery.id = dead.id AND delivery.status = 'dead'`);
   }
   /**
-   * Claims up to `limit` due deliveries, normally with one statement
-   * ({@link PostgresStatements.claimLanes}): from the lanes this owner already holds, then from free lanes
-   * it takes in the same statement, recording the batch in the lane rows. A claim that would have to take
-   * over a lane whose previous holder still runs deliveries under an expired lease continues in a
-   * transaction that charges their lost attempts first, taking free lanes a few at a time (4, 8, 16, ...);
-   * so does a claim whose statement kept seeing a lane it holds change under it, and one that came up
-   * short with more free lanes left than it looked at. The step that fails after
-   * the first one has recorded deliveries returns those instead of failing: a recorded delivery nobody
-   * received would be held for a whole lease. See {@link PostgresStatements.claim} for the rules a delivery
-   * must satisfy.
+   * Builds the filtered, creation-ordered listing. A delivery is `processing`
+   * while its row exists as `pending` and its lane lists its id; its attempt
+   * count, lease owner and lease expiry then come from the claim and the lane.
+   * Records of the completion history (when kept) are listed as `completed`.
    */
-  claim(request) {
-    if (request.handlers.length === 0 || !(request.limit > 0)) {
-      return Promise.resolve([]);
+  listDeliveries(query) {
+    const { parameters, filters, limit } = bindListFilters(query);
+    const current = this.#currentDeliveries(filters);
+    const includeHistory = this.#names.completionHistory && (query.status === void 0 || query.status === "completed");
+    if (!includeHistory) {
+      return {
+        sql: `${current}
+ORDER BY delivery.created_at, delivery.id
+LIMIT ${limit}`,
+        parameters
+      };
     }
-    return this.#serialized(request.leaseOwner, () => this.#claim(request));
+    const history = this.#completionHistory(filters);
+    return {
+      sql: `SELECT * FROM (
+${current}
+UNION ALL
+${history}
+) AS listed
+ORDER BY created_at, delivery_id
+LIMIT ${limit}`,
+      parameters
+    };
+  }
+  /** The deliveries that still exist, with a running one reported as `processing`. */
+  #currentDeliveries(filters) {
+    const inFlight = `(delivery.status = 'pending' AND delivery.id = ANY (lane.in_flight))`;
+    const whereCurrent = [
+      ...listConditions(filters, "delivery"),
+      ...filters.status === void 0 ? [] : [
+        `(CASE WHEN ${inFlight} THEN 'processing' ELSE delivery.status END) = ${filters.status}`
+      ]
+    ];
+    return `SELECT delivery.id AS delivery_id, delivery.handler,
+  CASE WHEN ${inFlight} THEN 'processing' ELSE delivery.status END AS status,
+  (delivery.attempts + CASE WHEN ${inFlight} THEN 1 ELSE 0 END)::int AS attempts,
+  ${isoText("delivery.available_at")} AS available_at,
+  CASE WHEN ${inFlight} THEN lane.lease_owner END AS lease_owner,
+  CASE WHEN ${inFlight} THEN ${isoText("lane.lease_expires_at")} END AS lease_expires_at,
+  delivery.last_error::text AS last_error,
+  ${isoText("delivery.created_at")} AS created_at,
+  ${isoText("delivery.updated_at")} AS updated_at,
+  ${isoText("delivery.completed_at")} AS completed_at,
+  ${eventColumns("event")}
+FROM ${this.#names.deliveries} AS delivery
+JOIN ${this.#names.lanes} AS lane ON lane.lane = delivery.lane
+JOIN ${this.#names.events} AS event ON event.id = delivery.event_id
+${whereCurrent.length === 0 ? "" : `WHERE ${whereCurrent.join(" AND ")}`}`;
+  }
+  /** The completion history records, listed as `completed`. */
+  #completionHistory(filters) {
+    const common = (alias) => listConditions(filters, alias);
+    return `SELECT done.id AS delivery_id, done.handler, 'completed' AS status, done.attempts,
+  ${isoText("done.available_at")} AS available_at,
+  NULL AS lease_owner,
+  NULL AS lease_expires_at,
+  NULL AS last_error,
+  ${isoText("done.created_at")} AS created_at,
+  ${isoText("done.completed_at")} AS updated_at,
+  ${isoText("done.completed_at")} AS completed_at,
+  ${eventColumns("event")}
+FROM ${this.#names.completions} AS done
+JOIN ${this.#names.events} AS event ON event.id = done.event_id
+${common("done").length === 0 ? "" : `WHERE ${common("done").join(" AND ")}`}`;
   }
   /**
-   * 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).
+   * Counts of rows by stored status (`pending` includes running deliveries;
+   * `completed` rows exist only after an upgrade from 0.1.0). Each count is
+   * answered from a partial index.
    */
-  #serialized(owner, work) {
-    const previous = this.#ownerQueues.get(owner) ?? Promise.resolve();
-    const run = previous.then(work, work);
-    const tail = run.then(
-      () => void 0,
-      () => void 0
-    );
-    this.#ownerQueues.set(owner, tail);
-    void tail.then(() => {
-      if (this.#ownerQueues.get(owner) === tail) {
-        this.#ownerQueues.delete(owner);
-      }
-    });
-    return run;
-  }
-  async #claim(request) {
-    if (this.#unreconciled.has(request.leaseOwner) && !await this.#reconcile(request.leaseOwner)) {
-      throw new Error(
-        `[PostgresEventStore](claim) Giving back unreturned deliveries still fails, so no claim is made | owner=${request.leaseOwner}`
-      );
-    }
-    const heldFirst = this.#drainingOwners.has(request.leaseOwner);
-    let rows;
-    try {
-      rows = await this.#claimInOneStatement(
-        request,
-        heldFirst ? this.#statements.claimHeldLanes : this.#statements.claimLanes
-      );
-    } catch (error) {
-      await this.#reconcile(request.leaseOwner);
-      throw error;
-    }
-    const heldLanes = new Set(JSON.parse(rows[0]["examined_lanes"]));
-    const claimed = this.#takeClaimed(rows, request.leaseOwner);
-    if (heldFirst && claimed.length < request.limit && rows[0]["stale"] !== true) {
-      try {
-        rows = await this.#claimInOneStatement(
-          { ...request, limit: request.limit - claimed.length },
-          this.#statements.claimLanes
-        );
-      } catch (error) {
-        await this.#reconcile(request.leaseOwner);
-        if (claimed.length === 0) {
-          this.#drainingOwners.delete(request.leaseOwner);
-          throw error;
-        }
-        this.#logger.error(
-          `[PostgresEventStore](claim) Claiming from free lanes failed, returning the deliveries already claimed | claimed=${claimed.length} | error=${error instanceof Error ? error.message : String(error)}`
-        );
-        return this.#handOutInDueOrder(claimed, request, heldLanes);
-      }
-      claimed.push(...this.#takeClaimed(rows, request.leaseOwner));
-    }
-    if (claimed.length < request.limit && (rows[0]["takeover_waiting"] === true || rows[0]["unexamined_free_lanes"] === true || rows[0]["stale"] === true)) {
-      try {
-        const more = await this.#claimMore(request, claimed.length);
-        this.#handOut(more, request.leaseOwner);
-        claimed.push(...more);
-      } catch (error) {
-        await this.#reconcile(request.leaseOwner);
-        if (claimed.length === 0) {
-          throw error;
-        }
-        this.#logger.error(
-          `[PostgresEventStore](claim) Taking more lanes failed, returning the deliveries already claimed | claimed=${claimed.length} | error=${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-    return this.#handOutInDueOrder(claimed, request, heldLanes);
+  get countByStatus() {
+    const deliveries = this.#names.deliveries;
+    return ["pending", "dead", "completed"].map(
+      (status) => `SELECT '${status}' AS status, count(*)::text AS count FROM ${deliveries} WHERE status = '${status}'`
+    ).join("\nUNION ALL\n");
   }
-  /** The deliveries a claim statement picked, registered as handed out to `leaseOwner`. */
-  #takeClaimed(rows, leaseOwner) {
-    const claimed = rows.filter((row) => row["delivery_id"] !== null);
-    this.#forgetFinished(rows[0], leaseOwner, claimed);
-    this.#handOut(claimed, leaseOwner);
-    return claimed;
+  /** Deliveries that are running: listed by a lane and still pending as rows. */
+  get countRunning() {
+    return `SELECT count(*)::text AS count
+FROM ${this.#names.lanes} AS lane
+CROSS JOIN LATERAL unnest(lane.in_flight) AS flying (id)
+JOIN ${this.#names.deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'`;
   }
-  #handOutInDueOrder(claimed, request, heldLanes) {
-    if (claimed.length >= request.limit && claimed.every((row) => heldLanes.has(readCount(row, "lane")))) {
-      this.#drainingOwners.add(request.leaseOwner);
-    } else {
-      this.#drainingOwners.delete(request.leaseOwner);
-    }
-    claimed.sort(compareDue);
-    return claimed.map((row) => mapClaimedDelivery(row, request.leaseExpiresAt));
+  get countCompletionHistory() {
+    return `SELECT count(*)::text AS count FROM ${this.#names.completions}`;
   }
   /**
-   * Runs `statement` ({@link PostgresStatements.claimLanes} or its held-lane form), again when it reports that it waited for a lane lock and
-   * read deliveries with an older snapshot than the lane it got. A held lane is only locked by an
-   * operation of its own owner (another claim, a reschedule), so a few attempts are enough.
+   * Oldest instant at which a delivery became claimable: `available_at` of a
+   * pending delivery that nobody runs, or the lease expiry of a lane that runs
+   * deliveries. Parameters: `[now]`.
    */
-  async #claimInOneStatement(request, statement) {
-    const parameters = [
-      request.now.toISOString(),
-      JSON.stringify(request.handlers),
-      request.limit,
-      request.leaseOwner,
-      request.leaseExpiresAt.toISOString(),
-      this.#generation(request.leaseOwner).toString()
-    ];
-    let rows = await this.#query(statement, parameters);
-    for (let attempt = 1; attempt < MAXIMUM_STALE_CLAIM_ATTEMPTS && rows[0]["stale"] === true; attempt += 1) {
-      rows = await this.#query(statement, parameters);
-    }
-    return rows;
+  get oldestDue() {
+    const deliveries = this.#names.deliveries;
+    const lanes = this.#names.lanes;
+    return `SELECT ${isoText("min(due.due_at)")} AS oldest_due_at FROM (
+  SELECT waiting.available_at AS due_at
+  FROM ${lanes} AS lane
+  CROSS JOIN LATERAL (
+    SELECT delivery.available_at FROM ${deliveries} AS delivery
+    WHERE delivery.lane = lane.lane AND delivery.status = 'pending'
+      AND delivery.available_at <= $1::timestamptz AND delivery.id <> ALL (lane.in_flight)
+    ORDER BY delivery.available_at LIMIT 1
+  ) AS waiting
+  UNION ALL
+  SELECT lane.lease_expires_at AS due_at
+  FROM ${lanes} AS lane
+  WHERE lane.lease_expires_at <= $1::timestamptz AND NOT ${noRunningDelivery(this.#names, "lane")}
+) AS due`;
+  }
+};
+
+// src/statements-setup.ts
+var SetupStatements = class {
+  #names;
+  constructor(names) {
+    this.#names = names;
   }
   /**
-   * Second step of {@link PostgresEventStore.claim}, in one transaction: takes free lanes a few at a
-   * time, lanes to take over included (their lost attempts are charged first), and records the batch.
-   * `alreadyClaimed` deliveries of the first step are in flight, so they are not picked again.
+   * Lock advisory key text for {@link setupLock}. It is derived from the schema
+   * name only, so stores with different table prefixes in one schema also
+   * serialize their `CREATE SCHEMA IF NOT EXISTS`, which is not race-free.
    */
-  async #claimMore(request, alreadyClaimed) {
-    const now = request.now.toISOString();
-    const leaseExpiresAt = request.leaseExpiresAt.toISOString();
-    const handlers = JSON.stringify(request.handlers);
-    const generation = this.#generation(request.leaseOwner).toString();
-    return this.#executor.transaction(async (transaction) => {
-      const claimed = [];
-      const remaining = () => request.limit - alreadyClaimed - claimed.length;
-      const takenLanes = /* @__PURE__ */ new Set();
-      for (let laneCount = INITIAL_LANES_PER_ROUND; remaining() > 0; ) {
-        const taken = await this.#query(
-          this.#statements.takeFreeLanes,
-          [now, handlers, laneCount, request.leaseOwner, leaseExpiresAt, generation],
-          transaction
-        );
-        if (taken.length === 0) {
-          break;
-        }
-        const lanes = taken.map((row) => readCount(row, "lane"));
-        for (const lane of lanes) {
-          takenLanes.add(lane);
-        }
-        claimed.push(
-          ...await this.#pickDeliveries(
-            [now, handlers, remaining(), JSON.stringify(lanes)],
-            transaction
-          )
-        );
-        laneCount *= 2;
-      }
-      await this.#recordClaim(claimed, takenLanes, request, transaction);
-      return claimed;
-    });
+  get setupLockKey() {
+    return `relaybus:${this.#names.schema}`;
   }
   /**
-   * The generation of the owner's claim statements. It only grows, also across restarts (it starts at the
-   * clock), and a reconciliation moves it up, which fences off every earlier statement still in flight.
+   * Whether the lane table carries `marker` as its comment, that is whether the schema statements
+   * that produce that marker already ran. Takes no table lock. Parameters: `[marker]`.
    */
-  #generation(owner, advance = false) {
-    const current = this.#generations.get(owner) ?? BigInt(Date.now());
-    const next = advance ? current + 1n > BigInt(Date.now()) ? current + 1n : BigInt(Date.now()) : current;
-    this.#generations.set(owner, next);
-    return next;
+  get schemaCurrent() {
+    return `SELECT EXISTS (
+  SELECT 1 FROM pg_catalog.pg_class AS c
+  JOIN pg_catalog.pg_namespace AS n ON n.oid = c.relnamespace
+  JOIN pg_catalog.pg_description AS d
+    ON d.objoid = c.oid AND d.classoid = 'pg_catalog.pg_class'::regclass AND d.objsubid = 0
+  WHERE n.nspname = '${this.#names.schema}' AND c.relname = '${this.#names.lanesTableName}' AND d.description = $1::text
+) AS current`;
   }
-  /** 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.#handedOut.delete(handedOutKey(lease.deliveryId, lease.leaseToken));
-    return result;
+  get setupLock() {
+    return "SELECT pg_advisory_xact_lock(hashtextextended($1::text, 0))";
   }
-  /** Remembers the claims handed to the caller of `claim` until they are settled. */
-  #handOut(rows, leaseOwner) {
-    for (const row of rows) {
-      const claim = mapClaimedDelivery(row, /* @__PURE__ */ new Date(0));
-      this.#handedOut.set(handedOutKey(claim.deliveryId, claim.leaseToken), {
-        owner: leaseOwner,
-        deliveryId: claim.deliveryId,
-        ...parseLeaseToken(claim.leaseToken)
-      });
+};
+
+// src/statements.ts
+var PostgresStatements = class {
+  setup;
+  append;
+  lanes;
+  claim;
+  completion;
+  queries;
+  purge;
+  constructor(names) {
+    this.setup = new SetupStatements(names);
+    this.append = new AppendStatements(names);
+    this.lanes = new LaneStatements(names);
+    this.claim = new ClaimStatements(names);
+    this.completion = new CompletionStatements(names);
+    this.queries = new QueryStatements(names);
+    this.purge = new PurgeStatements(names);
+  }
+};
+
+// src/postgres-event-store.ts
+var PostgresEventStore = class {
+  #state;
+  #appender;
+  #claims;
+  #completion;
+  #maintenance;
+  #owned = new OwnedConnections();
+  constructor(options) {
+    const { purgeBatchSize, wakeUp, queryOptions } = resolveStoreSettings(options);
+    const names = resolvePostgresNames(options);
+    const statements = new PostgresStatements(names);
+    const schemaStatements = createPostgresSchemaStatements(options);
+    const logger = options.logger ?? console;
+    const { executor, pool, ownedPool } = connect(options, { logger, owned: this.#owned });
+    const state = {
+      executor,
+      statements,
+      schemaStatements,
+      setupLockKey: statements.setup.setupLockKey,
+      schemaMarker: postgresSchemaMarker(schemaStatements.slice(0, -1)),
+      purgeBatchSize,
+      completionHistory: names.completionHistory,
+      logger,
+      queryOptions,
+      notifies: wakeUp === "notify",
+      query: ({ sql, parameters, transaction }) => executor.query(sql, parameters, transaction, queryOptions),
+      handedOut: new HandedOutLedger(),
+      unreconciled: /* @__PURE__ */ new Set(),
+      generations: /* @__PURE__ */ new Map(),
+      drainingOwners: /* @__PURE__ */ new Set(),
+      ownedPool,
+      pool,
+      notificationChannel: names.notificationChannel,
+      lastNotificationAt: Number.NEGATIVE_INFINITY,
+      trailingNotification: void 0,
+      closed: false,
+      ownTransactions: /* @__PURE__ */ new Map()
+    };
+    this.#state = state;
+    this.#appender = new PostgresAppend(state);
+    this.#claims = new PostgresClaims(state);
+    this.#completion = new PostgresCompletion(state);
+    this.#maintenance = new PostgresMaintenance(state);
+  }
+  /**
+   * Creates the schema, tables and indexes if they do not exist. Safe to call
+   * from many processes at once: a transaction-scoped advisory lock serializes
+   * the DDL, so racing `CREATE TABLE IF NOT EXISTS` statements cannot collide.
+   * When the lane table already carries the marker of the current statements
+   * ({@link postgresSchemaMarker}) nothing runs and no table is locked, so instances
+   * that start next to running dispatchers cannot deadlock with their claims.
+   * Skip it (`setupStore: false`) when a migration tool applies
+   * `createPostgresSchemaSql()` instead.
+   */
+  async setup() {
+    if (await this.#schemaIsCurrent()) {
+      return;
     }
+    await this.#state.executor.transaction(async (transaction) => {
+      await this.#state.executor.query(
+        this.#state.statements.setup.setupLock,
+        [this.#state.setupLockKey],
+        transaction
+      );
+      if (await this.#schemaIsCurrent(transaction)) {
+        return;
+      }
+      for (const statement of this.#state.schemaStatements) {
+        await this.#state.executor.query(statement, [], transaction);
+      }
+    });
+  }
+  async #schemaIsCurrent(transaction) {
+    const rows = await this.#state.executor.query(
+      this.#state.statements.setup.schemaCurrent,
+      [this.#state.schemaMarker],
+      transaction
+    );
+    return rows[0]["current"] === true;
   }
   /**
-   * Drops the registrations of the owner's held lanes whose delivery no longer runs there
-   * (completed inside the caller's transaction, deleted, or listed no more). Registrations of
-   * lanes this claim did not see stay: their tokens may still be valid.
+   * Runs `work` in a transaction of the executor. With `options.timeoutMs` (from `bus.transaction`)
+   * the server holds the transaction to the budget: `statement_timeout`, and for executors with
+   * `sessionTimeouts` (`pg`) also `idle_in_transaction_session_timeout` and, on PostgreSQL 17+,
+   * `transaction_timeout`, all scoped to the transaction. An executor with `transactionWithBudget`
+   * (`PgExecutor`) sets them with `BEGIN`, so the budget costs no round trip; on a pool the store
+   * created they are kept per connection and sent only when the connection does not have them yet.
    */
-  #forgetFinished(row, leaseOwner, claimed) {
-    const heldLanes = new Set(JSON.parse(row["examined_lanes"]));
-    const running = /* @__PURE__ */ new Set([
-      ...JSON.parse(row["running_ids"]),
-      ...claimed.map((picked) => picked["delivery_id"])
-    ]);
-    for (const [key, entry] of this.#handedOut) {
-      if (entry.owner === leaseOwner && heldLanes.has(entry.lane) && !running.has(entry.deliveryId)) {
-        this.#handedOut.delete(key);
+  async transaction(work, options) {
+    const own = { wake: false };
+    const tracked = async (transaction) => {
+      this.#state.ownTransactions.set(transaction, own);
+      try {
+        return await work(transaction);
+      } finally {
+        this.#state.ownTransactions.delete(transaction);
       }
+    };
+    const result = await (options === void 0 ? this.#state.executor.transaction(tracked) : inBudgetedTransaction(this.#state, { work: tracked, timeoutMs: options.timeoutMs }));
+    if (own.wake) {
+      this.#appender.wakeAfterCommit();
     }
+    return result;
   }
   /**
-   * After a claim failed, possibly after the database recorded its batch: gives back the recorded
-   * deliveries that were never handed out, keeping exactly the claims handed out and not settled.
-   * A failure is remembered and retried before the owner's next claim: other deliveries keep
-   * renewing the lane, so an unreturned one would otherwise never be recovered.
+   * Writes the entries in `transaction`, normally with one statement
+   * (`AppendStatements.insertFreshEvents`): keyed events reserve their sequence numbers (locking
+   * the key rows in sorted order, so publishers cannot deadlock inside one call), then the new events and
+   * their deliveries are inserted, ordered by primary key, and one notification wakes the dispatchers
+   * when a delivery is due now. Events that already existed get their missing handlers' deliveries in
+   * two more statements. Two transactions that append keys in opposite order across several calls can
+   * still deadlock (40P01); the database rolls one back and the caller retries.
+   * A duplicate event id still consumes a sequence number; gaps are harmless
+   * because only the order of sequences matters.
    */
-  async #reconcile(leaseOwner) {
-    const generation = this.#generation(leaseOwner, true);
-    const handedOut = [...this.#handedOut.values()].filter((entry) => entry.owner === leaseOwner).map(({ deliveryId, lane, epoch, claims }) => ({ id: deliveryId, lane, epoch, claims }));
-    try {
-      await this.#query(this.#statements.reconcileClaims, [
-        leaseOwner,
-        JSON.stringify(handedOut),
-        generation.toString()
-      ]);
-      this.#unreconciled.delete(leaseOwner);
-      return true;
-    } catch (error) {
-      this.#unreconciled.add(leaseOwner);
-      this.#logger.error(
-        `[PostgresEventStore](reconcile) Giving back unreturned deliveries failed, it is retried before the next claim | owner=${leaseOwner} | error=${error instanceof Error ? error.message : String(error)}`
-      );
-      return false;
-    }
-  }
-  /** Fast claim, then the slow one when the fast window was full of blocked followers. */
-  async #pickDeliveries(parameters, transaction) {
-    const limit = parameters[2];
-    const fastRows = await this.#query(this.#statements.claim, parameters, transaction);
-    const picked = fastRows.filter((row) => row["delivery_id"] !== null);
-    if (picked.length < limit && fastRows[0]["window_saturated"] === true) {
-      const slowRows = await this.#query(
-        this.#statements.claimBehindBlockedKeys,
-        parameters,
-        transaction
-      );
-      const pickedIds = new Set(picked.map((row) => row["delivery_id"]));
-      picked.push(
-        ...slowRows.filter(
-          (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 picked;
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  append(transaction, entries, now) {
+    return this.#appender.append(transaction, { entries, now });
   }
-  /** Writes the picked ids into their lane rows and frees the lanes that picked nothing. */
-  async #recordClaim(claimed, lanes, request, transaction) {
-    const idsByLane = /* @__PURE__ */ new Map();
-    for (const row of claimed) {
-      const lane = readCount(row, "lane");
-      idsByLane.set(lane, [...idsByLane.get(lane) ?? [], row["delivery_id"]]);
-    }
-    const idleLanes = [...lanes].filter((lane) => !idsByLane.has(lane));
-    if (idsByLane.size === 0 && idleLanes.length === 0) {
-      return;
-    }
-    await this.#query(
-      this.#statements.recordClaim,
-      [
-        JSON.stringify([...idsByLane].map(([lane, ids]) => ({ lane, ids }))),
-        JSON.stringify(idleLanes),
-        request.leaseOwner,
-        request.leaseExpiresAt.toISOString()
-      ],
-      transaction
-    );
+  /**
+   * Claims up to `limit` due deliveries, normally with one statement
+   * (`LaneStatements.claimLanes`): from the lanes this owner already holds, then from free lanes
+   * it takes in the same statement, recording the batch in the lane rows. A claim that would have to take
+   * over a lane whose previous holder still runs deliveries under an expired lease continues in a
+   * transaction that charges their lost attempts first, taking free lanes a few at a time (4, 8, 16, ...);
+   * so does a claim whose statement kept seeing a lane it holds change under it, and one that came up
+   * short with more free lanes left than it looked at. The step that fails after
+   * the first one has recorded deliveries returns those instead of failing: a recorded delivery nobody
+   * received would be held for a whole lease. See `ClaimStatements.claim` for the rules a delivery
+   * must satisfy.
+   */
+  claim(request) {
+    return this.#claims.claim(request);
   }
   extendLease(lease, leaseExpiresAt) {
-    return this.#whenIssued(
-      lease,
-      (held) => this.#changed(this.#statements.extendLease, [
-        lease.deliveryId,
-        held.lane,
-        held.epoch,
-        held.claims,
-        leaseExpiresAt.toISOString()
-      ])
-    );
+    return Promise.resolve(this.#completion.extendLease({ lease, leaseExpiresAt }));
   }
-  async complete(lease, now, transaction) {
-    return (await this.#completeLeases([lease], now, transaction))[0];
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
+  complete(lease, now, transaction) {
+    return this.#completion.complete(lease, { now, transaction });
   }
   completeMany(leases, now) {
-    return this.#completeLeases(leases, now, void 0);
+    return this.#completion.completeMany(leases, now);
   }
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   reschedule(lease, availableAt, error, now) {
-    return this.#settled(
-      lease,
-      this.#whenIssued(
+    return Promise.resolve(
+      this.#completion.changeClaim({
         lease,
-        (held) => this.#changed(this.#statements.reschedule, [
-          lease.deliveryId,
-          held.lane,
-          held.epoch,
-          held.claims,
-          availableAt.toISOString(),
-          JSON.stringify(error),
-          now.toISOString()
-        ])
-      )
+        change: { kind: "reschedule", availableAt, error, now }
+      })
     );
   }
+  // eslint-disable-next-line relaybus/max-two-params -- EventStore port signature
   bury(lease, error, now) {
-    return this.#settled(
-      lease,
-      this.#whenIssued(
-        lease,
-        (held) => this.#changed(this.#statements.bury, [
-          lease.deliveryId,
-          held.lane,
-          held.epoch,
-          held.claims,
-          JSON.stringify(error),
-          now.toISOString()
-        ])
-      )
+    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.#settled(
-      lease,
-      this.#whenIssued(
-        lease,
-        (held) => this.#changed(this.#statements.release, [
-          lease.deliveryId,
-          held.lane,
-          held.epoch,
-          held.claims,
-          now.toISOString()
-        ])
-      )
+    return Promise.resolve(
+      this.#completion.changeClaim({ lease, change: { kind: "release", now } })
     );
   }
   /**
@@ -2329,38 +3033,33 @@ var PostgresEventStore = class {
    * wakes its own dispatcher).
    */
   async watchNewDeliveries(listener) {
-    if (this.#pool === void 0 || !this.#notifies) {
+    if (this.#state.pool === void 0 || !this.#state.notifies) {
       return void 0;
     }
-    const options = this.#pool.options;
+    const options = this.#state.pool.options;
     const watcher = new NotificationListener(
       async () => {
         const client = new Client(options);
+        this.#owned.track(client);
         await client.connect();
         return client;
       },
-      this.#notificationChannel,
+      this.#state.notificationChannel,
       listener,
-      this.#logger
+      this.#state.logger
     );
     await watcher.start();
     return () => watcher.close();
   }
   /** Frees the lanes `leaseOwner` holds that run no delivery, so other workers need not wait for the lease to expire. */
-  async relinquish(leaseOwner) {
-    await this.#query(this.#statements.relinquish, [leaseOwner]);
+  relinquish(leaseOwner) {
+    return this.#maintenance.relinquish(leaseOwner);
   }
-  async listDeliveries(query) {
-    const statement = this.#statements.listDeliveries(query);
-    const rows = await this.#executor.query(statement.sql, statement.parameters);
-    return rows.map(mapDeliveryRecord);
+  listDeliveries(query) {
+    return this.#maintenance.listDeliveries(query);
   }
-  async requeue(deliveryIds, now) {
-    const rows = await this.#query(this.#statements.requeue, [
-      JSON.stringify(deliveryIds),
-      now.toISOString()
-    ]);
-    return readCount(rows[0], "count");
+  requeue(deliveryIds, now) {
+    return this.#maintenance.requeue(deliveryIds, now);
   }
   /**
    * Deletes purgeable deliveries in batches of `purgeBatchSize`, one short
@@ -2371,237 +3070,62 @@ var PostgresEventStore = class {
    * was subscribed. Events that a concurrent publish is attaching a delivery
    * to are skipped and kept.
    */
-  async purge(request) {
-    const total = { deletedDeliveries: 0, deletedEvents: 0 };
-    const batches = [
-      [
-        this.#statements.purgeCompletedBatch(),
-        request.completedBefore,
-        this.#statements.deleteOrphanEventsWithoutCompletion
-      ],
-      [
-        this.#statements.purgeDeadBatch(),
-        request.deadBefore,
-        this.#statements.deleteOrphanEventsWithoutCompletion
-      ]
-    ];
-    if (this.#completionHistory) {
-      batches.push([
-        this.#statements.purgeCompletionHistoryBatch(),
-        request.completedBefore,
-        this.#statements.deleteOrphanEventsWithoutCompletion
-      ]);
-    }
-    for (const [sql, cutoff, deleteOrphans] of batches) {
-      if (cutoff === void 0) {
-        continue;
-      }
-      let deletedInBatch = this.#purgeBatchSize;
-      while (deletedInBatch === this.#purgeBatchSize) {
-        const batch = await this.#purgeBatch(sql, cutoff, deleteOrphans);
-        deletedInBatch = batch.deletedDeliveries;
-        total.deletedDeliveries += batch.deletedDeliveries;
-        total.deletedEvents += batch.deletedEvents;
-      }
-    }
-    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(
-        this.#statements.lockOrphanEventsBatch,
-        this.#statements.deleteOrphanEventsWithoutCompletion,
-        orphanCutoff,
-        false
-      );
-    }
-    if (request.completedBefore !== void 0) {
-      total.deletedEvents += await this.#purgeOrphanEvents(
-        this.#statements.lockCompletedOrphanEventsBatch,
-        this.#statements.deleteExpiredCompletedOrphanEvents,
-        request.completedBefore,
-        true
-      );
-    }
-    return total;
-  }
-  async statistics(now) {
-    const stored = { pending: 0, dead: 0, completed: 0 };
-    for (const row of await this.#query(this.#statements.countByStatus, [])) {
-      stored[row["status"]] = readCount(row, "count");
-    }
-    const [running] = await this.#query(this.#statements.countRunning, []);
-    const processing = readCount(running, "count");
-    let completed = stored["completed"];
-    if (this.#completionHistory) {
-      const [history] = await this.#query(this.#statements.countCompletionHistory, []);
-      completed += readCount(history, "count");
-    }
-    const oldestDue = await this.#query(this.#statements.oldestDue, [now.toISOString()]);
-    return {
-      // The counts come from separate statements; a delivery that finishes in between must not make this negative.
-      pending: Math.max(0, stored["pending"] - processing),
-      processing,
-      completed,
-      dead: stored["dead"],
-      oldestDueAt: mapOldestDueAt(oldestDue)
-    };
-  }
-  /** Ends the pool this store created from `connectionString`. Pools and executors you passed in stay open. */
-  async close() {
-    this.#closed = true;
-    clearTimeout(this.#trailingNotification);
-    this.#trailingNotification = void 0;
-    const pool = this.#ownedPool;
-    this.#ownedPool = void 0;
-    await pool?.end();
-  }
-  /** Runs a statement of {@link PostgresStatements} whose text never changes, prepared when `preparedStatements` is on. */
-  #query(sql, parameters, transaction) {
-    return this.#executor.query(sql, parameters, transaction, this.#queryOptions);
+  purge(request) {
+    return this.#maintenance.purge(request);
   }
-  async #changed(sql, parameters) {
-    const rows = await this.#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);
+  statistics(now) {
+    return this.#maintenance.statistics(now);
   }
   /**
-   * 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
-   * by position, so two leases of one delivery (a stale and a current one) get
-   * their own answers; a lease listed twice completes once, at its first position.
+   * Ends the pool this store created from `connectionString`. Pools and executors you passed in stay
+   * open. Once `options.signal` aborts (the shutdown deadline passed), the connections the store opened
+   * itself are destroyed: queries still running on them fail at once instead of holding the shutdown.
    */
-  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 completed = /* @__PURE__ */ new Set();
-    if (issued.length > 0) {
-      const rows = await this.#query(
-        this.#statements.complete,
-        [JSON.stringify(issued), now.toISOString()],
-        transaction
-      );
-      for (const row of rows) {
-        completed.add(readCount(row, "ord"));
-      }
-    }
-    if (transaction === void 0) {
-      for (const lease of leases) {
-        this.#handedOut.delete(handedOutKey(lease.deliveryId, lease.leaseToken));
-      }
+  async close(options = {}) {
+    this.#state.closed = true;
+    this.#state.trailingNotification?.();
+    this.#state.trailingNotification = void 0;
+    const pool = this.#state.ownedPool;
+    this.#state.ownedPool = void 0;
+    const { signal } = options;
+    const force = () => this.#owned.destroyAll();
+    if (signal?.aborted === true) {
+      force();
     }
-    return leases.map((_, ord) => completed.has(ord));
-  }
-  async #purgeOrphanEvents(lockStatement, deleteStatement, cutoff, recheckCutoff) {
-    let deletedEvents = 0;
-    let removedInBatch = this.#purgeBatchSize;
-    while (removedInBatch === this.#purgeBatchSize) {
-      removedInBatch = await this.#executor.transaction(async (transaction) => {
-        const locked = await this.#query(
-          lockStatement,
-          [cutoff.toISOString(), this.#purgeBatchSize],
-          transaction
-        );
-        const ids = JSON.stringify(locked.map((row) => row["id"]));
-        const removed = await this.#query(
-          deleteStatement,
-          recheckCutoff ? [ids, cutoff.toISOString()] : [ids],
-          transaction
-        );
-        return readCount(removed[0], "count");
-      });
-      deletedEvents += removedInBatch;
+    signal?.addEventListener("abort", force, { once: true });
+    try {
+      await pool?.end();
+    } finally {
+      signal?.removeEventListener("abort", force);
     }
-    return deletedEvents;
   }
-  async #purgeBatch(sql, cutoff, deleteOrphans) {
-    return this.#executor.transaction(async (transaction) => {
-      const deleted = await this.#query(
-        sql,
-        [cutoff.toISOString(), this.#purgeBatchSize],
-        transaction
-      );
-      if (deleted.length === 0) {
-        return { deletedDeliveries: 0, deletedEvents: 0 };
-      }
-      const eventIds = JSON.stringify([
-        ...new Set(deleted.map((row) => row["event_id"]))
-      ]);
-      const locked = await this.#query(this.#statements.lockEvents, [eventIds], transaction);
-      const removed = await this.#query(
-        deleteOrphans,
-        [JSON.stringify(locked.map((row) => row["id"]))],
-        transaction
+};
+function connect(options, { logger, owned }) {
+  if (options.executor !== void 0) {
+    return { executor: options.executor, pool: void 0, ownedPool: void 0 };
+  }
+  const pool = options.pool ?? new Pool({
+    ...options.poolConfig,
+    connectionString: options.connectionString,
+    Client: owned.clientClass()
+  });
+  let ownedPool;
+  if (options.pool === void 0) {
+    const poolLogger = options.logger ?? console;
+    pool.on("error", (error) => {
+      poolLogger.error(
+        `[PostgresEventStore](connect) Idle connection failed, the pool replaces it | error=${error.message}`
       );
-      return { deletedDeliveries: deleted.length, deletedEvents: readCount(removed[0], "count") };
     });
+    ownedPool = pool;
   }
-};
-function planAppend(entries) {
-  const events = [];
-  const deliveries = [];
-  const outcomes = [];
-  const seenEventIds = /* @__PURE__ */ new Set();
-  const seenDeliveries = /* @__PURE__ */ new Set();
-  for (const { event, deliveries: newDeliveries } of entries) {
-    const repeated = seenEventIds.has(event.id);
-    seenEventIds.add(event.id);
-    outcomes.push({ eventId: event.id, repeated });
-    if (!repeated) {
-      events.push(event);
-    }
-    for (const delivery of newDeliveries) {
-      const identity = `${event.id}\0${delivery.handler}`;
-      if (!seenDeliveries.has(identity)) {
-        seenDeliveries.add(identity);
-        deliveries.push({
-          id: delivery.id,
-          event_id: event.id,
-          handler: delivery.handler,
-          available_at: delivery.availableAt.toISOString()
-        });
-      }
-    }
-  }
-  return { events, deliveries, outcomes };
-}
-function toEventRow(event, sequence, handlers) {
-  return {
-    id: event.id,
-    type: event.type,
-    source: event.source,
-    key: event.key,
-    sequence,
-    payload: event.payload,
-    headers: event.headers,
-    correlation_id: event.correlationId,
-    causation_id: event.causationId,
-    occurred_at: event.occurredAt.toISOString(),
-    handlers
-  };
-}
-function compareSequence(left, right) {
-  const first = BigInt(left["sequence"] ?? 0);
-  const second = BigInt(right["sequence"] ?? 0);
-  return Number(first > second) - Number(first < second);
-}
-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);
+  const executor = new PgExecutor(pool, {
+    logger,
+    sessionBudget: ownedPool !== void 0 && options.preparedStatements !== false
+  });
+  return { executor, pool, ownedPool };
 }
 
-export { PgExecutor, PostgresEventStore, createPostgresSchemaSql, createPostgresSchemaStatements, resolvePostgresNames };
+export { PgExecutor, PostgresEventStore, ReconcileFailedError, createPostgresSchemaSql, createPostgresSchemaStatements, resolvePostgresNames };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map