@rotorsoft/act-pg 1.13.6 → 1.13.8

package/dist/index.js

@@ -577,11 +577,17 @@ var PostgresStore = class {
     const client = await this._client("claim");
     try {
       await client.query("BEGIN");
-      const lane_clause = lane !== void 0 ? `AND s.lane = $5` : "";
-      const params = lane !== void 0 ? [lagging, leading, by, millis, lane] : [lagging, leading, by, millis];
+      const lane_clause = lane !== void 0 ? `AND s.lane = $6` : "";
+      const fair = lagging >= 2 ? Math.max(1, Math.floor(lagging / 4)) : 0;
+      const params = lane !== void 0 ? [lagging, leading, by, millis, fair, lane] : [lagging, leading, by, millis, fair];
       const { rows } = await client.query(
         `
         WITH
+        -- Plain read of the eligible frontier \u2014 no row lock here. A CTE
+        -- carrying FOR UPDATE never inlines, so locking it would materialize
+        -- and lock EVERY claimable stream for this transaction, starving
+        -- overlapping competing consumers. We only lock the small
+        -- lagging+leading candidate slice, down in the "locked" CTE.
         available AS (
           SELECT stream, source, at, priority, lane
           FROM ${this._fqs} s
@@ -605,17 +611,38 @@ var PostgresStore = class {
                 )
               LIMIT 1
             ))
-          FOR UPDATE SKIP LOCKED
         ),
         -- Priority lanes (ACT-102): higher priority first, then
         -- lagging-watermark order. With everyone at priority=0 the
         -- ORDER BY collapses to plain at ASC so existing workloads
         -- see no behavior change.
+        --
+        -- The lagging frontier is a UNION of two portions (ACT-1223): the
+        -- priority-ordered portion takes the first (lagging - fair) slots
+        -- by priority DESC, at ASC; a fairness reserve then fills fair more
+        -- slots by pure at ASC (priority ignored), excluding the ones
+        -- already chosen, so a default-priority lagging stream is never
+        -- starved out by sustained higher-priority load. With all
+        -- priorities equal both portions order by at, a no-op merge.
         lag AS (
-          SELECT stream, source, at, lane, TRUE AS lagging
-          FROM available
-          ORDER BY priority DESC, at ASC
-          LIMIT $1
+          (
+            SELECT stream, source, at, lane, TRUE AS lagging
+            FROM available
+            ORDER BY priority DESC, at ASC
+            LIMIT ($1::int - $5::int)
+          )
+          UNION
+          (
+            SELECT stream, source, at, lane, TRUE AS lagging
+            FROM available
+            WHERE stream NOT IN (
+              SELECT stream FROM available
+              ORDER BY priority DESC, at ASC
+              LIMIT ($1::int - $5::int)
+            )
+            ORDER BY at ASC
+            LIMIT $5
+          )
         ),
         lead AS (
           SELECT stream, source, at, lane, FALSE AS lagging
@@ -627,6 +654,20 @@ var PostgresStore = class {
           SELECT DISTINCT ON (stream) stream, source, at, lane, lagging
           FROM (SELECT * FROM lag UNION ALL SELECT * FROM lead) t
           ORDER BY stream, at
+        ),
+        -- Lock ONLY the <= lagging+leading candidate rows. The
+        -- lease-eligibility predicate is re-asserted here under the lock so a
+        -- lease acquired by a competing worker between the unlocked read and
+        -- this lock is never stolen. Competing workers SKIP-LOCK just this
+        -- slice, not the whole frontier, and claim other eligible streams.
+        locked AS (
+          SELECT s2.stream
+          FROM ${this._fqs} s2
+          WHERE s2.stream IN (SELECT stream FROM combined)
+            AND s2.blocked = false
+            AND (s2.leased_by IS NULL OR s2.leased_until <= NOW())
+            AND (s2.deferred_at IS NULL OR s2.deferred_at <= NOW())
+          FOR UPDATE OF s2 SKIP LOCKED
         )
         UPDATE ${this._fqs} s
         SET
@@ -635,6 +676,7 @@ var PostgresStore = class {
           retry = s.retry + 1
         FROM combined c
         WHERE s.stream = c.stream
+          AND s.stream IN (SELECT stream FROM locked)
         RETURNING s.stream, s.source, s.at, s.retry, c.lagging, s.lane
         `,
         params