bunqueue 2.8.60 → 2.9.2

package/dist/infrastructure/persistence/postgres/eventJournal.d.ts

@@ -0,0 +1,18 @@
+import type { PostgresContext } from './context';
+import type { PostgresStoreEvent } from './types';
+export interface PostgresEventJournalCursor {
+    readonly commitSeq: number;
+    readonly eventId: number;
+}
+export interface PostgresJournalEvent {
+    readonly commitSeq: number;
+    readonly event: PostgresStoreEvent;
+}
+export declare function latestPostgresEventJournalBaseline(ctx: PostgresContext): Promise<{
+    commitSeq: number;
+    latestEventId: number;
+}>;
+/** Load events in commit order, independent of physical BIGSERIAL allocation. */
+export declare function loadPostgresJournalEventsAfter(ctx: PostgresContext, cursor: PostgresEventJournalCursor, limit?: number): Promise<PostgresJournalEvent[]>;
+/** Remove commit envelopes after every referenced event and watermark is gone. */
+export declare function prunePostgresEventCommits(ctx: PostgresContext, limit?: number, maxBatches?: number): Promise<number>;

package/dist/infrastructure/persistence/postgres/eventJournal.js

@@ -0,0 +1,76 @@
+import { decodePostgresEvent, numeric } from './codec';
+export async function latestPostgresEventJournalBaseline(ctx) {
+    const [row] = await ctx.sql `
+    SELECT
+      (
+        SELECT MAX(commit_seq) FROM bunqueue_event_commits
+        WHERE namespace = ${ctx.config.namespace} AND commit_seq IS NOT NULL
+      ) AS commit_seq,
+      (
+        SELECT MAX(id) FROM bunqueue_events
+        WHERE namespace = ${ctx.config.namespace}
+      ) AS latest_event_id
+  `;
+    return {
+        commitSeq: numeric(row.commit_seq) ?? 0,
+        latestEventId: numeric(row.latest_event_id) ?? 0,
+    };
+}
+/** Load events in commit order, independent of physical BIGSERIAL allocation. */
+export async function loadPostgresJournalEventsAfter(ctx, cursor, limit = 1000) {
+    const rows = await ctx.sql `
+    SELECT event.id, event.queue, event.event_type, event.job_id,
+           event.occurred_at, event.payload, journal.commit_seq
+    FROM bunqueue_event_commits AS journal
+    JOIN bunqueue_events AS event
+      ON event.namespace = journal.namespace
+     AND event.transaction_id = journal.transaction_id
+    WHERE journal.namespace = ${ctx.config.namespace}
+      AND journal.commit_seq IS NOT NULL
+      AND (journal.commit_seq, event.id) > (${cursor.commitSeq}, ${cursor.eventId})
+    ORDER BY journal.commit_seq, event.id
+    LIMIT ${Math.max(1, limit)}
+  `;
+    return rows.map((row) => ({
+        commitSeq: numeric(row.commit_seq) ?? 0,
+        event: decodePostgresEvent(row),
+    }));
+}
+/** Remove commit envelopes after every referenced event and watermark is gone. */
+export async function prunePostgresEventCommits(ctx, limit = 10_000, maxBatches = 8) {
+    const batchSize = Math.max(1, limit);
+    const batchLimit = Math.max(1, maxBatches);
+    let total = 0;
+    for (let batch = 0; batch < batchLimit; batch++) {
+        const deleted = await ctx.sql `
+    WITH candidates AS MATERIALIZED (
+      SELECT journal.namespace, journal.transaction_id
+      FROM bunqueue_event_commits AS journal
+      WHERE journal.namespace = ${ctx.config.namespace}
+        AND journal.commit_seq IS NOT NULL
+        AND NOT EXISTS (
+          SELECT 1 FROM bunqueue_events AS event
+          WHERE event.namespace = journal.namespace
+            AND event.transaction_id = journal.transaction_id
+        )
+        AND NOT EXISTS (
+          SELECT 1 FROM bunqueue_event_prune_watermarks AS watermark
+          WHERE watermark.namespace = journal.namespace
+            AND watermark.transaction_id = journal.transaction_id
+        )
+      ORDER BY journal.commit_seq
+      LIMIT ${batchSize}
+      FOR UPDATE SKIP LOCKED
+    )
+    DELETE FROM bunqueue_event_commits AS journal
+    USING candidates
+    WHERE journal.namespace = candidates.namespace
+      AND journal.transaction_id = candidates.transaction_id
+    RETURNING journal.transaction_id
+  `;
+        total += deleted.length;
+        if (deleted.length < batchSize)
+            break;
+    }
+    return total;
+}

package/dist/infrastructure/persistence/postgres/eventJournalSchema.d.ts

@@ -0,0 +1,5 @@
+export declare const POSTGRES_REGISTER_EVENT_ROWS_BODY = "BEGIN\n  INSERT INTO bunqueue_event_commits (namespace, transaction_id)\n  SELECT DISTINCT namespace, transaction_id FROM new_event_rows\n  ORDER BY namespace, transaction_id\n  ON CONFLICT DO NOTHING;\n  RETURN NULL;\nEND;";
+export declare const POSTGRES_REGISTER_WATERMARK_ROWS_BODY = "BEGIN\n  INSERT INTO bunqueue_event_commits (namespace, transaction_id)\n  SELECT DISTINCT namespace, transaction_id FROM new_watermark_rows\n  ORDER BY namespace, transaction_id\n  ON CONFLICT DO NOTHING;\n  RETURN NULL;\nEND;";
+export declare const POSTGRES_ASSIGN_EVENT_COMMIT_BODY = "DECLARE\n  assigned_commit_seq BIGINT;\nBEGIN\n  PERFORM pg_advisory_xact_lock(hashtextextended(\n    'bunqueue:event-commit:' || length(NEW.namespace)::text || ':' || NEW.namespace,\n    0\n  ));\n  assigned_commit_seq := nextval('bunqueue_event_commit_seq');\n\n  UPDATE bunqueue_event_commits\n  SET commit_seq = assigned_commit_seq\n  WHERE namespace = NEW.namespace\n    AND transaction_id = NEW.transaction_id\n    AND commit_seq IS NULL;\n  UPDATE bunqueue_event_prune_watermarks\n  SET commit_seq = assigned_commit_seq,\n      pruned_commit_seq = CASE\n        WHEN prunes_current_transaction THEN GREATEST(\n          COALESCE(pruned_commit_seq, 0), assigned_commit_seq\n        )\n        ELSE pruned_commit_seq\n      END,\n      self_pruned_commit_seq = CASE\n        WHEN prunes_current_transaction THEN GREATEST(\n          COALESCE(self_pruned_commit_seq, 0), assigned_commit_seq\n        )\n        ELSE self_pruned_commit_seq\n      END,\n      prunes_current_transaction = FALSE\n  WHERE namespace = NEW.namespace\n    AND transaction_id = NEW.transaction_id\n    AND commit_seq IS NULL;\n  RETURN NULL;\nEND;";
+/** Commit-time journal sequencer installed by the PostgreSQL schema migration. */
+export declare const POSTGRES_EVENT_JOURNAL_SCHEMA = "\nCREATE SEQUENCE IF NOT EXISTS bunqueue_event_commit_seq AS BIGINT CACHE 1;\nALTER SEQUENCE bunqueue_event_commit_seq\n  AS BIGINT INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE CACHE 1;\n\nCREATE TABLE IF NOT EXISTS bunqueue_event_commits (\n  namespace TEXT NOT NULL,\n  transaction_id BIGINT NOT NULL,\n  commit_seq BIGINT,\n  PRIMARY KEY (namespace, transaction_id)\n);\n\nALTER TABLE bunqueue_event_commits\n  ADD COLUMN IF NOT EXISTS namespace TEXT;\nALTER TABLE bunqueue_event_commits\n  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;\nALTER TABLE bunqueue_event_commits\n  ADD COLUMN IF NOT EXISTS commit_seq BIGINT;\nALTER TABLE bunqueue_event_commits\n  ALTER COLUMN namespace TYPE TEXT USING namespace::text,\n  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint,\n  ALTER COLUMN commit_seq TYPE BIGINT USING commit_seq::bigint;\n\nALTER TABLE bunqueue_events\n  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id DROP DEFAULT;\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint;\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id SET DEFAULT (pg_current_xact_id()::text::bigint);\n\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS commit_seq BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS pruned_commit_seq BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS self_pruned_commit_seq BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS prunes_current_transaction BOOLEAN NOT NULL DEFAULT FALSE;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id DROP DEFAULT,\n  ALTER COLUMN pruned_commit_seq DROP DEFAULT,\n  ALTER COLUMN self_pruned_commit_seq DROP DEFAULT,\n  ALTER COLUMN prunes_current_transaction DROP DEFAULT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint,\n  ALTER COLUMN commit_seq TYPE BIGINT USING commit_seq::bigint,\n  ALTER COLUMN pruned_commit_seq TYPE BIGINT USING pruned_commit_seq::bigint,\n  ALTER COLUMN self_pruned_commit_seq TYPE BIGINT USING self_pruned_commit_seq::bigint,\n  ALTER COLUMN prunes_current_transaction TYPE BOOLEAN\n    USING prunes_current_transaction::boolean;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id SET DEFAULT (pg_current_xact_id()::text::bigint);\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN pruned_commit_seq SET DEFAULT 0,\n  ALTER COLUMN self_pruned_commit_seq SET DEFAULT 0,\n  ALTER COLUMN prunes_current_transaction SET DEFAULT FALSE;\n\nUPDATE bunqueue_events\nSET transaction_id = -id\nWHERE transaction_id IS NULL;\nUPDATE bunqueue_event_prune_watermarks\nSET transaction_id = COALESCE(transaction_id, -source_event_id),\n    commit_seq = COALESCE(commit_seq, source_event_id),\n    pruned_commit_seq = COALESCE(pruned_commit_seq, commit_seq, source_event_id),\n    self_pruned_commit_seq = COALESCE(self_pruned_commit_seq, 0)\nWHERE transaction_id IS NULL OR commit_seq IS NULL OR pruned_commit_seq IS NULL\n   OR self_pruned_commit_seq IS NULL;\n\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id SET NOT NULL;\nALTER TABLE bunqueue_event_commits\n  ALTER COLUMN namespace SET NOT NULL,\n  ALTER COLUMN transaction_id SET NOT NULL;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id SET NOT NULL,\n  ALTER COLUMN pruned_commit_seq SET NOT NULL,\n  ALTER COLUMN self_pruned_commit_seq SET NOT NULL,\n  ALTER COLUMN prunes_current_transaction SET NOT NULL;\n\nDO $migration$\nBEGIN\n  IF EXISTS (\n    SELECT 1 FROM pg_attribute\n    WHERE attrelid = to_regclass('bunqueue_events')\n      AND attname = 'commit_seq' AND NOT attisdropped\n  ) THEN\n    EXECUTE $sql$\n      INSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)\n      SELECT namespace, transaction_id, MAX(commit_seq)\n      FROM bunqueue_events\n      WHERE commit_seq IS NOT NULL\n      GROUP BY namespace, transaction_id\n      ON CONFLICT (namespace, transaction_id) DO UPDATE SET\n        commit_seq = GREATEST(\n          COALESCE(bunqueue_event_commits.commit_seq, 0),\n          excluded.commit_seq\n        )\n    $sql$;\n  ELSE\n    INSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)\n    SELECT namespace, transaction_id, MAX(id)\n    FROM bunqueue_events\n    GROUP BY namespace, transaction_id\n    ON CONFLICT (namespace, transaction_id) DO NOTHING;\n  END IF;\nEND;\n$migration$;\n\nINSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)\nSELECT namespace, transaction_id, MAX(commit_seq)\nFROM bunqueue_event_prune_watermarks\nWHERE commit_seq IS NOT NULL\nGROUP BY namespace, transaction_id\nON CONFLICT (namespace, transaction_id) DO UPDATE SET\n  commit_seq = GREATEST(\n    COALESCE(bunqueue_event_commits.commit_seq, 0),\n    excluded.commit_seq\n  );\n\nDO $block$\nDECLARE\n  journal_floor BIGINT := 0;\n  legacy_head_floor BIGINT := 0;\n  sequence_floor BIGINT := 0;\nBEGIN\n  SELECT COALESCE(MAX(commit_seq), 0) INTO journal_floor\n  FROM bunqueue_event_commits;\n  SELECT last_value INTO sequence_floor FROM bunqueue_event_commit_seq;\n  IF to_regclass('bunqueue_event_commit_heads') IS NOT NULL THEN\n    EXECUTE 'SELECT COALESCE(MAX(commit_seq), 0) FROM bunqueue_event_commit_heads'\n      INTO legacy_head_floor;\n  END IF;\n  PERFORM setval(\n    'bunqueue_event_commit_seq',\n    GREATEST(journal_floor, legacy_head_floor, sequence_floor, 1),\n    TRUE\n  );\nEND;\n$block$;\n\nDROP TABLE IF EXISTS bunqueue_event_commit_heads;\n\nDROP TRIGGER IF EXISTS bunqueue_events_register_commit ON bunqueue_events;\nDROP TRIGGER IF EXISTS bunqueue_watermarks_insert_register_commit\n  ON bunqueue_event_prune_watermarks;\nDROP TRIGGER IF EXISTS bunqueue_watermarks_update_register_commit\n  ON bunqueue_event_prune_watermarks;\nDROP TABLE IF EXISTS bunqueue_event_commit_assignments CASCADE;\nDROP INDEX IF EXISTS bunqueue_events_commit_idx;\nDROP INDEX IF EXISTS bunqueue_events_pending_commit_idx;\nALTER TABLE bunqueue_events DROP COLUMN IF EXISTS commit_seq;\n\nDROP INDEX IF EXISTS bunqueue_events_transaction_idx;\nDROP INDEX IF EXISTS bunqueue_event_commits_replay_idx;\nDROP INDEX IF EXISTS bunqueue_event_prune_watermarks_commit_idx;\nDROP INDEX IF EXISTS bunqueue_event_prune_watermarks_pending_commit_idx;\nDROP INDEX IF EXISTS bunqueue_event_prune_watermarks_transaction_idx;\n\nCREATE INDEX bunqueue_events_transaction_idx\n  ON bunqueue_events(namespace, transaction_id, id);\nCREATE INDEX bunqueue_event_commits_replay_idx\n  ON bunqueue_event_commits(namespace, commit_seq, transaction_id)\n  WHERE commit_seq IS NOT NULL;\nCREATE INDEX bunqueue_event_prune_watermarks_commit_idx\n  ON bunqueue_event_prune_watermarks(namespace, queue, commit_seq DESC)\n  WHERE commit_seq IS NOT NULL;\nCREATE INDEX bunqueue_event_prune_watermarks_pending_commit_idx\n  ON bunqueue_event_prune_watermarks(namespace, transaction_id)\n  WHERE commit_seq IS NULL;\nCREATE INDEX bunqueue_event_prune_watermarks_transaction_idx\n  ON bunqueue_event_prune_watermarks(namespace, transaction_id);\n\nCREATE OR REPLACE FUNCTION bunqueue_register_event_rows()\nRETURNS TRIGGER LANGUAGE plpgsql AS $function$\nBEGIN\n  INSERT INTO bunqueue_event_commits (namespace, transaction_id)\n  SELECT DISTINCT namespace, transaction_id FROM new_event_rows\n  ORDER BY namespace, transaction_id\n  ON CONFLICT DO NOTHING;\n  RETURN NULL;\nEND;\n$function$;\n\nCREATE OR REPLACE FUNCTION bunqueue_register_watermark_rows()\nRETURNS TRIGGER LANGUAGE plpgsql AS $function$\nBEGIN\n  INSERT INTO bunqueue_event_commits (namespace, transaction_id)\n  SELECT DISTINCT namespace, transaction_id FROM new_watermark_rows\n  ORDER BY namespace, transaction_id\n  ON CONFLICT DO NOTHING;\n  RETURN NULL;\nEND;\n$function$;\n\nCREATE OR REPLACE FUNCTION bunqueue_assign_event_commit()\nRETURNS TRIGGER LANGUAGE plpgsql AS $function$\nDECLARE\n  assigned_commit_seq BIGINT;\nBEGIN\n  PERFORM pg_advisory_xact_lock(hashtextextended(\n    'bunqueue:event-commit:' || length(NEW.namespace)::text || ':' || NEW.namespace,\n    0\n  ));\n  assigned_commit_seq := nextval('bunqueue_event_commit_seq');\n\n  UPDATE bunqueue_event_commits\n  SET commit_seq = assigned_commit_seq\n  WHERE namespace = NEW.namespace\n    AND transaction_id = NEW.transaction_id\n    AND commit_seq IS NULL;\n  UPDATE bunqueue_event_prune_watermarks\n  SET commit_seq = assigned_commit_seq,\n      pruned_commit_seq = CASE\n        WHEN prunes_current_transaction THEN GREATEST(\n          COALESCE(pruned_commit_seq, 0), assigned_commit_seq\n        )\n        ELSE pruned_commit_seq\n      END,\n      self_pruned_commit_seq = CASE\n        WHEN prunes_current_transaction THEN GREATEST(\n          COALESCE(self_pruned_commit_seq, 0), assigned_commit_seq\n        )\n        ELSE self_pruned_commit_seq\n      END,\n      prunes_current_transaction = FALSE\n  WHERE namespace = NEW.namespace\n    AND transaction_id = NEW.transaction_id\n    AND commit_seq IS NULL;\n  RETURN NULL;\nEND;\n$function$;\n\nDROP TRIGGER IF EXISTS bunqueue_events_register_commit ON bunqueue_events;\nCREATE TRIGGER bunqueue_events_register_commit\nAFTER INSERT ON bunqueue_events\nREFERENCING NEW TABLE AS new_event_rows\nFOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_event_rows();\n\nDROP TRIGGER IF EXISTS bunqueue_watermarks_insert_register_commit\n  ON bunqueue_event_prune_watermarks;\nCREATE TRIGGER bunqueue_watermarks_insert_register_commit\nAFTER INSERT ON bunqueue_event_prune_watermarks\nREFERENCING NEW TABLE AS new_watermark_rows\nFOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_watermark_rows();\n\nDROP TRIGGER IF EXISTS bunqueue_watermarks_update_register_commit\n  ON bunqueue_event_prune_watermarks;\nCREATE TRIGGER bunqueue_watermarks_update_register_commit\nAFTER UPDATE ON bunqueue_event_prune_watermarks\nREFERENCING NEW TABLE AS new_watermark_rows\nFOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_watermark_rows();\n\nDROP TRIGGER IF EXISTS bunqueue_assign_event_commit\n  ON bunqueue_event_commits;\nCREATE CONSTRAINT TRIGGER bunqueue_assign_event_commit\nAFTER INSERT ON bunqueue_event_commits\nDEFERRABLE INITIALLY DEFERRED\nFOR EACH ROW EXECUTE FUNCTION bunqueue_assign_event_commit();\n";

package/dist/infrastructure/persistence/postgres/eventJournalSchema.js

@@ -0,0 +1,267 @@
+export const POSTGRES_REGISTER_EVENT_ROWS_BODY = `BEGIN
+  INSERT INTO bunqueue_event_commits (namespace, transaction_id)
+  SELECT DISTINCT namespace, transaction_id FROM new_event_rows
+  ORDER BY namespace, transaction_id
+  ON CONFLICT DO NOTHING;
+  RETURN NULL;
+END;`;
+export const POSTGRES_REGISTER_WATERMARK_ROWS_BODY = `BEGIN
+  INSERT INTO bunqueue_event_commits (namespace, transaction_id)
+  SELECT DISTINCT namespace, transaction_id FROM new_watermark_rows
+  ORDER BY namespace, transaction_id
+  ON CONFLICT DO NOTHING;
+  RETURN NULL;
+END;`;
+export const POSTGRES_ASSIGN_EVENT_COMMIT_BODY = `DECLARE
+  assigned_commit_seq BIGINT;
+BEGIN
+  PERFORM pg_advisory_xact_lock(hashtextextended(
+    'bunqueue:event-commit:' || length(NEW.namespace)::text || ':' || NEW.namespace,
+    0
+  ));
+  assigned_commit_seq := nextval('bunqueue_event_commit_seq');
+
+  UPDATE bunqueue_event_commits
+  SET commit_seq = assigned_commit_seq
+  WHERE namespace = NEW.namespace
+    AND transaction_id = NEW.transaction_id
+    AND commit_seq IS NULL;
+  UPDATE bunqueue_event_prune_watermarks
+  SET commit_seq = assigned_commit_seq,
+      pruned_commit_seq = CASE
+        WHEN prunes_current_transaction THEN GREATEST(
+          COALESCE(pruned_commit_seq, 0), assigned_commit_seq
+        )
+        ELSE pruned_commit_seq
+      END,
+      self_pruned_commit_seq = CASE
+        WHEN prunes_current_transaction THEN GREATEST(
+          COALESCE(self_pruned_commit_seq, 0), assigned_commit_seq
+        )
+        ELSE self_pruned_commit_seq
+      END,
+      prunes_current_transaction = FALSE
+  WHERE namespace = NEW.namespace
+    AND transaction_id = NEW.transaction_id
+    AND commit_seq IS NULL;
+  RETURN NULL;
+END;`;
+/** Commit-time journal sequencer installed by the PostgreSQL schema migration. */
+export const POSTGRES_EVENT_JOURNAL_SCHEMA = `
+CREATE SEQUENCE IF NOT EXISTS bunqueue_event_commit_seq AS BIGINT CACHE 1;
+ALTER SEQUENCE bunqueue_event_commit_seq
+  AS BIGINT INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE CACHE 1;
+
+CREATE TABLE IF NOT EXISTS bunqueue_event_commits (
+  namespace TEXT NOT NULL,
+  transaction_id BIGINT NOT NULL,
+  commit_seq BIGINT,
+  PRIMARY KEY (namespace, transaction_id)
+);
+
+ALTER TABLE bunqueue_event_commits
+  ADD COLUMN IF NOT EXISTS namespace TEXT;
+ALTER TABLE bunqueue_event_commits
+  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;
+ALTER TABLE bunqueue_event_commits
+  ADD COLUMN IF NOT EXISTS commit_seq BIGINT;
+ALTER TABLE bunqueue_event_commits
+  ALTER COLUMN namespace TYPE TEXT USING namespace::text,
+  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint,
+  ALTER COLUMN commit_seq TYPE BIGINT USING commit_seq::bigint;
+
+ALTER TABLE bunqueue_events
+  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;
+ALTER TABLE bunqueue_events
+  ALTER COLUMN transaction_id DROP DEFAULT;
+ALTER TABLE bunqueue_events
+  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint;
+ALTER TABLE bunqueue_events
+  ALTER COLUMN transaction_id SET DEFAULT (pg_current_xact_id()::text::bigint);
+
+ALTER TABLE bunqueue_event_prune_watermarks
+  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;
+ALTER TABLE bunqueue_event_prune_watermarks
+  ADD COLUMN IF NOT EXISTS commit_seq BIGINT;
+ALTER TABLE bunqueue_event_prune_watermarks
+  ADD COLUMN IF NOT EXISTS pruned_commit_seq BIGINT;
+ALTER TABLE bunqueue_event_prune_watermarks
+  ADD COLUMN IF NOT EXISTS self_pruned_commit_seq BIGINT;
+ALTER TABLE bunqueue_event_prune_watermarks
+  ADD COLUMN IF NOT EXISTS prunes_current_transaction BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE bunqueue_event_prune_watermarks
+  ALTER COLUMN transaction_id DROP DEFAULT,
+  ALTER COLUMN pruned_commit_seq DROP DEFAULT,
+  ALTER COLUMN self_pruned_commit_seq DROP DEFAULT,
+  ALTER COLUMN prunes_current_transaction DROP DEFAULT;
+ALTER TABLE bunqueue_event_prune_watermarks
+  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint,
+  ALTER COLUMN commit_seq TYPE BIGINT USING commit_seq::bigint,
+  ALTER COLUMN pruned_commit_seq TYPE BIGINT USING pruned_commit_seq::bigint,
+  ALTER COLUMN self_pruned_commit_seq TYPE BIGINT USING self_pruned_commit_seq::bigint,
+  ALTER COLUMN prunes_current_transaction TYPE BOOLEAN
+    USING prunes_current_transaction::boolean;
+ALTER TABLE bunqueue_event_prune_watermarks
+  ALTER COLUMN transaction_id SET DEFAULT (pg_current_xact_id()::text::bigint);
+ALTER TABLE bunqueue_event_prune_watermarks
+  ALTER COLUMN pruned_commit_seq SET DEFAULT 0,
+  ALTER COLUMN self_pruned_commit_seq SET DEFAULT 0,
+  ALTER COLUMN prunes_current_transaction SET DEFAULT FALSE;
+
+UPDATE bunqueue_events
+SET transaction_id = -id
+WHERE transaction_id IS NULL;
+UPDATE bunqueue_event_prune_watermarks
+SET transaction_id = COALESCE(transaction_id, -source_event_id),
+    commit_seq = COALESCE(commit_seq, source_event_id),
+    pruned_commit_seq = COALESCE(pruned_commit_seq, commit_seq, source_event_id),
+    self_pruned_commit_seq = COALESCE(self_pruned_commit_seq, 0)
+WHERE transaction_id IS NULL OR commit_seq IS NULL OR pruned_commit_seq IS NULL
+   OR self_pruned_commit_seq IS NULL;
+
+ALTER TABLE bunqueue_events
+  ALTER COLUMN transaction_id SET NOT NULL;
+ALTER TABLE bunqueue_event_commits
+  ALTER COLUMN namespace SET NOT NULL,
+  ALTER COLUMN transaction_id SET NOT NULL;
+ALTER TABLE bunqueue_event_prune_watermarks
+  ALTER COLUMN transaction_id SET NOT NULL,
+  ALTER COLUMN pruned_commit_seq SET NOT NULL,
+  ALTER COLUMN self_pruned_commit_seq SET NOT NULL,
+  ALTER COLUMN prunes_current_transaction SET NOT NULL;
+
+DO $migration$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_attribute
+    WHERE attrelid = to_regclass('bunqueue_events')
+      AND attname = 'commit_seq' AND NOT attisdropped
+  ) THEN
+    EXECUTE $sql$
+      INSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)
+      SELECT namespace, transaction_id, MAX(commit_seq)
+      FROM bunqueue_events
+      WHERE commit_seq IS NOT NULL
+      GROUP BY namespace, transaction_id
+      ON CONFLICT (namespace, transaction_id) DO UPDATE SET
+        commit_seq = GREATEST(
+          COALESCE(bunqueue_event_commits.commit_seq, 0),
+          excluded.commit_seq
+        )
+    $sql$;
+  ELSE
+    INSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)
+    SELECT namespace, transaction_id, MAX(id)
+    FROM bunqueue_events
+    GROUP BY namespace, transaction_id
+    ON CONFLICT (namespace, transaction_id) DO NOTHING;
+  END IF;
+END;
+$migration$;
+
+INSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)
+SELECT namespace, transaction_id, MAX(commit_seq)
+FROM bunqueue_event_prune_watermarks
+WHERE commit_seq IS NOT NULL
+GROUP BY namespace, transaction_id
+ON CONFLICT (namespace, transaction_id) DO UPDATE SET
+  commit_seq = GREATEST(
+    COALESCE(bunqueue_event_commits.commit_seq, 0),
+    excluded.commit_seq
+  );
+
+DO $block$
+DECLARE
+  journal_floor BIGINT := 0;
+  legacy_head_floor BIGINT := 0;
+  sequence_floor BIGINT := 0;
+BEGIN
+  SELECT COALESCE(MAX(commit_seq), 0) INTO journal_floor
+  FROM bunqueue_event_commits;
+  SELECT last_value INTO sequence_floor FROM bunqueue_event_commit_seq;
+  IF to_regclass('bunqueue_event_commit_heads') IS NOT NULL THEN
+    EXECUTE 'SELECT COALESCE(MAX(commit_seq), 0) FROM bunqueue_event_commit_heads'
+      INTO legacy_head_floor;
+  END IF;
+  PERFORM setval(
+    'bunqueue_event_commit_seq',
+    GREATEST(journal_floor, legacy_head_floor, sequence_floor, 1),
+    TRUE
+  );
+END;
+$block$;
+
+DROP TABLE IF EXISTS bunqueue_event_commit_heads;
+
+DROP TRIGGER IF EXISTS bunqueue_events_register_commit ON bunqueue_events;
+DROP TRIGGER IF EXISTS bunqueue_watermarks_insert_register_commit
+  ON bunqueue_event_prune_watermarks;
+DROP TRIGGER IF EXISTS bunqueue_watermarks_update_register_commit
+  ON bunqueue_event_prune_watermarks;
+DROP TABLE IF EXISTS bunqueue_event_commit_assignments CASCADE;
+DROP INDEX IF EXISTS bunqueue_events_commit_idx;
+DROP INDEX IF EXISTS bunqueue_events_pending_commit_idx;
+ALTER TABLE bunqueue_events DROP COLUMN IF EXISTS commit_seq;
+
+DROP INDEX IF EXISTS bunqueue_events_transaction_idx;
+DROP INDEX IF EXISTS bunqueue_event_commits_replay_idx;
+DROP INDEX IF EXISTS bunqueue_event_prune_watermarks_commit_idx;
+DROP INDEX IF EXISTS bunqueue_event_prune_watermarks_pending_commit_idx;
+DROP INDEX IF EXISTS bunqueue_event_prune_watermarks_transaction_idx;
+
+CREATE INDEX bunqueue_events_transaction_idx
+  ON bunqueue_events(namespace, transaction_id, id);
+CREATE INDEX bunqueue_event_commits_replay_idx
+  ON bunqueue_event_commits(namespace, commit_seq, transaction_id)
+  WHERE commit_seq IS NOT NULL;
+CREATE INDEX bunqueue_event_prune_watermarks_commit_idx
+  ON bunqueue_event_prune_watermarks(namespace, queue, commit_seq DESC)
+  WHERE commit_seq IS NOT NULL;
+CREATE INDEX bunqueue_event_prune_watermarks_pending_commit_idx
+  ON bunqueue_event_prune_watermarks(namespace, transaction_id)
+  WHERE commit_seq IS NULL;
+CREATE INDEX bunqueue_event_prune_watermarks_transaction_idx
+  ON bunqueue_event_prune_watermarks(namespace, transaction_id);
+
+CREATE OR REPLACE FUNCTION bunqueue_register_event_rows()
+RETURNS TRIGGER LANGUAGE plpgsql AS $function$
+${POSTGRES_REGISTER_EVENT_ROWS_BODY}
+$function$;
+
+CREATE OR REPLACE FUNCTION bunqueue_register_watermark_rows()
+RETURNS TRIGGER LANGUAGE plpgsql AS $function$
+${POSTGRES_REGISTER_WATERMARK_ROWS_BODY}
+$function$;
+
+CREATE OR REPLACE FUNCTION bunqueue_assign_event_commit()
+RETURNS TRIGGER LANGUAGE plpgsql AS $function$
+${POSTGRES_ASSIGN_EVENT_COMMIT_BODY}
+$function$;
+
+DROP TRIGGER IF EXISTS bunqueue_events_register_commit ON bunqueue_events;
+CREATE TRIGGER bunqueue_events_register_commit
+AFTER INSERT ON bunqueue_events
+REFERENCING NEW TABLE AS new_event_rows
+FOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_event_rows();
+
+DROP TRIGGER IF EXISTS bunqueue_watermarks_insert_register_commit
+  ON bunqueue_event_prune_watermarks;
+CREATE TRIGGER bunqueue_watermarks_insert_register_commit
+AFTER INSERT ON bunqueue_event_prune_watermarks
+REFERENCING NEW TABLE AS new_watermark_rows
+FOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_watermark_rows();
+
+DROP TRIGGER IF EXISTS bunqueue_watermarks_update_register_commit
+  ON bunqueue_event_prune_watermarks;
+CREATE TRIGGER bunqueue_watermarks_update_register_commit
+AFTER UPDATE ON bunqueue_event_prune_watermarks
+REFERENCING NEW TABLE AS new_watermark_rows
+FOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_watermark_rows();
+
+DROP TRIGGER IF EXISTS bunqueue_assign_event_commit
+  ON bunqueue_event_commits;
+CREATE CONSTRAINT TRIGGER bunqueue_assign_event_commit
+AFTER INSERT ON bunqueue_event_commits
+DEFERRABLE INITIALLY DEFERRED
+FOR EACH ROW EXECUTE FUNCTION bunqueue_assign_event_commit();
+`;

package/dist/infrastructure/persistence/postgres/eventPruneWatermarks.d.ts

@@ -0,0 +1,26 @@
+import type { TransactionSQL } from 'bun';
+import type { PostgresContext } from './context';
+export interface PostgresEventPruneWatermarkInput {
+    readonly queue: string;
+    readonly sourceEventId: number;
+    readonly prunedThrough: number;
+    readonly prunedCommitSeq?: number;
+    readonly prunesCurrentTransaction?: boolean;
+}
+export interface PostgresEventPruneWatermark extends PostgresEventPruneWatermarkInput {
+    readonly commitSeq: number;
+    readonly prunedCommitSeq: number;
+    /** Newest commit that pruned part of its own queue events, 0 when none did. */
+    readonly selfPrunedCommitSeq: number;
+}
+export declare function maxPostgresEventId(rows: readonly {
+    id: number | string | bigint;
+}[]): number;
+export declare function summarizePostgresPrunedEvents(rows: readonly {
+    id: number | string | bigint;
+    commit_seq: number | string | bigint | null;
+}[]): Pick<PostgresEventPruneWatermarkInput, 'prunedThrough' | 'prunedCommitSeq' | 'prunesCurrentTransaction'>;
+/** Record durable evidence that queue event history was pruned in this transaction. */
+export declare function recordPostgresEventPruneWatermarks(tx: TransactionSQL, ctx: PostgresContext, inputs: readonly PostgresEventPruneWatermarkInput[]): Promise<void>;
+export declare function loadPostgresEventPruneWatermarks(ctx: PostgresContext): Promise<PostgresEventPruneWatermark[]>;
+export declare function deletePostgresEventPruneWatermark(tx: TransactionSQL, ctx: PostgresContext, queue: string): Promise<void>;

package/dist/infrastructure/persistence/postgres/eventPruneWatermarks.js

@@ -0,0 +1,129 @@
+import { numeric } from './codec';
+export function maxPostgresEventId(rows) {
+    return rows.reduce((latest, row) => Math.max(latest, numeric(row.id) ?? 0), 0);
+}
+export function summarizePostgresPrunedEvents(rows) {
+    return {
+        prunedThrough: maxPostgresEventId(rows),
+        prunedCommitSeq: rows.reduce((latest, row) => Math.max(latest, numeric(row.commit_seq) ?? 0), 0),
+        prunesCurrentTransaction: rows.some((row) => row.commit_seq === null),
+    };
+}
+function normalize(watermarks) {
+    const byQueue = new Map();
+    for (const watermark of watermarks) {
+        const current = byQueue.get(watermark.queue);
+        byQueue.set(watermark.queue, current
+            ? {
+                queue: watermark.queue,
+                sourceEventId: Math.max(current.sourceEventId, watermark.sourceEventId),
+                prunedThrough: Math.max(current.prunedThrough, watermark.prunedThrough),
+                prunedCommitSeq: Math.max(current.prunedCommitSeq ?? 0, watermark.prunedCommitSeq ?? 0),
+                prunesCurrentTransaction: current.prunesCurrentTransaction === true ||
+                    watermark.prunesCurrentTransaction === true,
+            }
+            : watermark);
+    }
+    return [...byQueue.values()].sort((left, right) => left.queue.localeCompare(right.queue));
+}
+/** Record durable evidence that queue event history was pruned in this transaction. */
+export async function recordPostgresEventPruneWatermarks(tx, ctx, inputs) {
+    const watermarks = normalize(inputs).filter(({ sourceEventId, prunedThrough }) => sourceEventId > 0 && prunedThrough > 0);
+    if (watermarks.length === 0)
+        return;
+    await tx `
+    WITH incoming AS (
+      SELECT batch.queue, batch.source_event_id, batch.pruned_through,
+             batch.pruned_commit_seq, batch.prunes_current_transaction
+      FROM unnest(
+        ${tx.array(watermarks.map(({ queue }) => queue), 'TEXT')},
+        ${tx.array(watermarks.map(({ sourceEventId }) => sourceEventId), 'BIGINT')},
+        ${tx.array(watermarks.map(({ prunedThrough }) => prunedThrough), 'BIGINT')},
+        ${tx.array(watermarks.map(({ prunedCommitSeq }) => prunedCommitSeq ?? 0), 'BIGINT')},
+        ${tx.array(watermarks.map(({ prunesCurrentTransaction }) => prunesCurrentTransaction ?? false), 'BOOLEAN')}
+      ) AS batch(
+        queue, source_event_id, pruned_through, pruned_commit_seq,
+        prunes_current_transaction
+      )
+    ), inserted AS (
+      INSERT INTO bunqueue_event_prune_watermarks
+        (namespace, queue, source_event_id, pruned_through, pruned_commit_seq,
+         self_pruned_commit_seq, prunes_current_transaction)
+      SELECT ${ctx.config.namespace}, queue, source_event_id, pruned_through,
+             GREATEST(
+               pruned_commit_seq,
+               COALESCE((
+                 SELECT MAX(existing.pruned_commit_seq)
+                 FROM bunqueue_event_prune_watermarks AS existing
+                 WHERE existing.namespace = ${ctx.config.namespace}
+                   AND existing.queue = incoming.queue
+               ), 0)
+             ),
+             COALESCE((
+               SELECT MAX(existing.self_pruned_commit_seq)
+               FROM bunqueue_event_prune_watermarks AS existing
+               WHERE existing.namespace = ${ctx.config.namespace}
+                 AND existing.queue = incoming.queue
+             ), 0),
+             prunes_current_transaction OR COALESCE((
+               SELECT bool_or(existing.prunes_current_transaction)
+               FROM bunqueue_event_prune_watermarks AS existing
+               WHERE existing.namespace = ${ctx.config.namespace}
+                 AND existing.queue = incoming.queue
+                 AND existing.commit_seq IS NULL
+             ), FALSE)
+      FROM incoming
+      ON CONFLICT (namespace, queue, source_event_id) DO UPDATE SET
+        pruned_through = GREATEST(
+          bunqueue_event_prune_watermarks.pruned_through,
+          excluded.pruned_through
+        ),
+        pruned_commit_seq = GREATEST(
+          COALESCE(bunqueue_event_prune_watermarks.pruned_commit_seq, 0),
+          COALESCE(excluded.pruned_commit_seq, 0)
+        ),
+        self_pruned_commit_seq = GREATEST(
+          COALESCE(bunqueue_event_prune_watermarks.self_pruned_commit_seq, 0),
+          COALESCE(excluded.self_pruned_commit_seq, 0)
+        ),
+        prunes_current_transaction =
+          bunqueue_event_prune_watermarks.prunes_current_transaction
+          OR excluded.prunes_current_transaction,
+        transaction_id = pg_current_xact_id()::text::bigint,
+        commit_seq = NULL
+      RETURNING namespace, queue, source_event_id, pruned_through
+    )
+    DELETE FROM bunqueue_event_prune_watermarks AS previous
+    USING inserted AS latest
+    WHERE previous.namespace = latest.namespace
+      AND previous.queue = latest.queue
+      AND previous.source_event_id <> latest.source_event_id
+      AND previous.pruned_through <= latest.pruned_through
+  `;
+}
+export async function loadPostgresEventPruneWatermarks(ctx) {
+    const rows = await ctx.sql `
+    SELECT DISTINCT ON (queue)
+           queue, source_event_id, pruned_through, commit_seq,
+           MAX(pruned_commit_seq) OVER (PARTITION BY queue) AS pruned_commit_seq,
+           MAX(self_pruned_commit_seq) OVER (PARTITION BY queue) AS self_pruned_commit_seq
+    FROM bunqueue_event_prune_watermarks
+    WHERE namespace = ${ctx.config.namespace}
+      AND commit_seq IS NOT NULL
+    ORDER BY queue, commit_seq DESC, source_event_id DESC
+  `;
+    return rows.map((row) => ({
+        queue: row.queue,
+        sourceEventId: numeric(row.source_event_id) ?? 0,
+        prunedThrough: numeric(row.pruned_through) ?? 0,
+        commitSeq: numeric(row.commit_seq) ?? 0,
+        prunedCommitSeq: numeric(row.pruned_commit_seq) ?? 0,
+        selfPrunedCommitSeq: numeric(row.self_pruned_commit_seq) ?? 0,
+    }));
+}
+export async function deletePostgresEventPruneWatermark(tx, ctx, queue) {
+    await tx `
+    DELETE FROM bunqueue_event_prune_watermarks
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+  `;
+}

package/dist/infrastructure/persistence/postgres/eventRetention.d.ts

@@ -0,0 +1,18 @@
+import type { TransactionSQL } from 'bun';
+import type { PostgresContext } from './context';
+export interface PostgresPrunedEventRow {
+    readonly id: number | string | bigint;
+    readonly commit_seq: number | string | bigint | null;
+}
+/** Serialize one autonomous queue-retention sweep without joining job lock domains. */
+export declare function lockPostgresEventRetention(tx: TransactionSQL, ctx: PostgresContext, queue: string): Promise<void>;
+/** Never wait for a late inline retention lock after job locks are already held. */
+export declare function tryLockPostgresEventRetention(tx: TransactionSQL, ctx: PostgresContext, queue: string): Promise<boolean>;
+/**
+ * Retain the newest queue events while locking overlapping prune candidates in
+ * one deterministic order. The materialized lock step prevents concurrent
+ * brokers from deleting the same physical tuples in conflicting scan orders.
+ */
+export declare function prunePostgresQueueEvents(tx: TransactionSQL, ctx: PostgresContext, queue: string, maxLength: number): Promise<PostgresPrunedEventRow[]>;
+/** Remove a queue's old outbox history in the same tuple order used by retention. */
+export declare function deletePostgresQueueEventHistory(tx: TransactionSQL, ctx: PostgresContext, queue: string): Promise<number>;

package/dist/infrastructure/persistence/postgres/eventRetention.js

@@ -0,0 +1,76 @@
+import { postgresAdvisoryLockName } from './advisoryLocks';
+/** Serialize one autonomous queue-retention sweep without joining job lock domains. */
+export async function lockPostgresEventRetention(tx, ctx, queue) {
+    const lockName = postgresAdvisoryLockName('event-retention', ctx.config.namespace, queue);
+    await tx `
+    SELECT pg_advisory_xact_lock(hashtextextended(${lockName}, 0))
+  `;
+}
+/** Never wait for a late inline retention lock after job locks are already held. */
+export async function tryLockPostgresEventRetention(tx, ctx, queue) {
+    const lockName = postgresAdvisoryLockName('event-retention', ctx.config.namespace, queue);
+    const [row] = await tx `
+    SELECT pg_try_advisory_xact_lock(hashtextextended(${lockName}, 0)) AS acquired
+  `;
+    return row.acquired;
+}
+/**
+ * Retain the newest queue events while locking overlapping prune candidates in
+ * one deterministic order. The materialized lock step prevents concurrent
+ * brokers from deleting the same physical tuples in conflicting scan orders.
+ */
+export async function prunePostgresQueueEvents(tx, ctx, queue, maxLength) {
+    return await tx `
+    WITH cutoff AS MATERIALIZED (
+      SELECT id
+      FROM bunqueue_events
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+      ORDER BY id DESC
+      OFFSET ${maxLength}
+      LIMIT 1
+    ), candidates AS MATERIALIZED (
+      SELECT event.id
+      FROM bunqueue_events AS event
+      CROSS JOIN cutoff
+      WHERE event.namespace = ${ctx.config.namespace} AND event.queue = ${queue}
+        AND event.id <= cutoff.id
+      ORDER BY event.id
+      FOR UPDATE OF event
+    ), removed AS (
+      DELETE FROM bunqueue_events AS event
+      USING candidates
+      WHERE event.id = candidates.id
+      RETURNING event.id, event.namespace, event.transaction_id
+    )
+    SELECT removed.id, journal.commit_seq
+    FROM removed
+    LEFT JOIN bunqueue_event_commits AS journal
+      ON journal.namespace = removed.namespace
+     AND journal.transaction_id = removed.transaction_id
+    ORDER BY removed.id
+  `;
+}
+/** Remove a queue's old outbox history in the same tuple order used by retention. */
+export async function deletePostgresQueueEventHistory(tx, ctx, queue) {
+    const removed = await tx `
+    WITH candidates AS MATERIALIZED (
+      SELECT event.id
+      FROM bunqueue_events AS event
+      WHERE event.namespace = ${ctx.config.namespace}
+        AND (
+          event.queue = ${queue}
+          OR (
+            event.event_type = 'queue-batch-overflow'
+            AND event.job_id = ${`__queue__:${queue}`}
+          )
+        )
+      ORDER BY event.id
+      FOR UPDATE OF event
+    )
+    DELETE FROM bunqueue_events AS event
+    USING candidates
+    WHERE event.id = candidates.id
+    RETURNING event.id
+  `;
+    return removed.length;
+}