bunqueue 2.9.0 → 2.9.2

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

@@ -1,5 +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      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;";
+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 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 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 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 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)\nWHERE transaction_id IS NULL OR commit_seq IS NULL OR 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 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      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";
+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

@@ -34,6 +34,12 @@ BEGIN
         )
         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
@@ -79,22 +85,27 @@ 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
@@ -103,8 +114,10 @@ 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)
-WHERE transaction_id IS NULL OR commit_seq IS NULL OR pruned_commit_seq IS NULL;
+    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;
@@ -114,6 +127,7 @@ ALTER TABLE bunqueue_event_commits
 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$

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

@@ -10,6 +10,8 @@ export interface PostgresEventPruneWatermarkInput {
 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;

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

@@ -48,7 +48,7 @@ export async function recordPostgresEventPruneWatermarks(tx, ctx, inputs) {
     ), inserted AS (
       INSERT INTO bunqueue_event_prune_watermarks
         (namespace, queue, source_event_id, pruned_through, pruned_commit_seq,
-         prunes_current_transaction)
+         self_pruned_commit_seq, prunes_current_transaction)
       SELECT ${ctx.config.namespace}, queue, source_event_id, pruned_through,
              GREATEST(
                pruned_commit_seq,
@@ -59,7 +59,19 @@ export async function recordPostgresEventPruneWatermarks(tx, ctx, inputs) {
                    AND existing.queue = incoming.queue
                ), 0)
              ),
-             prunes_current_transaction
+             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(
@@ -70,6 +82,10 @@ export async function recordPostgresEventPruneWatermarks(tx, ctx, inputs) {
           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,
@@ -89,7 +105,8 @@ 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(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
@@ -101,6 +118,7 @@ export async function loadPostgresEventPruneWatermarks(ctx) {
         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) {

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

@@ -13,14 +13,14 @@ export declare class PostgresEventStream {
     private readonly invalidationListeners;
     private readonly drainStatusListeners;
     private readonly waiters;
-    private readonly queueEventCursors;
+    private readonly queueCursors;
     private readonly retentionQueues;
     private journalCursor;
     private cursor;
-    private baselineCursor;
     private checkpointScanRequested;
     private drainRequested;
     private draining;
+    private retentionRetryTimer;
     private closed;
     constructor(ctx: PostgresContext);
     start(): Promise<void>;
@@ -36,9 +36,9 @@ export declare class PostgresEventStream {
     private drain;
     private drainLoop;
     private convergeEventRetention;
+    private scheduleRetentionRetry;
     private applyEvent;
     private invalidateQueue;
-    private applyPruneWatermark;
     private scanPruneWatermarks;
     private reportDrainStatus;
 }

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

@@ -1,7 +1,8 @@
 import { latestPostgresEventJournalBaseline, loadPostgresJournalEventsAfter, } from './eventJournal';
+import { PostgresEventCatchupCursors } from './eventCatchupCursors';
 import { loadPostgresEventPruneWatermarks } from './eventPruneWatermarks';
 import { POSTGRES_EVENT_CHANNEL } from './schema';
-import { trimPostgresQueueEvents } from './telemetry';
+import { tryTrimPostgresQueueEvents } from './telemetry';
 const MIN_EVENT_DRAIN_BATCH = 1_000;
 const MAX_EVENT_DRAIN_BATCH = 4_096;
 export function postgresEventDrainBatchSize(maxQueueEvents) {
@@ -19,14 +20,14 @@ export class PostgresEventStream {
     invalidationListeners = new Set();
     drainStatusListeners = new Set();
     waiters = new Map();
-    queueEventCursors = new Map();
+    queueCursors = new PostgresEventCatchupCursors();
     retentionQueues = new Set();
     journalCursor = { commitSeq: 0, eventId: 0 };
     cursor = 0;
-    baselineCursor = 0;
     checkpointScanRequested = false;
     drainRequested = false;
     draining = null;
+    retentionRetryTimer = null;
     closed = false;
     constructor(ctx) {
         this.ctx = ctx;
@@ -37,12 +38,16 @@ export class PostgresEventStream {
             loadPostgresEventPruneWatermarks(this.ctx),
         ]);
         this.cursor = baseline.latestEventId;
-        this.baselineCursor = baseline.commitSeq;
         this.journalCursor = { commitSeq: baseline.commitSeq, eventId: Number.MAX_SAFE_INTEGER };
+        this.queueCursors.reset(baseline.commitSeq);
         for (const watermark of watermarks) {
             if (watermark.commitSeq > baseline.commitSeq) {
-                this.queueEventCursors.set(watermark.queue, watermark.commitSeq);
+                this.queueCursors.applied(watermark.queue, watermark.commitSeq);
             }
+            // `PostgresQueueManagerState` loads a full snapshot of every queue after
+            // this call, so recorded prunes are already covered and must not refresh
+            // the freshly loaded read model.
+            this.queueCursors.remember(watermark);
         }
         this.subscription = await this.ctx.sql.listen(POSTGRES_EVENT_CHANNEL, (payload) => this.handleNotification(payload), () => void this.drain());
         this.pollTimer = setInterval(() => void this.drain(), this.ctx.config.pollIntervalMs);
@@ -64,6 +69,9 @@ export class PostgresEventStream {
         if (this.pollTimer)
             clearInterval(this.pollTimer);
         this.pollTimer = null;
+        if (this.retentionRetryTimer)
+            clearTimeout(this.retentionRetryTimer);
+        this.retentionRetryTimer = null;
         await this.subscription?.unlisten();
         this.subscription = null;
         for (const registrations of this.waiters.values()) {
@@ -148,10 +156,13 @@ export class PostgresEventStream {
             return this.draining;
         this.draining = this.drainLoop()
             .then(() => {
-            if (!this.closed)
+            if (!this.closed && !this.retentionRetryTimer)
                 this.reportDrainStatus(null);
         })
-            .catch((error) => this.reportDrainStatus(error instanceof Error ? error : new Error(String(error))))
+            .catch((error) => {
+            this.reportDrainStatus(error instanceof Error ? error : new Error(String(error)));
+            this.scheduleRetentionRetry();
+        })
             .finally(() => {
             this.draining = null;
             if (this.drainRequested && !this.closed)
@@ -166,6 +177,11 @@ export class PostgresEventStream {
             await this.convergeEventRetention();
             await this.scanPruneWatermarks();
             const entries = await loadPostgresJournalEventsAfter(this.ctx, this.journalCursor, batchSize);
+            // Always re-check retention against the pre-batch position: a prune that
+            // committed after the previous scan can have removed queue history this
+            // batch does not contain, and applying the batch would hide the gap.
+            if (entries.length > 0)
+                this.checkpointScanRequested = true;
             await this.scanPruneWatermarks();
             for (const entry of entries)
                 this.applyEvent(entry);
@@ -175,11 +191,18 @@ export class PostgresEventStream {
         }
     }
     async convergeEventRetention() {
+        if (this.retentionRetryTimer)
+            return;
+        const maxLength = this.ctx.config.maxQueueEvents;
         const queues = [...this.retentionQueues].sort();
         for (const queue of queues) {
             this.retentionQueues.delete(queue);
             try {
-                await trimPostgresQueueEvents(this.ctx, queue, this.ctx.config.maxQueueEvents);
+                const removed = await tryTrimPostgresQueueEvents(this.ctx, queue, maxLength);
+                if (removed === null) {
+                    this.retentionQueues.add(queue);
+                    this.scheduleRetentionRetry();
+                }
             }
             catch (error) {
                 this.retentionQueues.add(queue);
@@ -187,11 +210,21 @@ export class PostgresEventStream {
             }
         }
     }
+    scheduleRetentionRetry() {
+        if (this.closed || this.retentionRetryTimer || this.retentionQueues.size === 0)
+            return;
+        const delay = Math.min(this.ctx.config.pollIntervalMs, 250);
+        this.retentionRetryTimer = setTimeout(() => {
+            this.retentionRetryTimer = null;
+            if (!this.closed && this.retentionQueues.size > 0)
+                void this.drain(false);
+        }, delay);
+    }
     applyEvent(entry) {
         const { event, commitSeq } = entry;
         this.journalCursor = { commitSeq, eventId: event.id };
         this.cursor = Math.max(this.cursor, event.id);
-        this.queueEventCursors.set(event.queue, Math.max(this.queueEventCursors.get(event.queue) ?? this.baselineCursor, commitSeq));
+        this.queueCursors.applied(event.queue, commitSeq);
         if (requiresQueueInvalidation(event))
             this.invalidateQueue(event.queue);
         const delivered = { ...event, commitSeq };
@@ -214,13 +247,6 @@ export class PostgresEventStream {
             }
         }
     }
-    applyPruneWatermark(queue, commitSeq, prunedCommitSeq) {
-        const appliedThrough = this.queueEventCursors.get(queue) ?? this.baselineCursor;
-        if (appliedThrough >= prunedCommitSeq)
-            return;
-        this.queueEventCursors.set(queue, commitSeq);
-        this.invalidateQueue(queue);
-    }
     async scanPruneWatermarks() {
         if (!this.checkpointScanRequested)
             return;
@@ -228,7 +254,8 @@ export class PostgresEventStream {
         try {
             const watermarks = await loadPostgresEventPruneWatermarks(this.ctx);
             for (const watermark of watermarks) {
-                this.applyPruneWatermark(watermark.queue, watermark.commitSeq, watermark.prunedCommitSeq);
+                if (this.queueCursors.requiresRefresh(watermark))
+                    this.invalidateQueue(watermark.queue);
             }
         }
         catch (error) {

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

@@ -0,0 +1,15 @@
+import type { TransactionSQL } from 'bun';
+import type { GroupPullOptions } from '../../../domain/types/group';
+import type { PostgresContext } from './context';
+import type { PostgresJobRow } from './types';
+/** Assign durable rotation positions to every pending group lacking one. */
+export declare function ensurePostgresGroupStates(tx: TransactionSQL, ctx: PostgresContext, queue: string, sequence: number): Promise<number>;
+/** Reset fixed windows when they expire or a worker changes the effective defaults. */
+export declare function refreshPostgresGroupRateWindows(tx: TransactionSQL, ctx: PostgresContext, queue: string, options: GroupPullOptions | undefined, now: number): Promise<void>;
+/** Consume group budgets and move the durable round-robin cursor after row locks are secured. */
+export declare function commitPostgresGroupClaims(tx: TransactionSQL, ctx: PostgresContext, input: {
+    queue: string;
+    rows: readonly PostgresJobRow[];
+    options?: GroupPullOptions;
+    sequence: number;
+}): Promise<void>;

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

@@ -0,0 +1,95 @@
+/** Assign durable rotation positions to every pending group lacking one. */
+export async function ensurePostgresGroupStates(tx, ctx, queue, sequence) {
+    const assigned = await tx `
+    WITH unsequenced AS (
+      SELECT job.group_id, MIN(job.group_order) AS first_order
+      FROM bunqueue_jobs AS job
+      LEFT JOIN bunqueue_group_state AS groups
+        ON groups.namespace = job.namespace AND groups.queue = job.queue
+       AND groups.group_id = job.group_id
+      WHERE job.namespace = ${ctx.config.namespace} AND job.queue = ${queue}
+        AND job.group_id IS NOT NULL AND groups.last_served IS NULL
+        AND job.state IN ('waiting', 'prioritized', 'delayed')
+      GROUP BY job.group_id
+    ), ordered AS (
+      SELECT group_id,
+             row_number() OVER (ORDER BY first_order, group_id) AS position
+      FROM unsequenced
+    )
+    INSERT INTO bunqueue_group_state (namespace, queue, group_id, last_served)
+    SELECT ${ctx.config.namespace}, ${queue}, group_id, ${sequence} + position
+    FROM ordered
+    ON CONFLICT (namespace, queue, group_id) DO UPDATE
+    SET last_served = EXCLUDED.last_served
+    WHERE bunqueue_group_state.last_served IS NULL
+    RETURNING group_id
+  `;
+    if (assigned.length === 0)
+        return sequence;
+    const next = sequence + assigned.length;
+    await tx `
+    UPDATE bunqueue_queue_state SET group_sequence = ${next}
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+  `;
+    return next;
+}
+/** Reset fixed windows when they expire or a worker changes the effective defaults. */
+export async function refreshPostgresGroupRateWindows(tx, ctx, queue, options, now) {
+    if (!options?.limit)
+        return;
+    const { max, duration } = options.limit;
+    await tx `
+    UPDATE bunqueue_group_state AS groups
+    SET rate_window_started_at = ${now}, rate_count = 0,
+        rate_effective_max = COALESCE(groups.rate_limit, ${max}),
+        rate_effective_duration_ms = COALESCE(groups.rate_duration_ms, ${duration})
+    WHERE groups.namespace = ${ctx.config.namespace} AND groups.queue = ${queue}
+      AND EXISTS (
+        SELECT 1 FROM bunqueue_jobs AS job
+        WHERE job.namespace = groups.namespace AND job.queue = groups.queue
+          AND job.group_id = groups.group_id
+          AND job.state IN ('waiting', 'prioritized', 'delayed')
+      )
+      AND (
+        groups.rate_window_started_at IS NULL
+        OR groups.rate_effective_max IS DISTINCT FROM COALESCE(groups.rate_limit, ${max})
+        OR groups.rate_effective_duration_ms IS DISTINCT FROM
+             COALESCE(groups.rate_duration_ms, ${duration})
+        OR groups.rate_window_started_at + COALESCE(groups.rate_duration_ms, ${duration}) <= ${now}
+      )
+  `;
+}
+/** Consume group budgets and move the durable round-robin cursor after row locks are secured. */
+export async function commitPostgresGroupClaims(tx, ctx, input) {
+    const { queue, rows, options, sequence } = input;
+    const grouped = rows.filter((row) => row.group_id !== null);
+    if (grouped.length === 0)
+        return;
+    const turns = new Map();
+    for (let index = 0; index < grouped.length; index++) {
+        const groupId = grouped[index].group_id;
+        const current = turns.get(groupId);
+        turns.set(groupId, {
+            last: sequence + index + 1,
+            count: (current?.count ?? 0) + 1,
+        });
+    }
+    const entries = [...turns.entries()];
+    await tx `
+    UPDATE bunqueue_group_state AS groups
+    SET last_served = batch.last_served,
+        rate_count = groups.rate_count + CASE WHEN ${options?.limit !== undefined}
+          THEN batch.claimed_count ELSE 0 END
+    FROM unnest(
+      ${tx.array(entries.map(([groupId]) => groupId), 'TEXT')},
+      ${tx.array(entries.map(([, value]) => value.last), 'BIGINT')},
+      ${tx.array(entries.map(([, value]) => value.count), 'INTEGER')}
+    ) AS batch(group_id, last_served, claimed_count)
+    WHERE groups.namespace = ${ctx.config.namespace} AND groups.queue = ${queue}
+      AND groups.group_id = batch.group_id
+  `;
+    await tx `
+    UPDATE bunqueue_queue_state SET group_sequence = ${sequence + grouped.length}
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+  `;
+}

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

@@ -0,0 +1,2 @@
+/** Correctness-critical group schema and idempotent v19 repair operations. */
+export declare const POSTGRES_GROUP_SCHEMA = "\nCREATE SEQUENCE IF NOT EXISTS bunqueue_group_order_seq AS BIGINT CACHE 1;\nALTER SEQUENCE bunqueue_group_order_seq\n  AS BIGINT INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE CACHE 1;\n\nALTER TABLE bunqueue_jobs ADD COLUMN IF NOT EXISTS group_order BIGINT;\nALTER TABLE bunqueue_jobs\n  ALTER COLUMN group_order TYPE BIGINT USING group_order::bigint,\n  ALTER COLUMN group_order DROP DEFAULT,\n  ALTER COLUMN group_order DROP NOT NULL;\n\nDO $group_order_backfill$\nDECLARE\n  target RECORD;\nBEGIN\n  PERFORM setval(\n    'bunqueue_group_order_seq',\n    GREATEST(\n      (SELECT last_value FROM bunqueue_group_order_seq),\n      COALESCE((SELECT MAX(group_order) FROM bunqueue_jobs), 0),\n      1\n    ),\n    TRUE\n  );\n  FOR target IN\n    SELECT namespace, id\n    FROM bunqueue_jobs\n    WHERE group_id IS NOT NULL AND group_order IS NULL\n    ORDER BY created_at, id, namespace\n  LOOP\n    UPDATE bunqueue_jobs\n    SET group_order = nextval('bunqueue_group_order_seq')\n    WHERE namespace = target.namespace AND id = target.id;\n  END LOOP;\nEND;\n$group_order_backfill$;\n\nCREATE TABLE IF NOT EXISTS bunqueue_group_state (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  group_id TEXT NOT NULL,\n  rate_limit BIGINT,\n  rate_duration_ms BIGINT,\n  rate_window_started_at BIGINT,\n  rate_count BIGINT NOT NULL DEFAULT 0,\n  rate_effective_max BIGINT,\n  rate_effective_duration_ms BIGINT,\n  concurrency_limit BIGINT,\n  last_served BIGINT,\n  PRIMARY KEY (namespace, queue, group_id)\n);\nALTER TABLE bunqueue_group_state\n  ADD COLUMN IF NOT EXISTS namespace TEXT,\n  ADD COLUMN IF NOT EXISTS queue TEXT,\n  ADD COLUMN IF NOT EXISTS group_id TEXT,\n  ADD COLUMN IF NOT EXISTS rate_limit BIGINT,\n  ADD COLUMN IF NOT EXISTS rate_duration_ms BIGINT,\n  ADD COLUMN IF NOT EXISTS rate_window_started_at BIGINT,\n  ADD COLUMN IF NOT EXISTS rate_count BIGINT DEFAULT 0,\n  ADD COLUMN IF NOT EXISTS rate_effective_max BIGINT,\n  ADD COLUMN IF NOT EXISTS rate_effective_duration_ms BIGINT,\n  ADD COLUMN IF NOT EXISTS concurrency_limit BIGINT,\n  ADD COLUMN IF NOT EXISTS last_served BIGINT;\nALTER TABLE bunqueue_group_state\n  ALTER COLUMN namespace TYPE TEXT USING namespace::text,\n  ALTER COLUMN queue TYPE TEXT USING queue::text,\n  ALTER COLUMN group_id TYPE TEXT USING group_id::text,\n  ALTER COLUMN rate_limit TYPE BIGINT USING rate_limit::bigint,\n  ALTER COLUMN rate_duration_ms TYPE BIGINT USING rate_duration_ms::bigint,\n  ALTER COLUMN rate_window_started_at TYPE BIGINT USING rate_window_started_at::bigint,\n  ALTER COLUMN rate_count TYPE BIGINT USING rate_count::bigint,\n  ALTER COLUMN rate_effective_max TYPE BIGINT USING rate_effective_max::bigint,\n  ALTER COLUMN rate_effective_duration_ms TYPE BIGINT USING rate_effective_duration_ms::bigint,\n  ALTER COLUMN concurrency_limit TYPE BIGINT USING concurrency_limit::bigint,\n  ALTER COLUMN last_served TYPE BIGINT USING last_served::bigint;\nUPDATE bunqueue_group_state SET rate_count = 0 WHERE rate_count IS NULL;\nALTER TABLE bunqueue_group_state\n  ALTER COLUMN namespace DROP DEFAULT,\n  ALTER COLUMN namespace SET NOT NULL,\n  ALTER COLUMN queue DROP DEFAULT,\n  ALTER COLUMN queue SET NOT NULL,\n  ALTER COLUMN group_id DROP DEFAULT,\n  ALTER COLUMN group_id SET NOT NULL,\n  ALTER COLUMN rate_limit DROP DEFAULT,\n  ALTER COLUMN rate_limit DROP NOT NULL,\n  ALTER COLUMN rate_duration_ms DROP DEFAULT,\n  ALTER COLUMN rate_duration_ms DROP NOT NULL,\n  ALTER COLUMN rate_window_started_at DROP DEFAULT,\n  ALTER COLUMN rate_window_started_at DROP NOT NULL,\n  ALTER COLUMN rate_count SET DEFAULT 0,\n  ALTER COLUMN rate_count SET NOT NULL,\n  ALTER COLUMN rate_effective_max DROP DEFAULT,\n  ALTER COLUMN rate_effective_max DROP NOT NULL,\n  ALTER COLUMN rate_effective_duration_ms DROP DEFAULT,\n  ALTER COLUMN rate_effective_duration_ms DROP NOT NULL,\n  ALTER COLUMN concurrency_limit DROP DEFAULT,\n  ALTER COLUMN concurrency_limit DROP NOT NULL,\n  ALTER COLUMN last_served DROP DEFAULT,\n  ALTER COLUMN last_served DROP NOT NULL;\n\nDO $group_state_primary_key$\nDECLARE\n  constraint_name TEXT;\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1\n    FROM pg_constraint AS constraint_state\n    JOIN pg_index AS index_state ON index_state.indexrelid = constraint_state.conindid\n    JOIN pg_class AS index_class ON index_class.oid = index_state.indexrelid\n    JOIN pg_am AS access_method ON access_method.oid = index_class.relam\n    WHERE constraint_state.conrelid = to_regclass('bunqueue_group_state')\n      AND constraint_state.contype = 'p'\n      AND constraint_state.convalidated\n      AND NOT constraint_state.condeferrable\n      AND NOT constraint_state.condeferred\n      AND index_state.indisprimary AND index_state.indisunique\n      AND index_state.indisvalid AND index_state.indisready\n      AND access_method.amname = 'btree'\n      AND ARRAY(\n        SELECT attribute.attname::text\n        FROM unnest(constraint_state.conkey) WITH ORDINALITY AS key(attnum, position)\n        JOIN pg_attribute AS attribute\n          ON attribute.attrelid = constraint_state.conrelid\n         AND attribute.attnum = key.attnum\n        ORDER BY key.position\n      ) = ARRAY['namespace', 'queue', 'group_id']\n  ) THEN\n    FOR constraint_name IN\n      SELECT conname FROM pg_constraint\n      WHERE conrelid = to_regclass('bunqueue_group_state')\n        AND (contype = 'p' OR conname = 'bunqueue_group_state_pkey')\n    LOOP\n      EXECUTE format(\n        'ALTER TABLE bunqueue_group_state DROP CONSTRAINT %I',\n        constraint_name\n      );\n    END LOOP;\n    IF to_regclass('bunqueue_group_state_pkey') IS NOT NULL THEN\n      DROP INDEX bunqueue_group_state_pkey;\n    END IF;\n    ALTER TABLE bunqueue_group_state\n      ADD CONSTRAINT bunqueue_group_state_pkey PRIMARY KEY (namespace, queue, group_id);\n  END IF;\nEND;\n$group_state_primary_key$;\n\nDROP INDEX IF EXISTS bunqueue_jobs_group_ready_idx;\nCREATE INDEX bunqueue_jobs_group_ready_idx\n  ON bunqueue_jobs(namespace, queue, group_id, run_at ASC, group_order ASC, id ASC)\n  WHERE group_id IS NOT NULL AND state IN ('waiting', 'prioritized', 'delayed');\nDROP INDEX IF EXISTS bunqueue_group_state_rotation_idx;\nCREATE INDEX bunqueue_group_state_rotation_idx\n  ON bunqueue_group_state(namespace, queue, last_served, group_id);\n";

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

@@ -0,0 +1,155 @@
+/** Correctness-critical group schema and idempotent v19 repair operations. */
+export const POSTGRES_GROUP_SCHEMA = `
+CREATE SEQUENCE IF NOT EXISTS bunqueue_group_order_seq AS BIGINT CACHE 1;
+ALTER SEQUENCE bunqueue_group_order_seq
+  AS BIGINT INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE CACHE 1;
+
+ALTER TABLE bunqueue_jobs ADD COLUMN IF NOT EXISTS group_order BIGINT;
+ALTER TABLE bunqueue_jobs
+  ALTER COLUMN group_order TYPE BIGINT USING group_order::bigint,
+  ALTER COLUMN group_order DROP DEFAULT,
+  ALTER COLUMN group_order DROP NOT NULL;
+
+DO $group_order_backfill$
+DECLARE
+  target RECORD;
+BEGIN
+  PERFORM setval(
+    'bunqueue_group_order_seq',
+    GREATEST(
+      (SELECT last_value FROM bunqueue_group_order_seq),
+      COALESCE((SELECT MAX(group_order) FROM bunqueue_jobs), 0),
+      1
+    ),
+    TRUE
+  );
+  FOR target IN
+    SELECT namespace, id
+    FROM bunqueue_jobs
+    WHERE group_id IS NOT NULL AND group_order IS NULL
+    ORDER BY created_at, id, namespace
+  LOOP
+    UPDATE bunqueue_jobs
+    SET group_order = nextval('bunqueue_group_order_seq')
+    WHERE namespace = target.namespace AND id = target.id;
+  END LOOP;
+END;
+$group_order_backfill$;
+
+CREATE TABLE IF NOT EXISTS bunqueue_group_state (
+  namespace TEXT NOT NULL,
+  queue TEXT NOT NULL,
+  group_id TEXT NOT NULL,
+  rate_limit BIGINT,
+  rate_duration_ms BIGINT,
+  rate_window_started_at BIGINT,
+  rate_count BIGINT NOT NULL DEFAULT 0,
+  rate_effective_max BIGINT,
+  rate_effective_duration_ms BIGINT,
+  concurrency_limit BIGINT,
+  last_served BIGINT,
+  PRIMARY KEY (namespace, queue, group_id)
+);
+ALTER TABLE bunqueue_group_state
+  ADD COLUMN IF NOT EXISTS namespace TEXT,
+  ADD COLUMN IF NOT EXISTS queue TEXT,
+  ADD COLUMN IF NOT EXISTS group_id TEXT,
+  ADD COLUMN IF NOT EXISTS rate_limit BIGINT,
+  ADD COLUMN IF NOT EXISTS rate_duration_ms BIGINT,
+  ADD COLUMN IF NOT EXISTS rate_window_started_at BIGINT,
+  ADD COLUMN IF NOT EXISTS rate_count BIGINT DEFAULT 0,
+  ADD COLUMN IF NOT EXISTS rate_effective_max BIGINT,
+  ADD COLUMN IF NOT EXISTS rate_effective_duration_ms BIGINT,
+  ADD COLUMN IF NOT EXISTS concurrency_limit BIGINT,
+  ADD COLUMN IF NOT EXISTS last_served BIGINT;
+ALTER TABLE bunqueue_group_state
+  ALTER COLUMN namespace TYPE TEXT USING namespace::text,
+  ALTER COLUMN queue TYPE TEXT USING queue::text,
+  ALTER COLUMN group_id TYPE TEXT USING group_id::text,
+  ALTER COLUMN rate_limit TYPE BIGINT USING rate_limit::bigint,
+  ALTER COLUMN rate_duration_ms TYPE BIGINT USING rate_duration_ms::bigint,
+  ALTER COLUMN rate_window_started_at TYPE BIGINT USING rate_window_started_at::bigint,
+  ALTER COLUMN rate_count TYPE BIGINT USING rate_count::bigint,
+  ALTER COLUMN rate_effective_max TYPE BIGINT USING rate_effective_max::bigint,
+  ALTER COLUMN rate_effective_duration_ms TYPE BIGINT USING rate_effective_duration_ms::bigint,
+  ALTER COLUMN concurrency_limit TYPE BIGINT USING concurrency_limit::bigint,
+  ALTER COLUMN last_served TYPE BIGINT USING last_served::bigint;
+UPDATE bunqueue_group_state SET rate_count = 0 WHERE rate_count IS NULL;
+ALTER TABLE bunqueue_group_state
+  ALTER COLUMN namespace DROP DEFAULT,
+  ALTER COLUMN namespace SET NOT NULL,
+  ALTER COLUMN queue DROP DEFAULT,
+  ALTER COLUMN queue SET NOT NULL,
+  ALTER COLUMN group_id DROP DEFAULT,
+  ALTER COLUMN group_id SET NOT NULL,
+  ALTER COLUMN rate_limit DROP DEFAULT,
+  ALTER COLUMN rate_limit DROP NOT NULL,
+  ALTER COLUMN rate_duration_ms DROP DEFAULT,
+  ALTER COLUMN rate_duration_ms DROP NOT NULL,
+  ALTER COLUMN rate_window_started_at DROP DEFAULT,
+  ALTER COLUMN rate_window_started_at DROP NOT NULL,
+  ALTER COLUMN rate_count SET DEFAULT 0,
+  ALTER COLUMN rate_count SET NOT NULL,
+  ALTER COLUMN rate_effective_max DROP DEFAULT,
+  ALTER COLUMN rate_effective_max DROP NOT NULL,
+  ALTER COLUMN rate_effective_duration_ms DROP DEFAULT,
+  ALTER COLUMN rate_effective_duration_ms DROP NOT NULL,
+  ALTER COLUMN concurrency_limit DROP DEFAULT,
+  ALTER COLUMN concurrency_limit DROP NOT NULL,
+  ALTER COLUMN last_served DROP DEFAULT,
+  ALTER COLUMN last_served DROP NOT NULL;
+
+DO $group_state_primary_key$
+DECLARE
+  constraint_name TEXT;
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1
+    FROM pg_constraint AS constraint_state
+    JOIN pg_index AS index_state ON index_state.indexrelid = constraint_state.conindid
+    JOIN pg_class AS index_class ON index_class.oid = index_state.indexrelid
+    JOIN pg_am AS access_method ON access_method.oid = index_class.relam
+    WHERE constraint_state.conrelid = to_regclass('bunqueue_group_state')
+      AND constraint_state.contype = 'p'
+      AND constraint_state.convalidated
+      AND NOT constraint_state.condeferrable
+      AND NOT constraint_state.condeferred
+      AND index_state.indisprimary AND index_state.indisunique
+      AND index_state.indisvalid AND index_state.indisready
+      AND access_method.amname = 'btree'
+      AND ARRAY(
+        SELECT attribute.attname::text
+        FROM unnest(constraint_state.conkey) WITH ORDINALITY AS key(attnum, position)
+        JOIN pg_attribute AS attribute
+          ON attribute.attrelid = constraint_state.conrelid
+         AND attribute.attnum = key.attnum
+        ORDER BY key.position
+      ) = ARRAY['namespace', 'queue', 'group_id']
+  ) THEN
+    FOR constraint_name IN
+      SELECT conname FROM pg_constraint
+      WHERE conrelid = to_regclass('bunqueue_group_state')
+        AND (contype = 'p' OR conname = 'bunqueue_group_state_pkey')
+    LOOP
+      EXECUTE format(
+        'ALTER TABLE bunqueue_group_state DROP CONSTRAINT %I',
+        constraint_name
+      );
+    END LOOP;
+    IF to_regclass('bunqueue_group_state_pkey') IS NOT NULL THEN
+      DROP INDEX bunqueue_group_state_pkey;
+    END IF;
+    ALTER TABLE bunqueue_group_state
+      ADD CONSTRAINT bunqueue_group_state_pkey PRIMARY KEY (namespace, queue, group_id);
+  END IF;
+END;
+$group_state_primary_key$;
+
+DROP INDEX IF EXISTS bunqueue_jobs_group_ready_idx;
+CREATE INDEX bunqueue_jobs_group_ready_idx
+  ON bunqueue_jobs(namespace, queue, group_id, run_at ASC, group_order ASC, id ASC)
+  WHERE group_id IS NOT NULL AND state IN ('waiting', 'prioritized', 'delayed');
+DROP INDEX IF EXISTS bunqueue_group_state_rotation_idx;
+CREATE INDEX bunqueue_group_state_rotation_idx
+  ON bunqueue_group_state(namespace, queue, last_served, group_id);
+`;

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

@@ -0,0 +1,3 @@
+import type { TransactionSQL } from 'bun';
+/** Verify every catalog property required by durable group scheduling. */
+export declare function hasCurrentPostgresGroupSchema(tx: TransactionSQL): Promise<boolean>;