@relaybus/postgres 0.1.0 → 0.2.0

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/pg-executor.ts","../src/identifiers.ts","../src/names.ts","../src/sql-fragments.ts","../src/schema.ts","../src/row-mapping.ts","../src/statements.ts","../src/postgres-event-store.ts"],"names":["ConfigurationError","Pool"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { Pool, PoolClient } from 'pg';\nimport type { PostgresExecutor, PostgresParameter, PostgresRow } from './executor.js';\n\n/**\n * Executor for a `pg` {@link Pool}. A transaction is a dedicated pool client\n * between `BEGIN` and `COMMIT`; it is handed to callers as the transaction\n * handle, so they can run their own queries on it.\n */\nexport class PgExecutor implements PostgresExecutor<PoolClient> {\n  readonly #pool: Pool;\n\n  constructor(pool: Pool) {\n    this.#pool = pool;\n  }\n\n  async transaction<T>(work: (transaction: PoolClient) => Promise<T>): Promise<T> {\n    const client = await this.#pool.connect();\n    try {\n      await client.query('BEGIN');\n      const result = await work(client);\n      await client.query('COMMIT');\n      client.release();\n      return result;\n    } catch (error) {\n      await this.#rollbackAndRelease(client);\n      throw error;\n    }\n  }\n\n  async query(\n    sql: string,\n    parameters: readonly PostgresParameter[],\n    transaction?: PoolClient,\n  ): Promise<readonly PostgresRow[]> {\n    const result = await (transaction ?? this.#pool).query<PostgresRow>(sql, [...parameters]);\n    return result.rows;\n  }\n\n  /** A client whose rollback fails is in an unknown state, so it is destroyed instead of reused. */\n  async #rollbackAndRelease(client: PoolClient): Promise<void> {\n    try {\n      await client.query('ROLLBACK');\n      client.release();\n    } catch {\n      client.release(true);\n    }\n  }\n}\n","import { ConfigurationError } from '@relaybus/core';\n\nconst IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_]*$/;\nconst MAXIMUM_IDENTIFIER_LENGTH = 63;\n\n/**\n * Throws {@link ConfigurationError} unless `value` is a plain lower-case\n * PostgreSQL identifier. Identifiers are interpolated into SQL text (they\n * cannot be bound as parameters), so this is the injection boundary: only\n * letters, digits and underscores survive, and nothing needs escaping.\n */\nexport function assertIdentifier(label: string, value: string): void {\n  if (!IDENTIFIER_PATTERN.test(value) || value.length > MAXIMUM_IDENTIFIER_LENGTH) {\n    throw new ConfigurationError(\n      `${label} '${value}' must match ${String(IDENTIFIER_PATTERN)} and be at most ${MAXIMUM_IDENTIFIER_LENGTH} characters`,\n    );\n  }\n}\n\n/** Double-quotes an identifier that already passed {@link assertIdentifier}. */\nexport function quoteIdentifier(value: string): string {\n  return `\"${value}\"`;\n}\n","import { ConfigurationError } from '@relaybus/core';\nimport { assertIdentifier, quoteIdentifier } from './identifiers.js';\n\n/** Where relaybus keeps its tables. */\nexport interface PostgresSchemaOptions {\n  /** Schema that holds the tables. Created by `setup()` when it is not `public`. Default `'public'`. */\n  readonly schema?: string;\n  /**\n   * Prepended to every table and index name, which makes the names\n   * `<prefix>events`, `<prefix>deliveries` and `<prefix>key_sequences`.\n   * Lower-case letters, digits and underscores. Default `'relaybus_'`.\n   */\n  readonly tablePrefix?: string;\n}\n\n/** Validated, quoted names used to build SQL. */\nexport interface PostgresNames {\n  readonly schema: string;\n  readonly quotedSchema: string;\n  readonly events: string;\n  readonly deliveries: string;\n  readonly keySequences: string;\n  /** Index names, quoted but not schema-qualified (an index lives in its table's schema). */\n  readonly indexes: {\n    readonly deliveryEventHandler: string;\n    readonly deliveryDue: string;\n    readonly deliveryDueUnkeyed: string;\n    readonly deliveryHandlerCreated: string;\n    readonly eventCreated: string;\n    readonly deliveryKeyUnfinished: string;\n    readonly deliveryKeyProcessing: string;\n    readonly deliveryStatusCreated: string;\n    readonly deliveryCompleted: string;\n    readonly deliveryDead: string;\n  };\n}\n\nconst DEFAULT_SCHEMA = 'public';\nconst DEFAULT_TABLE_PREFIX = 'relaybus_';\nconst TABLE_PREFIX_PATTERN = /^[a-z0-9_]*$/;\n\n/**\n * Validates the options and derives every name the store uses. Every name,\n * including the longest index name, is checked against the PostgreSQL 63\n * character limit so that a too-long prefix fails here and not as a\n * silently truncated, colliding name in the database.\n */\nexport function resolvePostgresNames(options: PostgresSchemaOptions = {}): PostgresNames {\n  const schema = options.schema ?? DEFAULT_SCHEMA;\n  const tablePrefix = options.tablePrefix ?? DEFAULT_TABLE_PREFIX;\n  assertIdentifier('schema', schema);\n  if (!TABLE_PREFIX_PATTERN.test(tablePrefix)) {\n    throw new ConfigurationError(\n      `tablePrefix '${tablePrefix}' must match ${String(TABLE_PREFIX_PATTERN)}`,\n    );\n  }\n  const name = (suffix: string): string => {\n    const identifier = `${tablePrefix}${suffix}`;\n    assertIdentifier(`tablePrefix '${tablePrefix}' produces the name`, identifier);\n    return identifier;\n  };\n  const quotedSchema = quoteIdentifier(schema);\n  const table = (suffix: string): string => `${quotedSchema}.${quoteIdentifier(name(suffix))}`;\n  const index = (suffix: string): string => quoteIdentifier(name(suffix));\n  return {\n    schema,\n    quotedSchema,\n    events: table('events'),\n    deliveries: table('deliveries'),\n    keySequences: table('key_sequences'),\n    indexes: {\n      deliveryEventHandler: index('deliveries_event_handler_unique'),\n      deliveryDue: index('deliveries_due_idx'),\n      deliveryDueUnkeyed: index('deliveries_due_unkeyed_idx'),\n      deliveryHandlerCreated: index('deliveries_handler_created_idx'),\n      eventCreated: index('events_created_idx'),\n      deliveryKeyUnfinished: index('deliveries_key_unfinished_idx'),\n      deliveryKeyProcessing: index('deliveries_key_processing_idx'),\n      deliveryStatusCreated: index('deliveries_status_created_idx'),\n      deliveryCompleted: index('deliveries_completed_idx'),\n      deliveryDead: index('deliveries_dead_idx'),\n    },\n  };\n}\n","/**\n * The instant a delivery becomes claimable: `available_at` while pending,\n * `lease_expires_at` while processing. The claim query, the statistics query\n * and the partial index all use this exact expression, which is what lets\n * PostgreSQL answer \"earliest due delivery\" from an index.\n */\nexport function dueAtExpression(alias?: string): string {\n  const prefix = alias === undefined ? '' : `${alias}.`;\n  return `CASE WHEN ${prefix}status = 'pending' THEN ${prefix}available_at ELSE ${prefix}lease_expires_at END`;\n}\n\n/**\n * Renders a timestamptz as ISO-8601 text in UTC. Reading timestamps as text\n * makes results independent of the driver's type parsers (Drizzle, for\n * instance, replaces them) and of the session time zone.\n */\nexport function isoText(expression: string): string {\n  return `to_char(${expression} AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"')`;\n}\n","import { resolvePostgresNames, type PostgresSchemaOptions } from './names.js';\nimport { dueAtExpression } from './sql-fragments.js';\n\n/**\n * Statements that create the schema, tables and indexes, in dependency order.\n * Every statement is idempotent (`IF NOT EXISTS`). Run them in one transaction\n * and serialize concurrent runs (see {@link PostgresEventStore.setup}), or\n * paste {@link createPostgresSchemaSql} into your own migration tool.\n *\n * `events.id` and `deliveries.id` are `text` so that any caller-supplied id\n * (UUID, ULID, deterministic business id) is accepted. `deliveries.id` uses the\n * `C` collation so that ordering by id matches a byte-wise comparison on every\n * database, whatever its locale.\n */\nexport function createPostgresSchemaStatements(options: PostgresSchemaOptions = {}): string[] {\n  const names = resolvePostgresNames(options);\n  const unfinished = `status IN ('pending', 'processing')`;\n  const statements = [\n    `CREATE TABLE IF NOT EXISTS ${names.events} (\n  id text PRIMARY KEY,\n  type text NOT NULL,\n  source text NOT NULL,\n  key text,\n  sequence bigint,\n  payload jsonb NOT NULL,\n  headers jsonb NOT NULL DEFAULT '{}'::jsonb,\n  correlation_id text,\n  causation_id text,\n  occurred_at timestamptz NOT NULL,\n  created_at timestamptz NOT NULL\n)`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.eventCreated} ON ${names.events} (created_at, id)`,\n    `CREATE TABLE IF NOT EXISTS ${names.keySequences} (\n  key text PRIMARY KEY,\n  sequence bigint NOT NULL\n)`,\n    `CREATE TABLE IF NOT EXISTS ${names.deliveries} (\n  id text COLLATE \"C\" PRIMARY KEY,\n  event_id text NOT NULL REFERENCES ${names.events} (id) ON DELETE CASCADE,\n  handler text NOT NULL,\n  status text NOT NULL CHECK (status IN ('pending', 'processing', 'completed', 'dead')),\n  attempts integer NOT NULL DEFAULT 0,\n  available_at timestamptz NOT NULL,\n  lease_owner text,\n  lease_token text,\n  lease_expires_at timestamptz,\n  last_error jsonb,\n  key text,\n  sequence bigint,\n  created_at timestamptz NOT NULL,\n  updated_at timestamptz NOT NULL,\n  completed_at timestamptz,\n  CONSTRAINT ${names.indexes.deliveryEventHandler} UNIQUE (event_id, handler)\n)`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryDue} ON ${names.deliveries} ((${dueAtExpression()}), id) WHERE ${unfinished}`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryDueUnkeyed} ON ${names.deliveries} ((${dueAtExpression()}), id) WHERE key IS NULL AND ${unfinished}`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryKeyUnfinished} ON ${names.deliveries} (handler, key, sequence) WHERE key IS NOT NULL AND ${unfinished}`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryKeyProcessing} ON ${names.deliveries} (handler, key) WHERE key IS NOT NULL AND status = 'processing'`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryStatusCreated} ON ${names.deliveries} (status, created_at, id)`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryHandlerCreated} ON ${names.deliveries} (handler, created_at, id)`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryCompleted} ON ${names.deliveries} (completed_at, id) WHERE status = 'completed'`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryDead} ON ${names.deliveries} (updated_at, id) WHERE status = 'dead'`,\n  ];\n  if (names.schema !== 'public') {\n    statements.unshift(`CREATE SCHEMA IF NOT EXISTS ${names.quotedSchema}`);\n  }\n  return statements;\n}\n\n/**\n * The statements of {@link createPostgresSchemaStatements} as one SQL script,\n * for migration tools. Pair it with `new RelayBus({ setupStore: false })`.\n */\nexport function createPostgresSchemaSql(options: PostgresSchemaOptions = {}): string {\n  return `${createPostgresSchemaStatements(options).join(';\\n\\n')};\\n`;\n}\n","import type {\n  ClaimedDelivery,\n  DeliveryRecord,\n  DeliveryStatus,\n  ErrorInfo,\n  EventEnvelope,\n  EventHeaders,\n} from '@relaybus/core';\nimport type { PostgresRow } from './executor.js';\n\n// Rows come from statements written in this package, so their shape is known.\n// Casting here is the single place where driver output is trusted.\n\nfunction text(row: PostgresRow, column: string): string {\n  return row[column] as string;\n}\n\nfunction nullableText(row: PostgresRow, column: string): string | null {\n  return row[column] as string | null;\n}\n\nfunction nullableDate(row: PostgresRow, column: string): Date | null {\n  const value = nullableText(row, column);\n  return value === null ? null : new Date(value);\n}\n\n/** Count columns arrive as number, string or bigint depending on the driver. */\nexport function readCount(row: PostgresRow, column: string): number {\n  return Number(row[column]);\n}\n\nexport function mapEventEnvelope(row: PostgresRow): EventEnvelope {\n  return {\n    id: text(row, 'event_id'),\n    type: text(row, 'event_type'),\n    source: text(row, 'event_source'),\n    key: nullableText(row, 'event_key'),\n    payload: JSON.parse(text(row, 'event_payload')) as unknown,\n    headers: JSON.parse(text(row, 'event_headers')) as EventHeaders,\n    correlationId: nullableText(row, 'event_correlation_id'),\n    causationId: nullableText(row, 'event_causation_id'),\n    occurredAt: new Date(text(row, 'event_occurred_at')),\n  };\n}\n\nexport function mapClaimedDelivery(row: PostgresRow, leaseExpiresAt: Date): ClaimedDelivery {\n  return {\n    deliveryId: text(row, 'delivery_id'),\n    leaseToken: text(row, 'lease_token'),\n    handler: text(row, 'handler'),\n    attempt: readCount(row, 'attempts'),\n    leaseExpiresAt,\n    event: mapEventEnvelope(row),\n  };\n}\n\nexport function mapDeliveryRecord(row: PostgresRow): DeliveryRecord {\n  const lastError = nullableText(row, 'last_error');\n  return {\n    id: text(row, 'delivery_id'),\n    handler: text(row, 'handler'),\n    status: text(row, 'status') as DeliveryStatus,\n    attempts: readCount(row, 'attempts'),\n    availableAt: new Date(text(row, 'available_at')),\n    leaseOwner: nullableText(row, 'lease_owner'),\n    leaseExpiresAt: nullableDate(row, 'lease_expires_at'),\n    lastError: lastError === null ? null : (JSON.parse(lastError) as ErrorInfo),\n    createdAt: new Date(text(row, 'created_at')),\n    updatedAt: new Date(text(row, 'updated_at')),\n    completedAt: nullableDate(row, 'completed_at'),\n    event: mapEventEnvelope(row),\n  };\n}\n\nexport function mapOldestDueAt(rows: readonly PostgresRow[]): Date | null {\n  return rows.length === 0 ? null : new Date(text(rows[0]!, 'oldest_due_at'));\n}\n","import type { DeliveryQuery } from '@relaybus/core';\nimport type { PostgresNames } from './names.js';\nimport { dueAtExpression, isoText } from './sql-fragments.js';\nimport type { PostgresParameter } from './executor.js';\n\nexport interface PostgresStatement {\n  readonly sql: string;\n  readonly parameters: readonly PostgresParameter[];\n}\n\nconst DEFAULT_LIST_LIMIT = 100;\n\nfunction eventColumns(alias: string): string {\n  return `${alias}.id AS event_id,\n    ${alias}.type AS event_type,\n    ${alias}.source AS event_source,\n    ${alias}.key AS event_key,\n    ${alias}.payload::text AS event_payload,\n    ${alias}.headers::text AS event_headers,\n    ${alias}.correlation_id AS event_correlation_id,\n    ${alias}.causation_id AS event_causation_id,\n    ${isoText(`${alias}.occurred_at`)} AS event_occurred_at`;\n}\n\n/** `WITH changed AS (<dml> RETURNING 1) SELECT count(*)`: a top-level SELECT works the same on every driver. */\nfunction countChanged(dml: string): string {\n  return `WITH changed AS (${dml} RETURNING 1) SELECT count(*)::int AS count FROM changed`;\n}\n\n/**\n * Due deliveries the fast claim examines before it gives up and lets the slow\n * claim look at the heads of all keys.\n */\nconst CLAIM_SCAN_WINDOW = 256;\n\nconst UNFINISHED_PREDICATE = (alias: string): string =>\n  `${alias}.status IN ('pending', 'processing')`;\n\nconst HANDLER_PREDICATE = `delivery.handler = ANY (ARRAY(SELECT jsonb_array_elements_text($2::jsonb)))`;\n\nconst CLEAR_LEASE = 'lease_owner = NULL, lease_token = NULL, lease_expires_at = NULL';\n\n/**\n * SQL text for every operation of the store. Statements take their data as\n * parameters; only validated identifiers are interpolated. Documents travel\n * as one JSON text parameter expanded server-side with `jsonb_to_recordset`,\n * which keeps the statements identical across drivers and avoids array\n * literal encoding differences.\n */\nexport class PostgresStatements {\n  readonly #names: PostgresNames;\n\n  constructor(names: PostgresNames) {\n    this.#names = names;\n  }\n\n  /**\n   * Lock advisory key text for {@link setupLock}. It is derived from the schema\n   * name only, so stores with different table prefixes in one schema also\n   * serialize their `CREATE SCHEMA IF NOT EXISTS`, which is not race-free.\n   */\n  get setupLockKey(): string {\n    return `relaybus:${this.#names.schema}`;\n  }\n\n  get setupLock(): string {\n    return 'SELECT pg_advisory_xact_lock(hashtextextended($1::text, 0))';\n  }\n\n  /**\n   * Reserves sequence numbers per key. Parameters: `[{ key, count }]` as JSON.\n   * Keys are locked in sorted order, so publishers cannot deadlock within one\n   * call (across calls of one transaction they can, see the README); each row lock is held until the publishing transaction ends, which makes\n   * sequence order equal commit order for a key.\n   */\n  get reserveSequences(): string {\n    return `INSERT INTO ${this.#names.keySequences} AS reserved (key, sequence)\nSELECT requested.key, requested.count\nFROM jsonb_to_recordset($1::jsonb) AS requested (key text, count bigint)\nORDER BY requested.key\nON CONFLICT (key) DO UPDATE SET sequence = reserved.sequence + EXCLUDED.sequence\nRETURNING reserved.key AS key, reserved.sequence::text AS sequence`;\n  }\n\n  /** Parameters: `[eventsJson, createdAt]`. Returns the ids that were inserted. */\n  get insertEvents(): string {\n    return `INSERT INTO ${this.#names.events}\n  (id, type, source, key, sequence, payload, headers, correlation_id, causation_id, occurred_at, created_at)\nSELECT incoming.id, incoming.type, incoming.source, incoming.key, incoming.sequence,\n  COALESCE(incoming.payload, 'null'::jsonb), COALESCE(incoming.headers, '{}'::jsonb),\n  incoming.correlation_id, incoming.causation_id, incoming.occurred_at, $2::timestamptz\nFROM jsonb_to_recordset($1::jsonb) AS incoming (\n  id text, type text, source text, key text, sequence bigint, payload jsonb, headers jsonb,\n  correlation_id text, causation_id text, occurred_at timestamptz)\nORDER BY incoming.id\nON CONFLICT (id) DO NOTHING\nRETURNING id`;\n  }\n\n  /**\n   * Parameters: `[deliveriesJson, createdAt]`. Key and sequence are copied from\n   * the stored event, so a delivery added later to an existing event keeps the\n   * event's position in its key. Returns the ids that were inserted.\n   */\n  get insertDeliveries(): string {\n    return `INSERT INTO ${this.#names.deliveries}\n  (id, event_id, handler, status, attempts, available_at, key, sequence, created_at, updated_at)\nSELECT incoming.id, incoming.event_id, incoming.handler, 'pending', 0, incoming.available_at,\n  event.key, event.sequence, $2::timestamptz, $2::timestamptz\nFROM jsonb_to_recordset($1::jsonb) AS incoming (id text, event_id text, handler text, available_at timestamptz)\nJOIN ${this.#names.events} AS event ON event.id = incoming.event_id\nORDER BY incoming.event_id, incoming.handler\nON CONFLICT (event_id, handler) DO NOTHING\nRETURNING id`;\n  }\n\n  /**\n   * Fast claim: leases from the first {@link CLAIM_SCAN_WINDOW} due deliveries\n   * in due order, which is everything the claim needs while the front of the\n   * queue is not clogged with blocked followers of busy keys. Parameters:\n   * `[now, handlersJson, limit, leaseOwner, leaseExpiresAt]`.\n   *\n   * Always returns one row per leased delivery, or a single row whose\n   * `delivery_id` is null when nothing was leased. `window_saturated` says\n   * whether the window was full: when it is and fewer than `limit` deliveries\n   * were leased, deliveries beyond the window may still be claimable and the\n   * caller runs {@link claimBehindBlockedKeys}. When the window is not\n   * saturated every due delivery was examined, so the result is complete.\n   *\n   * Candidates are chosen with `FOR UPDATE SKIP LOCKED`, so two claimers never\n   * lock the same row. A keyed delivery is a candidate only when it is the head\n   * of its (handler, key), that is (a) no earlier delivery of that handler and\n   * key is pending or processing, which is the ordering guarantee, and (b) no\n   * other delivery of that handler and key holds a live lease. Rule b covers a\n   * delivery that re-enters the key behind a running one (requeue, or a handler\n   * added to an old event); an expired lease does not count, because its worker\n   * is presumed dead and the key must not stall behind it.\n   *\n   * Why SKIP LOCKED alone is enough for ordering: only the head of a key can\n   * ever be a candidate, and the head is a single row. Two claimers racing\n   * for it either skip it (the other holds the row lock) or, if the other\n   * already committed, re-check the row's new version (now processing and not\n   * due), which excludes it. Followers stay blocked because their predecessor\n   * remains pending or processing in every snapshot until it completes or is\n   * buried, and that commit happens-before the next claim that sees it.\n   */\n  get claim(): string {\n    const deliveries = this.#names.deliveries;\n    return `WITH due_window AS MATERIALIZED (\n  SELECT delivery.id\n  FROM ${deliveries} AS delivery\n  WHERE ${UNFINISHED_PREDICATE('delivery')}\n    AND ${dueAtExpression('delivery')} <= $1::timestamptz\n    AND ${HANDLER_PREDICATE}\n  ORDER BY ${dueAtExpression('delivery')}, delivery.id\n  LIMIT ${CLAIM_SCAN_WINDOW}\n), candidates AS MATERIALIZED (\n  SELECT delivery.id, ${dueAtExpression('delivery')} AS due_at\n  FROM due_window\n  JOIN ${deliveries} AS delivery ON delivery.id = due_window.id\n  WHERE ${UNFINISHED_PREDICATE('delivery')}\n    AND ${dueAtExpression('delivery')} <= $1::timestamptz\n    AND (\n      delivery.key IS NULL\n      OR NOT (\n        EXISTS (\n          SELECT 1 FROM ${deliveries} AS earlier\n          WHERE earlier.key IS NOT NULL AND earlier.handler = delivery.handler AND earlier.key = delivery.key\n            AND ${UNFINISHED_PREDICATE('earlier')}\n            AND earlier.sequence < delivery.sequence\n        )\n        OR ${this.#liveLeaseElsewhere()}\n      )\n    )\n  ORDER BY due_at, delivery.id\n  LIMIT $3::int\n  FOR UPDATE OF delivery SKIP LOCKED\n), ${this.#leaseCandidates()}\nSELECT (SELECT count(*) FROM due_window) >= ${CLAIM_SCAN_WINDOW} AS window_saturated, leased.*\nFROM (SELECT 1) AS anchor\nLEFT JOIN (${this.#leasedRows()}) AS leased ON true\nORDER BY leased.due_at, leased.delivery_id`;\n  }\n\n  /**\n   * Slow claim, run when {@link claim} leased too few deliveries from a full\n   * window: the front of the due queue is mostly followers of blocked keys.\n   * Same parameters, rules and locking as {@link claim}, but heads are found\n   * with `DISTINCT ON (handler, key)` over the unfinished-key index, so the\n   * cost follows the number of unfinished keyed deliveries (one index-only\n   * scan) instead of one probe per due follower.\n   */\n  get claimBehindBlockedKeys(): string {\n    const deliveries = this.#names.deliveries;\n    return `WITH heads AS MATERIALIZED (\n  SELECT DISTINCT ON (head.handler, head.key) head.id\n  FROM ${deliveries} AS head\n  WHERE head.key IS NOT NULL\n    AND ${UNFINISHED_PREDICATE('head')}\n    AND head.handler = ANY (ARRAY(SELECT jsonb_array_elements_text($2::jsonb)))\n  ORDER BY head.handler, head.key, head.sequence\n), keyed AS MATERIALIZED (\n  SELECT delivery.id, ${dueAtExpression('delivery')} AS due_at\n  FROM heads\n  JOIN ${deliveries} AS delivery ON delivery.id = heads.id\n  WHERE ${UNFINISHED_PREDICATE('delivery')}\n    AND ${dueAtExpression('delivery')} <= $1::timestamptz\n    AND NOT ${this.#liveLeaseElsewhere()}\n  ORDER BY due_at, delivery.id\n  LIMIT $3::int\n  FOR UPDATE OF delivery SKIP LOCKED\n), unkeyed AS MATERIALIZED (\n  SELECT delivery.id, ${dueAtExpression('delivery')} AS due_at\n  FROM ${deliveries} AS delivery\n  WHERE delivery.key IS NULL\n    AND ${UNFINISHED_PREDICATE('delivery')}\n    AND ${dueAtExpression('delivery')} <= $1::timestamptz\n    AND ${HANDLER_PREDICATE}\n  ORDER BY due_at, delivery.id\n  LIMIT $3::int\n  FOR UPDATE OF delivery SKIP LOCKED\n), candidates AS MATERIALIZED (\n  SELECT id, due_at FROM (\n    SELECT id, due_at FROM keyed\n    UNION ALL\n    SELECT id, due_at FROM unkeyed\n  ) AS both_sets\n  ORDER BY due_at, id\n  LIMIT $3::int\n), ${this.#leaseCandidates()}\nSELECT false AS window_saturated, leased.*\nFROM (SELECT 1) AS anchor\nLEFT JOIN (${this.#leasedRows()}) AS leased ON true\nORDER BY leased.due_at, leased.delivery_id`;\n  }\n\n  /** True when another delivery of the candidate's handler and key holds a live lease. */\n  #liveLeaseElsewhere(): string {\n    return `EXISTS (\n          SELECT 1 FROM ${this.#names.deliveries} AS running\n          WHERE running.key IS NOT NULL\n            AND running.handler = delivery.handler AND running.key = delivery.key\n            AND running.status = 'processing' AND running.lease_expires_at > $1::timestamptz\n            AND running.id <> delivery.id\n        )`;\n  }\n\n  /** The `claimed` CTE: leases every row of `candidates`. */\n  #leaseCandidates(): string {\n    return `claimed AS (\n  UPDATE ${this.#names.deliveries} AS target\n  SET status = 'processing',\n      attempts = target.attempts + 1,\n      lease_owner = $4::text,\n      lease_token = gen_random_uuid()::text,\n      lease_expires_at = $5::timestamptz,\n      updated_at = $1::timestamptz\n  FROM candidates\n  WHERE target.id = candidates.id\n  RETURNING target.id, target.event_id, target.handler, target.attempts, target.lease_token, candidates.due_at\n)`;\n  }\n\n  /** Leased deliveries joined with their events, as the claim result columns. */\n  #leasedRows(): string {\n    return `SELECT claimed.due_at, claimed.id AS delivery_id, claimed.handler, claimed.attempts::int AS attempts, claimed.lease_token,\n  ${eventColumns('event')}\nFROM claimed\nJOIN ${this.#names.events} AS event ON event.id = claimed.event_id`;\n  }\n\n  /** Parameters: `[deliveryId, leaseToken, leaseExpiresAt, now]`. */\n  get extendLease(): string {\n    return countChanged(`UPDATE ${this.#names.deliveries}\nSET lease_expires_at = $3::timestamptz, updated_at = $4::timestamptz\nWHERE id = $1::text AND status = 'processing' AND lease_token = $2::text`);\n  }\n\n  /** Parameters: `[deliveryId, leaseToken, now]`. */\n  get complete(): string {\n    return countChanged(`UPDATE ${this.#names.deliveries}\nSET status = 'completed', completed_at = $3::timestamptz, updated_at = $3::timestamptz, ${CLEAR_LEASE}\nWHERE id = $1::text AND status = 'processing' AND lease_token = $2::text`);\n  }\n\n  /** Parameters: `[deliveryId, leaseToken, availableAt, errorJson, now]`. */\n  get reschedule(): string {\n    return countChanged(`UPDATE ${this.#names.deliveries}\nSET status = 'pending', available_at = $3::timestamptz, last_error = $4::jsonb, updated_at = $5::timestamptz, ${CLEAR_LEASE}\nWHERE id = $1::text AND status = 'processing' AND lease_token = $2::text`);\n  }\n\n  /** Parameters: `[deliveryId, leaseToken, errorJson, now]`. */\n  get bury(): string {\n    return countChanged(`UPDATE ${this.#names.deliveries}\nSET status = 'dead', last_error = $3::jsonb, updated_at = $4::timestamptz, ${CLEAR_LEASE}\nWHERE id = $1::text AND status = 'processing' AND lease_token = $2::text`);\n  }\n\n  /**\n   * Gives a leased delivery back without spending its attempt: pending, due\n   * `now`, attempt count decremented. Parameters: `[deliveryId, leaseToken, now]`.\n   */\n  get release(): string {\n    return countChanged(`UPDATE ${this.#names.deliveries}\nSET status = 'pending', available_at = $3::timestamptz, attempts = attempts - 1, updated_at = $3::timestamptz, ${CLEAR_LEASE}\nWHERE id = $1::text AND status = 'processing' AND lease_token = $2::text`);\n  }\n\n  /** Parameters: `[deliveryIdsJson, now]`. */\n  get requeue(): string {\n    return countChanged(`UPDATE ${this.#names.deliveries}\nSET status = 'pending', attempts = 0, available_at = $2::timestamptz, updated_at = $2::timestamptz\nWHERE id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb))) AND status = 'dead'`);\n  }\n\n  /** Builds the filtered, creation-ordered listing. */\n  listDeliveries(query: DeliveryQuery): PostgresStatement {\n    const parameters: PostgresParameter[] = [];\n    const conditions: string[] = [];\n    const bind = (value: PostgresParameter): string => {\n      parameters.push(value);\n      return `$${parameters.length}::${typeof value === 'number' ? 'int' : 'text'}`;\n    };\n    if (query.status !== undefined) {\n      conditions.push(`delivery.status = ${bind(query.status)}`);\n    }\n    if (query.handler !== undefined) {\n      conditions.push(`delivery.handler = ${bind(query.handler)}`);\n    }\n    if (query.eventType !== undefined) {\n      conditions.push(`event.type = ${bind(query.eventType)}`);\n    }\n    if (query.eventId !== undefined) {\n      conditions.push(`delivery.event_id = ${bind(query.eventId)}`);\n    }\n    const where = conditions.length === 0 ? '' : `WHERE ${conditions.join(' AND ')}`;\n    const limit = bind(query.limit ?? DEFAULT_LIST_LIMIT);\n    const sql = `SELECT delivery.id AS delivery_id, delivery.handler, delivery.status, delivery.attempts::int AS attempts,\n  ${isoText('delivery.available_at')} AS available_at,\n  delivery.lease_owner,\n  ${isoText('delivery.lease_expires_at')} AS lease_expires_at,\n  delivery.last_error::text AS last_error,\n  ${isoText('delivery.created_at')} AS created_at,\n  ${isoText('delivery.updated_at')} AS updated_at,\n  ${isoText('delivery.completed_at')} AS completed_at,\n  ${eventColumns('event')}\nFROM ${this.#names.deliveries} AS delivery\nJOIN ${this.#names.events} AS event ON event.id = delivery.event_id\n${where}\nORDER BY delivery.created_at, delivery.id\nLIMIT ${limit}`;\n    return { sql, parameters };\n  }\n\n  get countByStatus(): string {\n    return `SELECT status, count(*)::text AS count FROM ${this.#names.deliveries} GROUP BY status`;\n  }\n\n  /** Parameters: `[now]`. */\n  get oldestDue(): string {\n    return `SELECT ${isoText('due_at')} AS oldest_due_at FROM (\n  SELECT ${dueAtExpression('delivery')} AS due_at\n  FROM ${this.#names.deliveries} AS delivery\n  WHERE delivery.status IN ('pending', 'processing') AND ${dueAtExpression('delivery')} <= $1::timestamptz\n  ORDER BY due_at\n  LIMIT 1\n) AS oldest`;\n  }\n\n  /**\n   * Deletes one bounded batch of purgeable deliveries and returns the event id\n   * of each deleted delivery. Parameters: `[cutoff, batchSize]`.\n   * `FOR UPDATE SKIP LOCKED` keeps purge from waiting on, or being waited on by, anything.\n   */\n  purgeCompletedBatch(): string {\n    return this.#purgeBatch(\n      `status = 'completed' AND completed_at < $1::timestamptz`,\n      'completed_at',\n    );\n  }\n\n  purgeDeadBatch(): string {\n    return this.#purgeBatch(`status = 'dead' AND updated_at < $1::timestamptz`, 'updated_at');\n  }\n\n  /**\n   * Selects and locks one bounded batch of events created before the cutoff\n   * that no delivery references. Parameters: `[cutoff, batchSize]`. The ids go\n   * through {@link deleteOrphanEvents}, which re-checks under a fresh snapshot.\n   */\n  get lockOrphanEventsBatch(): string {\n    return `SELECT event.id FROM ${this.#names.events} AS event\nWHERE event.created_at < $1::timestamptz\n  AND NOT EXISTS (SELECT 1 FROM ${this.#names.deliveries} AS delivery WHERE delivery.event_id = event.id)\nORDER BY event.created_at, event.id\nLIMIT $2::int\nFOR UPDATE OF event SKIP LOCKED`;\n  }\n\n  /**\n   * Locks the given events, skipping any that a concurrent transaction is\n   * referencing from a new delivery (a foreign key check holds `FOR KEY\n   * SHARE`, which conflicts with this lock). Parameters: `[eventIdsJson]`.\n   */\n  get lockEvents(): string {\n    return `SELECT id FROM ${this.#names.events}\nWHERE id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb)))\nFOR UPDATE SKIP LOCKED`;\n  }\n\n  /**\n   * Deletes locked events that no delivery references. It must run as a\n   * statement of its own after {@link lockEvents}: it then takes a fresh\n   * snapshot that includes every delivery committed before the lock was\n   * granted, so an event that just gained a delivery is never cascaded away.\n   * Parameters: `[eventIdsJson]`.\n   */\n  get deleteOrphanEvents(): string {\n    const events = this.#names.events;\n    return countChanged(`DELETE FROM ${events} AS event\nWHERE event.id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb)))\n  AND NOT EXISTS (SELECT 1 FROM ${this.#names.deliveries} AS delivery WHERE delivery.event_id = event.id)`);\n  }\n\n  #purgeBatch(condition: string, orderColumn: string): string {\n    const deliveries = this.#names.deliveries;\n    return `WITH batch AS MATERIALIZED (\n  SELECT id FROM ${deliveries}\n  WHERE ${condition}\n  ORDER BY ${orderColumn}, id\n  LIMIT $2::int\n  FOR UPDATE SKIP LOCKED\n), deleted AS (\n  DELETE FROM ${deliveries} AS delivery USING batch WHERE delivery.id = batch.id RETURNING delivery.event_id\n)\nSELECT event_id FROM deleted`;\n  }\n}\n","import {\n  ConfigurationError,\n  type AppendEntry,\n  type AppendResult,\n  type ClaimRequest,\n  type ClaimedDelivery,\n  type DeliveryQuery,\n  type DeliveryRecord,\n  type DeliveryStatus,\n  type ErrorInfo,\n  type EventEnvelope,\n  type EventStore,\n  type EventStoreStatistics,\n  type LeaseReference,\n  type PurgeRequest,\n  type PurgeResult,\n  type RelayBusLogger,\n} from '@relaybus/core';\nimport { Pool, type PoolClient, type PoolConfig } from 'pg';\nimport type { PostgresExecutor, PostgresParameter, PostgresRow } from './executor.js';\nimport { resolvePostgresNames, type PostgresSchemaOptions } from './names.js';\nimport { PgExecutor } from './pg-executor.js';\nimport { mapClaimedDelivery, mapDeliveryRecord, mapOldestDueAt, readCount } from './row-mapping.js';\nimport { createPostgresSchemaStatements } from './schema.js';\nimport { PostgresStatements } from './statements.js';\n\n/** Options shared by every way of connecting. */\nexport interface PostgresEventStoreSettings extends PostgresSchemaOptions {\n  /**\n   * Maximum deliveries deleted per transaction by `purge`. Smaller batches\n   * hold row locks for less time; `purge` keeps going until nothing is left.\n   * Default 1000.\n   */\n  readonly purgeBatchSize?: number;\n  /**\n   * Receives errors of idle connections in a pool the store creates itself\n   * (database failover, `pg_terminate_backend`, network resets). Default\n   * `console`. A pool you pass in is yours: attach `pool.on('error', ...)` to\n   * it, otherwise `pg` raises an unhandled `error` event and the process exits.\n   */\n  readonly logger?: RelayBusLogger;\n}\n\n/** Use an existing `pg` pool. The store never closes it. */\nexport interface PostgresPoolOptions extends PostgresEventStoreSettings {\n  readonly pool: Pool;\n  readonly connectionString?: never;\n  readonly poolConfig?: never;\n  readonly executor?: never;\n}\n\n/** Let the store create (and on `close()` end) its own `pg` pool. */\nexport interface PostgresConnectionOptions extends PostgresEventStoreSettings {\n  readonly connectionString: string;\n  /** Extra `pg` pool settings, for example `max`. */\n  readonly poolConfig?: Omit<PoolConfig, 'connectionString'>;\n  readonly pool?: never;\n  readonly executor?: never;\n}\n\n/** Use another database library through an adapter. The store never closes it. */\nexport interface PostgresExecutorOptions<TTransaction> extends PostgresEventStoreSettings {\n  readonly executor: PostgresExecutor<TTransaction>;\n  readonly pool?: never;\n  readonly connectionString?: never;\n  readonly poolConfig?: never;\n}\n\nexport type PostgresEventStoreOptions<TTransaction = PoolClient> =\n  PostgresPoolOptions | PostgresConnectionOptions | PostgresExecutorOptions<TTransaction>;\n\nconst DEFAULT_PURGE_BATCH_SIZE = 1_000;\n\ninterface EventRow {\n  readonly id: string;\n  readonly type: string;\n  readonly source: string;\n  readonly key: string | null;\n  readonly sequence: string | null;\n  readonly payload: unknown;\n  readonly headers: EventEnvelope['headers'];\n  readonly correlation_id: string | null;\n  readonly causation_id: string | null;\n  readonly occurred_at: string;\n}\n\ninterface DeliveryRow {\n  readonly id: string;\n  readonly event_id: string;\n  readonly handler: string;\n  readonly available_at: string;\n}\n\n/**\n * PostgreSQL {@link EventStore} (PostgreSQL 13 or newer).\n *\n * The transaction handle is whatever the chosen driver uses: a `pg`\n * `PoolClient` by default, or a Kysely / Knex / TypeORM / Drizzle / Prisma\n * transaction through the adapters in `@relaybus/postgres/<library>`. Events\n * published with that handle commit and roll back together with the caller's\n * own writes.\n *\n * Guarantees:\n * - **Atomic publish.** Events and deliveries are written in the caller's transaction.\n * - **Per-key order.** Each key has a counter row in the key-sequence table.\n *   Publishing locks that row and holds the lock until commit, so two\n *   transactions publishing the same key are serialized and sequence order\n *   equals commit order. Claiming then hands out only the lowest unfinished\n *   sequence of a (handler, key).\n * - **Safe parallel claiming.** One `FOR UPDATE SKIP LOCKED` statement leases\n *   deliveries; any number of processes can claim at once.\n * - **Fenced state changes.** Complete, reschedule, bury and extend only apply\n *   to the lease token that claimed the delivery.\n * - **App clock.** Every timestamp comes from the `now` the caller passes in,\n *   never from the database clock.\n */\nexport class PostgresEventStore<TTransaction = PoolClient> implements EventStore<TTransaction> {\n  readonly #executor: PostgresExecutor<TTransaction>;\n  readonly #statements: PostgresStatements;\n  readonly #schemaStatements: readonly string[];\n  readonly #setupLockKey: string;\n  readonly #purgeBatchSize: number;\n  #ownedPool: Pool | undefined;\n\n  constructor(options: PostgresEventStoreOptions<TTransaction>) {\n    const sources = [options.pool, options.connectionString, options.executor].filter(\n      (source) => source !== undefined,\n    );\n    if (sources.length !== 1) {\n      throw new ConfigurationError(\n        'PostgresEventStore needs exactly one of pool, connectionString or executor',\n      );\n    }\n    const purgeBatchSize = options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE;\n    if (!Number.isInteger(purgeBatchSize) || purgeBatchSize < 1) {\n      throw new ConfigurationError(\n        `purgeBatchSize must be a positive integer, received ${String(purgeBatchSize)}`,\n      );\n    }\n    const names = resolvePostgresNames(options);\n    this.#statements = new PostgresStatements(names);\n    this.#schemaStatements = createPostgresSchemaStatements(options);\n    this.#setupLockKey = this.#statements.setupLockKey;\n    this.#purgeBatchSize = purgeBatchSize;\n    if (options.executor !== undefined) {\n      this.#executor = options.executor;\n    } else {\n      const pool =\n        options.pool ??\n        new Pool({ ...options.poolConfig, connectionString: options.connectionString });\n      if (options.pool === undefined) {\n        const logger = options.logger ?? console;\n        pool.on('error', (error) => {\n          logger.error(\n            `[PostgresEventStore](constructor) Idle connection failed, the pool replaces it | error=${error.message}`,\n          );\n        });\n        this.#ownedPool = pool;\n      }\n      // Without an executor the transaction type is PoolClient, as the default type argument states.\n      this.#executor = new PgExecutor(pool) as unknown as PostgresExecutor<TTransaction>;\n    }\n  }\n\n  /**\n   * Creates the schema, tables and indexes if they do not exist. Safe to call\n   * from many processes at once: a transaction-scoped advisory lock serializes\n   * the DDL, so racing `CREATE TABLE IF NOT EXISTS` statements cannot collide.\n   * Skip it (`setupStore: false`) when a migration tool applies\n   * `createPostgresSchemaSql()` instead.\n   */\n  async setup(): Promise<void> {\n    await this.#executor.transaction(async (transaction) => {\n      await this.#executor.query(this.#statements.setupLock, [this.#setupLockKey], transaction);\n      for (const statement of this.#schemaStatements) {\n        await this.#executor.query(statement, [], transaction);\n      }\n    });\n  }\n\n  transaction<T>(work: (transaction: TTransaction) => Promise<T>): Promise<T> {\n    return this.#executor.transaction(work);\n  }\n\n  /**\n   * Writes the entries in `transaction`. Keyed events reserve their sequence\n   * numbers first (locking the key rows in sorted order, so publishers cannot\n   * deadlock inside one call), then events, then deliveries, each in a single\n   * multi-row statement ordered by primary key. Two transactions that append\n   * keys in opposite order across several calls can still deadlock (40P01);\n   * the database rolls one back and the caller retries.\n   * A duplicate event id still consumes a sequence number; gaps are harmless\n   * because only the order of sequences matters.\n   */\n  async append(\n    transaction: TTransaction,\n    entries: readonly AppendEntry[],\n    now: Date,\n  ): Promise<AppendResult> {\n    const plan = planAppend(entries);\n    const createdAt = now.toISOString();\n    const sequences = await this.#reserveSequences(plan.events, transaction);\n    const insertedEventIds = new Set(\n      plan.events.length === 0\n        ? []\n        : (\n            await this.#executor.query(\n              this.#statements.insertEvents,\n              [JSON.stringify(toEventRows(plan.events, sequences)), createdAt],\n              transaction,\n            )\n          ).map((row) => row['id'] as string),\n    );\n    const insertedDeliveries =\n      plan.deliveries.length === 0\n        ? []\n        : await this.#executor.query(\n            this.#statements.insertDeliveries,\n            [JSON.stringify(plan.deliveries), createdAt],\n            transaction,\n          );\n    const appendedEventIds: string[] = [];\n    const duplicateEventIds: string[] = [];\n    for (const { eventId, repeated } of plan.outcomes) {\n      (!repeated && insertedEventIds.has(eventId) ? appendedEventIds : duplicateEventIds).push(\n        eventId,\n      );\n    }\n    return {\n      appendedEventIds,\n      duplicateEventIds,\n      appendedDeliveryCount: insertedDeliveries.length,\n    };\n  }\n\n  /**\n   * Leases up to `limit` due deliveries with `FOR UPDATE SKIP LOCKED`. The fast\n   * statement examines the first due deliveries; only when they are mostly\n   * blocked followers of busy keys does a second statement look at the heads of\n   * all keys. See {@link PostgresStatements.claim} for why that keeps a\n   * (handler, key) strictly one-at-a-time and in order.\n   */\n  async claim(request: ClaimRequest): Promise<ClaimedDelivery[]> {\n    if (request.handlers.length === 0 || !(request.limit > 0)) {\n      return [];\n    }\n    const parameters = (limit: number): PostgresParameter[] => [\n      request.now.toISOString(),\n      JSON.stringify(request.handlers),\n      limit,\n      request.leaseOwner,\n      request.leaseExpiresAt.toISOString(),\n    ];\n    const fastRows = await this.#executor.query(this.#statements.claim, parameters(request.limit));\n    const leased = fastRows.filter((row) => row['delivery_id'] !== null);\n    if (leased.length < request.limit && fastRows[0]!['window_saturated'] === true) {\n      leased.push(\n        ...(\n          await this.#executor.query(\n            this.#statements.claimBehindBlockedKeys,\n            parameters(request.limit - leased.length),\n          )\n        ).filter((row) => row['delivery_id'] !== null),\n      );\n    }\n    return leased.map((row) => mapClaimedDelivery(row, request.leaseExpiresAt));\n  }\n\n  extendLease(lease: LeaseReference, leaseExpiresAt: Date, now: Date): Promise<boolean> {\n    return this.#changed(this.#statements.extendLease, [\n      lease.deliveryId,\n      lease.leaseToken,\n      leaseExpiresAt.toISOString(),\n      now.toISOString(),\n    ]);\n  }\n\n  complete(lease: LeaseReference, now: Date, transaction?: TTransaction): Promise<boolean> {\n    return this.#changed(\n      this.#statements.complete,\n      [lease.deliveryId, lease.leaseToken, now.toISOString()],\n      transaction,\n    );\n  }\n\n  reschedule(\n    lease: LeaseReference,\n    availableAt: Date,\n    error: ErrorInfo,\n    now: Date,\n  ): Promise<boolean> {\n    return this.#changed(this.#statements.reschedule, [\n      lease.deliveryId,\n      lease.leaseToken,\n      availableAt.toISOString(),\n      JSON.stringify(error),\n      now.toISOString(),\n    ]);\n  }\n\n  bury(lease: LeaseReference, error: ErrorInfo, now: Date): Promise<boolean> {\n    return this.#changed(this.#statements.bury, [\n      lease.deliveryId,\n      lease.leaseToken,\n      JSON.stringify(error),\n      now.toISOString(),\n    ]);\n  }\n\n  /** Returns a leased delivery to pending, due now, without counting the attempt. */\n  release(lease: LeaseReference, now: Date): Promise<boolean> {\n    return this.#changed(this.#statements.release, [\n      lease.deliveryId,\n      lease.leaseToken,\n      now.toISOString(),\n    ]);\n  }\n\n  async listDeliveries(query: DeliveryQuery): Promise<DeliveryRecord[]> {\n    const statement = this.#statements.listDeliveries(query);\n    const rows = await this.#executor.query(statement.sql, statement.parameters);\n    return rows.map(mapDeliveryRecord);\n  }\n\n  async requeue(deliveryIds: readonly string[], now: Date): Promise<number> {\n    const rows = await this.#executor.query(this.#statements.requeue, [\n      JSON.stringify(deliveryIds),\n      now.toISOString(),\n    ]);\n    return readCount(rows[0]!, 'count');\n  }\n\n  /**\n   * Deletes purgeable deliveries in batches of `purgeBatchSize`, one short\n   * transaction per batch, then the events those batches left without any\n   * delivery. Finally, events created before the earliest given cutoff that\n   * have no delivery at all are removed: they are what a publish leaves behind\n   * when its last delivery was purged in the same instant, or when no handler\n   * was subscribed. Events that a concurrent publish is attaching a delivery\n   * to are skipped and kept.\n   */\n  async purge(request: PurgeRequest): Promise<PurgeResult> {\n    const total = { deletedDeliveries: 0, deletedEvents: 0 };\n    const batches: Array<[string, Date | undefined]> = [\n      [this.#statements.purgeCompletedBatch(), request.completedBefore],\n      [this.#statements.purgeDeadBatch(), request.deadBefore],\n    ];\n    for (const [sql, cutoff] of batches) {\n      if (cutoff === undefined) {\n        continue;\n      }\n      let deletedInBatch = this.#purgeBatchSize;\n      while (deletedInBatch === this.#purgeBatchSize) {\n        const batch = await this.#purgeBatch(sql, cutoff);\n        deletedInBatch = batch.deletedDeliveries;\n        total.deletedDeliveries += batch.deletedDeliveries;\n        total.deletedEvents += batch.deletedEvents;\n      }\n    }\n    const orphanCutoff = [request.completedBefore, request.deadBefore]\n      .filter((cutoff) => cutoff !== undefined)\n      .sort((first, second) => first.getTime() - second.getTime())[0];\n    if (orphanCutoff !== undefined) {\n      total.deletedEvents += await this.#purgeOrphanEvents(orphanCutoff);\n    }\n    return total;\n  }\n\n  async statistics(now: Date): Promise<EventStoreStatistics> {\n    const counts: Record<DeliveryStatus, number> = {\n      pending: 0,\n      processing: 0,\n      completed: 0,\n      dead: 0,\n    };\n    for (const row of await this.#executor.query(this.#statements.countByStatus, [])) {\n      // A CHECK constraint restricts the column to the four statuses.\n      counts[row['status'] as DeliveryStatus] = readCount(row, 'count');\n    }\n    const oldestDue = await this.#executor.query(this.#statements.oldestDue, [now.toISOString()]);\n    return { ...counts, oldestDueAt: mapOldestDueAt(oldestDue) };\n  }\n\n  /** Ends the pool this store created from `connectionString`. Pools and executors you passed in stay open. */\n  async close(): Promise<void> {\n    const pool = this.#ownedPool;\n    this.#ownedPool = undefined;\n    await pool?.end();\n  }\n\n  async #changed(\n    sql: string,\n    parameters: readonly PostgresParameter[],\n    transaction?: TTransaction,\n  ): Promise<boolean> {\n    const rows = await this.#executor.query(sql, parameters, transaction);\n    return readCount(rows[0]!, 'count') > 0;\n  }\n\n  async #reserveSequences(\n    events: readonly EventEnvelope[],\n    transaction: TTransaction,\n  ): Promise<Map<string, bigint>> {\n    const counts = new Map<string, number>();\n    for (const event of events) {\n      if (event.key !== null) {\n        counts.set(event.key, (counts.get(event.key) ?? 0) + 1);\n      }\n    }\n    const firstSequences = new Map<string, bigint>();\n    if (counts.size === 0) {\n      return firstSequences;\n    }\n    const requested = [...counts].map(([key, count]) => ({ key, count }));\n    const rows = await this.#executor.query(\n      this.#statements.reserveSequences,\n      [JSON.stringify(requested)],\n      transaction,\n    );\n    for (const row of rows) {\n      const key = row['key'] as string;\n      firstSequences.set(key, BigInt(row['sequence'] as string) - BigInt(counts.get(key)!) + 1n);\n    }\n    return firstSequences;\n  }\n\n  async #purgeOrphanEvents(cutoff: Date): Promise<number> {\n    let deletedEvents = 0;\n    let removedInBatch = this.#purgeBatchSize;\n    while (removedInBatch === this.#purgeBatchSize) {\n      removedInBatch = await this.#executor.transaction(async (transaction) => {\n        const locked = await this.#executor.query(\n          this.#statements.lockOrphanEventsBatch,\n          [cutoff.toISOString(), this.#purgeBatchSize],\n          transaction,\n        );\n        const removed = await this.#executor.query(\n          this.#statements.deleteOrphanEvents,\n          [JSON.stringify(locked.map((row: PostgresRow) => row['id'] as string))],\n          transaction,\n        );\n        return readCount(removed[0]!, 'count');\n      });\n      deletedEvents += removedInBatch;\n    }\n    return deletedEvents;\n  }\n\n  async #purgeBatch(\n    sql: string,\n    cutoff: Date,\n  ): Promise<{ deletedDeliveries: number; deletedEvents: number }> {\n    return this.#executor.transaction(async (transaction) => {\n      const deleted = await this.#executor.query(\n        sql,\n        [cutoff.toISOString(), this.#purgeBatchSize],\n        transaction,\n      );\n      if (deleted.length === 0) {\n        return { deletedDeliveries: 0, deletedEvents: 0 };\n      }\n      const eventIds = JSON.stringify([\n        ...new Set(deleted.map((row) => row['event_id'] as string)),\n      ]);\n      const locked = await this.#executor.query(\n        this.#statements.lockEvents,\n        [eventIds],\n        transaction,\n      );\n      const removed = await this.#executor.query(\n        this.#statements.deleteOrphanEvents,\n        [JSON.stringify(locked.map((row: PostgresRow) => row['id'] as string))],\n        transaction,\n      );\n      return { deletedDeliveries: deleted.length, deletedEvents: readCount(removed[0]!, 'count') };\n    });\n  }\n}\n\ninterface AppendPlan {\n  /** First occurrence of every event id in the call, in entry order. */\n  readonly events: readonly EventEnvelope[];\n  readonly deliveries: readonly DeliveryRow[];\n  /** One per entry: its event id, and whether an earlier entry of the call carried the same id. */\n  readonly outcomes: ReadonlyArray<{ readonly eventId: string; readonly repeated: boolean }>;\n}\n\nfunction planAppend(entries: readonly AppendEntry[]): AppendPlan {\n  const events: EventEnvelope[] = [];\n  const deliveries: DeliveryRow[] = [];\n  const outcomes: Array<{ eventId: string; repeated: boolean }> = [];\n  const seenEventIds = new Set<string>();\n  const seenDeliveries = new Set<string>();\n  for (const { event, deliveries: newDeliveries } of entries) {\n    const repeated = seenEventIds.has(event.id);\n    seenEventIds.add(event.id);\n    outcomes.push({ eventId: event.id, repeated });\n    if (!repeated) {\n      events.push(event);\n    }\n    for (const delivery of newDeliveries) {\n      const identity = `${event.id}\\u0000${delivery.handler}`;\n      if (!seenDeliveries.has(identity)) {\n        seenDeliveries.add(identity);\n        deliveries.push({\n          id: delivery.id,\n          event_id: event.id,\n          handler: delivery.handler,\n          available_at: delivery.availableAt.toISOString(),\n        });\n      }\n    }\n  }\n  return { events, deliveries, outcomes };\n}\n\nfunction toEventRows(\n  events: readonly EventEnvelope[],\n  firstSequences: ReadonlyMap<string, bigint>,\n): EventRow[] {\n  const nextSequences = new Map(firstSequences);\n  return events.map((event) => {\n    let sequence: string | null = null;\n    if (event.key !== null) {\n      const next = nextSequences.get(event.key)!;\n      nextSequences.set(event.key, next + 1n);\n      sequence = next.toString();\n    }\n    return {\n      id: event.id,\n      type: event.type,\n      source: event.source,\n      key: event.key,\n      sequence,\n      payload: event.payload,\n      headers: event.headers,\n      correlation_id: event.correlationId,\n      causation_id: event.causationId,\n      occurred_at: event.occurredAt.toISOString(),\n    };\n  });\n}\n"]}
+{"version":3,"sources":["../src/pg-executor.ts","../src/identifiers.ts","../src/names.ts","../src/sql-fragments.ts","../src/schema.ts","../src/notification-listener.ts","../src/row-mapping.ts","../src/statements.ts","../src/postgres-event-store.ts"],"names":["createHash","ConfigurationError","Pool","inserted","Client"],"mappings":"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","file":"index.cjs","sourcesContent":["import { createHash } from 'node:crypto';\nimport type { RelayBusLogger } from '@relaybus/core';\nimport type { Pool, PoolClient } from 'pg';\nimport type {\n  PostgresExecutor,\n  PostgresParameter,\n  PostgresQueryOptions,\n  PostgresRow,\n} from './executor.js';\n\n/**\n * SQLSTATEs of a named statement the server does not know (26000) or already has under that name\n * (42P05). Both mean the connection the statement ran on is not the session that prepared it, which is\n * what a pooler in transaction mode without prepared statement support (PgBouncer before 1.21) does.\n */\nconst FOREIGN_SESSION_ERRORS = new Set(['26000', '42P05']);\n\nexport interface PgExecutorOptions {\n  /** Receives the warning sent when prepared statements are switched off. Default `console`. */\n  readonly logger?: RelayBusLogger;\n}\n\n/**\n * Executor for a `pg` {@link Pool}. A transaction is a dedicated pool client\n * between `BEGIN` and `COMMIT`; it is handed to callers as the transaction\n * handle, so they can run their own queries on it.\n *\n * A statement sent with `prepare: true` is a named prepared statement: each\n * connection parses and plans its text once and from then on only binds the\n * parameters. Its name is derived from the text, so stores with different\n * tables never share one. When the server reports that a prepared statement\n * does not exist on the connection, or already does (a pooler such as\n * PgBouncer before 1.21 in transaction mode hands every transaction another\n * server session), the executor stops preparing for good, logs a warning, and\n * runs the statement again unprepared unless it belonged to a transaction,\n * which has failed by then and is the caller's to retry.\n */\nexport class PgExecutor implements PostgresExecutor<PoolClient> {\n  readonly #pool: Pool;\n  readonly #logger: RelayBusLogger;\n  readonly #names = new Map<string, string>();\n  #preparing = true;\n\n  constructor(pool: Pool, options: PgExecutorOptions = {}) {\n    this.#pool = pool;\n    this.#logger = options.logger ?? console;\n  }\n\n  async transaction<T>(work: (transaction: PoolClient) => Promise<T>): Promise<T> {\n    const client = await this.#pool.connect();\n    try {\n      await client.query('BEGIN');\n      const result = await work(client);\n      await client.query('COMMIT');\n      client.release();\n      return result;\n    } catch (error) {\n      await this.#rollbackAndRelease(client);\n      throw error;\n    }\n  }\n\n  async query(\n    sql: string,\n    parameters: readonly PostgresParameter[],\n    transaction?: PoolClient,\n    options?: PostgresQueryOptions,\n  ): Promise<readonly PostgresRow[]> {\n    const queryable = transaction ?? this.#pool;\n    const values = [...parameters];\n    if (options?.prepare !== true || !this.#preparing) {\n      return (await queryable.query<PostgresRow>(sql, values)).rows;\n    }\n    try {\n      return (await queryable.query<PostgresRow>({ name: this.#nameOf(sql), text: sql, values }))\n        .rows;\n    } catch (error) {\n      if (!FOREIGN_SESSION_ERRORS.has((error as { code?: unknown }).code as string)) {\n        throw error;\n      }\n      if (this.#preparing) {\n        this.#preparing = false;\n        this.#logger.warn(\n          `[PgExecutor](query) The server does not keep prepared statements per connection, statements are sent unprepared from now on; set preparedStatements: false to skip this check | code=${String((error as { code?: unknown }).code)}`,\n        );\n      }\n      if (transaction !== undefined) {\n        throw error;\n      }\n      return (await queryable.query<PostgresRow>(sql, values)).rows;\n    }\n  }\n\n  /** `relaybus_` and 24 hex digits of the SHA-256 of the text: well under the 63 bytes of an identifier. */\n  #nameOf(sql: string): string {\n    let name = this.#names.get(sql);\n    if (name === undefined) {\n      name = `relaybus_${createHash('sha256').update(sql).digest('hex').slice(0, 24)}`;\n      this.#names.set(sql, name);\n    }\n    return name;\n  }\n\n  /** A client whose rollback fails is in an unknown state, so it is destroyed instead of reused. */\n  async #rollbackAndRelease(client: PoolClient): Promise<void> {\n    try {\n      await client.query('ROLLBACK');\n      client.release();\n    } catch {\n      client.release(true);\n    }\n  }\n}\n","import { ConfigurationError } from '@relaybus/core';\n\nconst IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_]*$/;\nconst MAXIMUM_IDENTIFIER_LENGTH = 63;\n\n/**\n * Throws {@link ConfigurationError} unless `value` is a plain lower-case\n * PostgreSQL identifier. Identifiers are interpolated into SQL text (they\n * cannot be bound as parameters), so this is the injection boundary: only\n * letters, digits and underscores survive, and nothing needs escaping.\n */\nexport function assertIdentifier(label: string, value: string): void {\n  if (!IDENTIFIER_PATTERN.test(value) || value.length > MAXIMUM_IDENTIFIER_LENGTH) {\n    throw new ConfigurationError(\n      `${label} '${value}' must match ${String(IDENTIFIER_PATTERN)} and be at most ${MAXIMUM_IDENTIFIER_LENGTH} characters`,\n    );\n  }\n}\n\n/** Double-quotes an identifier that already passed {@link assertIdentifier}. */\nexport function quoteIdentifier(value: string): string {\n  return `\"${value}\"`;\n}\n","import { ConfigurationError } from '@relaybus/core';\nimport { createHash } from 'node:crypto';\nimport { assertIdentifier, quoteIdentifier } from './identifiers.js';\n\n/** Where relaybus keeps its tables. */\nexport interface PostgresSchemaOptions {\n  /** Schema that holds the tables. Created by `setup()` when it is not `public`. Default `'public'`. */\n  readonly schema?: string;\n  /**\n   * Prepended to every table and index name, which makes the names\n   * `<prefix>events`, `<prefix>deliveries` and `<prefix>key_sequences`.\n   * Lower-case letters, digits and underscores. Default `'relaybus_'`.\n   */\n  readonly tablePrefix?: string;\n  /**\n   * Keep an append-only record of completed deliveries in\n   * `<prefix>completed_deliveries`, so `listDeliveries({ status: 'completed' })`,\n   * `statistics().completed` and `retention.completed` keep working. Default\n   * `false`: a completed delivery is deleted, which avoids the dead tuples and\n   * index churn of updating it. Use the same value in every process.\n   */\n  readonly completionHistory?: boolean;\n}\n\n/** Validated, quoted names used to build SQL. */\nexport interface PostgresNames {\n  readonly schema: string;\n  readonly quotedSchema: string;\n  readonly events: string;\n  readonly deliveries: string;\n  readonly keySequences: string;\n  /** Lane lease rows: one per lane, see {@link LANE_COUNT}. */\n  readonly lanes: string;\n  /** Unquoted, unqualified name of {@link lanes}, for catalog lookups. */\n  readonly lanesTableName: string;\n  /** One row per event that had a delivery complete: when the last one did. Retention of completed work is measured from it. */\n  readonly eventCompletions: string;\n  /** Completion history, present only with `completionHistory`. */\n  readonly completions: string;\n  readonly completionHistory: boolean;\n  /**\n   * Channel of the notifications that wake dispatchers when deliveries were published:\n   * `<schema>.<prefix>deliveries`, or a hash of it when that is longer than a channel name may be.\n   */\n  readonly notificationChannel: string;\n  /** Index names, quoted but not schema-qualified (an index lives in its table's schema). */\n  readonly indexes: {\n    readonly deliveryEventHandler: string;\n    readonly deliveryLaneDue: string;\n    readonly deliveryKeyPending: string;\n    readonly eventCreated: string;\n    readonly deliveryCompleted: string;\n    readonly deliveryDead: string;\n    readonly completionCompleted: string;\n    readonly eventCompletionsCompleted: string;\n    /** Indexes of the 0.1.0 schema that the current schema drops. */\n    readonly obsolete: readonly string[];\n  };\n}\n\n/**\n * Number of lanes. Every delivery belongs to the lane of its ordering key (or of\n * its event id when the event has no key); workers lease whole lanes. The count\n * is fixed because the lane of a delivery is stored, and all processes must\n * agree on it.\n */\nexport const LANE_COUNT = 256;\n\nconst DEFAULT_SCHEMA = 'public';\nconst MAXIMUM_CHANNEL_LENGTH = 63;\nconst DEFAULT_TABLE_PREFIX = 'relaybus_';\nconst TABLE_PREFIX_PATTERN = /^[a-z0-9_]*$/;\n\n/**\n * Validates the options and derives every name the store uses. Every name,\n * including the longest index name, is checked against the PostgreSQL 63\n * character limit so that a too-long prefix fails here and not as a\n * silently truncated, colliding name in the database.\n */\nexport function resolvePostgresNames(options: PostgresSchemaOptions = {}): PostgresNames {\n  const schema = options.schema ?? DEFAULT_SCHEMA;\n  const tablePrefix = options.tablePrefix ?? DEFAULT_TABLE_PREFIX;\n  assertIdentifier('schema', schema);\n  if (!TABLE_PREFIX_PATTERN.test(tablePrefix)) {\n    throw new ConfigurationError(\n      `tablePrefix '${tablePrefix}' must match ${String(TABLE_PREFIX_PATTERN)}`,\n    );\n  }\n  const name = (suffix: string): string => {\n    const identifier = `${tablePrefix}${suffix}`;\n    assertIdentifier(`tablePrefix '${tablePrefix}' produces the name`, identifier);\n    return identifier;\n  };\n  const quotedSchema = quoteIdentifier(schema);\n  const table = (suffix: string): string => `${quotedSchema}.${quoteIdentifier(name(suffix))}`;\n  const index = (suffix: string): string => quoteIdentifier(name(suffix));\n  return {\n    schema,\n    quotedSchema,\n    events: table('events'),\n    deliveries: table('deliveries'),\n    keySequences: table('key_sequences'),\n    lanes: table('lanes'),\n    lanesTableName: name('lanes'),\n    eventCompletions: table('event_completions'),\n    completions: table('completed_deliveries'),\n    completionHistory: options.completionHistory ?? false,\n    notificationChannel: channelName(`${schema}.${tablePrefix}deliveries`),\n    indexes: {\n      deliveryEventHandler: index('deliveries_event_handler_unique'),\n      deliveryLaneDue: index('deliveries_lane_due_idx'),\n      deliveryKeyPending: index('deliveries_key_pending_idx'),\n      eventCreated: index('events_created_idx'),\n      deliveryCompleted: index('deliveries_completed_idx'),\n      deliveryDead: index('deliveries_dead_idx'),\n      completionCompleted: index('completed_deliveries_completed_idx'),\n      eventCompletionsCompleted: index('event_completions_completed_idx'),\n      obsolete: [\n        index('deliveries_due_idx'),\n        index('deliveries_due_unkeyed_idx'),\n        index('deliveries_handler_created_idx'),\n        index('deliveries_key_unfinished_idx'),\n        index('deliveries_key_processing_idx'),\n        index('deliveries_status_created_idx'),\n      ],\n    },\n  };\n}\n\n/** PostgreSQL truncates names longer than 63 bytes, which could merge channels: those are hashed instead. */\nfunction channelName(readable: string): string {\n  return readable.length <= MAXIMUM_CHANNEL_LENGTH\n    ? readable\n    : `relaybus_${createHash('sha256').update(readable).digest('hex').slice(0, 32)}`;\n}\n","import { LANE_COUNT } from './names.js';\n\n/**\n * Renders a timestamptz as ISO-8601 text in UTC. Reading timestamps as text\n * makes results independent of the driver's type parsers (Drizzle, for\n * instance, replaces them) and of the session time zone.\n */\nexport function isoText(expression: string): string {\n  return `to_char(${expression} AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"')`;\n}\n\n/**\n * The lane of a delivery: a hash of the ordering key, or of the event id when\n * the event has no key. All deliveries of one key therefore share a lane and\n * are owned by one worker at a time, which is what keeps their order.\n * `hashtextextended` is stable across PostgreSQL versions and platforms.\n */\nexport function laneExpression(keyExpression: string, eventIdExpression: string): string {\n  return `(hashtextextended(COALESCE(${keyExpression}, ${eventIdExpression}), 0) & ${LANE_COUNT - 1})::smallint`;\n}\n","import { createHash } from 'node:crypto';\nimport { LANE_COUNT, resolvePostgresNames, type PostgresSchemaOptions } from './names.js';\nimport { laneExpression } from './sql-fragments.js';\n\n/**\n * Statements that create the schema, tables and indexes, in dependency order,\n * and upgrade a 0.1.0 schema in place. Every statement is idempotent\n * (`IF NOT EXISTS`, or guarded by a check for the 0.1.0 columns). Run them in\n * one transaction and serialize concurrent runs (see\n * {@link PostgresEventStore.setup}), or paste {@link createPostgresSchemaSql}\n * into your own migration tool.\n *\n * `events.id` and `deliveries.id` are `text` so that any caller-supplied id\n * (UUID, ULID, deterministic business id) is accepted. `deliveries.id` uses the\n * `C` collation so that ordering by id matches a byte-wise comparison on every\n * database, whatever its locale.\n *\n * A delivery row is written once (insert) and removed once (delete) on the\n * normal path. The lease lives in the lane row a delivery belongs to, so\n * claiming, renewing and completing never update an indexed column of the\n * delivery. The lane table is tiny, has no index besides its primary key and\n * leaves free space in its pages, so its updates are heap-only (HOT).\n */\nexport function createPostgresSchemaStatements(options: PostgresSchemaOptions = {}): string[] {\n  const names = resolvePostgresNames(options);\n  const statements = [\n    `CREATE TABLE IF NOT EXISTS ${names.events} (\n  id text PRIMARY KEY,\n  type text NOT NULL,\n  source text NOT NULL,\n  key text,\n  sequence bigint,\n  payload jsonb NOT NULL,\n  headers jsonb NOT NULL DEFAULT '{}'::jsonb,\n  correlation_id text,\n  causation_id text,\n  occurred_at timestamptz NOT NULL,\n  created_at timestamptz NOT NULL,\n  handlers text[] NOT NULL DEFAULT '{}'\n)`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.eventCreated} ON ${names.events} (created_at, id)`,\n    `CREATE TABLE IF NOT EXISTS ${names.keySequences} (\n  key text PRIMARY KEY,\n  sequence bigint NOT NULL\n)`,\n    `CREATE TABLE IF NOT EXISTS ${names.deliveries} (\n  id text COLLATE \"C\" PRIMARY KEY,\n  event_id text NOT NULL REFERENCES ${names.events} (id) ON DELETE CASCADE,\n  handler text NOT NULL,\n  lane smallint NOT NULL,\n  claims integer NOT NULL DEFAULT 0,\n  status text NOT NULL CHECK (status IN ('pending', 'processing', 'completed', 'dead')),\n  attempts integer NOT NULL DEFAULT 0,\n  available_at timestamptz NOT NULL,\n  last_error jsonb,\n  key text,\n  sequence bigint,\n  created_at timestamptz NOT NULL,\n  updated_at timestamptz NOT NULL,\n  completed_at timestamptz,\n  CONSTRAINT ${names.indexes.deliveryEventHandler} UNIQUE (event_id, handler)\n) WITH (autovacuum_vacuum_scale_factor = 0.02, autovacuum_analyze_scale_factor = 0.05)`,\n    upgradeFromVersion010(names),\n    `ALTER TABLE ${names.deliveries} ADD COLUMN IF NOT EXISTS claims integer NOT NULL DEFAULT 0`,\n    `ALTER TABLE ${names.deliveries} SET (autovacuum_vacuum_scale_factor = 0.02, autovacuum_analyze_scale_factor = 0.05)`,\n    ...names.indexes.obsolete.map((index) => `DROP INDEX IF EXISTS ${names.quotedSchema}.${index}`),\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryLaneDue} ON ${names.deliveries} (lane, available_at, id) WHERE status = 'pending'`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryKeyPending} ON ${names.deliveries} (lane, handler, key, sequence) WHERE key IS NOT NULL AND status = 'pending'`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryCompleted} ON ${names.deliveries} (completed_at, id) WHERE status = 'completed'`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.deliveryDead} ON ${names.deliveries} (updated_at, id) WHERE status = 'dead'`,\n    `CREATE TABLE IF NOT EXISTS ${names.lanes} (\n  lane smallint PRIMARY KEY CHECK (lane >= 0 AND lane < ${LANE_COUNT}),\n  epoch bigint NOT NULL DEFAULT 0,\n  lease_owner text,\n  lease_expires_at timestamptz,\n  in_flight text[] NOT NULL DEFAULT '{}',\n  claim_floor bigint NOT NULL DEFAULT 0\n) WITH (fillfactor = 50)`,\n    `ALTER TABLE ${names.lanes} ADD COLUMN IF NOT EXISTS claim_floor bigint NOT NULL DEFAULT 0`,\n    `CREATE TABLE IF NOT EXISTS ${names.eventCompletions} (\n  event_id text PRIMARY KEY REFERENCES ${names.events} (id) ON DELETE CASCADE,\n  completed_at timestamptz NOT NULL\n)`,\n    `CREATE INDEX IF NOT EXISTS ${names.indexes.eventCompletionsCompleted} ON ${names.eventCompletions} (completed_at, event_id)`,\n    `INSERT INTO ${names.lanes} (lane) SELECT generate_series(0, ${LANE_COUNT - 1})::smallint ON CONFLICT (lane) DO NOTHING`,\n  ];\n  if (names.completionHistory) {\n    statements.push(\n      `CREATE TABLE IF NOT EXISTS ${names.completions} (\n  id text COLLATE \"C\" PRIMARY KEY,\n  event_id text NOT NULL REFERENCES ${names.events} (id) ON DELETE CASCADE,\n  handler text NOT NULL,\n  attempts integer NOT NULL,\n  available_at timestamptz NOT NULL,\n  created_at timestamptz NOT NULL,\n  completed_at timestamptz NOT NULL\n)`,\n      `CREATE INDEX IF NOT EXISTS ${names.indexes.completionCompleted} ON ${names.completions} (completed_at, id)`,\n    );\n  }\n  if (names.schema !== 'public') {\n    statements.unshift(`CREATE SCHEMA IF NOT EXISTS ${names.quotedSchema}`);\n  }\n  statements.push(`COMMENT ON TABLE ${names.lanes} IS '${postgresSchemaMarker(statements)}'`);\n  return statements;\n}\n\n/**\n * The comment the last schema statement leaves on the lane table: a hash of every statement\n * before it. {@link PostgresEventStore.setup} reads it to skip the statements when the schema is\n * already current, because their table locks queue behind running claims and completions and\n * deadlock with them.\n */\nexport function postgresSchemaMarker(statements: readonly string[]): string {\n  return `relaybus schema ${createHash('sha256').update(statements.join(';')).digest('hex').slice(0, 32)}`;\n}\n\n/**\n * Upgrades a 0.1.0 deliveries table, recognized by its `lease_token` column.\n * Rows keep their ids, attempts and payload references. Deliveries that were\n * `processing` become `pending` (their attempt stays counted, as a lost lease\n * would count it), every row gets its lane, every event learns which handlers\n * it already has deliveries for, and the per-delivery lease columns go. Deliveries completed under 0.1.0 stay as `completed` rows until\n * `retention.completed` purges them. Stop all 0.1.0 workers before the first\n * run: they cannot use the upgraded tables.\n */\nfunction upgradeFromVersion010(names: ReturnType<typeof resolvePostgresNames>): string {\n  return `DO $relaybus_upgrade$\nBEGIN\n  IF EXISTS (\n    SELECT 1 FROM pg_attribute\n    WHERE attrelid = '${names.deliveries}'::regclass AND attname = 'lease_token' AND NOT attisdropped\n  ) THEN\n    ALTER TABLE ${names.events} ADD COLUMN IF NOT EXISTS handlers text[] NOT NULL DEFAULT '{}';\n    UPDATE ${names.events} AS event SET handlers = known.handlers\n    FROM (\n      SELECT event_id, array_agg(handler) AS handlers FROM ${names.deliveries} GROUP BY event_id\n    ) AS known\n    WHERE event.id = known.event_id;\n    ALTER TABLE ${names.deliveries} ADD COLUMN IF NOT EXISTS lane smallint;\n    UPDATE ${names.deliveries} SET lane = ${laneExpression('key', 'event_id')} WHERE lane IS NULL;\n    ALTER TABLE ${names.deliveries} ALTER COLUMN lane SET NOT NULL;\n    UPDATE ${names.deliveries} SET status = 'pending' WHERE status = 'processing';\n    ALTER TABLE ${names.deliveries}\n      DROP COLUMN lease_owner, DROP COLUMN lease_token, DROP COLUMN lease_expires_at;\n  END IF;\nEND\n$relaybus_upgrade$`;\n}\n\n/**\n * The statements of {@link createPostgresSchemaStatements} as one SQL script,\n * for migration tools. Pair it with `new RelayBus({ setupStore: false })`.\n */\nexport function createPostgresSchemaSql(options: PostgresSchemaOptions = {}): string {\n  return `${createPostgresSchemaStatements(options).join(';\\n\\n')};\\n`;\n}\n","import type { RelayBusLogger } from '@relaybus/core';\n\n/** Wait before a lost listening connection is opened again. */\nconst RECONNECT_DELAY_MS = 1_000;\n\n/** What the listener needs of a connection: a `pg` `Client` has it. */\nexport interface ListeningConnection {\n  on(event: 'notification', listener: () => void): unknown;\n  on(event: 'error', listener: (error: Error) => void): unknown;\n  on(event: 'end', listener: () => void): unknown;\n  query(sql: string): Promise<unknown>;\n  end(): Promise<void>;\n}\n\n/**\n * Holds one connection of its own (outside any pool, so it never takes a connection the store needs)\n * that `LISTEN`s on a channel, and calls a listener for every notification. The notifications are hints\n * for the dispatcher, never needed for correctness: when the connection is lost it is replaced after a\n * pause, and the listener is called once for whatever was sent meanwhile.\n */\nexport class NotificationListener {\n  readonly #connect: () => Promise<ListeningConnection>;\n  readonly #channel: string;\n  readonly #listener: () => void;\n  readonly #logger: RelayBusLogger;\n  /** Ends the current connection, listening or still starting; undefined while there is none. */\n  #drop: (() => Promise<void>) | undefined;\n  #reconnectTimer: NodeJS.Timeout | undefined;\n  #closed = false;\n\n  constructor(\n    connect: () => Promise<ListeningConnection>,\n    channel: string,\n    listener: () => void,\n    logger: RelayBusLogger,\n  ) {\n    this.#connect = connect;\n    this.#channel = channel;\n    this.#listener = listener;\n    this.#logger = logger;\n  }\n\n  /** Connects and listens. Rejects when that fails; a connection lost later is replaced. */\n  async start(): Promise<void> {\n    const connection = await this.#connect();\n    let ended = false;\n    let ending: Promise<void> = Promise.resolve();\n    // Idempotent: a loss, a failed start and closing may all end the same connection. `ended` is set\n    // first because ending can report the end synchronously, which calls back into `onLost`.\n    const end = (): Promise<void> => {\n      if (!ended) {\n        ended = true;\n        ending = connection.end().catch(() => undefined);\n      }\n      return ending;\n    };\n    if (this.#closed) {\n      await end();\n      return;\n    }\n    // Registered before LISTEN, so closing ends a connection whose LISTEN has not answered yet.\n    this.#drop = end;\n    let listening = false;\n    const onLost = (error?: Error): void => {\n      if (!listening || ended) {\n        // While starting, a failure surfaces as the rejection of LISTEN, which ends the connection.\n        return;\n      }\n      void end();\n      // Only a listening connection gets here, and it is always the current one.\n      this.#drop = undefined;\n      this.#logger.warn(\n        `[NotificationListener](start) Listening connection lost, opening another | channel=${this.#channel} | error=${error?.message ?? 'connection ended'}`,\n      );\n      this.#scheduleReconnect();\n    };\n    connection.on('error', onLost);\n    connection.on('end', () => onLost());\n    connection.on('notification', () => this.#listener());\n    try {\n      await connection.query(`LISTEN \"${this.#channel}\"`);\n    } catch (error) {\n      if (this.#drop === end) {\n        this.#drop = undefined;\n      }\n      await end();\n      if (this.#closed) {\n        // Closing ended the connection while LISTEN was pending: not a failure to report.\n        return;\n      }\n      throw error;\n    }\n    if (this.#closed) {\n      await end();\n      return;\n    }\n    listening = true;\n  }\n\n  #scheduleReconnect(): void {\n    this.#reconnectTimer = setTimeout(() => {\n      this.#reconnectTimer = undefined;\n      this.start().then(\n        () => {\n          if (!this.#closed) {\n            this.#listener();\n          }\n        },\n        (error: unknown) => {\n          this.#logger.warn(\n            `[NotificationListener](scheduleReconnect) Listening again failed, retrying | channel=${this.#channel} | error=${error instanceof Error ? error.message : String(error)}`,\n          );\n          if (!this.#closed) {\n            this.#scheduleReconnect();\n          }\n        },\n      );\n    }, RECONNECT_DELAY_MS);\n    this.#reconnectTimer.unref();\n  }\n\n  /** Stops listening for good and ends the connection. */\n  async close(): Promise<void> {\n    this.#closed = true;\n    clearTimeout(this.#reconnectTimer);\n    const drop = this.#drop;\n    this.#drop = undefined;\n    await drop?.();\n  }\n}\n","import type {\n  ClaimedDelivery,\n  DeliveryRecord,\n  DeliveryStatus,\n  ErrorInfo,\n  EventEnvelope,\n  EventHeaders,\n} from '@relaybus/core';\nimport type { PostgresRow } from './executor.js';\nimport { LANE_COUNT } from './names.js';\n\n// Rows come from statements written in this package, so their shape is known.\n// Casting here is the single place where driver output is trusted.\n\nfunction text(row: PostgresRow, column: string): string {\n  return row[column] as string;\n}\n\nfunction nullableText(row: PostgresRow, column: string): string | null {\n  return row[column] as string | null;\n}\n\nfunction nullableDate(row: PostgresRow, column: string): Date | null {\n  const value = nullableText(row, column);\n  return value === null ? null : new Date(value);\n}\n\n/** Count columns arrive as number, string or bigint depending on the driver. */\nexport function readCount(row: PostgresRow, column: string): number {\n  return Number(row[column]);\n}\n\nexport function mapEventEnvelope(row: PostgresRow): EventEnvelope {\n  return {\n    id: text(row, 'event_id'),\n    type: text(row, 'event_type'),\n    source: text(row, 'event_source'),\n    key: nullableText(row, 'event_key'),\n    payload: JSON.parse(text(row, 'event_payload')) as unknown,\n    headers: JSON.parse(text(row, 'event_headers')) as EventHeaders,\n    correlationId: nullableText(row, 'event_correlation_id'),\n    causationId: nullableText(row, 'event_causation_id'),\n    occurredAt: new Date(text(row, 'event_occurred_at')),\n  };\n}\n\n/**\n * The fencing token of a claimed delivery names its lane and the lane's epoch,\n * so every state change can check the lane without reading the delivery first.\n */\nexport function formatLeaseToken(lane: number, epoch: string, claims: number): string {\n  return `${lane}:${epoch}:${claims}`;\n}\n\nexport interface LaneLease {\n  readonly lane: number;\n  readonly epoch: string;\n  /** How many claims of this delivery ended before this one; every end of a claim bumps it, so an old lease can never match a newer claim. */\n  readonly claims: number;\n}\n\nconst LEASE_TOKEN_PATTERN = /^(\\d{1,3}):(\\d{1,18}):(\\d{1,9})$/;\n\n/** Splits a lease token; undefined when it was not issued by this store. */\nexport function parseLeaseToken(token: string): LaneLease | undefined {\n  const match = LEASE_TOKEN_PATTERN.exec(token);\n  if (match === null || Number(match[1]) >= LANE_COUNT) {\n    return undefined;\n  }\n  return { lane: Number(match[1]), epoch: match[2]!, claims: Number(match[3]) };\n}\n\nexport function mapClaimedDelivery(row: PostgresRow, leaseExpiresAt: Date): ClaimedDelivery {\n  return {\n    deliveryId: text(row, 'delivery_id'),\n    leaseToken: formatLeaseToken(\n      readCount(row, 'lane'),\n      text(row, 'epoch'),\n      readCount(row, 'claims'),\n    ),\n    handler: text(row, 'handler'),\n    attempt: readCount(row, 'attempt'),\n    leaseExpiresAt,\n    event: mapEventEnvelope(row),\n  };\n}\n\nexport function mapDeliveryRecord(row: PostgresRow): DeliveryRecord {\n  const lastError = nullableText(row, 'last_error');\n  return {\n    id: text(row, 'delivery_id'),\n    handler: text(row, 'handler'),\n    status: text(row, 'status') as DeliveryStatus,\n    attempts: readCount(row, 'attempts'),\n    availableAt: new Date(text(row, 'available_at')),\n    leaseOwner: nullableText(row, 'lease_owner'),\n    leaseExpiresAt: nullableDate(row, 'lease_expires_at'),\n    lastError: lastError === null ? null : (JSON.parse(lastError) as ErrorInfo),\n    createdAt: new Date(text(row, 'created_at')),\n    updatedAt: new Date(text(row, 'updated_at')),\n    completedAt: nullableDate(row, 'completed_at'),\n    event: mapEventEnvelope(row),\n  };\n}\n\nexport function mapOldestDueAt(rows: readonly PostgresRow[]): Date | null {\n  return nullableDate(rows[0]!, 'oldest_due_at');\n}\n","import type { DeliveryQuery } from '@relaybus/core';\nimport type { PostgresNames } from './names.js';\nimport { isoText, laneExpression } from './sql-fragments.js';\nimport type { PostgresParameter } from './executor.js';\n\nexport interface PostgresStatement {\n  readonly sql: string;\n  readonly parameters: readonly PostgresParameter[];\n}\n\nconst DEFAULT_LIST_LIMIT = 100;\n\nfunction eventColumns(alias: string): string {\n  return `${alias}.id AS event_id,\n    ${alias}.type AS event_type,\n    ${alias}.source AS event_source,\n    ${alias}.key AS event_key,\n    ${alias}.payload::text AS event_payload,\n    ${alias}.headers::text AS event_headers,\n    ${alias}.correlation_id AS event_correlation_id,\n    ${alias}.causation_id AS event_causation_id,\n    ${isoText(`${alias}.occurred_at`)} AS event_occurred_at`;\n}\n\n/** `WITH changed AS (<dml> RETURNING 1) SELECT count(*)`: a top-level SELECT works the same on every driver. */\nfunction countChanged(dml: string): string {\n  return `WITH changed AS (${dml} RETURNING 1) SELECT count(*)::int AS count FROM changed`;\n}\n\n/**\n * Due deliveries the fast claim examines before it gives up and lets the slow\n * claim look at the heads of all keys.\n */\nconst CLAIM_SCAN_WINDOW = 256;\n\n/** Due deliveries the fast claim reads from one lane. A lane that fills it may hide claimable deliveries behind blocked followers. */\nconst LANE_SCAN_WINDOW = 64;\n\n/**\n * Due deliveries of a free lane a claim looks at when it decides how many lanes to take: their unkeyed\n * deliveries and distinct keys estimate what the lane can give, so a deep backlog is taken a few lanes\n * at a time and a lane of few hot keys counts for no more than its keys.\n */\nconst LANE_DEPTH_CAP = 16;\n\n/** Free lanes a claim that needs more takes at least (those with the oldest due deliveries), as in its first round. */\nconst INITIAL_FREE_LANES = 4;\n\n/**\n * Free lanes a claim looks at beyond the number of deliveries it still wants, so lanes whose due\n * deliveries all wait behind a key's later head do not hide the others. When even these are not enough\n * the claim continues in the transaction that takes lanes round by round.\n */\nconst FREE_LANE_SURPLUS = 16;\n\nconst HANDLER_PREDICATE = `delivery.handler = ANY (ARRAY(SELECT jsonb_array_elements_text($2::jsonb)))`;\n\nconst LANE_LIST = `ARRAY(SELECT jsonb_array_elements_text($4::jsonb)::smallint)`;\n\n/**\n * SQL text for every operation of the store. Statements take their data as\n * parameters; only validated identifiers are interpolated. Documents travel\n * as one JSON text parameter expanded server-side with `jsonb_to_recordset`,\n * which keeps the statements identical across drivers and avoids array\n * literal encoding differences.\n *\n * Leasing is per lane, not per delivery. A lane row carries the owner, an\n * `epoch` (the fencing token: it grows every time the lane changes hands) and\n * `in_flight`, the ids of the deliveries the owner has claimed. A claim\n * therefore writes one lane row for a whole batch and no delivery row; a\n * completion deletes delivery rows and writes no lane row. `in_flight` may\n * list ids that were completed (their rows are gone): a delivery is in flight\n * only while its row exists as `pending` and its id is listed.\n *\n * **Lock order.** Every statement that can wait for a lock takes its locks in this order, and rows of\n * one table in key order, so no two of them can wait for each other in a cycle:\n *\n * 1. the setup advisory lock and the schema DDL ({@link setupLock}); only while the schema is created or\n *    upgraded, never on a current schema (see `PostgresEventStore.setup`);\n * 2. `key_sequences` rows, in key order ({@link insertFreshEvents});\n * 3. `events` rows, in id order ({@link lockExistingEvents}, the inserts of a publish, the foreign key\n *    checks of new deliveries and completions);\n * 4. `lanes` rows, in lane order: `FOR NO KEY UPDATE` for the owner's held lanes, `FOR KEY SHARE` for\n *    completions, `FOR UPDATE SKIP LOCKED` (never waits) for lanes taken from others;\n * 5. `deliveries` rows, only of lanes locked in step 4 (claims, completions, reschedules, takeovers),\n *    or inserted new (publish), or `dead` ones in id order ({@link requeue});\n * 6. `event_completions` rows, in event id order ({@link complete}).\n *\n * Publishing never touches `lanes`, and dispatching never touches `key_sequences`. Purging only takes\n * `SKIP LOCKED` row locks and then deletes rows nobody references, so it never waits in a cycle either.\n * A caller's own transaction (a transactional handler that completes and publishes) adds the locks of\n * its own statements in the order it runs them; as documented on `append`, keys appended in opposite\n * orders by two such transactions can still deadlock, and the database then rolls one back.\n */\nexport class PostgresStatements {\n  readonly #names: PostgresNames;\n\n  constructor(names: PostgresNames) {\n    this.#names = names;\n  }\n\n  /**\n   * Lock advisory key text for {@link setupLock}. It is derived from the schema\n   * name only, so stores with different table prefixes in one schema also\n   * serialize their `CREATE SCHEMA IF NOT EXISTS`, which is not race-free.\n   */\n  get setupLockKey(): string {\n    return `relaybus:${this.#names.schema}`;\n  }\n\n  /**\n   * Whether the lane table carries `marker` as its comment, that is whether the schema statements\n   * that produce that marker already ran. Takes no table lock. Parameters: `[marker]`.\n   */\n  get schemaCurrent(): string {\n    // Reads the catalogs with the statement's snapshot. `to_regclass` and `obj_description` would go\n    // through the backend's catalog caches, which keep \"no such table\" until the session processes\n    // invalidations; a setup that waited for the setup lock would then miss a schema created meanwhile.\n    return `SELECT EXISTS (\n  SELECT 1 FROM pg_catalog.pg_class AS c\n  JOIN pg_catalog.pg_namespace AS n ON n.oid = c.relnamespace\n  JOIN pg_catalog.pg_description AS d\n    ON d.objoid = c.oid AND d.classoid = 'pg_catalog.pg_class'::regclass AND d.objsubid = 0\n  WHERE n.nspname = '${this.#names.schema}' AND c.relname = '${this.#names.lanesTableName}' AND d.description = $1::text\n) AS current`;\n  }\n\n  get setupLock(): string {\n    return 'SELECT pg_advisory_xact_lock(hashtextextended($1::text, 0))';\n  }\n\n  /**\n   * Publishes in one statement: reserves the sequences of the keys (`[{ key, count }]` in `$4`, locked in\n   * 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\n   * the events of `$1` that do not exist yet and the deliveries of `$3` that belong to them, and sends one\n   * wake-up notification when a delivery it inserted is due at `$5`. Parameters:\n   * `[eventsJson, createdAt, deliveriesJson, keyCountsJson, now]`. Returns one row per event of `$1`: its\n   * id, its sequence, whether this statement inserted it, and (on every row) how many deliveries it\n   * inserted. Deliveries of events that already existed are left to {@link insertDeliveries}.\n   */\n  get insertFreshEvents(): string {\n    const events = this.#names.events;\n    return `WITH reserved AS (\n  INSERT INTO ${this.#names.keySequences} AS reserved (key, sequence)\n  SELECT requested.key, requested.count\n  FROM jsonb_to_recordset($4::jsonb) AS requested (key text, count bigint)\n  ORDER BY requested.key\n  ON CONFLICT (key) DO UPDATE SET sequence = reserved.sequence + EXCLUDED.sequence\n  RETURNING reserved.key AS key, reserved.sequence AS sequence\n), incoming AS (\n  SELECT incoming.*,\n    CASE WHEN incoming.key IS NULL THEN NULL ELSE\n      reserved.sequence - count(*) OVER (PARTITION BY incoming.key)\n        + row_number() OVER (PARTITION BY incoming.key ORDER BY incoming.ordinal)\n    END AS sequence\n  FROM jsonb_to_recordset($1::jsonb) AS incoming (\n    ordinal int, id text, type text, source text, key text, payload jsonb, headers jsonb,\n    correlation_id text, causation_id text, occurred_at timestamptz, handlers text[])\n  LEFT JOIN reserved ON reserved.key = incoming.key\n), inserted_events AS (\n  INSERT INTO ${events}\n    (id, type, source, key, sequence, payload, headers, correlation_id, causation_id, occurred_at, created_at, handlers)\n  SELECT incoming.id, incoming.type, incoming.source, incoming.key, incoming.sequence,\n    COALESCE(incoming.payload, 'null'::jsonb), COALESCE(incoming.headers, '{}'::jsonb),\n    incoming.correlation_id, incoming.causation_id, incoming.occurred_at, $2::timestamptz,\n    COALESCE(incoming.handlers, '{}')\n  FROM incoming\n  ORDER BY incoming.id\n  ON CONFLICT (id) DO NOTHING\n  RETURNING id, key, sequence\n), inserted_deliveries AS (\n  INSERT INTO ${this.#names.deliveries}\n    (id, event_id, handler, lane, status, attempts, available_at, key, sequence, created_at, updated_at)\n  SELECT delivery.id, delivery.event_id, delivery.handler, ${laneExpression('event.key', 'event.id')}, 'pending', 0,\n    delivery.available_at, event.key, event.sequence, $2::timestamptz, $2::timestamptz\n  FROM jsonb_to_recordset($3::jsonb) AS delivery (id text, event_id text, handler text, available_at timestamptz)\n  JOIN inserted_events AS event ON event.id = delivery.event_id\n  ORDER BY delivery.event_id, delivery.handler\n  ON CONFLICT (event_id, handler) DO NOTHING\n  RETURNING available_at\n), ${this.#wakeUp('inserted_deliveries', '$5')}\nSELECT incoming.id, incoming.sequence::text AS sequence,\n  incoming.id IN (SELECT inserted_events.id FROM inserted_events) AS inserted,\n  (SELECT count(*) FROM inserted_deliveries)::int AS deliveries\nFROM incoming\nWHERE (SELECT count(*) FROM woken) >= 0`;\n  }\n\n  /** One wake-up notification on {@link PostgresNames.notificationChannel}, outside any publishing transaction. */\n  get notify(): string {\n    return `SELECT pg_notify('${this.#names.notificationChannel}', '')`;\n  }\n\n  /**\n   * A CTE `woken` that sends one notification on {@link PostgresNames.notificationChannel} when a row of\n   * `inserted` is due at `now`. PostgreSQL delivers it when the transaction commits, merges the same\n   * notification sent twice in one transaction, and drops it on rollback. The statement must reference\n   * `woken` for it to run.\n   */\n  #wakeUp(inserted: string, now: string): string {\n    return `woken AS (\n  SELECT pg_notify('${this.#names.notificationChannel}', '') FROM (\n    SELECT 1 FROM ${inserted} WHERE ${inserted}.available_at <= ${now}::timestamptz LIMIT 1\n  ) AS due\n)`;\n  }\n\n  /**\n   * Parameters: `[eventsJson, createdAt]`. Returns the ids that were inserted.\n   * `handlers` is the list of handlers the event gets deliveries for: it\n   * outlives the deliveries, which are deleted when they complete.\n   */\n  get insertEvents(): string {\n    return `INSERT INTO ${this.#names.events}\n  (id, type, source, key, sequence, payload, headers, correlation_id, causation_id, occurred_at, created_at, handlers)\nSELECT incoming.id, incoming.type, incoming.source, incoming.key, incoming.sequence,\n  COALESCE(incoming.payload, 'null'::jsonb), COALESCE(incoming.headers, '{}'::jsonb),\n  incoming.correlation_id, incoming.causation_id, incoming.occurred_at, $2::timestamptz,\n  COALESCE(incoming.handlers, '{}')\nFROM jsonb_to_recordset($1::jsonb) AS incoming (\n  id text, type text, source text, key text, sequence bigint, payload jsonb, headers jsonb,\n  correlation_id text, causation_id text, occurred_at timestamptz, handlers text[])\nORDER BY incoming.id\nON CONFLICT (id) DO NOTHING\nRETURNING id`;\n  }\n\n  /**\n   * Locks events that were not inserted by the current append, in id order, so\n   * that appends adding handlers to the same event run one after the other.\n   * Parameters: `[eventIdsJson]`. `FOR NO KEY UPDATE` conflicts with itself and\n   * not with the foreign key checks of other inserts.\n   */\n  get lockExistingEvents(): string {\n    return `SELECT id FROM ${this.#names.events}\nWHERE id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb)))\nORDER BY id\nFOR NO KEY UPDATE`;\n  }\n\n  /**\n   * Parameters: `[deliveriesJson, createdAt, insertedEventIdsJson, now]`. Key and\n   * sequence are copied from the stored event, so a delivery added later to an\n   * existing event keeps the event's position in its key and lands in the same\n   * lane. Returns the ids that were inserted.\n   *\n   * The deliveries of events this call just inserted are all new. For an event\n   * that already existed, a handler gets a delivery only if the event does not\n   * list it yet: a completed delivery is deleted, but its handler stays listed,\n   * so a redelivered or republished event never runs a handler twice. The\n   * handlers added to an existing event are appended to its list.\n   */\n  get insertDeliveries(): string {\n    const events = this.#names.events;\n    const insertedEvents = `ARRAY(SELECT jsonb_array_elements_text($3::jsonb))`;\n    return `WITH incoming AS (\n  SELECT incoming.id, incoming.event_id, incoming.handler, incoming.available_at\n  FROM jsonb_to_recordset($1::jsonb) AS incoming (id text, event_id text, handler text, available_at timestamptz)\n), fresh AS (\n  SELECT incoming.*, event.key, event.sequence, ${laneExpression('event.key', 'event.id')} AS lane\n  FROM incoming\n  JOIN ${events} AS event ON event.id = incoming.event_id\n  WHERE event.id = ANY (${insertedEvents}) OR NOT incoming.handler = ANY (event.handlers)\n), inserted AS (\n  INSERT INTO ${this.#names.deliveries}\n    (id, event_id, handler, lane, status, attempts, available_at, key, sequence, created_at, updated_at)\n  SELECT fresh.id, fresh.event_id, fresh.handler, fresh.lane, 'pending', 0, fresh.available_at,\n    fresh.key, fresh.sequence, $2::timestamptz, $2::timestamptz\n  FROM fresh\n  ORDER BY fresh.event_id, fresh.handler\n  ON CONFLICT (event_id, handler) DO NOTHING\n  RETURNING id, event_id, handler, available_at\n), extended AS (\n  UPDATE ${events} AS event SET handlers = event.handlers || added.handlers\n  FROM (\n    SELECT inserted.event_id, array_agg(inserted.handler) AS handlers FROM inserted\n    WHERE inserted.event_id <> ALL (${insertedEvents}) GROUP BY inserted.event_id\n  ) AS added\n  WHERE event.id = added.event_id\n  RETURNING event.id\n), ${this.#wakeUp('inserted', '$4')}\nSELECT id FROM inserted WHERE (SELECT count(*) FROM woken) >= 0`;\n  }\n\n  /**\n   * A claim in one statement, the only one in the common case. Parameters:\n   * `[now, handlersJson, limit, leaseOwner, leaseExpiresAt, generation]`.\n   *\n   * 1. **Held lanes.** The lanes this owner holds under a live lease whose `claim_floor` is exactly the\n   *    generation are locked `FOR NO KEY UPDATE` in lane order. A lane above it was raised by a\n   *    reconciliation, so a statement of a claim whose caller gave up (a client timeout does not cancel\n   *    the statement on the server) and that reaches the server late records nothing; a lane below it was\n   *    taken by such a late statement after the reconciliation, and its listed deliveries were never\n   *    handed out. A lane that another transaction of this owner is changing makes the statement wait;\n   *    the statement then reports `stale` and does nothing (see the `stale` CTE).\n   * 2. **Free lanes**, only when the held lanes yield fewer than `limit`: the free lanes with a due\n   *    delivery (one index probe per free lane) are ranked by their oldest due delivery; the first\n   *    {@link INITIAL_FREE_LANES} that can give something now, and further ones until what they can give\n   *    (estimated from their first {@link LANE_DEPTH_CAP} due deliveries) covers what is still wanted, are locked\n   *    `FOR UPDATE SKIP LOCKED`, so a lane another claimer has is skipped, never waited\n   *    for. A lane that still runs deliveries of an expired lease is left to the transaction of\n   *    {@link takeFreeLanes}, which charges their lost attempts (`takeover_waiting`); so is any lane whose\n   *    locked row differs from what the statement's snapshot saw. A lane that runs nothing and did not\n   *    change cannot have had a delivery written since the snapshot, so its deliveries can be read here.\n   * 3. **Picks** follow the rules of {@link claim}: the fast window of each lane, and for lanes whose\n   *    window filled up while the batch is not full, the heads of all keys (a loose index scan per lane).\n   * 4. **Writes**: one update per lane. A held lane records its picks; a taken lane gets a new epoch, the\n   *    owner, the lease and its picks; a taken lane that yielded nothing is not written. Held lanes that\n   *    picked nothing, run nothing and have no full scan window are freed.\n   *\n   * Always returns one row per picked delivery, or one row whose `delivery_id` is null. `running_ids`\n   * (JSON text) lists the deliveries the held lanes still run, `examined_lanes` the held lanes.\n   */\n  get claimLanes(): string {\n    return this.#claimLanes(true);\n  }\n\n  /**\n   * {@link claimLanes} limited to the lanes the owner holds: the same parameters, rows and writes, without\n   * looking at free lanes (`takeover_waiting` and `unexamined_free_lanes` are false). A worker draining a\n   * backlog finds its batch in the lanes it holds; this statement is about half as costly to plan, and\n   * the caller runs {@link claimLanes} after it only when it came up short.\n   */\n  get claimHeldLanes(): string {\n    return this.#claimLanes(false);\n  }\n\n  #claimLanes(includeFreeLanes: boolean): string {\n    const deliveries = this.#names.deliveries;\n    const lanes = this.#names.lanes;\n    const freeLane = (alias: string): string =>\n      `(${alias}.lease_expires_at IS NULL OR ${alias}.lease_expires_at <= $1::timestamptz\n      OR (${alias}.lease_owner = $4::text AND ${alias}.claim_floor < $6::bigint))`;\n    const free = includeFreeLanes\n      ? `), free_lanes AS MATERIALIZED (\n  -- The oldest due delivery of each free lane: one index probe per free lane, bounded by the due time,\n  -- so deliveries scheduled for later are never read.\n  SELECT lane.lane, lane.epoch, lane.in_flight, lane.lease_owner, lane.lease_expires_at,\n    oldest.available_at, oldest.id, NOT ${this.#noRunningDelivery('lane')} AS running\n  FROM ${lanes} AS lane\n  CROSS JOIN LATERAL (\n    SELECT delivery.available_at, delivery.id\n    FROM ${deliveries} AS delivery\n    WHERE delivery.lane = lane.lane AND delivery.status = 'pending'\n      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}\n    ORDER BY delivery.available_at, delivery.id\n    LIMIT 1\n  ) AS oldest\n  WHERE (SELECT count FROM wanted) > 0 AND ${freeLane('lane')}\n  ORDER BY oldest.available_at, oldest.id\n  LIMIT (SELECT count FROM wanted) + ${FREE_LANE_SURPLUS}\n), free_depth AS MATERIALIZED (\n  -- What each candidate lane can give now, from its first due deliveries: unkeyed ones, and of a key its\n  -- lowest one when nothing earlier of the key is pending. Lanes that can give nothing are passed over;\n  -- of the others, the first ${INITIAL_FREE_LANES} are taken, and further ones until they cover what is\n  -- still wanted, so the earliest due work of the free lanes comes first.\n  SELECT runnable.lane,\n    row_number() OVER (ORDER BY runnable.available_at, runnable.id) AS rank,\n    sum(runnable.count) OVER (ORDER BY runnable.available_at, runnable.id ROWS UNBOUNDED PRECEDING) - runnable.count AS due_before\n  FROM (\n    SELECT lane_candidate.lane, lane_candidate.available_at, lane_candidate.id, depth.count\n    FROM free_lanes AS lane_candidate\n    CROSS JOIN LATERAL (\n      -- A full window that shows nothing runnable may hide runnable work behind it: such a lane counts\n      -- once, and the claim looks behind its blocked deliveries.\n      SELECT GREATEST(count(*) FILTER (\n          WHERE due.key IS NULL OR (due.position = 1 AND NOT EXISTS (\n            SELECT 1 FROM ${deliveries} AS earlier\n            WHERE earlier.lane = due.lane AND earlier.handler = due.handler AND earlier.key = due.key\n              AND earlier.status = 'pending' AND earlier.key IS NOT NULL AND earlier.sequence < due.sequence\n          ))\n        ), CASE WHEN count(*) >= ${LANE_DEPTH_CAP} THEN 1 ELSE 0 END) AS count\n      FROM (\n        SELECT window_rows.*,\n          row_number() OVER (PARTITION BY window_rows.handler, window_rows.key ORDER BY window_rows.sequence) AS position\n        FROM (\n          SELECT delivery.lane, delivery.handler, delivery.key, delivery.sequence FROM ${deliveries} AS delivery\n          WHERE delivery.lane = lane_candidate.lane AND delivery.status = 'pending'\n            AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}\n          ORDER BY delivery.available_at, delivery.id\n          LIMIT ${LANE_DEPTH_CAP}\n        ) AS window_rows\n      ) AS due\n    ) AS depth\n    WHERE NOT lane_candidate.running AND depth.count > 0\n  ) AS runnable\n), free_locked AS MATERIALIZED (\n  SELECT lane.lane, lane.epoch, lane.in_flight, lane.lease_owner, lane.lease_expires_at\n  FROM ${lanes} AS lane\n  WHERE lane.lane IN (\n      SELECT chosen.lane FROM free_depth AS chosen\n      WHERE chosen.rank <= ${INITIAL_FREE_LANES} OR chosen.due_before < (SELECT count FROM wanted)\n    )\n    AND ${freeLane('lane')}\n  ORDER BY lane.lane\n  FOR UPDATE SKIP LOCKED\n), free_scope AS MATERIALIZED (\n  -- A lane whose locked row is not the one the snapshot saw changed hands meanwhile: left for a later claim.\n  SELECT locked.lane, locked.epoch + 1 AS epoch, '{}'::text[] AS in_flight\n  FROM free_locked AS locked\n  JOIN free_lanes AS seen ON seen.lane = locked.lane\n  WHERE locked.epoch = seen.epoch AND locked.in_flight = seen.in_flight\n    AND locked.lease_owner IS NOT DISTINCT FROM seen.lease_owner\n    AND locked.lease_expires_at IS NOT DISTINCT FROM seen.lease_expires_at\n), ${this.#candidates('free', 'free_scope', null, '(SELECT count FROM wanted)')}`\n      : `), free_lanes AS (\n  SELECT NULL::smallint AS lane, NULL::bigint AS epoch, NULL::text[] AS in_flight, false AS running WHERE false\n), free_scope AS (\n  SELECT NULL::smallint AS lane, NULL::bigint AS epoch WHERE false\n), free_candidates AS (\n  SELECT NULL::text AS id, NULL::smallint AS lane, NULL::timestamptz AS available_at WHERE false\n)`;\n    return `WITH held AS MATERIALIZED (\n  SELECT lane.lane, lane.epoch, lane.in_flight\n  FROM ${lanes} AS lane\n  WHERE lane.lease_owner = $4::text AND lane.lease_expires_at > $1::timestamptz\n    AND lane.claim_floor = $6::bigint\n  ORDER BY lane.lane\n  FOR NO KEY UPDATE\n), stale AS (\n  -- A claim that waited for a lane lock sees the new lane row but reads deliveries with the snapshot it took\n  -- before the wait: whatever changed the lane meanwhile (a reschedule, a release) may also have changed\n  -- deliveries it cannot see. The statement then does nothing and reports it, and the caller runs it again.\n  SELECT EXISTS (\n    SELECT 1 FROM held\n    JOIN ${lanes} AS before ON before.lane = held.lane\n    WHERE before.epoch <> held.epoch OR before.in_flight IS DISTINCT FROM held.in_flight\n  ) AS value\n), held_scope AS MATERIALIZED (\n  SELECT held.lane, held.epoch, held.in_flight FROM held WHERE NOT (SELECT value FROM stale)\n), held_running AS MATERIALIZED (\n  SELECT delivery.handler, delivery.key\n  FROM held_scope\n  CROSS JOIN LATERAL unnest(held_scope.in_flight) AS flying (id)\n  JOIN ${deliveries} AS delivery ON delivery.id = flying.id\n  WHERE delivery.status = 'pending' AND delivery.key IS NOT NULL\n), ${this.#candidates('held', 'held_scope', 'held_running', '$3::int')}, wanted AS MATERIALIZED (\n  SELECT CASE WHEN (SELECT value FROM stale) THEN 0\n    ELSE $3::int - (SELECT count(*) FROM held_candidates)::int END AS count\n${free}, claim_scope AS MATERIALIZED (\n  SELECT held_scope.lane, held_scope.epoch FROM held_scope\n  UNION ALL\n  SELECT free_scope.lane, free_scope.epoch FROM free_scope\n), picked_rows AS MATERIALIZED (\n  SELECT candidates.available_at AS due_at, delivery.id AS delivery_id, delivery.lane::int AS lane,\n    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,\n    ${eventColumns('event')}\n  FROM (\n    SELECT held_candidates.id, held_candidates.lane, held_candidates.available_at FROM held_candidates\n    UNION ALL\n    SELECT free_candidates.id, free_candidates.lane, free_candidates.available_at FROM free_candidates\n  ) AS candidates\n  JOIN claim_scope AS scope ON scope.lane = candidates.lane\n  JOIN ${deliveries} AS delivery ON delivery.id = candidates.id\n  JOIN ${this.#names.events} AS event ON event.id = delivery.event_id\n), by_lane AS (\n  SELECT picked_rows.lane, array_agg(picked_rows.delivery_id) AS ids FROM picked_rows GROUP BY picked_rows.lane\n), still_running AS (\n  -- The retained ids come from the locked \\`held\\` rows, not from the lane table: a claim that waited for the lock\n  -- must see the in-flight list the claim before it recorded, which the statement snapshot may not.\n  SELECT held.lane, array_agg(delivery.id) AS ids\n  FROM by_lane\n  JOIN held ON held.lane = by_lane.lane\n  CROSS JOIN LATERAL unnest(held.in_flight) AS flying (id)\n  JOIN ${deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'\n  GROUP BY held.lane\n), extended AS (\n  UPDATE ${lanes} AS lane\n  SET in_flight = COALESCE(still_running.ids, '{}') || by_lane.ids,\n      lease_expires_at = GREATEST(lane.lease_expires_at, $5::timestamptz)\n  FROM by_lane\n  JOIN held_scope ON held_scope.lane = by_lane.lane\n  LEFT JOIN still_running ON still_running.lane = by_lane.lane\n  WHERE lane.lane = by_lane.lane\n  RETURNING lane.lane\n), taken AS (\n  UPDATE ${lanes} AS lane\n  SET epoch = free_scope.epoch, lease_owner = $4::text, lease_expires_at = $5::timestamptz,\n      in_flight = by_lane.ids, claim_floor = $6::bigint\n  FROM free_scope\n  JOIN by_lane ON by_lane.lane = free_scope.lane\n  WHERE lane.lane = free_scope.lane\n  RETURNING lane.lane\n), saturated_lanes AS (\n  SELECT held_window.lane FROM held_window GROUP BY held_window.lane HAVING count(*) >= ${LANE_SCAN_WINDOW}\n), freed AS (\n  UPDATE ${lanes} AS lane\n  SET lease_owner = NULL, lease_expires_at = NULL, in_flight = '{}'\n  FROM held\n  WHERE lane.lane = held.lane\n    AND lane.lane NOT IN (SELECT lane FROM by_lane)\n    AND lane.lane NOT IN (SELECT lane FROM saturated_lanes)\n    AND (SELECT count(*) FROM held_window) < ${CLAIM_SCAN_WINDOW}\n    AND NOT (SELECT value FROM stale)\n    AND ${this.#noRunningDelivery('lane')}\n  RETURNING lane.lane\n)\nSELECT (SELECT value FROM stale) AS stale,\n  EXISTS (SELECT 1 FROM free_lanes WHERE free_lanes.running) AS takeover_waiting,\n  (SELECT count(*) FROM free_lanes) = (SELECT count FROM wanted) + ${FREE_LANE_SURPLUS} AS unexamined_free_lanes,\n  (\n    SELECT COALESCE(jsonb_agg(delivery.id), '[]'::jsonb)\n    FROM held\n    CROSS JOIN LATERAL unnest(held.in_flight) AS flying (id)\n    JOIN ${deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'\n  )::text AS running_ids,\n  (SELECT COALESCE(jsonb_agg(held.lane), '[]'::jsonb) FROM held)::text AS examined_lanes,\n  picked.*\nFROM (SELECT 1) AS anchor\nLEFT JOIN picked_rows AS picked ON true\nORDER BY picked.due_at, picked.delivery_id`;\n  }\n\n  /**\n   * The head (lowest pending sequence) of every key of every wanted handler in the lane `scope.lane`,\n   * as a subquery returning `(id, lane, available_at, handler, key)`. A loose index scan on the\n   * pending-key index hops from key to key of a handler, and after its last key on to the first key of\n   * the next wanted handler, so the cost follows the number of keys, not the number of followers. The\n   * handlers are walked inside the recursion instead of joined to it: a join multiplied the planner's\n   * cost estimate by the handler count, which pushed the claim statements over `jit_above_cost`, and\n   * compiling them took longer than running them.\n   */\n  #keyHeads(scope: string): string {\n    const deliveries = this.#names.deliveries;\n    // `key IS NOT NULL` is spelled out only where nothing else implies it: next to `key > ...` or\n    // `key = ...` the planner proves the partial index from those, and with the column all null in the\n    // statistics the extra clause made it expect one row behind many index entries and cost every hop as a\n    // full range scan.\n    const pending = `candidate.lane = ${scope}.lane AND candidate.status = 'pending'`;\n    const nextHandler = (after: string): string =>\n      `(SELECT min(wanted.handler) FROM jsonb_array_elements_text($2::jsonb) AS wanted (handler)${after === '' ? '' : ` WHERE wanted.handler > ${after}`})`;\n    return `\n    WITH RECURSIVE hops (handler, key) AS (\n      SELECT ${nextHandler('')}, NULL::text\n      UNION ALL\n      SELECT CASE WHEN next.key IS NULL THEN ${nextHandler('hops.handler')} ELSE hops.handler END, next.key\n      FROM hops\n      CROSS JOIN LATERAL (\n        SELECT CASE WHEN hops.key IS NULL\n          THEN (SELECT candidate.key FROM ${deliveries} AS candidate\n                WHERE ${pending} AND candidate.handler = hops.handler AND candidate.key IS NOT NULL\n                ORDER BY candidate.key LIMIT 1)\n          ELSE (SELECT candidate.key FROM ${deliveries} AS candidate\n                WHERE ${pending} AND candidate.handler = hops.handler AND candidate.key > hops.key\n                ORDER BY candidate.key LIMIT 1)\n        END AS key\n        OFFSET 0\n      ) AS next\n      WHERE hops.handler IS NOT NULL\n    )\n    SELECT lowest.id, lowest.lane, lowest.available_at, lowest.handler, lowest.key\n    FROM hops\n    CROSS JOIN LATERAL (\n      SELECT candidate.id, candidate.lane, candidate.available_at, candidate.handler, candidate.key\n      FROM ${deliveries} AS candidate\n      WHERE ${pending} AND candidate.handler = hops.handler AND candidate.key = hops.key\n      ORDER BY candidate.sequence LIMIT 1\n    ) AS lowest\n    WHERE hops.key IS NOT NULL\n  `;\n  }\n\n  /**\n   * CTEs that pick up to `limit` claimable deliveries from the lanes of the CTE `scope` (columns `lane`,\n   * `epoch`, `in_flight`), named after `prefix`; the result is `<prefix>_candidates (id, lane, available_at)`.\n   * The rules are those of {@link claim}. The fast window reads the first {@link LANE_SCAN_WINDOW} due\n   * deliveries of each lane (at most {@link CLAIM_SCAN_WINDOW} together); of a key, only the lowest sequence\n   * in the window can be its head, so only that one is checked for an earlier pending delivery. Only when\n   * that yields fewer than `limit` are the lanes whose window filled up looked at again with a loose index\n   * scan over the heads of all their keys. `running` names the CTE of the keyed deliveries running in the\n   * lanes, or is null when nothing runs there.\n   */\n  #candidates(prefix: string, scope: string, running: string | null, limit: string): string {\n    const deliveries = this.#names.deliveries;\n    const notRunning = (alias: string): string =>\n      running === null\n        ? 'true'\n        : `NOT EXISTS (SELECT 1 FROM ${running} AS running WHERE running.handler = ${alias}.handler AND running.key = ${alias}.key)`;\n    return `${prefix}_window AS MATERIALIZED (\n  SELECT recent.id, recent.lane, recent.available_at, recent.handler, recent.key, recent.sequence\n  FROM ${scope}\n  CROSS JOIN LATERAL (\n    SELECT delivery.id, delivery.lane, delivery.available_at, delivery.handler, delivery.key, delivery.sequence\n    FROM ${deliveries} AS delivery\n    WHERE delivery.lane = ${scope}.lane AND delivery.status = 'pending'\n      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}\n      AND delivery.id <> ALL (${scope}.in_flight)\n    ORDER BY delivery.available_at, delivery.id\n    LIMIT ${LANE_SCAN_WINDOW}\n  ) AS recent\n  ORDER BY recent.available_at, recent.id\n  LIMIT ${CLAIM_SCAN_WINDOW}\n), ${prefix}_fast AS MATERIALIZED (\n  SELECT picked.id, picked.lane, picked.available_at FROM (\n    SELECT unkeyed.id, unkeyed.lane, unkeyed.available_at FROM ${prefix}_window AS unkeyed WHERE unkeyed.key IS NULL\n    UNION ALL\n    SELECT head.id, head.lane, head.available_at\n    FROM (\n      SELECT DISTINCT ON (keyed.handler, keyed.key) keyed.id, keyed.lane, keyed.available_at, keyed.handler, keyed.key, keyed.sequence\n      FROM ${prefix}_window AS keyed\n      WHERE keyed.key IS NOT NULL\n      ORDER BY keyed.handler, keyed.key, keyed.sequence\n    ) AS head\n    WHERE NOT EXISTS (\n        SELECT 1 FROM ${deliveries} AS earlier\n        WHERE earlier.lane = head.lane AND earlier.handler = head.handler AND earlier.key = head.key\n          AND earlier.status = 'pending' AND earlier.key IS NOT NULL AND earlier.sequence < head.sequence\n      ) AND ${notRunning('head')}\n  ) AS picked\n  ORDER BY picked.available_at, picked.id\n  LIMIT ${limit}\n), ${prefix}_saturated AS MATERIALIZED (\n  SELECT ${scope}.lane, ${scope}.in_flight FROM ${scope}\n  WHERE (SELECT count(*) FROM ${prefix}_fast) < ${limit}\n    AND ((SELECT count(*) FROM ${prefix}_window) >= ${CLAIM_SCAN_WINDOW}\n      OR ${scope}.lane IN (\n        SELECT full_lane.lane FROM ${prefix}_window AS full_lane\n        GROUP BY full_lane.lane HAVING count(*) >= ${LANE_SCAN_WINDOW}\n      ))\n), ${prefix}_heads AS MATERIALIZED (\n  SELECT head.id, head.lane, head.available_at, head.handler, head.key\n  FROM ${prefix}_saturated AS scope\n  CROSS JOIN LATERAL (${this.#keyHeads('scope')}) AS head\n), ${prefix}_keyed AS MATERIALIZED (\n  SELECT heads.id, heads.lane, heads.available_at\n  FROM ${prefix}_heads AS heads\n  JOIN ${prefix}_saturated AS scope ON scope.lane = heads.lane\n  WHERE heads.available_at <= $1::timestamptz AND heads.id <> ALL (scope.in_flight) AND ${notRunning('heads')}\n  ORDER BY heads.available_at, heads.id\n  LIMIT ${limit}\n), ${prefix}_unkeyed AS MATERIALIZED (\n  SELECT recent.id, recent.lane, recent.available_at\n  FROM ${prefix}_saturated AS scope\n  CROSS JOIN LATERAL (\n    SELECT delivery.id, delivery.lane, delivery.available_at\n    FROM ${deliveries} AS delivery\n    WHERE delivery.lane = scope.lane AND delivery.key IS NULL AND delivery.status = 'pending'\n      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}\n      AND delivery.id <> ALL (scope.in_flight)\n    ORDER BY delivery.available_at, delivery.id\n    LIMIT ${limit}\n  ) AS recent\n  ORDER BY recent.available_at, recent.id\n  LIMIT ${limit}\n), ${prefix}_candidates AS MATERIALIZED (\n  SELECT chosen.id, chosen.lane, chosen.available_at FROM (\n    SELECT fast.id, fast.lane, fast.available_at FROM ${prefix}_fast AS fast\n    UNION\n    SELECT keyed.id, keyed.lane, keyed.available_at FROM ${prefix}_keyed AS keyed\n    UNION\n    SELECT unkeyed.id, unkeyed.lane, unkeyed.available_at FROM ${prefix}_unkeyed AS unkeyed\n  ) AS chosen\n  ORDER BY chosen.available_at, chosen.id\n  LIMIT ${limit}\n)`;\n  }\n\n  /**\n   * Takes up to `$3` free lanes (no lease, or an expired one) that have a due\n   * delivery of the requested handlers, the ones with the oldest due delivery\n   * first. Parameters: `[now, handlersJson, laneCount, leaseOwner, leaseExpiresAt, generation]`.\n   * The lane gets the owner's `generation` as its `claim_floor`. A lane the owner itself holds under a live\n   * lease with a lower floor was taken by a claim statement that reached the server after its caller gave up\n   * and the owner reconciled (or by an earlier incarnation of the same owner): it is taken over like the lane of a\n   * crashed worker, so its listed deliveries are charged an attempt.\n   *\n   * A taken lane gets a new epoch, which fences everything the previous owner\n   * still holds. Deliveries the previous owner had in flight are the ones whose\n   * attempt was never recorded (a claim writes no delivery row), so each of\n   * them is charged one attempt here: a worker that crashes with a poison\n   * message still runs it into the retry limit. Lanes another claimer has locked\n   * are skipped, never waited for.\n   */\n  get takeFreeLanes(): string {\n    const deliveries = this.#names.deliveries;\n    const lanes = this.#names.lanes;\n    return `WITH picked AS (\n  -- in_flight is read here, from the locked version of the lane: a settlement that committed after the\n  -- statement took its snapshot has taken its delivery out of the list already and must not be charged again.\n  SELECT free.lane, free.in_flight\n  FROM ${lanes} AS free\n  CROSS JOIN LATERAL (\n    SELECT delivery.available_at, delivery.id\n    FROM ${deliveries} AS delivery\n    WHERE delivery.lane = free.lane AND delivery.status = 'pending'\n      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}\n    ORDER BY delivery.available_at, delivery.id\n    LIMIT 1\n  ) AS oldest\n  WHERE free.lease_expires_at IS NULL OR free.lease_expires_at <= $1::timestamptz\n    OR (free.lease_owner = $4::text AND free.claim_floor < $6::bigint)\n  ORDER BY oldest.available_at, oldest.id\n  LIMIT $3::int\n  FOR UPDATE OF free SKIP LOCKED\n), charged AS (\n  UPDATE ${deliveries} AS delivery SET attempts = delivery.attempts + 1, claims = delivery.claims + 1\n  FROM (\n    SELECT unnest(picked.in_flight) AS id FROM picked\n  ) AS lost\n  WHERE delivery.id = lost.id AND delivery.status = 'pending'\n  RETURNING delivery.id\n), taken AS (\n  UPDATE ${lanes} AS lane\n  SET epoch = lane.epoch + 1, lease_owner = $4::text, lease_expires_at = $5::timestamptz, in_flight = '{}',\n      claim_floor = $6::bigint\n  FROM picked WHERE lane.lane = picked.lane\n  RETURNING lane.lane, lane.epoch\n)\nSELECT lane::int AS lane, epoch::text AS epoch FROM taken ORDER BY lane`;\n  }\n\n  /**\n   * Fast claim: picks from the first {@link CLAIM_SCAN_WINDOW} due deliveries of\n   * the given lanes in due order, which is everything the claim needs while the\n   * front of the queue is not clogged with blocked followers of busy keys.\n   * Parameters: `[now, handlersJson, limit, lanesJson]`. The lanes must be held\n   * and locked by the caller.\n   *\n   * Always returns one row per picked delivery, or a single row whose\n   * `delivery_id` is null when nothing was picked. `window_saturated` says\n   * whether the window was full: when it is and fewer than `limit` deliveries\n   * were picked, deliveries beyond the window may still be claimable and the\n   * caller runs {@link claimBehindBlockedKeys}. When the window is not\n   * saturated every due delivery was examined, so the result is complete.\n   *\n   * A delivery is a candidate when it is pending, due, and not in flight. A\n   * keyed delivery is a candidate only when it is the head of its (handler,\n   * key), that is (a) no earlier delivery of that handler and key is pending\n   * (an earlier one in flight is still a pending row, which is the ordering\n   * guarantee), and (b) no other delivery of that handler and key is in\n   * flight, which covers a delivery that re-enters the key behind a running one\n   * (requeue, or a handler added to an old event).\n   *\n   * No row is locked or written here: the lanes' exclusive leases are the\n   * mutual exclusion, so two claimers never see the same lane.\n   */\n  get claim(): string {\n    return `WITH ${this.#scopeAndRunning(`SELECT lane.lane, lane.epoch, lane.in_flight FROM ${this.#names.lanes} AS lane WHERE lane.lane = ANY (${LANE_LIST})`)},\n${this.#fastWindow()}\n)\n${this.#pickedRows(`((SELECT count(*) FROM due_window) >= ${CLAIM_SCAN_WINDOW} OR EXISTS (SELECT 1 FROM due_window GROUP BY lane HAVING count(*) >= ${LANE_SCAN_WINDOW}))`)}`;\n  }\n\n  /** The `due_window` and `candidates` CTEs of the fast claim, up to (not including) the closing parenthesis of `candidates`. */\n  #fastWindow(): string {\n    const deliveries = this.#names.deliveries;\n    return `due_window AS MATERIALIZED (\n  SELECT recent.id, recent.lane, recent.available_at\n  FROM scope\n  CROSS JOIN LATERAL (\n    SELECT delivery.id, delivery.lane, delivery.available_at\n    FROM ${deliveries} AS delivery\n    WHERE delivery.lane = scope.lane AND delivery.status = 'pending'\n      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}\n      AND delivery.id <> ALL (scope.in_flight)\n    ORDER BY delivery.available_at, delivery.id\n    LIMIT ${LANE_SCAN_WINDOW}\n  ) AS recent\n  ORDER BY recent.available_at, recent.id\n  LIMIT ${CLAIM_SCAN_WINDOW}\n), candidates AS MATERIALIZED (\n  SELECT delivery.id, delivery.lane, delivery.available_at\n  FROM due_window\n  JOIN ${deliveries} AS delivery ON delivery.id = due_window.id\n  WHERE delivery.key IS NULL OR NOT (${this.#blockedKey('delivery')})\n  ORDER BY delivery.available_at, delivery.id\n  LIMIT $3::int`;\n  }\n\n  /**\n   * Slow claim, run when {@link claim} picked too few deliveries from a full\n   * window: the front of the due queue is mostly followers of blocked keys.\n   * Same parameters and rules as {@link claim}, but heads are found with\n   * a loose index scan over the pending-key index of each lane (it hops from key\n   * to key), so the cost follows the number of pending keys in the lanes\n   * instead of one probe per due follower.\n   */\n  get claimBehindBlockedKeys(): string {\n    const deliveries = this.#names.deliveries;\n    return `WITH ${this.#scopeAndRunning(`SELECT lane.lane, lane.epoch, lane.in_flight FROM ${this.#names.lanes} AS lane WHERE lane.lane = ANY (${LANE_LIST})`)},\nheads AS MATERIALIZED (\n  SELECT head.id, head.lane, head.available_at, head.handler, head.key\n  FROM scope\n  CROSS JOIN LATERAL (${this.#keyHeads('scope')}) AS head\n), keyed AS MATERIALIZED (\n  SELECT heads.id, heads.lane, heads.available_at\n  FROM heads\n  JOIN scope ON scope.lane = heads.lane\n  WHERE heads.available_at <= $1::timestamptz AND heads.id <> ALL (scope.in_flight)\n    AND NOT EXISTS (SELECT 1 FROM running WHERE running.handler = heads.handler AND running.key = heads.key)\n  ORDER BY heads.available_at, heads.id\n  LIMIT $3::int\n), unkeyed AS MATERIALIZED (\n  SELECT recent.id, recent.lane, recent.available_at\n  FROM scope\n  CROSS JOIN LATERAL (\n    SELECT delivery.id, delivery.lane, delivery.available_at\n    FROM ${deliveries} AS delivery\n    WHERE delivery.lane = scope.lane AND delivery.key IS NULL AND delivery.status = 'pending'\n      AND delivery.available_at <= $1::timestamptz AND ${HANDLER_PREDICATE}\n      AND delivery.id <> ALL (scope.in_flight)\n    ORDER BY delivery.available_at, delivery.id\n    LIMIT $3::int\n  ) AS recent\n  ORDER BY recent.available_at, recent.id\n  LIMIT $3::int\n), candidates AS MATERIALIZED (\n  SELECT id, lane, available_at FROM (\n    SELECT id, lane, available_at FROM keyed\n    UNION ALL\n    SELECT id, lane, available_at FROM unkeyed\n  ) AS both_sets\n  ORDER BY available_at, id\n  LIMIT $3::int\n)\n${this.#pickedRows('false')}`;\n  }\n\n  /** The held lanes with their epochs and in-flight ids, and the keyed deliveries running in them. */\n  #scopeAndRunning(scopeQuery: string): string {\n    const deliveries = this.#names.deliveries;\n    return `scope AS MATERIALIZED (\n  ${scopeQuery}\n), running AS MATERIALIZED (\n  SELECT delivery.handler, delivery.key\n  FROM scope\n  CROSS JOIN LATERAL unnest(scope.in_flight) AS flying (id)\n  JOIN ${deliveries} AS delivery ON delivery.id = flying.id\n  WHERE delivery.status = 'pending' AND delivery.key IS NOT NULL\n)`;\n  }\n\n  /** True when an earlier delivery of the candidate's handler and key is pending, or another one is running. */\n  #blockedKey(alias: string): string {\n    return `EXISTS (\n        SELECT 1 FROM ${this.#names.deliveries} AS earlier\n        WHERE earlier.lane = ${alias}.lane AND earlier.handler = ${alias}.handler AND earlier.key = ${alias}.key\n          AND earlier.status = 'pending' AND earlier.key IS NOT NULL\n          AND earlier.sequence < ${alias}.sequence\n      ) OR ${this.#runningElsewhere(alias)}`;\n  }\n\n  /** True when a delivery of the candidate's handler and key is in flight. The candidate itself never is. */\n  #runningElsewhere(alias: string): string {\n    return `EXISTS (\n        SELECT 1 FROM running\n        WHERE running.handler = ${alias}.handler AND running.key = ${alias}.key\n      )`;\n  }\n\n  /** Final SELECT shared by both claims: the picked deliveries with their lane epoch and event. */\n  #pickedRows(saturated: string): string {\n    return `SELECT ${saturated} AS window_saturated, picked.*\nFROM (SELECT 1) AS anchor\nLEFT JOIN (\n  ${this.#pickedRowsSelect()}\n) AS picked ON true\nORDER BY picked.due_at, picked.delivery_id`;\n  }\n\n  /** The picked deliveries joined with the lane epoch and their event, as the claim result columns. */\n  #pickedRowsSelect(): string {\n    return `SELECT candidates.available_at AS due_at, delivery.id AS delivery_id, delivery.lane::int AS lane,\n    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,\n    ${eventColumns('event')}\n  FROM candidates\n  JOIN scope ON scope.lane = candidates.lane\n  JOIN ${this.#names.deliveries} AS delivery ON delivery.id = candidates.id\n  JOIN ${this.#names.events} AS event ON event.id = delivery.event_id`;\n  }\n\n  /**\n   * Records the deliveries a claim picked in their lanes and frees the lanes it\n   * took or held for nothing. Parameters:\n   * `[pickedJson, idleLanesJson, leaseOwner, leaseExpiresAt]` with\n   * `pickedJson = [{ lane, ids }]`.\n   *\n   * A picked lane lists the ids that are still in flight (listed ids whose row\n   * still exists) plus the new ones, and its lease reaches `leaseExpiresAt`.\n   * An idle lane is freed when no delivery of it is in flight, so other workers\n   * need not wait for the lease to expire.\n   */\n  get recordClaim(): string {\n    const deliveries = this.#names.deliveries;\n    const lanes = this.#names.lanes;\n    return `WITH picked AS (\n  SELECT recorded.lane, recorded.ids\n  FROM jsonb_to_recordset($1::jsonb) AS recorded (lane smallint, ids text[])\n), still_running AS (\n  SELECT lane.lane, array_agg(delivery.id) AS ids\n  FROM picked\n  JOIN ${lanes} AS lane ON lane.lane = picked.lane\n  CROSS JOIN LATERAL unnest(lane.in_flight) AS flying (id)\n  JOIN ${deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'\n  GROUP BY lane.lane\n), extended AS (\n  UPDATE ${lanes} AS lane\n  SET in_flight = COALESCE(still_running.ids, '{}') || picked.ids,\n      lease_expires_at = GREATEST(lane.lease_expires_at, $4::timestamptz)\n  FROM picked\n  LEFT JOIN still_running ON still_running.lane = picked.lane\n  WHERE lane.lane = picked.lane\n  RETURNING lane.lane\n), freed AS (\n  UPDATE ${lanes} AS lane\n  SET lease_owner = NULL, lease_expires_at = NULL, in_flight = '{}'\n  WHERE lane.lane = ANY (ARRAY(SELECT jsonb_array_elements_text($2::jsonb)::smallint))\n    AND lane.lease_owner = $3::text\n    AND ${this.#noRunningDelivery('lane')}\n  RETURNING lane.lane\n)\nSELECT (SELECT count(*) FROM extended)::int AS extended, (SELECT count(*) FROM freed)::int AS freed`;\n  }\n\n  /** True when none of the lane's listed deliveries exists as a pending row. */\n  #noRunningDelivery(laneAlias: string): string {\n    return `NOT EXISTS (\n      SELECT 1 FROM unnest(${laneAlias}.in_flight) AS flying (id)\n      JOIN ${this.#names.deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'\n    )`;\n  }\n\n  /**\n   * Keeps in the in-flight lists of the lanes `$1` holds only the claims in `$2`\n   * (`[{ id, lane, epoch, claims }]`, the ones this store handed out and nobody\n   * settled yet) and takes every other delivery out. That is a batch a claim\n   * recorded but whose answer never arrived: nothing runs it and the lane lease,\n   * renewed by the owner's other deliveries, would keep it away from everybody for\n   * ever. A claim matches only with the lane epoch and the delivery generation it was\n   * handed out with. Parameters: `[leaseOwner, handedOutJson, generation]`; a lane whose `claim_floor` is above\n   * the generation was reconciled by a newer call, so an older (late) reconciliation leaves it alone.\n   * The lanes are locked in lane order first (see the lock order on {@link PostgresStatements}).\n   */\n  get reconcileClaims(): string {\n    const deliveries = this.#names.deliveries;\n    const handedOut = `jsonb_to_recordset($2::jsonb) AS handed (id text, lane smallint, epoch bigint, claims int)`;\n    const kept = `SELECT 1 FROM ${handedOut} JOIN ${deliveries} AS delivery ON delivery.id = handed.id\n      WHERE handed.id = flying.id AND handed.lane = lane.lane AND handed.epoch = lane.epoch AND delivery.claims = handed.claims`;\n    return `WITH owned AS MATERIALIZED (\n  SELECT lane.lane FROM ${this.#names.lanes} AS lane\n  WHERE lane.lease_owner = $1::text AND lane.claim_floor <= $3::bigint\n  ORDER BY lane.lane\n  FOR NO KEY UPDATE\n)\nUPDATE ${this.#names.lanes} AS lane\nSET in_flight = ARRAY(SELECT flying.id FROM unnest(lane.in_flight) AS flying (id) WHERE EXISTS (${kept})),\n    claim_floor = $3::bigint\nFROM owned\nWHERE lane.lane = owned.lane AND lane.lease_owner = $1::text AND lane.claim_floor <= $3::bigint`;\n  }\n\n  /**\n   * Frees every lane `$1` holds that has no running delivery, locking them in lane order first.\n   * Parameters: `[leaseOwner]`.\n   */\n  get relinquish(): string {\n    return `WITH owned AS MATERIALIZED (\n  SELECT lane.lane FROM ${this.#names.lanes} AS lane\n  WHERE lane.lease_owner = $1::text\n  ORDER BY lane.lane\n  FOR NO KEY UPDATE\n)\nUPDATE ${this.#names.lanes} AS lane\nSET lease_owner = NULL, lease_expires_at = NULL, in_flight = '{}'\nFROM owned\nWHERE lane.lane = owned.lane AND lane.lease_owner = $1::text AND ${this.#noRunningDelivery('lane')}`;\n  }\n\n  /**\n   * Extends the lease of the lane a running delivery belongs to; the lane lease\n   * never shrinks. Parameters: `[deliveryId, lane, epoch, claims, leaseExpiresAt]`.\n   */\n  get extendLease(): string {\n    return countChanged(`UPDATE ${this.#names.lanes} AS lane\nSET lease_expires_at = GREATEST(lane.lease_expires_at, $5::timestamptz)\nWHERE lane.lane = $2::smallint AND lane.epoch = $3::bigint AND $1::text = ANY (lane.in_flight)\n  AND EXISTS (\n    SELECT 1 FROM ${this.#names.deliveries} AS delivery\n    WHERE delivery.id = $1::text AND delivery.status = 'pending' AND delivery.claims = $4::int\n  )`);\n  }\n\n  /**\n   * Deletes the running deliveries whose lane lease is still the one they were\n   * claimed under. Parameters: `[leasesJson, now]` with\n   * `leasesJson = [{ ord, id, lane, epoch, claims }]`. Returns the `ord` of every lease that was completed, so\n   * results are matched to leases and not to delivery ids. A delivery is only deleted by the claim that\n   * is still its current one (`claims`), which makes a stale lease harmless even when the same owner re-claimed\n   * the delivery in the same lane epoch. The event gets a completion time for retention.\n   *\n   * The lane rows are locked `FOR KEY SHARE` first, in lane order, and the lock\n   * is held until the surrounding transaction ends. A claimer that takes the\n   * lane over locks it `FOR UPDATE`, which conflicts with that lock, so it\n   * skips the lane until this completion commits or rolls back: a completion\n   * and a takeover cannot both succeed for one delivery, which is what makes a\n   * transactional handler's writes effectively-once. The weakest lock that\n   * conflicts with a takeover is used on purpose: it does not conflict with the\n   * owner's own claim and heartbeats (plain updates of the lane row), which\n   * would otherwise wait for every completion in progress. With a completion history the deleted rows are copied to\n   * it in the same statement.\n   */\n  get complete(): string {\n    const deliveries = this.#names.deliveries;\n    const history = this.#names.completionHistory;\n    return `WITH leases AS (\n  SELECT lease.ord, lease.id, lease.lane, lease.epoch, lease.claims\n  FROM jsonb_to_recordset($1::jsonb) AS lease (ord int, id text, lane smallint, epoch bigint, claims int)\n), fence AS MATERIALIZED (\n  SELECT lane.lane, lane.epoch, lane.in_flight\n  FROM ${this.#names.lanes} AS lane\n  WHERE lane.lane IN (SELECT lane FROM leases)\n  ORDER BY lane.lane\n  FOR KEY SHARE\n), completed AS (\n  DELETE FROM ${deliveries} AS delivery\n  USING leases JOIN fence ON fence.lane = leases.lane AND fence.epoch = leases.epoch\n  WHERE delivery.id = leases.id AND delivery.lane = leases.lane AND delivery.status = 'pending'\n    AND delivery.claims = leases.claims AND leases.id = ANY (fence.in_flight)\n  RETURNING leases.ord, delivery.id, delivery.event_id, delivery.handler, delivery.attempts, delivery.available_at, delivery.created_at\n), stamped AS (\n  INSERT INTO ${this.#names.eventCompletions} (event_id, completed_at)\n  SELECT DISTINCT completed.event_id, $2::timestamptz FROM completed\n  -- Event id order: completions of other handlers of the same events lock these rows too.\n  ORDER BY completed.event_id\n  ON CONFLICT (event_id) DO UPDATE SET completed_at = GREATEST(${this.#names.eventCompletions}.completed_at, EXCLUDED.completed_at)\n  RETURNING event_id\n)${\n      history\n        ? `, archived AS (\n  INSERT INTO ${this.#names.completions} (id, event_id, handler, attempts, available_at, created_at, completed_at)\n  SELECT id, event_id, handler, attempts + 1, available_at, created_at, $2::timestamptz FROM completed\n  RETURNING id\n)`\n        : ''\n    }\nSELECT ord FROM completed`;\n  }\n\n  /**\n   * Returns a running delivery to pending, due at `availableAt`, and takes it\n   * out of the lane's in-flight list. Parameters:\n   * `[deliveryId, lane, epoch, claims, availableAt, errorJson, now]`. The attempt that\n   * just ended is counted.\n   */\n  get reschedule(): string {\n    return this.#leaveFlight(\n      `SET available_at = $5::timestamptz, last_error = $6::jsonb, attempts = delivery.attempts + 1, claims = delivery.claims + 1, updated_at = $7::timestamptz`,\n    );\n  }\n\n  /** Parameters: `[deliveryId, lane, epoch, claims, errorJson, now]`. The attempt that just ended is counted. */\n  get bury(): string {\n    return this.#leaveFlight(\n      `SET status = 'dead', last_error = $5::jsonb, attempts = delivery.attempts + 1, claims = delivery.claims + 1, updated_at = $6::timestamptz`,\n    );\n  }\n\n  /**\n   * Gives a running delivery back without spending its attempt (an attempt is\n   * only recorded when it ends in failure or a lost lease): pending, due `now`.\n   * Parameters: `[deliveryId, lane, epoch, claims, now]`.\n   */\n  get release(): string {\n    return this.#leaveFlight(\n      `SET available_at = $5::timestamptz, claims = delivery.claims + 1, updated_at = $5::timestamptz`,\n    );\n  }\n\n  /**\n   * Applies `assignments` to a running delivery and removes it from its lane's\n   * in-flight list, if the lane still has the caller's epoch. The lane row is\n   * locked first (`FOR NO KEY UPDATE`, which conflicts with a takeover's `FOR UPDATE`), so a takeover cannot interleave. Parameters\n   * `$1`..`$4` are always `[deliveryId, lane, epoch, claims]`; ending a claim bumps `claims`.\n   */\n  #leaveFlight(assignments: string): string {\n    const lanes = this.#names.lanes;\n    return `WITH fence AS MATERIALIZED (\n  SELECT lane.lane FROM ${lanes} AS lane\n  WHERE lane.lane = $2::smallint AND lane.epoch = $3::bigint AND $1::text = ANY (lane.in_flight)\n  FOR NO KEY UPDATE\n), changed AS (\n  UPDATE ${this.#names.deliveries} AS delivery ${assignments}\n  FROM fence\n  WHERE delivery.id = $1::text AND delivery.lane = fence.lane AND delivery.status = 'pending'\n    AND delivery.claims = $4::int\n  RETURNING delivery.id\n), trimmed AS (\n  UPDATE ${lanes} AS lane SET in_flight = array_remove(lane.in_flight, $1::text)\n  FROM changed WHERE lane.lane = $2::smallint\n  RETURNING lane.lane\n)\nSELECT count(*)::int AS count FROM changed`;\n  }\n\n  /** Parameters: `[deliveryIdsJson, now]`. The dead rows are locked in id order first. */\n  get requeue(): string {\n    const deliveries = this.#names.deliveries;\n    return countChanged(`WITH dead AS MATERIALIZED (\n  SELECT delivery.id FROM ${deliveries} AS delivery\n  WHERE delivery.id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb))) AND delivery.status = 'dead'\n  ORDER BY delivery.id\n  FOR NO KEY UPDATE\n)\nUPDATE ${deliveries} AS delivery\nSET status = 'pending', attempts = 0, available_at = $2::timestamptz, updated_at = $2::timestamptz\nFROM dead\nWHERE delivery.id = dead.id AND delivery.status = 'dead'`);\n  }\n\n  /**\n   * Builds the filtered, creation-ordered listing. A delivery is `processing`\n   * while its row exists as `pending` and its lane lists its id; its attempt\n   * count, lease owner and lease expiry then come from the claim and the lane.\n   * Records of the completion history (when kept) are listed as `completed`.\n   */\n  listDeliveries(query: DeliveryQuery): PostgresStatement {\n    const parameters: PostgresParameter[] = [];\n    const bind = (value: PostgresParameter): string => {\n      parameters.push(value);\n      return `$${parameters.length}::${typeof value === 'number' ? 'int' : 'text'}`;\n    };\n    const filters = {\n      handler: query.handler === undefined ? undefined : bind(query.handler),\n      eventType: query.eventType === undefined ? undefined : bind(query.eventType),\n      eventId: query.eventId === undefined ? undefined : bind(query.eventId),\n      status: query.status === undefined ? undefined : bind(query.status),\n    };\n    const limit = bind(query.limit ?? DEFAULT_LIST_LIMIT);\n    const common = (alias: string): string[] => [\n      ...(filters.handler === undefined ? [] : [`${alias}.handler = ${filters.handler}`]),\n      ...(filters.eventType === undefined ? [] : [`event.type = ${filters.eventType}`]),\n      ...(filters.eventId === undefined ? [] : [`${alias}.event_id = ${filters.eventId}`]),\n    ];\n    const inFlight = `(delivery.status = 'pending' AND delivery.id = ANY (lane.in_flight))`;\n    const whereCurrent = [\n      ...common('delivery'),\n      ...(filters.status === undefined\n        ? []\n        : [\n            `(CASE WHEN ${inFlight} THEN 'processing' ELSE delivery.status END) = ${filters.status}`,\n          ]),\n    ];\n    const current = `SELECT delivery.id AS delivery_id, delivery.handler,\n  CASE WHEN ${inFlight} THEN 'processing' ELSE delivery.status END AS status,\n  (delivery.attempts + CASE WHEN ${inFlight} THEN 1 ELSE 0 END)::int AS attempts,\n  ${isoText('delivery.available_at')} AS available_at,\n  CASE WHEN ${inFlight} THEN lane.lease_owner END AS lease_owner,\n  CASE WHEN ${inFlight} THEN ${isoText('lane.lease_expires_at')} END AS lease_expires_at,\n  delivery.last_error::text AS last_error,\n  ${isoText('delivery.created_at')} AS created_at,\n  ${isoText('delivery.updated_at')} AS updated_at,\n  ${isoText('delivery.completed_at')} AS completed_at,\n  ${eventColumns('event')}\nFROM ${this.#names.deliveries} AS delivery\nJOIN ${this.#names.lanes} AS lane ON lane.lane = delivery.lane\nJOIN ${this.#names.events} AS event ON event.id = delivery.event_id\n${whereCurrent.length === 0 ? '' : `WHERE ${whereCurrent.join(' AND ')}`}`;\n    const includeHistory =\n      this.#names.completionHistory && (query.status === undefined || query.status === 'completed');\n    if (!includeHistory) {\n      return {\n        sql: `${current}\\nORDER BY delivery.created_at, delivery.id\\nLIMIT ${limit}`,\n        parameters,\n      };\n    }\n    const history = `SELECT done.id AS delivery_id, done.handler, 'completed' AS status, done.attempts,\n  ${isoText('done.available_at')} AS available_at,\n  NULL AS lease_owner,\n  NULL AS lease_expires_at,\n  NULL AS last_error,\n  ${isoText('done.created_at')} AS created_at,\n  ${isoText('done.completed_at')} AS updated_at,\n  ${isoText('done.completed_at')} AS completed_at,\n  ${eventColumns('event')}\nFROM ${this.#names.completions} AS done\nJOIN ${this.#names.events} AS event ON event.id = done.event_id\n${common('done').length === 0 ? '' : `WHERE ${common('done').join(' AND ')}`}`;\n    return {\n      sql: `SELECT * FROM (\\n${current}\\nUNION ALL\\n${history}\\n) AS listed\\nORDER BY created_at, delivery_id\\nLIMIT ${limit}`,\n      parameters,\n    };\n  }\n\n  /**\n   * Counts of rows by stored status (`pending` includes running deliveries;\n   * `completed` rows exist only after an upgrade from 0.1.0). Each count is\n   * answered from a partial index.\n   */\n  get countByStatus(): string {\n    const deliveries = this.#names.deliveries;\n    return ['pending', 'dead', 'completed']\n      .map(\n        (status) =>\n          `SELECT '${status}' AS status, count(*)::text AS count FROM ${deliveries} WHERE status = '${status}'`,\n      )\n      .join('\\nUNION ALL\\n');\n  }\n\n  /** Deliveries that are running: listed by a lane and still pending as rows. */\n  get countRunning(): string {\n    return `SELECT count(*)::text AS count\nFROM ${this.#names.lanes} AS lane\nCROSS JOIN LATERAL unnest(lane.in_flight) AS flying (id)\nJOIN ${this.#names.deliveries} AS delivery ON delivery.id = flying.id AND delivery.status = 'pending'`;\n  }\n\n  get countCompletionHistory(): string {\n    return `SELECT count(*)::text AS count FROM ${this.#names.completions}`;\n  }\n\n  /**\n   * Oldest instant at which a delivery became claimable: `available_at` of a\n   * pending delivery that nobody runs, or the lease expiry of a lane that runs\n   * deliveries. Parameters: `[now]`.\n   */\n  get oldestDue(): string {\n    const deliveries = this.#names.deliveries;\n    const lanes = this.#names.lanes;\n    return `SELECT ${isoText('min(due.due_at)')} AS oldest_due_at FROM (\n  SELECT waiting.available_at AS due_at\n  FROM ${lanes} AS lane\n  CROSS JOIN LATERAL (\n    SELECT delivery.available_at FROM ${deliveries} AS delivery\n    WHERE delivery.lane = lane.lane AND delivery.status = 'pending'\n      AND delivery.available_at <= $1::timestamptz AND delivery.id <> ALL (lane.in_flight)\n    ORDER BY delivery.available_at LIMIT 1\n  ) AS waiting\n  UNION ALL\n  SELECT lane.lease_expires_at AS due_at\n  FROM ${lanes} AS lane\n  WHERE lane.lease_expires_at <= $1::timestamptz AND NOT ${this.#noRunningDelivery('lane')}\n) AS due`;\n  }\n\n  /**\n   * Deletes one bounded batch of purgeable deliveries (or of the completion\n   * history) and returns the event id of each deleted row. Parameters:\n   * `[cutoff, batchSize]`. `FOR UPDATE SKIP LOCKED` keeps purge from waiting\n   * on, or being waited on by, anything.\n   */\n  purgeCompletedBatch(): string {\n    return this.#purgeBatch(\n      this.#names.deliveries,\n      `status = 'completed' AND completed_at < $1::timestamptz`,\n      'completed_at',\n    );\n  }\n\n  purgeCompletionHistoryBatch(): string {\n    return this.#purgeBatch(\n      this.#names.completions,\n      `completed_at < $1::timestamptz`,\n      'completed_at',\n    );\n  }\n\n  purgeDeadBatch(): string {\n    return this.#purgeBatch(\n      this.#names.deliveries,\n      `status = 'dead' AND updated_at < $1::timestamptz`,\n      'updated_at',\n    );\n  }\n\n  /**\n   * Selects and locks one bounded batch of events created before the cutoff\n   * that no delivery references and that never had a delivery complete (those\n   * are measured from their completion, see {@link lockCompletedOrphanEventsBatch}).\n   * Parameters: `[cutoff, batchSize]`. The ids go through\n   * {@link deleteOrphanEventsWithoutCompletion} or {@link deleteExpiredCompletedOrphanEvents}, which re-check under a fresh snapshot.\n   */\n  get lockOrphanEventsBatch(): string {\n    return `SELECT event.id FROM ${this.#names.events} AS event\nWHERE event.created_at < $1::timestamptz\n  AND ${this.#unreferenced('event')}\n  AND NOT EXISTS (SELECT 1 FROM ${this.#names.eventCompletions} AS completion WHERE completion.event_id = event.id)\nORDER BY event.created_at, event.id\nLIMIT $2::int\nFOR UPDATE OF event SKIP LOCKED`;\n  }\n\n  /**\n   * Like {@link lockOrphanEventsBatch} for events that had a delivery complete:\n   * they go once their last completion is older than the cutoff, however old the\n   * event itself is. Parameters: `[cutoff, batchSize]`.\n   */\n  get lockCompletedOrphanEventsBatch(): string {\n    return `SELECT event.id FROM ${this.#names.events} AS event\nJOIN ${this.#names.eventCompletions} AS completion ON completion.event_id = event.id\nWHERE completion.completed_at < $1::timestamptz\n  AND ${this.#unreferenced('event')}\nORDER BY completion.completed_at, event.id\nLIMIT $2::int\nFOR UPDATE OF event SKIP LOCKED`;\n  }\n\n  /**\n   * Locks the given events, skipping any that a concurrent transaction is\n   * referencing from a new delivery (a foreign key check holds `FOR KEY\n   * SHARE`, which conflicts with this lock). Parameters: `[eventIdsJson]`.\n   */\n  get lockEvents(): string {\n    return `SELECT id FROM ${this.#names.events}\nWHERE id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb)))\nFOR UPDATE SKIP LOCKED`;\n  }\n\n  /**\n   * Deletes events that no delivery references and whose last completion is older than\n   * `$2`, checked again under the fresh snapshot of this statement: a completion recorded\n   * after the sweep selected the event moves its time and keeps the event. Parameters:\n   * `[eventIdsJson, cutoff]`.\n   */\n  get deleteExpiredCompletedOrphanEvents(): string {\n    return countChanged(`DELETE FROM ${this.#names.events} AS event\nWHERE event.id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb)))\n  AND ${this.#unreferenced('event')}\n  AND EXISTS (\n    SELECT 1 FROM ${this.#names.eventCompletions} AS completion\n    WHERE completion.event_id = event.id AND completion.completed_at < $2::timestamptz\n  )`);\n  }\n\n  /**\n   * Deletes locked events that no delivery references and that never had a delivery complete.\n   * It must run as a statement of its own after {@link lockEvents}: it then takes a fresh\n   * snapshot that includes every delivery committed before the lock was granted, so an event\n   * that just gained a delivery is never cascaded away. Keeps events that had a delivery complete:\n   * deleting dead letters must not shorten the retention of completed work.\n   */\n  get deleteOrphanEventsWithoutCompletion(): string {\n    return countChanged(`DELETE FROM ${this.#names.events} AS event\nWHERE event.id = ANY (ARRAY(SELECT jsonb_array_elements_text($1::jsonb)))\n  AND ${this.#unreferenced('event')}\n  AND NOT EXISTS (SELECT 1 FROM ${this.#names.eventCompletions} AS completion WHERE completion.event_id = event.id)`);\n  }\n\n  /** True when no delivery and no completion history record references the event. */\n  #unreferenced(eventAlias: string): string {\n    const history = this.#names.completionHistory\n      ? ` AND NOT EXISTS (SELECT 1 FROM ${this.#names.completions} AS done WHERE done.event_id = ${eventAlias}.id)`\n      : '';\n    return `NOT EXISTS (SELECT 1 FROM ${this.#names.deliveries} AS delivery WHERE delivery.event_id = ${eventAlias}.id)${history}`;\n  }\n\n  #purgeBatch(table: string, condition: string, orderColumn: string): string {\n    return `WITH batch AS MATERIALIZED (\n  SELECT id FROM ${table}\n  WHERE ${condition}\n  ORDER BY ${orderColumn}, id\n  LIMIT $2::int\n  FOR UPDATE SKIP LOCKED\n), deleted AS (\n  DELETE FROM ${table} AS delivery USING batch WHERE delivery.id = batch.id RETURNING delivery.event_id\n)\nSELECT event_id FROM deleted`;\n  }\n}\n","import {\n  ConfigurationError,\n  type AppendEntry,\n  type AppendResult,\n  type ClaimRequest,\n  type ClaimedDelivery,\n  type DeliveryQuery,\n  type DeliveryRecord,\n  type ErrorInfo,\n  type EventEnvelope,\n  type EventStore,\n  type EventStoreStatistics,\n  type LeaseReference,\n  type PurgeRequest,\n  type PurgeResult,\n  type RelayBusLogger,\n} from '@relaybus/core';\nimport { Client, Pool, type PoolClient, type PoolConfig } from 'pg';\nimport type {\n  PostgresExecutor,\n  PostgresParameter,\n  PostgresQueryOptions,\n  PostgresRow,\n} from './executor.js';\nimport { resolvePostgresNames, type PostgresSchemaOptions } from './names.js';\nimport { NotificationListener } from './notification-listener.js';\nimport { PgExecutor } from './pg-executor.js';\nimport {\n  mapClaimedDelivery,\n  mapDeliveryRecord,\n  mapOldestDueAt,\n  parseLeaseToken,\n  readCount,\n  type LaneLease,\n} from './row-mapping.js';\nimport { createPostgresSchemaStatements, postgresSchemaMarker } from './schema.js';\nimport { PostgresStatements } from './statements.js';\n\n/** Options shared by every way of connecting. */\nexport interface PostgresEventStoreSettings extends PostgresSchemaOptions {\n  /**\n   * Maximum deliveries deleted per transaction by `purge`. Smaller batches\n   * hold row locks for less time; `purge` keeps going until nothing is left.\n   * Default 1000.\n   */\n  readonly purgeBatchSize?: number;\n  /**\n   * Receives errors of idle connections in a pool the store creates itself\n   * (database failover, `pg_terminate_backend`, network resets). Default\n   * `console`. A pool you pass in is yours: attach `pool.on('error', ...)` to\n   * it, otherwise `pg` raises an unhandled `error` event and the process exits.\n   */\n  readonly logger?: RelayBusLogger;\n  /**\n   * Send the statements the store repeats (publish, claim, complete, renew) as named prepared\n   * statements, so each connection parses and plans their text once instead of on every call. Default\n   * `true`. Set `false` behind a pooler in transaction mode that does not keep prepared statements per\n   * client (PgBouncer before 1.21, or 1.21+ with `max_prepared_statements = 0`). Left on there, the\n   * first statement that lands on another server session fails once, then the store stops preparing\n   * and logs a warning. Only executors that support it prepare (`PgExecutor`, the default); the\n   * other adapters send every statement unprepared.\n   */\n  readonly preparedStatements?: boolean;\n  /**\n   * How dispatchers in other processes learn about new deliveries.\n   * - `'notify'` (default): a publishing transaction sends `NOTIFY` (at most one per 10 ms per store,\n   *   the rest merged into one trailing notification after the commit) and each dispatcher listens\n   *   with `LISTEN` on a connection of its own, so a delivery is picked up within milliseconds.\n   * - `'poll'`: no `NOTIFY`, no listening connection. Other processes find new deliveries when they\n   *   poll (`dispatcher.pollInterval`, default 1 s); a dispatcher in the publishing process is still\n   *   woken at once. Use it behind a pooler in transaction mode, where `LISTEN` does not work.\n   */\n  readonly wakeUp?: PostgresWakeUp;\n}\n\n/** See {@link PostgresEventStoreSettings.wakeUp}. */\nexport type PostgresWakeUp = 'notify' | 'poll';\n\nconst WAKE_UPS: readonly PostgresWakeUp[] = ['notify', 'poll'];\n\n/** Use an existing `pg` pool. The store never closes it. */\nexport interface PostgresPoolOptions extends PostgresEventStoreSettings {\n  readonly pool: Pool;\n  readonly connectionString?: never;\n  readonly poolConfig?: never;\n  readonly executor?: never;\n}\n\n/** Let the store create (and on `close()` end) its own `pg` pool. */\nexport interface PostgresConnectionOptions extends PostgresEventStoreSettings {\n  readonly connectionString: string;\n  /** Extra `pg` pool settings, for example `max`. */\n  readonly poolConfig?: Omit<PoolConfig, 'connectionString'>;\n  readonly pool?: never;\n  readonly executor?: never;\n}\n\n/** Use another database library through an adapter. The store never closes it. */\nexport interface PostgresExecutorOptions<TTransaction> extends PostgresEventStoreSettings {\n  readonly executor: PostgresExecutor<TTransaction>;\n  readonly pool?: never;\n  readonly connectionString?: never;\n  readonly poolConfig?: never;\n}\n\nexport type PostgresEventStoreOptions<TTransaction = PoolClient> =\n  PostgresPoolOptions | PostgresConnectionOptions | PostgresExecutorOptions<TTransaction>;\n\nconst DEFAULT_PURGE_BATCH_SIZE = 1_000;\n/** Lanes a claim takes in its first round; every further round takes twice as many. */\nconst INITIAL_LANES_PER_ROUND = 4;\n/** Attempts of the held-lane claim before a stale statement is given up for this call (a later claim finds the work). */\nconst MAXIMUM_STALE_CLAIM_ATTEMPTS = 3;\n\n/**\n * Least time between two wake-up notifications of one store. A transaction that sends `NOTIFY` holds a\n * database-wide lock from its commit until the commit is flushed, so a notification per publishing\n * transaction made concurrent publishers commit one at a time.\n */\nconst NOTIFICATION_INTERVAL_MS = 10;\n\ninterface EventRow {\n  readonly id: string;\n  readonly type: string;\n  readonly source: string;\n  readonly key: string | null;\n  readonly sequence: string | null;\n  readonly payload: unknown;\n  readonly headers: EventEnvelope['headers'];\n  readonly correlation_id: string | null;\n  readonly causation_id: string | null;\n  readonly occurred_at: string;\n  readonly handlers: readonly string[];\n}\n\ninterface HandedOutClaim extends LaneLease {\n  readonly owner: string;\n  readonly deliveryId: string;\n}\n\nfunction handedOutKey(deliveryId: string, leaseToken: string): string {\n  return `${deliveryId}\\u0000${leaseToken}`;\n}\n\ninterface DeliveryRow {\n  readonly id: string;\n  readonly event_id: string;\n  readonly handler: string;\n  readonly available_at: string;\n}\n\n/**\n * PostgreSQL {@link EventStore} (PostgreSQL 13 or newer).\n *\n * The transaction handle is whatever the chosen driver uses: a `pg`\n * `PoolClient` by default, or a Kysely / Knex / TypeORM / Drizzle / Prisma\n * transaction through the adapters in `@relaybus/postgres/<library>`. Events\n * published with that handle commit and roll back together with the caller's\n * own writes.\n *\n * Guarantees:\n * - **Atomic publish.** Events and deliveries are written in the caller's transaction.\n * - **Per-key order.** Each key has a counter row in the key-sequence table.\n *   Publishing locks that row and holds the lock until commit, so two\n *   transactions publishing the same key are serialized and sequence order\n *   equals commit order. Claiming then hands out only the lowest unfinished\n *   sequence of a (handler, key), and all deliveries of a key live in one lane,\n *   so one worker at a time sees them.\n * - **Lane leases.** Workers lease lanes (256 hash buckets of the ordering key\n *   or event id), not single deliveries. A claim writes one lane row for a\n *   whole batch and never writes a delivery row; a completion deletes the\n *   delivery rows. Delivery rows are therefore inserted once and deleted once,\n *   which leaves no dead index entries from updates on the normal path.\n * - **Fenced state changes.** Complete, reschedule, bury and extend only apply\n *   with the epoch of the lane lease that claimed the delivery. A lane taken\n *   over by another worker gets a new epoch, which fences everything the\n *   previous holder still runs. Completion takes a key-share lock on the lane\n *   row, so it cannot interleave with a takeover.\n * - **Attempts survive crashes.** A claim records which deliveries it put in\n *   flight in the lane row. If the holder dies, the next holder charges one\n *   attempt to each of them, so a poison message still reaches the retry limit.\n * - **App clock.** Every timestamp comes from the `now` the caller passes in,\n *   never from the database clock.\n *\n * Completed deliveries are deleted. Pass `completionHistory: true` to keep an\n * append-only record for `listDeliveries({ status: 'completed' })`.\n */\nexport class PostgresEventStore<TTransaction = PoolClient> implements EventStore<TTransaction> {\n  readonly #executor: PostgresExecutor<TTransaction>;\n  readonly #statements: PostgresStatements;\n  readonly #schemaStatements: readonly string[];\n  readonly #setupLockKey: string;\n  readonly #schemaMarker: string;\n  readonly #purgeBatchSize: number;\n  readonly #completionHistory: boolean;\n  readonly #logger: RelayBusLogger;\n  /** Passed with every statement whose text is fixed: asks the executor to prepare it (`preparedStatements`). */\n  readonly #queryOptions: PostgresQueryOptions | undefined;\n  readonly #notifies: boolean;\n  /** Every claim handed to a caller and not settled yet, by delivery id and exact lease token. */\n  readonly #handedOut = new Map<string, HandedOutClaim>();\n  readonly #unreconciled = new Set<string>();\n  readonly #generations = new Map<string, bigint>();\n  readonly #ownerQueues = new Map<string, Promise<void>>();\n  /** Owners whose last claim was filled from the lanes they held. */\n  readonly #drainingOwners = new Set<string>();\n  #ownedPool: Pool | undefined;\n  /** The `pg` pool behind the store, when it has one: listening for notifications needs a connection of its own. */\n  readonly #pool: Pool | undefined;\n  readonly #notificationChannel: string;\n  #lastNotificationAt = Number.NEGATIVE_INFINITY;\n  #trailingNotification: ReturnType<typeof setTimeout> | undefined;\n  /** Set by `close()`: a transaction that commits afterwards schedules no wake-up. */\n  #closed = false;\n  /** The transactions `transaction` runs right now, and whether one of their appends left its wake-up for after the commit. */\n  readonly #ownTransactions = new Map<unknown, { wake: boolean }>();\n\n  constructor(options: PostgresEventStoreOptions<TTransaction>) {\n    const sources = [options.pool, options.connectionString, options.executor].filter(\n      (source) => source !== undefined,\n    );\n    if (sources.length !== 1) {\n      throw new ConfigurationError(\n        'PostgresEventStore needs exactly one of pool, connectionString or executor',\n      );\n    }\n    const purgeBatchSize = options.purgeBatchSize ?? DEFAULT_PURGE_BATCH_SIZE;\n    if (!Number.isInteger(purgeBatchSize) || purgeBatchSize < 1) {\n      throw new ConfigurationError(\n        `purgeBatchSize must be a positive integer, received ${String(purgeBatchSize)}`,\n      );\n    }\n    const wakeUp = options.wakeUp ?? 'notify';\n    if (!WAKE_UPS.includes(wakeUp)) {\n      throw new ConfigurationError(`wakeUp must be 'notify' or 'poll', received ${String(wakeUp)}`);\n    }\n    const preparedStatements = options.preparedStatements ?? true;\n    if (typeof preparedStatements !== 'boolean') {\n      throw new ConfigurationError(\n        `preparedStatements must be a boolean, received ${String(preparedStatements)}`,\n      );\n    }\n    this.#notifies = wakeUp === 'notify';\n    this.#queryOptions = preparedStatements ? { prepare: true } : undefined;\n    const names = resolvePostgresNames(options);\n    this.#statements = new PostgresStatements(names);\n    this.#schemaStatements = createPostgresSchemaStatements(options);\n    this.#setupLockKey = this.#statements.setupLockKey;\n    this.#schemaMarker = postgresSchemaMarker(this.#schemaStatements.slice(0, -1));\n    this.#purgeBatchSize = purgeBatchSize;\n    this.#completionHistory = names.completionHistory;\n    this.#logger = options.logger ?? console;\n    this.#notificationChannel = names.notificationChannel;\n    if (options.executor !== undefined) {\n      this.#executor = options.executor;\n      this.#pool = undefined;\n    } else {\n      const pool =\n        options.pool ??\n        new Pool({ ...options.poolConfig, connectionString: options.connectionString });\n      if (options.pool === undefined) {\n        const logger = options.logger ?? console;\n        pool.on('error', (error) => {\n          logger.error(\n            `[PostgresEventStore](constructor) Idle connection failed, the pool replaces it | error=${error.message}`,\n          );\n        });\n        this.#ownedPool = pool;\n      }\n      this.#pool = pool;\n      // Without an executor the transaction type is PoolClient, as the default type argument states.\n      this.#executor = new PgExecutor(pool, {\n        logger: this.#logger,\n      }) as unknown as PostgresExecutor<TTransaction>;\n    }\n  }\n\n  /**\n   * Creates the schema, tables and indexes if they do not exist. Safe to call\n   * from many processes at once: a transaction-scoped advisory lock serializes\n   * the DDL, so racing `CREATE TABLE IF NOT EXISTS` statements cannot collide.\n   * When the lane table already carries the marker of the current statements\n   * ({@link postgresSchemaMarker}) nothing runs and no table is locked, so instances\n   * that start next to running dispatchers cannot deadlock with their claims.\n   * Skip it (`setupStore: false`) when a migration tool applies\n   * `createPostgresSchemaSql()` instead.\n   */\n  async setup(): Promise<void> {\n    // DDL on a current schema would still lock the tables, and those locks deadlock with running claims.\n    if (await this.#schemaIsCurrent()) {\n      return;\n    }\n    await this.#executor.transaction(async (transaction) => {\n      await this.#executor.query(this.#statements.setupLock, [this.#setupLockKey], transaction);\n      if (await this.#schemaIsCurrent(transaction)) {\n        return;\n      }\n      for (const statement of this.#schemaStatements) {\n        await this.#executor.query(statement, [], transaction);\n      }\n    });\n  }\n\n  async #schemaIsCurrent(transaction?: TTransaction): Promise<boolean> {\n    const rows = await this.#executor.query(\n      this.#statements.schemaCurrent,\n      [this.#schemaMarker],\n      transaction,\n    );\n    return rows[0]!['current'] === true;\n  }\n\n  async transaction<T>(work: (transaction: TTransaction) => Promise<T>): Promise<T> {\n    const own = { wake: false };\n    const result = await this.#executor.transaction(async (transaction) => {\n      this.#ownTransactions.set(transaction, own);\n      try {\n        return await work(transaction);\n      } finally {\n        this.#ownTransactions.delete(transaction);\n      }\n    });\n    if (own.wake) {\n      this.#wakeAfterCommit();\n    }\n    return result;\n  }\n\n  /**\n   * Writes the entries in `transaction`, normally with one statement\n   * ({@link PostgresStatements.insertFreshEvents}): keyed events reserve their sequence numbers (locking\n   * the key rows in sorted order, so publishers cannot deadlock inside one call), then the new events and\n   * their deliveries are inserted, ordered by primary key, and one notification wakes the dispatchers\n   * when a delivery is due now. Events that already existed get their missing handlers' deliveries in\n   * two more statements. Two transactions that append keys in opposite order across several calls can\n   * still deadlock (40P01); the database rolls one back and the caller retries.\n   * A duplicate event id still consumes a sequence number; gaps are harmless\n   * because only the order of sequences matters.\n   */\n  async append(\n    transaction: TTransaction,\n    entries: readonly AppendEntry[],\n    now: Date,\n  ): Promise<AppendResult> {\n    const plan = planAppend(entries);\n    if (plan.events.length === 0) {\n      return { appendedEventIds: [], duplicateEventIds: [], appendedDeliveryCount: 0 };\n    }\n    const createdAt = now.toISOString();\n    const wakeAt = this.#wakeAt(plan.deliveries, now, transaction);\n    const handlersByEvent = new Map<string, string[]>();\n    for (const delivery of plan.deliveries) {\n      handlersByEvent.set(delivery.event_id, [\n        ...(handlersByEvent.get(delivery.event_id) ?? []),\n        delivery.handler,\n      ]);\n    }\n    const keyCounts = new Map<string, number>();\n    for (const event of plan.events) {\n      if (event.key !== null) {\n        keyCounts.set(event.key, (keyCounts.get(event.key) ?? 0) + 1);\n      }\n    }\n    const fresh = await this.#query(\n      this.#statements.insertFreshEvents,\n      [\n        JSON.stringify(\n          plan.events.map((event, ordinal) => ({\n            ordinal,\n            ...toEventRow(event, null, handlersByEvent.get(event.id) ?? []),\n          })),\n        ),\n        createdAt,\n        JSON.stringify(plan.deliveries),\n        JSON.stringify([...keyCounts].map(([key, count]) => ({ key, count }))),\n        wakeAt,\n      ],\n      transaction,\n    );\n    const insertedEventIds = new Set(\n      fresh.filter((row) => row['inserted'] === true).map((row) => row['id'] as string),\n    );\n    let appendedDeliveryCount = readCount(fresh[0]!, 'deliveries');\n    const remaining = plan.deliveries.filter(\n      (delivery) => !insertedEventIds.has(delivery.event_id),\n    );\n    if (remaining.length > 0) {\n      appendedDeliveryCount += await this.#appendToExistingEvents(\n        transaction,\n        plan,\n        fresh,\n        remaining,\n        handlersByEvent,\n        insertedEventIds,\n        createdAt,\n        wakeAt,\n      );\n    }\n    const appendedEventIds: string[] = [];\n    const duplicateEventIds: string[] = [];\n    for (const { eventId, repeated } of plan.outcomes) {\n      (!repeated && insertedEventIds.has(eventId) ? appendedEventIds : duplicateEventIds).push(\n        eventId,\n      );\n    }\n    return { appendedEventIds, duplicateEventIds, appendedDeliveryCount };\n  }\n\n  /**\n   * The time the publishing statements notify the dispatchers for (deliveries due by then wake them),\n   * or `null` for no notification. An append in a transaction of the caller's always notifies, at its\n   * commit. In a transaction of this store, only the first append within {@link NOTIFICATION_INTERVAL_MS}\n   * does; the others leave the wake-up to {@link #wakeAfterCommit}, which runs once their transaction\n   * committed, so no committed delivery waits for the poll.\n   */\n  #wakeAt(deliveries: readonly DeliveryRow[], now: Date, transaction: TTransaction): string | null {\n    if (\n      !this.#notifies ||\n      !deliveries.some((delivery) => Date.parse(delivery.available_at) <= now.getTime())\n    ) {\n      return null;\n    }\n    const own = this.#ownTransactions.get(transaction);\n    if (own !== undefined && Date.now() - this.#lastNotificationAt < NOTIFICATION_INTERVAL_MS) {\n      own.wake = true;\n      return null;\n    }\n    this.#lastNotificationAt = Date.now();\n    return now.toISOString();\n  }\n\n  /**\n   * Wakes the dispatchers for a committed transaction whose appends sent no notification: at once when\n   * none was sent within {@link NOTIFICATION_INTERVAL_MS}, otherwise once when the interval ends. A\n   * wake-up already scheduled covers this transaction too, since it is sent after this commit. Nothing is\n   * sent once the store is closed or the `pg` pool behind it is ending: no dispatcher can be woken through\n   * it then, and the deliveries are found by polling.\n   */\n  #wakeAfterCommit(): void {\n    if (this.#trailingNotification !== undefined || this.#closed) {\n      return;\n    }\n    this.#trailingNotification = setTimeout(\n      () => {\n        this.#trailingNotification = undefined;\n        if (this.#pool?.ending === true) {\n          return;\n        }\n        this.#lastNotificationAt = Date.now();\n        this.#query(this.#statements.notify, []).catch((error: unknown) => {\n          this.#logger.error(\n            `[PostgresEventStore](wakeAfterCommit) Waking the dispatchers failed, they find the deliveries when they poll | error=${error instanceof Error ? error.message : String(error)}`,\n          );\n        });\n      },\n      Math.max(0, this.#lastNotificationAt + NOTIFICATION_INTERVAL_MS - Date.now()),\n    );\n  }\n\n  /**\n   * Adds the deliveries of events the publishing statement found already stored. An event that already\n   * exists may be getting the same new handler from another transaction at this very moment. Whoever\n   * holds the event decides, so the freshness check of the insert sees what the other transaction\n   * committed, even if its delivery has completed since. An existing event that a purge removed\n   * meanwhile is inserted again (with the sequence reserved for it) instead of being skipped; its id is\n   * added to `insertedEventIds`. Returns how many deliveries were inserted.\n   */\n  async #appendToExistingEvents(\n    transaction: TTransaction,\n    plan: AppendPlan,\n    fresh: readonly PostgresRow[],\n    deliveries: readonly DeliveryRow[],\n    handlersByEvent: ReadonlyMap<string, string[]>,\n    insertedEventIds: Set<string>,\n    createdAt: string,\n    wakeAt: string | null,\n  ): Promise<number> {\n    const sequences = new Map(\n      fresh.map((row) => [row['id'] as string, row['sequence'] as string | null]),\n    );\n    const reinserted: string[] = [];\n    let existing = plan.events\n      .filter((event) => !insertedEventIds.has(event.id))\n      .map((event) =>\n        toEventRow(event, sequences.get(event.id)!, handlersByEvent.get(event.id) ?? []),\n      );\n    while (existing.length > 0) {\n      const locked = new Set(\n        (\n          await this.#query(\n            this.#statements.lockExistingEvents,\n            [JSON.stringify(existing.map((row) => row.id).sort())],\n            transaction,\n          )\n        ).map((row) => row['id'] as string),\n      );\n      const gone = existing.filter((row) => !locked.has(row.id));\n      if (gone.length > 0) {\n        const inserted = await this.#query(\n          this.#statements.insertEvents,\n          [JSON.stringify(gone), createdAt],\n          transaction,\n        );\n        for (const row of inserted) {\n          insertedEventIds.add(row['id'] as string);\n          reinserted.push(row['id'] as string);\n        }\n      }\n      existing = gone.filter((row) => !insertedEventIds.has(row.id));\n    }\n    const inserted = await this.#query(\n      this.#statements.insertDeliveries,\n      [JSON.stringify(deliveries), createdAt, JSON.stringify(reinserted), wakeAt],\n      transaction,\n    );\n    return inserted.length;\n  }\n\n  /**\n   * Claims up to `limit` due deliveries, normally with one statement\n   * ({@link PostgresStatements.claimLanes}): from the lanes this owner already holds, then from free lanes\n   * it takes in the same statement, recording the batch in the lane rows. A claim that would have to take\n   * over a lane whose previous holder still runs deliveries under an expired lease continues in a\n   * transaction that charges their lost attempts first, taking free lanes a few at a time (4, 8, 16, ...);\n   * so does a claim whose statement kept seeing a lane it holds change under it, and one that came up\n   * short with more free lanes left than it looked at. The step that fails after\n   * the first one has recorded deliveries returns those instead of failing: a recorded delivery nobody\n   * received would be held for a whole lease. See {@link PostgresStatements.claim} for the rules a delivery\n   * must satisfy.\n   */\n  claim(request: ClaimRequest): Promise<ClaimedDelivery[]> {\n    if (request.handlers.length === 0 || !(request.limit > 0)) {\n      return Promise.resolve([]);\n    }\n    return this.#serialized(request.leaseOwner, () => this.#claim(request));\n  }\n\n  /**\n   * Runs `work` after the earlier claims of the same owner on this store settled. The\n   * bookkeeping of what was handed out and the reconciliation of a failed claim need\n   * one claim at a time per owner (the dispatcher claims one batch at a time anyway;\n   * `runOnce` next to a running dispatcher is what this guards against).\n   */\n  #serialized<T>(owner: string, work: () => Promise<T>): Promise<T> {\n    const previous = this.#ownerQueues.get(owner) ?? Promise.resolve();\n    const run = previous.then(work, work);\n    const tail = run.then(\n      () => undefined,\n      () => undefined,\n    );\n    this.#ownerQueues.set(owner, tail);\n    void tail.then(() => {\n      if (this.#ownerQueues.get(owner) === tail) {\n        this.#ownerQueues.delete(owner);\n      }\n    });\n    return run;\n  }\n\n  async #claim(request: ClaimRequest): Promise<ClaimedDelivery[]> {\n    if (\n      this.#unreconciled.has(request.leaseOwner) &&\n      !(await this.#reconcile(request.leaseOwner))\n    ) {\n      // The generation moved on and the lanes were not told: claiming now would take the owner's live lanes for foreign ones.\n      throw new Error(\n        `[PostgresEventStore](claim) Giving back unreturned deliveries still fails, so no claim is made | owner=${request.leaseOwner}`,\n      );\n    }\n    // An owner whose last claim was filled from the lanes it held is draining a backlog there: those\n    // lanes are asked first.\n    const heldFirst = this.#drainingOwners.has(request.leaseOwner);\n    let rows: readonly PostgresRow[];\n    try {\n      rows = await this.#claimInOneStatement(\n        request,\n        heldFirst ? this.#statements.claimHeldLanes : this.#statements.claimLanes,\n      );\n    } catch (error) {\n      await this.#reconcile(request.leaseOwner);\n      throw error;\n    }\n    const heldLanes = new Set(JSON.parse(rows[0]!['examined_lanes'] as string) as number[]);\n    const claimed = this.#takeClaimed(rows, request.leaseOwner);\n    if (heldFirst && claimed.length < request.limit && rows[0]!['stale'] !== true) {\n      try {\n        rows = await this.#claimInOneStatement(\n          { ...request, limit: request.limit - claimed.length },\n          this.#statements.claimLanes,\n        );\n      } catch (error) {\n        await this.#reconcile(request.leaseOwner);\n        if (claimed.length === 0) {\n          this.#drainingOwners.delete(request.leaseOwner);\n          throw error;\n        }\n        this.#logger.error(\n          `[PostgresEventStore](claim) Claiming from free lanes failed, returning the deliveries already claimed | claimed=${claimed.length} | error=${error instanceof Error ? error.message : String(error)}`,\n        );\n        return this.#handOutInDueOrder(claimed, request, heldLanes);\n      }\n      claimed.push(...this.#takeClaimed(rows, request.leaseOwner));\n    }\n    if (\n      claimed.length < request.limit &&\n      (rows[0]!['takeover_waiting'] === true ||\n        rows[0]!['unexamined_free_lanes'] === true ||\n        rows[0]!['stale'] === true)\n    ) {\n      try {\n        const more = await this.#claimMore(request, claimed.length);\n        this.#handOut(more, request.leaseOwner);\n        claimed.push(...more);\n      } catch (error) {\n        await this.#reconcile(request.leaseOwner);\n        if (claimed.length === 0) {\n          throw error;\n        }\n        this.#logger.error(\n          `[PostgresEventStore](claim) Taking more lanes failed, returning the deliveries already claimed | claimed=${claimed.length} | error=${error instanceof Error ? error.message : String(error)}`,\n        );\n      }\n    }\n    return this.#handOutInDueOrder(claimed, request, heldLanes);\n  }\n\n  /** The deliveries a claim statement picked, registered as handed out to `leaseOwner`. */\n  #takeClaimed(rows: readonly PostgresRow[], leaseOwner: string): PostgresRow[] {\n    const claimed = rows.filter((row) => row['delivery_id'] !== null);\n    this.#forgetFinished(rows[0]!, leaseOwner, claimed);\n    this.#handOut(claimed, leaseOwner);\n    return claimed;\n  }\n\n  #handOutInDueOrder(\n    claimed: PostgresRow[],\n    request: ClaimRequest,\n    heldLanes: ReadonlySet<number>,\n  ): ClaimedDelivery[] {\n    if (\n      claimed.length >= request.limit &&\n      claimed.every((row) => heldLanes.has(readCount(row, 'lane')))\n    ) {\n      this.#drainingOwners.add(request.leaseOwner);\n    } else {\n      this.#drainingOwners.delete(request.leaseOwner);\n    }\n    // The steps pick from different lanes; hand the batch out in due order, like a single query would.\n    claimed.sort(compareDue);\n    return claimed.map((row) => mapClaimedDelivery(row, request.leaseExpiresAt));\n  }\n\n  /**\n   * Runs `statement` ({@link PostgresStatements.claimLanes} or its held-lane form), again when it reports that it waited for a lane lock and\n   * read deliveries with an older snapshot than the lane it got. A held lane is only locked by an\n   * operation of its own owner (another claim, a reschedule), so a few attempts are enough.\n   */\n  async #claimInOneStatement(\n    request: ClaimRequest,\n    statement: string,\n  ): Promise<readonly PostgresRow[]> {\n    const parameters = [\n      request.now.toISOString(),\n      JSON.stringify(request.handlers),\n      request.limit,\n      request.leaseOwner,\n      request.leaseExpiresAt.toISOString(),\n      this.#generation(request.leaseOwner).toString(),\n    ];\n    let rows = await this.#query(statement, parameters);\n    for (\n      let attempt = 1;\n      attempt < MAXIMUM_STALE_CLAIM_ATTEMPTS && rows[0]!['stale'] === true;\n      attempt += 1\n    ) {\n      rows = await this.#query(statement, parameters);\n    }\n    return rows;\n  }\n\n  /**\n   * Second step of {@link PostgresEventStore.claim}, in one transaction: takes free lanes a few at a\n   * time, lanes to take over included (their lost attempts are charged first), and records the batch.\n   * `alreadyClaimed` deliveries of the first step are in flight, so they are not picked again.\n   */\n  async #claimMore(request: ClaimRequest, alreadyClaimed: number): Promise<PostgresRow[]> {\n    const now = request.now.toISOString();\n    const leaseExpiresAt = request.leaseExpiresAt.toISOString();\n    const handlers = JSON.stringify(request.handlers);\n    // Taken before the transaction starts: a transaction that reaches the server late keeps its generation.\n    const generation = this.#generation(request.leaseOwner).toString();\n    return this.#executor.transaction(async (transaction) => {\n      const claimed: PostgresRow[] = [];\n      const remaining = (): number => request.limit - alreadyClaimed - claimed.length;\n      const takenLanes = new Set<number>();\n      for (let laneCount = INITIAL_LANES_PER_ROUND; remaining() > 0;) {\n        const taken = await this.#query(\n          this.#statements.takeFreeLanes,\n          [now, handlers, laneCount, request.leaseOwner, leaseExpiresAt, generation],\n          transaction,\n        );\n        if (taken.length === 0) {\n          break;\n        }\n        const lanes = taken.map((row) => readCount(row, 'lane'));\n        for (const lane of lanes) {\n          takenLanes.add(lane);\n        }\n        claimed.push(\n          ...(await this.#pickDeliveries(\n            [now, handlers, remaining(), JSON.stringify(lanes)],\n            transaction,\n          )),\n        );\n        laneCount *= 2;\n      }\n      await this.#recordClaim(claimed, takenLanes, request, transaction);\n      return claimed;\n    });\n  }\n\n  /**\n   * The generation of the owner's claim statements. It only grows, also across restarts (it starts at the\n   * clock), and a reconciliation moves it up, which fences off every earlier statement still in flight.\n   */\n  #generation(owner: string, advance = false): bigint {\n    const current = this.#generations.get(owner) ?? BigInt(Date.now());\n    const next = advance\n      ? current + 1n > BigInt(Date.now())\n        ? current + 1n\n        : BigInt(Date.now())\n      : current;\n    this.#generations.set(owner, next);\n    return next;\n  }\n\n  /** Forgets a handed-out lease once the store answered about it (any answer: the claim is over or fenced out). */\n  async #settled(lease: LeaseReference, work: Promise<boolean>): Promise<boolean> {\n    const result = await work;\n    this.#handedOut.delete(handedOutKey(lease.deliveryId, lease.leaseToken));\n    return result;\n  }\n\n  /** Remembers the claims handed to the caller of `claim` until they are settled. */\n  #handOut(rows: readonly PostgresRow[], leaseOwner: string): void {\n    for (const row of rows) {\n      const claim = mapClaimedDelivery(row, new Date(0));\n      this.#handedOut.set(handedOutKey(claim.deliveryId, claim.leaseToken), {\n        owner: leaseOwner,\n        deliveryId: claim.deliveryId,\n        ...parseLeaseToken(claim.leaseToken)!,\n      });\n    }\n  }\n\n  /**\n   * Drops the registrations of the owner's held lanes whose delivery no longer runs there\n   * (completed inside the caller's transaction, deleted, or listed no more). Registrations of\n   * lanes this claim did not see stay: their tokens may still be valid.\n   */\n  #forgetFinished(row: PostgresRow, leaseOwner: string, claimed: readonly PostgresRow[]): void {\n    // Lanes the statement freed are examined too: nothing runs there any more.\n    const heldLanes = new Set(JSON.parse(row['examined_lanes'] as string) as number[]);\n    const running = new Set([\n      ...(JSON.parse(row['running_ids'] as string) as string[]),\n      ...claimed.map((picked) => picked['delivery_id'] as string),\n    ]);\n    for (const [key, entry] of this.#handedOut) {\n      if (\n        entry.owner === leaseOwner &&\n        heldLanes.has(entry.lane) &&\n        !running.has(entry.deliveryId)\n      ) {\n        this.#handedOut.delete(key);\n      }\n    }\n  }\n\n  /**\n   * After a claim failed, possibly after the database recorded its batch: gives back the recorded\n   * deliveries that were never handed out, keeping exactly the claims handed out and not settled.\n   * A failure is remembered and retried before the owner's next claim: other deliveries keep\n   * renewing the lane, so an unreturned one would otherwise never be recovered.\n   */\n  async #reconcile(leaseOwner: string): Promise<boolean> {\n    // Claim statements of the generation before are fenced off by the new one.\n    const generation = this.#generation(leaseOwner, true);\n    const handedOut = [...this.#handedOut.values()]\n      .filter((entry) => entry.owner === leaseOwner)\n      .map(({ deliveryId, lane, epoch, claims }) => ({ id: deliveryId, lane, epoch, claims }));\n    try {\n      await this.#query(this.#statements.reconcileClaims, [\n        leaseOwner,\n        JSON.stringify(handedOut),\n        generation.toString(),\n      ]);\n      this.#unreconciled.delete(leaseOwner);\n      return true;\n    } catch (error) {\n      this.#unreconciled.add(leaseOwner);\n      this.#logger.error(\n        `[PostgresEventStore](reconcile) Giving back unreturned deliveries failed, it is retried before the next claim | owner=${leaseOwner} | error=${error instanceof Error ? error.message : String(error)}`,\n      );\n      return false;\n    }\n  }\n\n  /** Fast claim, then the slow one when the fast window was full of blocked followers. */\n  async #pickDeliveries(\n    parameters: readonly PostgresParameter[],\n    transaction: TTransaction,\n  ): Promise<PostgresRow[]> {\n    const limit = parameters[2] as number;\n    const fastRows = await this.#query(this.#statements.claim, parameters, transaction);\n    const picked = fastRows.filter((row) => row['delivery_id'] !== null);\n    if (picked.length < limit && fastRows[0]!['window_saturated'] === true) {\n      const slowRows = await this.#query(\n        this.#statements.claimBehindBlockedKeys,\n        parameters,\n        transaction,\n      );\n      // Nothing was written, so the slow statement sees the fast statement's picks again.\n      // Both pick at most the head of a key, so the union is still one delivery per key.\n      const pickedIds = new Set(picked.map((row) => row['delivery_id']));\n      picked.push(\n        ...slowRows.filter(\n          (row) => row['delivery_id'] !== null && !pickedIds.has(row['delivery_id']),\n        ),\n      );\n      // The two statements read at different moments: a dead letter requeued in between can put a key's\n      // predecessor in one result and its successor in the other. Only the lowest of a key may run.\n      const seenKeys = new Set<string>();\n      const kept = [...picked]\n        .sort((left, right) => compareSequence(left, right))\n        .filter((row) => {\n          if (row['delivery_key'] === null) {\n            return true;\n          }\n          const group = `${row['handler'] as string}\\u0000${row['delivery_key'] as string}`;\n          return !seenKeys.has(group) && Boolean(seenKeys.add(group));\n        });\n      kept.sort(compareDue);\n      return kept.slice(0, limit);\n    }\n    return picked;\n  }\n\n  /** Writes the picked ids into their lane rows and frees the lanes that picked nothing. */\n  async #recordClaim(\n    claimed: readonly PostgresRow[],\n    lanes: ReadonlySet<number>,\n    request: ClaimRequest,\n    transaction: TTransaction,\n  ): Promise<void> {\n    const idsByLane = new Map<number, string[]>();\n    for (const row of claimed) {\n      const lane = readCount(row, 'lane');\n      idsByLane.set(lane, [...(idsByLane.get(lane) ?? []), row['delivery_id'] as string]);\n    }\n    const idleLanes = [...lanes].filter((lane) => !idsByLane.has(lane));\n    if (idsByLane.size === 0 && idleLanes.length === 0) {\n      return;\n    }\n    await this.#query(\n      this.#statements.recordClaim,\n      [\n        JSON.stringify([...idsByLane].map(([lane, ids]) => ({ lane, ids }))),\n        JSON.stringify(idleLanes),\n        request.leaseOwner,\n        request.leaseExpiresAt.toISOString(),\n      ],\n      transaction,\n    );\n  }\n\n  extendLease(lease: LeaseReference, leaseExpiresAt: Date): Promise<boolean> {\n    return this.#whenIssued(lease, (held) =>\n      this.#changed(this.#statements.extendLease, [\n        lease.deliveryId,\n        held.lane,\n        held.epoch,\n        held.claims,\n        leaseExpiresAt.toISOString(),\n      ]),\n    );\n  }\n\n  async complete(lease: LeaseReference, now: Date, transaction?: TTransaction): Promise<boolean> {\n    return (await this.#completeLeases([lease], now, transaction))[0]!;\n  }\n\n  completeMany(leases: readonly LeaseReference[], now: Date): Promise<boolean[]> {\n    return this.#completeLeases(leases, now, undefined);\n  }\n\n  reschedule(\n    lease: LeaseReference,\n    availableAt: Date,\n    error: ErrorInfo,\n    now: Date,\n  ): Promise<boolean> {\n    return this.#settled(\n      lease,\n      this.#whenIssued(lease, (held) =>\n        this.#changed(this.#statements.reschedule, [\n          lease.deliveryId,\n          held.lane,\n          held.epoch,\n          held.claims,\n          availableAt.toISOString(),\n          JSON.stringify(error),\n          now.toISOString(),\n        ]),\n      ),\n    );\n  }\n\n  bury(lease: LeaseReference, error: ErrorInfo, now: Date): Promise<boolean> {\n    return this.#settled(\n      lease,\n      this.#whenIssued(lease, (held) =>\n        this.#changed(this.#statements.bury, [\n          lease.deliveryId,\n          held.lane,\n          held.epoch,\n          held.claims,\n          JSON.stringify(error),\n          now.toISOString(),\n        ]),\n      ),\n    );\n  }\n\n  /** Returns a leased delivery to pending, due now, without counting the attempt. */\n  release(lease: LeaseReference, now: Date): Promise<boolean> {\n    return this.#settled(\n      lease,\n      this.#whenIssued(lease, (held) =>\n        this.#changed(this.#statements.release, [\n          lease.deliveryId,\n          held.lane,\n          held.epoch,\n          held.claims,\n          now.toISOString(),\n        ]),\n      ),\n    );\n  }\n\n  /**\n   * Calls `listener` soon after a transaction that published deliveries due at once commits, in any\n   * process: `append` sends one `pg_notify` per call (merged per transaction, none for delayed\n   * deliveries), and this listens with `LISTEN` on a connection of its own, opened with the settings of\n   * the store's pool (one connection more than the pool's `max`). A lost connection is replaced after a\n   * second. Resolves with `undefined` for a store built on an `executor`, which has no connection of its\n   * own to listen on, and with `wakeUp: 'poll'`: polling then finds new deliveries (and the bus still\n   * wakes its own dispatcher).\n   */\n  async watchNewDeliveries(listener: () => void): Promise<(() => Promise<void>) | undefined> {\n    if (this.#pool === undefined || !this.#notifies) {\n      return undefined;\n    }\n    const options = this.#pool.options;\n    const watcher = new NotificationListener(\n      async () => {\n        // A client of its own, with the pool's connection settings: the pool keeps all its connections.\n        const client = new Client(options);\n        await client.connect();\n        return client;\n      },\n      this.#notificationChannel,\n      listener,\n      this.#logger,\n    );\n    await watcher.start();\n    return () => watcher.close();\n  }\n\n  /** Frees the lanes `leaseOwner` holds that run no delivery, so other workers need not wait for the lease to expire. */\n  async relinquish(leaseOwner: string): Promise<void> {\n    await this.#query(this.#statements.relinquish, [leaseOwner]);\n  }\n\n  async listDeliveries(query: DeliveryQuery): Promise<DeliveryRecord[]> {\n    const statement = this.#statements.listDeliveries(query);\n    const rows = await this.#executor.query(statement.sql, statement.parameters);\n    return rows.map(mapDeliveryRecord);\n  }\n\n  async requeue(deliveryIds: readonly string[], now: Date): Promise<number> {\n    const rows = await this.#query(this.#statements.requeue, [\n      JSON.stringify(deliveryIds),\n      now.toISOString(),\n    ]);\n    return readCount(rows[0]!, 'count');\n  }\n\n  /**\n   * Deletes purgeable deliveries in batches of `purgeBatchSize`, one short\n   * transaction per batch, then the events those batches left without any\n   * delivery. Finally, events created before the earliest given cutoff that\n   * have no delivery at all are removed: they are what a publish leaves behind\n   * when its last delivery was purged in the same instant, or when no handler\n   * was subscribed. Events that a concurrent publish is attaching a delivery\n   * to are skipped and kept.\n   */\n  async purge(request: PurgeRequest): Promise<PurgeResult> {\n    const total = { deletedDeliveries: 0, deletedEvents: 0 };\n    const batches: Array<[string, Date | undefined, string]> = [\n      [\n        this.#statements.purgeCompletedBatch(),\n        request.completedBefore,\n        this.#statements.deleteOrphanEventsWithoutCompletion,\n      ],\n      [\n        this.#statements.purgeDeadBatch(),\n        request.deadBefore,\n        this.#statements.deleteOrphanEventsWithoutCompletion,\n      ],\n    ];\n    if (this.#completionHistory) {\n      batches.push([\n        this.#statements.purgeCompletionHistoryBatch(),\n        request.completedBefore,\n        this.#statements.deleteOrphanEventsWithoutCompletion,\n      ]);\n    }\n    for (const [sql, cutoff, deleteOrphans] of batches) {\n      if (cutoff === undefined) {\n        continue;\n      }\n      let deletedInBatch = this.#purgeBatchSize;\n      while (deletedInBatch === this.#purgeBatchSize) {\n        const batch = await this.#purgeBatch(sql, cutoff, deleteOrphans);\n        deletedInBatch = batch.deletedDeliveries;\n        total.deletedDeliveries += batch.deletedDeliveries;\n        total.deletedEvents += batch.deletedEvents;\n      }\n    }\n    const orphanCutoff = [request.completedBefore, request.deadBefore]\n      .filter((cutoff) => cutoff !== undefined)\n      .sort((first, second) => first.getTime() - second.getTime())[0];\n    if (orphanCutoff !== undefined) {\n      total.deletedEvents += await this.#purgeOrphanEvents(\n        this.#statements.lockOrphanEventsBatch,\n        this.#statements.deleteOrphanEventsWithoutCompletion,\n        orphanCutoff,\n        false,\n      );\n    }\n    if (request.completedBefore !== undefined) {\n      total.deletedEvents += await this.#purgeOrphanEvents(\n        this.#statements.lockCompletedOrphanEventsBatch,\n        this.#statements.deleteExpiredCompletedOrphanEvents,\n        request.completedBefore,\n        true,\n      );\n    }\n    return total;\n  }\n\n  async statistics(now: Date): Promise<EventStoreStatistics> {\n    const stored: Record<string, number> = { pending: 0, dead: 0, completed: 0 };\n    for (const row of await this.#query(this.#statements.countByStatus, [])) {\n      stored[row['status'] as string] = readCount(row, 'count');\n    }\n    const [running] = await this.#query(this.#statements.countRunning, []);\n    const processing = readCount(running!, 'count');\n    let completed = stored['completed']!;\n    if (this.#completionHistory) {\n      const [history] = await this.#query(this.#statements.countCompletionHistory, []);\n      completed += readCount(history!, 'count');\n    }\n    const oldestDue = await this.#query(this.#statements.oldestDue, [now.toISOString()]);\n    return {\n      // The counts come from separate statements; a delivery that finishes in between must not make this negative.\n      pending: Math.max(0, stored['pending']! - processing),\n      processing,\n      completed,\n      dead: stored['dead']!,\n      oldestDueAt: mapOldestDueAt(oldestDue),\n    };\n  }\n\n  /** Ends the pool this store created from `connectionString`. Pools and executors you passed in stay open. */\n  async close(): Promise<void> {\n    this.#closed = true;\n    clearTimeout(this.#trailingNotification);\n    this.#trailingNotification = undefined;\n    const pool = this.#ownedPool;\n    this.#ownedPool = undefined;\n    await pool?.end();\n  }\n\n  /** Runs a statement of {@link PostgresStatements} whose text never changes, prepared when `preparedStatements` is on. */\n  #query(\n    sql: string,\n    parameters: readonly PostgresParameter[],\n    transaction?: TTransaction,\n  ): Promise<readonly PostgresRow[]> {\n    return this.#executor.query(sql, parameters, transaction, this.#queryOptions);\n  }\n\n  async #changed(sql: string, parameters: readonly PostgresParameter[]): Promise<boolean> {\n    const rows = await this.#query(sql, parameters);\n    return readCount(rows[0]!, 'count') > 0;\n  }\n\n  /** Runs `operation` for a lease this store issued; any other token cannot be held. */\n  async #whenIssued(\n    lease: LeaseReference,\n    operation: (held: LaneLease) => Promise<boolean>,\n  ): Promise<boolean> {\n    const held = parseLeaseToken(lease.leaseToken);\n    return held !== undefined && (await operation(held));\n  }\n\n  /**\n   * Deletes the delivery of every lease that is still the current claim of its\n   * delivery. Returns one flag per lease, in order. Results are matched to leases\n   * by position, so two leases of one delivery (a stale and a current one) get\n   * their own answers; a lease listed twice completes once, at its first position.\n   */\n  async #completeLeases(\n    leases: readonly LeaseReference[],\n    now: Date,\n    transaction: TTransaction | undefined,\n  ): Promise<boolean[]> {\n    const issued: Array<{ ord: number; id: string } & LaneLease> = [];\n    const seen = new Set<string>();\n    leases.forEach((lease, ord) => {\n      const held = parseLeaseToken(lease.leaseToken);\n      const identity = `${lease.deliveryId}\\u0000${lease.leaseToken}`;\n      if (held !== undefined && !seen.has(identity)) {\n        seen.add(identity);\n        issued.push({ ord, id: lease.deliveryId, ...held });\n      }\n    });\n    const completed = new Set<number>();\n    if (issued.length > 0) {\n      const rows = await this.#query(\n        this.#statements.complete,\n        [JSON.stringify(issued), now.toISOString()],\n        transaction,\n      );\n      for (const row of rows) {\n        completed.add(readCount(row, 'ord'));\n      }\n    }\n    if (transaction === undefined) {\n      // Inside the caller's transaction the completion is only provisional: it may roll back and retry.\n      for (const lease of leases) {\n        this.#handedOut.delete(handedOutKey(lease.deliveryId, lease.leaseToken));\n      }\n    }\n    return leases.map((_, ord) => completed.has(ord));\n  }\n\n  async #purgeOrphanEvents(\n    lockStatement: string,\n    deleteStatement: string,\n    cutoff: Date,\n    recheckCutoff: boolean,\n  ): Promise<number> {\n    let deletedEvents = 0;\n    let removedInBatch = this.#purgeBatchSize;\n    while (removedInBatch === this.#purgeBatchSize) {\n      removedInBatch = await this.#executor.transaction(async (transaction) => {\n        const locked = await this.#query(\n          lockStatement,\n          [cutoff.toISOString(), this.#purgeBatchSize],\n          transaction,\n        );\n        const ids = JSON.stringify(locked.map((row: PostgresRow) => row['id'] as string));\n        const removed = await this.#query(\n          deleteStatement,\n          recheckCutoff ? [ids, cutoff.toISOString()] : [ids],\n          transaction,\n        );\n        return readCount(removed[0]!, 'count');\n      });\n      deletedEvents += removedInBatch;\n    }\n    return deletedEvents;\n  }\n\n  async #purgeBatch(\n    sql: string,\n    cutoff: Date,\n    deleteOrphans: string,\n  ): Promise<{ deletedDeliveries: number; deletedEvents: number }> {\n    return this.#executor.transaction(async (transaction) => {\n      const deleted = await this.#query(\n        sql,\n        [cutoff.toISOString(), this.#purgeBatchSize],\n        transaction,\n      );\n      if (deleted.length === 0) {\n        return { deletedDeliveries: 0, deletedEvents: 0 };\n      }\n      const eventIds = JSON.stringify([\n        ...new Set(deleted.map((row) => row['event_id'] as string)),\n      ]);\n      const locked = await this.#query(this.#statements.lockEvents, [eventIds], transaction);\n      const removed = await this.#query(\n        deleteOrphans,\n        [JSON.stringify(locked.map((row: PostgresRow) => row['id'] as string))],\n        transaction,\n      );\n      return { deletedDeliveries: deleted.length, deletedEvents: readCount(removed[0]!, 'count') };\n    });\n  }\n}\n\ninterface AppendPlan {\n  /** First occurrence of every event id in the call, in entry order. */\n  readonly events: readonly EventEnvelope[];\n  readonly deliveries: readonly DeliveryRow[];\n  /** One per entry: its event id, and whether an earlier entry of the call carried the same id. */\n  readonly outcomes: ReadonlyArray<{ readonly eventId: string; readonly repeated: boolean }>;\n}\n\nfunction planAppend(entries: readonly AppendEntry[]): AppendPlan {\n  const events: EventEnvelope[] = [];\n  const deliveries: DeliveryRow[] = [];\n  const outcomes: Array<{ eventId: string; repeated: boolean }> = [];\n  const seenEventIds = new Set<string>();\n  const seenDeliveries = new Set<string>();\n  for (const { event, deliveries: newDeliveries } of entries) {\n    const repeated = seenEventIds.has(event.id);\n    seenEventIds.add(event.id);\n    outcomes.push({ eventId: event.id, repeated });\n    if (!repeated) {\n      events.push(event);\n    }\n    for (const delivery of newDeliveries) {\n      const identity = `${event.id}\\u0000${delivery.handler}`;\n      if (!seenDeliveries.has(identity)) {\n        seenDeliveries.add(identity);\n        deliveries.push({\n          id: delivery.id,\n          event_id: event.id,\n          handler: delivery.handler,\n          available_at: delivery.availableAt.toISOString(),\n        });\n      }\n    }\n  }\n  return { events, deliveries, outcomes };\n}\n\nfunction toEventRow(\n  event: EventEnvelope,\n  sequence: string | null,\n  handlers: readonly string[],\n): EventRow {\n  return {\n    id: event.id,\n    type: event.type,\n    source: event.source,\n    key: event.key,\n    sequence,\n    payload: event.payload,\n    headers: event.headers,\n    correlation_id: event.correlationId,\n    causation_id: event.causationId,\n    occurred_at: event.occurredAt.toISOString(),\n    handlers,\n  };\n}\n\nfunction compareSequence(left: PostgresRow, right: PostgresRow): number {\n  const first = BigInt((left['sequence'] as string | null) ?? 0);\n  const second = BigInt((right['sequence'] as string | null) ?? 0);\n  return Number(first > second) - Number(first < second);\n}\n\nfunction compareDue(left: PostgresRow, right: PostgresRow): number {\n  return (\n    compareText(left['due_at'] as string, right['due_at'] as string) ||\n    compareText(left['delivery_id'] as string, right['delivery_id'] as string)\n  );\n}\n\nfunction compareText(left: string, right: string): number {\n  return Number(left > right) - Number(left < right);\n}\n"]}