velocious 1.0.739 → 1.0.740

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -153,9 +153,11 @@ export function buildLaneFairnessOrderSql({configuration, db, nowMs, jobsTable,
153
153
 
154
154
  /**
155
155
  * Builds the raw lane-fairness rank used to compose the primary queue rank. A configured capped
156
- * lane without a claim stamp receives the full global ceiling boost as never-served work; a lane
157
- * without a durable queue counter contributes zero and keeps the historical row-age fallback.
158
- * A long-ago claim stamp contributes its full starvation age to the primary rank.
156
+ * lane without a claim stamp contributes no service-age bonus: without a claim there is no
157
+ * lane-service history to rank. Once its row reaches its own cap, its configured priority is
158
+ * retained as a small primary-key tie signal so a deep backlog cannot win solely by row age. A
159
+ * long-ago claim stamp contributes its full starvation age to the primary rank. A lane without a
160
+ * durable queue counter contributes zero and keeps the historical row-age fallback.
159
161
  * @param {object} args - Options.
160
162
  * @param {import("../configuration.js").default} args.configuration - Active configuration.
161
163
  * @param {import("../database/drivers/base.js").default} args.db - Connection.
@@ -170,7 +172,6 @@ export function buildLaneFairnessRankSql({configuration, db, nowMs, jobsTable, c
170
172
 
171
173
  const queues = configuration.getBackgroundJobsConfig().queues || {}
172
174
  const highestPriority = Math.max(0, ...Object.values(queues).map((queueConfig) => Number.isFinite(queueConfig?.priority) ? Number(queueConfig.priority) : 0))
173
- const neverServedBoost = (highestPriority + 1) * unitMs
174
175
  const queueExpression = `COALESCE(${jobsTable}.${db.quoteColumn("queue")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)})`
175
176
  const cappedQueues = Object.entries(queues).filter(([, queueConfig]) => Number.isInteger(queueConfig?.maxConcurrent) && Number(queueConfig.maxConcurrent) > 0)
176
177
  // Only queues with a `maxConcurrent` get a durable lane counter. With none configured there is
@@ -181,5 +182,11 @@ export function buildLaneFairnessRankSql({configuration, db, nowMs, jobsTable, c
181
182
  `(SELECT ${concurrencyTable}.${db.quoteColumn("last_claimed_at_ms")} FROM ${concurrencyTable} ` +
182
183
  `WHERE ${concurrencyTable}.${db.quoteColumn("concurrency_key")} = ${laneKeyCase})`
183
184
 
184
- return `(CASE WHEN ${laneKeyCase} IS NULL THEN 0 WHEN ${lastClaimedLookup} IS NULL THEN ${neverServedBoost} ELSE (${Number(nowMs)} - ${lastClaimedLookup}) END)`
185
+ const neverServedTie = `CASE ${queueExpression} ${cappedQueues.map(([queue, queueConfig]) => {
186
+ const priority = Number.isFinite(queueConfig?.priority) ? Number(queueConfig.priority) : 0
187
+ const agingCap = (highestPriority - priority + 1) * unitMs
188
+ return `WHEN ${db.quote(queue)} THEN CASE WHEN ${jobsTable}.${db.quoteColumn("scheduled_at_ms")} <= (${Number(nowMs)} - ${agingCap}) THEN ${priority} ELSE 0 END`
189
+ }).join(" ")} ELSE 0 END`
190
+
191
+ return `(CASE WHEN ${laneKeyCase} IS NULL THEN 0 WHEN ${lastClaimedLookup} IS NULL THEN (${neverServedTie}) ELSE (${Number(nowMs)} - ${lastClaimedLookup}) END)`
185
192
  }
@@ -100,9 +100,11 @@ export declare function buildLaneFairnessOrderSql({ configuration, db, nowMs, jo
100
100
  }): string | null;
101
101
  /**
102
102
  * Builds the raw lane-fairness rank used to compose the primary queue rank. A configured capped
103
- * lane without a claim stamp receives the full global ceiling boost as never-served work; a lane
104
- * without a durable queue counter contributes zero and keeps the historical row-age fallback.
105
- * A long-ago claim stamp contributes its full starvation age to the primary rank.
103
+ * lane without a claim stamp contributes no service-age bonus: without a claim there is no
104
+ * lane-service history to rank. Once its row reaches its own cap, its configured priority is
105
+ * retained as a small primary-key tie signal so a deep backlog cannot win solely by row age. A
106
+ * long-ago claim stamp contributes its full starvation age to the primary rank. A lane without a
107
+ * durable queue counter contributes zero and keeps the historical row-age fallback.
106
108
  * @param {object} args - Options.
107
109
  * @param {import("../configuration.js").default} args.configuration - Active configuration.
108
110
  * @param {import("../database/drivers/base.js").default} args.db - Connection.
@@ -1 +1 @@
1
- {"version":3,"file":"queue-priority-order.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/queue-priority-order.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC,QAAQ,CAAA;AAEzD;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,KAAK,EAH5C,OAG4C,GAF1C,MAAM,GAAG,IAAI,CAQzB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,EAH3C,OAAO,qBAAqB,EAAE,OAGa,GAFzC,MAAM,GAAG,IAAI,CAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,CAAC,EAAC,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAC,EANpF;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAA4D,EAAE,EAAtD,OAAO,6BAA6B,EAAE,OAAO,CACrD;IAAqB,KAAK,EAAlB,MAAM,CACd;IAA6B,gBAAgB,AAA7C,CACA,EADQ,MAAM,GAAG,IAAI,CACrB;CAEoF,GAF1E,MAAM,GAAG,IAAI,CAmCzB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAH7B,MAG6B,GAF3B,MAAM,CAIlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,yBAAyB,CAAC,EAAC,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAC,EAP9F;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAA4D,EAAE,EAAtD,OAAO,6BAA6B,EAAE,OAAO,CACrD;IAAqB,KAAK,EAAlB,MAAM,CACd;IAAqB,SAAS,EAAtB,MAAM,CACd;IAAqB,gBAAgB,EAA7B,MAAM,CACd;CAE8F,GAFpF,MAAM,GAAG,IAAI,CAazB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,EAAC,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAC,EAP7F;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAA4D,EAAE,EAAtD,OAAO,6BAA6B,EAAE,OAAO,CACrD;IAAqB,KAAK,EAAlB,MAAM,CACd;IAAqB,SAAS,EAAtB,MAAM,CACd;IAAqB,gBAAgB,EAA7B,MAAM,CACd;CAE6F,GAFnF,MAAM,GAAG,IAAI,CAoBzB"}
1
+ {"version":3,"file":"queue-priority-order.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/queue-priority-order.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC,QAAQ,CAAA;AAEzD;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,KAAK,EAH5C,OAG4C,GAF1C,MAAM,GAAG,IAAI,CAQzB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,EAH3C,OAAO,qBAAqB,EAAE,OAGa,GAFzC,MAAM,GAAG,IAAI,CAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,CAAC,EAAC,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAC,EANpF;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAA4D,EAAE,EAAtD,OAAO,6BAA6B,EAAE,OAAO,CACrD;IAAqB,KAAK,EAAlB,MAAM,CACd;IAA6B,gBAAgB,AAA7C,CACA,EADQ,MAAM,GAAG,IAAI,CACrB;CAEoF,GAF1E,MAAM,GAAG,IAAI,CAmCzB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAH7B,MAG6B,GAF3B,MAAM,CAIlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,yBAAyB,CAAC,EAAC,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAC,EAP9F;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAA4D,EAAE,EAAtD,OAAO,6BAA6B,EAAE,OAAO,CACrD;IAAqB,KAAK,EAAlB,MAAM,CACd;IAAqB,SAAS,EAAtB,MAAM,CACd;IAAqB,gBAAgB,EAA7B,MAAM,CACd;CAE8F,GAFpF,MAAM,GAAG,IAAI,CAazB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CAAC,EAAC,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAC,EAP7F;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAA4D,EAAE,EAAtD,OAAO,6BAA6B,EAAE,OAAO,CACrD;IAAqB,KAAK,EAAlB,MAAM,CACd;IAAqB,SAAS,EAAtB,MAAM,CACd;IAAqB,gBAAgB,EAA7B,MAAM,CACd;CAE6F,GAFnF,MAAM,GAAG,IAAI,CAyBzB"}
@@ -139,9 +139,11 @@ export function buildLaneFairnessOrderSql({ configuration, db, nowMs, jobsTable,
139
139
  }
140
140
  /**
141
141
  * Builds the raw lane-fairness rank used to compose the primary queue rank. A configured capped
142
- * lane without a claim stamp receives the full global ceiling boost as never-served work; a lane
143
- * without a durable queue counter contributes zero and keeps the historical row-age fallback.
144
- * A long-ago claim stamp contributes its full starvation age to the primary rank.
142
+ * lane without a claim stamp contributes no service-age bonus: without a claim there is no
143
+ * lane-service history to rank. Once its row reaches its own cap, its configured priority is
144
+ * retained as a small primary-key tie signal so a deep backlog cannot win solely by row age. A
145
+ * long-ago claim stamp contributes its full starvation age to the primary rank. A lane without a
146
+ * durable queue counter contributes zero and keeps the historical row-age fallback.
145
147
  * @param {object} args - Options.
146
148
  * @param {import("../configuration.js").default} args.configuration - Active configuration.
147
149
  * @param {import("../database/drivers/base.js").default} args.db - Connection.
@@ -156,7 +158,6 @@ export function buildLaneFairnessRankSql({ configuration, db, nowMs, jobsTable,
156
158
  return null;
157
159
  const queues = configuration.getBackgroundJobsConfig().queues || {};
158
160
  const highestPriority = Math.max(0, ...Object.values(queues).map((queueConfig) => Number.isFinite(queueConfig?.priority) ? Number(queueConfig.priority) : 0));
159
- const neverServedBoost = (highestPriority + 1) * unitMs;
160
161
  const queueExpression = `COALESCE(${jobsTable}.${db.quoteColumn("queue")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)})`;
161
162
  const cappedQueues = Object.entries(queues).filter(([, queueConfig]) => Number.isInteger(queueConfig?.maxConcurrent) && Number(queueConfig.maxConcurrent) > 0);
162
163
  // Only queues with a `maxConcurrent` get a durable lane counter. With none configured there is
@@ -166,6 +167,11 @@ export function buildLaneFairnessRankSql({ configuration, db, nowMs, jobsTable,
166
167
  const laneKeyCase = `CASE ${queueExpression} ${cappedQueues.map(([queue]) => `WHEN ${db.quote(queue)} THEN ${db.quote(laneConcurrencyKey(queue))}`).join(" ")} ELSE NULL END`;
167
168
  const lastClaimedLookup = `(SELECT ${concurrencyTable}.${db.quoteColumn("last_claimed_at_ms")} FROM ${concurrencyTable} ` +
168
169
  `WHERE ${concurrencyTable}.${db.quoteColumn("concurrency_key")} = ${laneKeyCase})`;
169
- return `(CASE WHEN ${laneKeyCase} IS NULL THEN 0 WHEN ${lastClaimedLookup} IS NULL THEN ${neverServedBoost} ELSE (${Number(nowMs)} - ${lastClaimedLookup}) END)`;
170
+ const neverServedTie = `CASE ${queueExpression} ${cappedQueues.map(([queue, queueConfig]) => {
171
+ const priority = Number.isFinite(queueConfig?.priority) ? Number(queueConfig.priority) : 0;
172
+ const agingCap = (highestPriority - priority + 1) * unitMs;
173
+ return `WHEN ${db.quote(queue)} THEN CASE WHEN ${jobsTable}.${db.quoteColumn("scheduled_at_ms")} <= (${Number(nowMs)} - ${agingCap}) THEN ${priority} ELSE 0 END`;
174
+ }).join(" ")} ELSE 0 END`;
175
+ return `(CASE WHEN ${laneKeyCase} IS NULL THEN 0 WHEN ${lastClaimedLookup} IS NULL THEN (${neverServedTie}) ELSE (${Number(nowMs)} - ${lastClaimedLookup}) END)`;
170
176
  }
171
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue-priority-order.js","sourceRoot":"","sources":["../../../src/background-jobs/queue-priority-order.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,4BAA4B,EAAE,4BAA4B,EAAC,MAAM,oBAAoB,CAAA;AAE7F;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,KAAK,CAAA;AAEzD;;;;;GAKG;AACH,MAAM,UAAU,iCAAiC,CAAC,KAAK;IACrD,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IAC/B,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,oCAAoC,CAAA;IACpE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,oCAAoC,CAAA;IAE9F,OAAO,MAAM,CAAC,KAAK,CAAC,CAAA;AACtB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,aAAa;IACpD,OAAO,iCAAiC,CAAC,aAAa,CAAC,uBAAuB,EAAE,CAAC,wBAAwB,CAAC,CAAA;AAC5G,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,0BAA0B,CAAC,EAAC,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAC;IACrF,MAAM,MAAM,GAAG,aAAa,CAAC,uBAAuB,EAAE,CAAC,MAAM,IAAI,EAAE,CAAA;IACnE,sCAAsC;IACtC,MAAM,WAAW,GAAG,EAAE,CAAA;IACtB,IAAI,eAAe,GAAG,CAAC,CAAA;IAEvB,KAAK,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1D,MAAM,QAAQ,GAAG,WAAW,EAAE,QAAQ,CAAA;QAEtC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAAE,SAAQ;QAExC,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;QAEvE,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA;IAC/D,CAAC;IAED,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IAEzC,MAAM,eAAe,GAAG,YAAY,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,4BAA4B,CAAC,GAAG,CAAA;IACzG,MAAM,YAAY,GAAG,QAAQ,eAAe,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAA;IACzJ,MAAM,MAAM,GAAG,wBAAwB,CAAC,aAAa,CAAC,CAAA;IAEtD,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,YAAY,CAAA;IAExC,MAAM,gBAAgB,GAAG,CAAC,eAAe,GAAG,CAAC,CAAC,GAAG,MAAM,CAAA;IACvD,MAAM,QAAQ,GAAG,QAAQ,eAAe,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,eAAe,GAAG,QAAQ,GAAG,CAAC,CAAC,GAAG,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,gBAAgB,MAAM,CAAA;IACxM,MAAM,iBAAiB,GAAG,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAA;IAE3D,MAAM,YAAY,GAAG,gBAAgB,CAAC,CAAC,CAAC,OAAO,gBAAgB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAA;IAEvE,OAAO,IAAI,YAAY,MAAM,MAAM,KAAK;QACtC,aAAa,iBAAiB,QAAQ,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,QAAQ,UAAU,QAAQ,GAAG;QACxF,SAAS,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,iBAAiB,QAAQ,YAAY,GAAG,CAAA;AAC1E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAK;IACtC,OAAO,GAAG,4BAA4B,GAAG,KAAK,EAAE,CAAA;AAClD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,yBAAyB,CAAC,EAAC,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAC;IAC/F,IAAI,wBAAwB,CAAC,aAAa,CAAC,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IAEjE,MAAM,MAAM,GAAG,aAAa,CAAC,uBAAuB,EAAE,CAAC,MAAM,IAAI,EAAE,CAAA;IACnE,MAAM,eAAe,GAAG,YAAY,SAAS,IAAI,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,4BAA4B,CAAC,GAAG,CAAA;IACtH,MAAM,WAAW,GAAG,QAAQ,eAAe,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAA;IAClL,MAAM,iBAAiB,GACrB,WAAW,gBAAgB,IAAI,EAAE,CAAC,WAAW,CAAC,oBAAoB,CAAC,SAAS,gBAAgB,GAAG;QAC/F,SAAS,gBAAgB,IAAI,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC,MAAM,WAAW,GAAG,CAAA;IAEpF,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,eAAe,iBAAiB,KAAK,SAAS,IAAI,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC,SAAS,CAAA;AACtH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,wBAAwB,CAAC,EAAC,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAC;IAC9F,MAAM,MAAM,GAAG,wBAAwB,CAAC,aAAa,CAAC,CAAA;IACtD,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IAEhC,MAAM,MAAM,GAAG,aAAa,CAAC,uBAAuB,EAAE,CAAC,MAAM,IAAI,EAAE,CAAA;IACnE,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC7J,MAAM,gBAAgB,GAAG,CAAC,eAAe,GAAG,CAAC,CAAC,GAAG,MAAM,CAAA;IACvD,MAAM,eAAe,GAAG,YAAY,SAAS,IAAI,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,4BAA4B,CAAC,GAAG,CAAA;IACtH,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAA;IAC9J,+FAA+F;IAC/F,oGAAoG;IACpG,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IAC1C,MAAM,WAAW,GAAG,QAAQ,eAAe,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAA;IAC7K,MAAM,iBAAiB,GACrB,WAAW,gBAAgB,IAAI,EAAE,CAAC,WAAW,CAAC,oBAAoB,CAAC,SAAS,gBAAgB,GAAG;QAC/F,SAAS,gBAAgB,IAAI,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC,MAAM,WAAW,GAAG,CAAA;IAEpF,OAAO,cAAc,WAAW,wBAAwB,iBAAiB,iBAAiB,gBAAgB,UAAU,MAAM,CAAC,KAAK,CAAC,MAAM,iBAAiB,QAAQ,CAAA;AAClK,CAAC","sourcesContent":["// @ts-check\n\nimport {DEFAULT_BACKGROUND_JOB_QUEUE, QUEUE_CONCURRENCY_KEY_PREFIX} from \"./job-semantics.js\"\n\n/**\n * How many milliseconds of eligible waiting cancel one unit of `queues[name].priority`.\n * `1` priority unit buys this much queue-jumping: with the default, a lane ranked 10 points\n * below another is overtaken once the lower lane has an eligible job that has been waiting\n * 10 minutes. Time is the only condition — nothing here runs on a cadence, and a lane that\n * is dispatched normally never ages far enough for the term to matter.\n */\nexport const DEFAULT_QUEUE_PRIORITY_AGING_UNIT_MS = 60000\n\n/**\n * Normalizes `backgroundJobs.queuePriorityAgingUnitMs`. Invalid values fall back to the\n * default; `null` opts out and restores the strict queue-priority ordering.\n * @param {unknown} value - Configured value.\n * @returns {number | null} - Milliseconds per priority unit, or null when aging is disabled.\n */\nexport function normalizeQueuePriorityAgingUnitMs(value) {\n  if (value === null) return null\n  if (value === undefined) return DEFAULT_QUEUE_PRIORITY_AGING_UNIT_MS\n  if (!Number.isFinite(value) || Number(value) <= 0) return DEFAULT_QUEUE_PRIORITY_AGING_UNIT_MS\n\n  return Number(value)\n}\n\n/**\n * Reads the configured aging unit.\n * @param {import(\"../configuration.js\").default} configuration - Active configuration.\n * @returns {number | null} - Milliseconds per priority unit, or null when aging is disabled.\n */\nexport function queuePriorityAgingUnitMs(configuration) {\n  return normalizeQueuePriorityAgingUnitMs(configuration.getBackgroundJobsConfig().queuePriorityAgingUnitMs)\n}\n\n/**\n * Builds the dispatch ranking expression for the queued-job claim.\n *\n * `queues[name].priority` alone is a strict global order: the claim takes one job per cycle,\n * so a lane only gets dispatched when every higher-priority lane is empty or already at its\n * own `maxConcurrent` cap. A lane whose cap is far above what the fleet can actually run —\n * a `builds` lane capped at 200 that never holds more than a dozen runners — is therefore\n * never skipped, and every lane below it receives zero claims for as long as it stays\n * non-empty.\n *\n * Aging adds the row's own eligible wait, scaled by the priority unit, and caps that wait per\n * lane at the gap between the lane and the highest configured priority plus one unit. The lane\n * service age is folded into this same primary rank, so a lane that has gone without a claim can\n * cross the global ceiling before its own row-age cap. The queue-keyed service term remains\n * constant within a lane, preserving the existing intra-lane ordering and ceiling alternation.\n *\n * Without a prior lane claim, the legacy row-age behavior remains the fallback. After a lane has\n * a durable claim stamp, its service age contributes directly to the rank, reducing the bound\n * from the full priority cap whenever another lane holds a deep aged backlog.\n * @param {object} args - Options.\n * @param {import(\"../configuration.js\").default} args.configuration - Active configuration.\n * @param {import(\"../database/drivers/base.js\").default} args.db - Connection.\n * @param {number} args.nowMs - Dispatch instant.\n * @param {string | null} [args.laneFairnessRank] - Raw lane fairness rank to fold into the primary rank.\n * @returns {string | null} - Raw SQL rank expression, or null when no queue is prioritized.\n */\nexport function buildQueuePriorityOrderSql({configuration, db, nowMs, laneFairnessRank}) {\n  const queues = configuration.getBackgroundJobsConfig().queues || {}\n  /** @type {Array<[string, number]>} */\n  const prioritized = []\n  let highestPriority = 0\n\n  for (const [queue, queueConfig] of Object.entries(queues)) {\n    const priority = queueConfig?.priority\n\n    if (!Number.isFinite(priority)) continue\n\n    if (Number(priority) !== 0) prioritized.push([queue, Number(priority)])\n\n    highestPriority = Math.max(highestPriority, Number(priority))\n  }\n\n  if (prioritized.length === 0) return null\n\n  const queueExpression = `COALESCE(${db.quoteColumn(\"queue\")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)})`\n  const priorityRank = `CASE ${queueExpression} ${prioritized.map(([queue, priority]) => `WHEN ${db.quote(queue)} THEN ${priority}`).join(\" \")} ELSE 0 END`\n  const unitMs = queuePriorityAgingUnitMs(configuration)\n\n  if (unitMs === null) return priorityRank\n\n  const highestCeilingMs = (highestPriority + 1) * unitMs\n  const agingCap = `CASE ${queueExpression} ${prioritized.map(([queue, priority]) => `WHEN ${db.quote(queue)} THEN ${(highestPriority - priority + 1) * unitMs}`).join(\" \")} ELSE ${highestCeilingMs} END`\n  const scheduledAtColumn = db.quoteColumn(\"scheduled_at_ms\")\n\n  const laneFairness = laneFairnessRank ? ` + (${laneFairnessRank})` : \"\"\n\n  return `(${priorityRank} * ${unitMs} + ` +\n    `CASE WHEN ${scheduledAtColumn} <= (${db.quote(nowMs)} - ${agingCap}) THEN ${agingCap} ` +\n    `ELSE (${db.quote(nowMs)} - ${scheduledAtColumn}) END${laneFairness})`\n}\n\n/**\n * The counter row that represents a lane: the queue's own concurrency counter. An explicit\n * `concurrencyKey` groups unrelated jobs, so it never names a lane.\n * @param {string} queue - Normalized queue name.\n * @returns {string} - Queue-derived concurrency key.\n */\nexport function laneConcurrencyKey(queue) {\n  return `${QUEUE_CONCURRENCY_KEY_PREFIX}${queue}`\n}\n\n/**\n * Builds the lane-fairness tie-break term for the queued-job claim: how long the candidate's\n * own lane has gone without receiving a claim, longest-starved-first.\n *\n * Reaching the aging ceiling is not the same as winning the claim. Because every lane converges\n * on the same ceiling, all aged lanes tie, and a tie broken by `scheduled_at_ms` is won\n * permanently by whichever lane holds the deepest aged backlog: a lane with one fresh row is\n * only served when the backlog lane reaches its own `maxConcurrent` cap, which never happens\n * when that cap is far above what the fleet can actually run. Ordering by time-since-last-claim\n * makes the ceiling tie alternate between starved lanes.\n *\n * The lane is the queue, not the candidate's concurrency counter. Most of a busy lane's rows can\n * sit under explicit per-group keys (TensorBuzz groups its `builds` backlog by\n * `cleanup-build-run-output-<build group id>`), and those keys are deliberately not stamped —\n * reading them would make the term equal the row's own age again and hand the tie back to the\n * deepest backlog, which is the monopoly this term exists to break. Every row of a queue\n * therefore reads its queue's counter, which keeps the term constant within a lane and leaves\n * intra-lane order untouched.\n *\n * A queue with no counter row (no configured `maxConcurrent`, or a queue name the configuration\n * does not declare), and a counter whose stamp is NULL, fall back to the row's own eligible wait,\n * which reproduces the previous `scheduled_at_ms ASC` ordering exactly.\n *\n * Returns null when aging is opted out (`queuePriorityAgingUnitMs: null`): opting out asks for\n * strict queue-priority ordering, so no time-based reordering is applied.\n * @param {object} args - Options.\n * @param {import(\"../configuration.js\").default} args.configuration - Active configuration.\n * @param {import(\"../database/drivers/base.js\").default} args.db - Connection.\n * @param {number} args.nowMs - Dispatch instant.\n * @param {string} args.jobsTable - Quoted jobs table name.\n * @param {string} args.concurrencyTable - Quoted concurrency counter table name.\n * @returns {string | null} - Raw SQL `ORDER BY … DESC` term, or null when not applicable.\n */\nexport function buildLaneFairnessOrderSql({configuration, db, nowMs, jobsTable, concurrencyTable}) {\n  if (queuePriorityAgingUnitMs(configuration) === null) return null\n\n  const queues = configuration.getBackgroundJobsConfig().queues || {}\n  const queueExpression = `COALESCE(${jobsTable}.${db.quoteColumn(\"queue\")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)})`\n  const laneKeyCase = `CASE ${queueExpression} ${Object.keys(queues).map((queue) => `WHEN ${db.quote(queue)} THEN ${db.quote(laneConcurrencyKey(queue))}`).join(\" \")} ELSE NULL END`\n  const lastClaimedLookup =\n    `(SELECT ${concurrencyTable}.${db.quoteColumn(\"last_claimed_at_ms\")} FROM ${concurrencyTable} ` +\n    `WHERE ${concurrencyTable}.${db.quoteColumn(\"concurrency_key\")} = ${laneKeyCase})`\n\n  return `(${Number(nowMs)} - COALESCE(${lastClaimedLookup}, ${jobsTable}.${db.quoteColumn(\"scheduled_at_ms\")})) DESC`\n}\n\n/**\n * Builds the raw lane-fairness rank used to compose the primary queue rank. A configured capped\n * lane without a claim stamp receives the full global ceiling boost as never-served work; a lane\n * without a durable queue counter contributes zero and keeps the historical row-age fallback.\n * A long-ago claim stamp contributes its full starvation age to the primary rank.\n * @param {object} args - Options.\n * @param {import(\"../configuration.js\").default} args.configuration - Active configuration.\n * @param {import(\"../database/drivers/base.js\").default} args.db - Connection.\n * @param {number} args.nowMs - Dispatch instant.\n * @param {string} args.jobsTable - Quoted jobs table name.\n * @param {string} args.concurrencyTable - Quoted concurrency counter table name.\n * @returns {string | null} - Raw SQL lane fairness rank, or null when not applicable.\n */\nexport function buildLaneFairnessRankSql({configuration, db, nowMs, jobsTable, concurrencyTable}) {\n  const unitMs = queuePriorityAgingUnitMs(configuration)\n  if (unitMs === null) return null\n\n  const queues = configuration.getBackgroundJobsConfig().queues || {}\n  const highestPriority = Math.max(0, ...Object.values(queues).map((queueConfig) => Number.isFinite(queueConfig?.priority) ? Number(queueConfig.priority) : 0))\n  const neverServedBoost = (highestPriority + 1) * unitMs\n  const queueExpression = `COALESCE(${jobsTable}.${db.quoteColumn(\"queue\")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)})`\n  const cappedQueues = Object.entries(queues).filter(([, queueConfig]) => Number.isInteger(queueConfig?.maxConcurrent) && Number(queueConfig.maxConcurrent) > 0)\n  // Only queues with a `maxConcurrent` get a durable lane counter. With none configured there is\n  // no counter row to read, and a `CASE` with no `WHEN` arms is invalid SQL, so no lane term applies.\n  if (cappedQueues.length === 0) return null\n  const laneKeyCase = `CASE ${queueExpression} ${cappedQueues.map(([queue]) => `WHEN ${db.quote(queue)} THEN ${db.quote(laneConcurrencyKey(queue))}`).join(\" \")} ELSE NULL END`\n  const lastClaimedLookup =\n    `(SELECT ${concurrencyTable}.${db.quoteColumn(\"last_claimed_at_ms\")} FROM ${concurrencyTable} ` +\n    `WHERE ${concurrencyTable}.${db.quoteColumn(\"concurrency_key\")} = ${laneKeyCase})`\n\n  return `(CASE WHEN ${laneKeyCase} IS NULL THEN 0 WHEN ${lastClaimedLookup} IS NULL THEN ${neverServedBoost} ELSE (${Number(nowMs)} - ${lastClaimedLookup}) END)`\n}\n"]}
177
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue-priority-order.js","sourceRoot":"","sources":["../../../src/background-jobs/queue-priority-order.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {DEFAULT_BACKGROUND_JOB_QUEUE, QUEUE_CONCURRENCY_KEY_PREFIX} from \"./job-semantics.js\"\n\n/**\n * How many milliseconds of eligible waiting cancel one unit of `queues[name].priority`.\n * `1` priority unit buys this much queue-jumping: with the default, a lane ranked 10 points\n * below another is overtaken once the lower lane has an eligible job that has been waiting\n * 10 minutes. Time is the only condition — nothing here runs on a cadence, and a lane that\n * is dispatched normally never ages far enough for the term to matter.\n */\nexport const DEFAULT_QUEUE_PRIORITY_AGING_UNIT_MS = 60000\n\n/**\n * Normalizes `backgroundJobs.queuePriorityAgingUnitMs`. Invalid values fall back to the\n * default; `null` opts out and restores the strict queue-priority ordering.\n * @param {unknown} value - Configured value.\n * @returns {number | null} - Milliseconds per priority unit, or null when aging is disabled.\n */\nexport function normalizeQueuePriorityAgingUnitMs(value) {\n  if (value === null) return null\n  if (value === undefined) return DEFAULT_QUEUE_PRIORITY_AGING_UNIT_MS\n  if (!Number.isFinite(value) || Number(value) <= 0) return DEFAULT_QUEUE_PRIORITY_AGING_UNIT_MS\n\n  return Number(value)\n}\n\n/**\n * Reads the configured aging unit.\n * @param {import(\"../configuration.js\").default} configuration - Active configuration.\n * @returns {number | null} - Milliseconds per priority unit, or null when aging is disabled.\n */\nexport function queuePriorityAgingUnitMs(configuration) {\n  return normalizeQueuePriorityAgingUnitMs(configuration.getBackgroundJobsConfig().queuePriorityAgingUnitMs)\n}\n\n/**\n * Builds the dispatch ranking expression for the queued-job claim.\n *\n * `queues[name].priority` alone is a strict global order: the claim takes one job per cycle,\n * so a lane only gets dispatched when every higher-priority lane is empty or already at its\n * own `maxConcurrent` cap. A lane whose cap is far above what the fleet can actually run —\n * a `builds` lane capped at 200 that never holds more than a dozen runners — is therefore\n * never skipped, and every lane below it receives zero claims for as long as it stays\n * non-empty.\n *\n * Aging adds the row's own eligible wait, scaled by the priority unit, and caps that wait per\n * lane at the gap between the lane and the highest configured priority plus one unit. The lane\n * service age is folded into this same primary rank, so a lane that has gone without a claim can\n * cross the global ceiling before its own row-age cap. The queue-keyed service term remains\n * constant within a lane, preserving the existing intra-lane ordering and ceiling alternation.\n *\n * Without a prior lane claim, the legacy row-age behavior remains the fallback. After a lane has\n * a durable claim stamp, its service age contributes directly to the rank, reducing the bound\n * from the full priority cap whenever another lane holds a deep aged backlog.\n * @param {object} args - Options.\n * @param {import(\"../configuration.js\").default} args.configuration - Active configuration.\n * @param {import(\"../database/drivers/base.js\").default} args.db - Connection.\n * @param {number} args.nowMs - Dispatch instant.\n * @param {string | null} [args.laneFairnessRank] - Raw lane fairness rank to fold into the primary rank.\n * @returns {string | null} - Raw SQL rank expression, or null when no queue is prioritized.\n */\nexport function buildQueuePriorityOrderSql({configuration, db, nowMs, laneFairnessRank}) {\n  const queues = configuration.getBackgroundJobsConfig().queues || {}\n  /** @type {Array<[string, number]>} */\n  const prioritized = []\n  let highestPriority = 0\n\n  for (const [queue, queueConfig] of Object.entries(queues)) {\n    const priority = queueConfig?.priority\n\n    if (!Number.isFinite(priority)) continue\n\n    if (Number(priority) !== 0) prioritized.push([queue, Number(priority)])\n\n    highestPriority = Math.max(highestPriority, Number(priority))\n  }\n\n  if (prioritized.length === 0) return null\n\n  const queueExpression = `COALESCE(${db.quoteColumn(\"queue\")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)})`\n  const priorityRank = `CASE ${queueExpression} ${prioritized.map(([queue, priority]) => `WHEN ${db.quote(queue)} THEN ${priority}`).join(\" \")} ELSE 0 END`\n  const unitMs = queuePriorityAgingUnitMs(configuration)\n\n  if (unitMs === null) return priorityRank\n\n  const highestCeilingMs = (highestPriority + 1) * unitMs\n  const agingCap = `CASE ${queueExpression} ${prioritized.map(([queue, priority]) => `WHEN ${db.quote(queue)} THEN ${(highestPriority - priority + 1) * unitMs}`).join(\" \")} ELSE ${highestCeilingMs} END`\n  const scheduledAtColumn = db.quoteColumn(\"scheduled_at_ms\")\n\n  const laneFairness = laneFairnessRank ? ` + (${laneFairnessRank})` : \"\"\n\n  return `(${priorityRank} * ${unitMs} + ` +\n    `CASE WHEN ${scheduledAtColumn} <= (${db.quote(nowMs)} - ${agingCap}) THEN ${agingCap} ` +\n    `ELSE (${db.quote(nowMs)} - ${scheduledAtColumn}) END${laneFairness})`\n}\n\n/**\n * The counter row that represents a lane: the queue's own concurrency counter. An explicit\n * `concurrencyKey` groups unrelated jobs, so it never names a lane.\n * @param {string} queue - Normalized queue name.\n * @returns {string} - Queue-derived concurrency key.\n */\nexport function laneConcurrencyKey(queue) {\n  return `${QUEUE_CONCURRENCY_KEY_PREFIX}${queue}`\n}\n\n/**\n * Builds the lane-fairness tie-break term for the queued-job claim: how long the candidate's\n * own lane has gone without receiving a claim, longest-starved-first.\n *\n * Reaching the aging ceiling is not the same as winning the claim. Because every lane converges\n * on the same ceiling, all aged lanes tie, and a tie broken by `scheduled_at_ms` is won\n * permanently by whichever lane holds the deepest aged backlog: a lane with one fresh row is\n * only served when the backlog lane reaches its own `maxConcurrent` cap, which never happens\n * when that cap is far above what the fleet can actually run. Ordering by time-since-last-claim\n * makes the ceiling tie alternate between starved lanes.\n *\n * The lane is the queue, not the candidate's concurrency counter. Most of a busy lane's rows can\n * sit under explicit per-group keys (TensorBuzz groups its `builds` backlog by\n * `cleanup-build-run-output-<build group id>`), and those keys are deliberately not stamped —\n * reading them would make the term equal the row's own age again and hand the tie back to the\n * deepest backlog, which is the monopoly this term exists to break. Every row of a queue\n * therefore reads its queue's counter, which keeps the term constant within a lane and leaves\n * intra-lane order untouched.\n *\n * A queue with no counter row (no configured `maxConcurrent`, or a queue name the configuration\n * does not declare), and a counter whose stamp is NULL, fall back to the row's own eligible wait,\n * which reproduces the previous `scheduled_at_ms ASC` ordering exactly.\n *\n * Returns null when aging is opted out (`queuePriorityAgingUnitMs: null`): opting out asks for\n * strict queue-priority ordering, so no time-based reordering is applied.\n * @param {object} args - Options.\n * @param {import(\"../configuration.js\").default} args.configuration - Active configuration.\n * @param {import(\"../database/drivers/base.js\").default} args.db - Connection.\n * @param {number} args.nowMs - Dispatch instant.\n * @param {string} args.jobsTable - Quoted jobs table name.\n * @param {string} args.concurrencyTable - Quoted concurrency counter table name.\n * @returns {string | null} - Raw SQL `ORDER BY … DESC` term, or null when not applicable.\n */\nexport function buildLaneFairnessOrderSql({configuration, db, nowMs, jobsTable, concurrencyTable}) {\n  if (queuePriorityAgingUnitMs(configuration) === null) return null\n\n  const queues = configuration.getBackgroundJobsConfig().queues || {}\n  const queueExpression = `COALESCE(${jobsTable}.${db.quoteColumn(\"queue\")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)})`\n  const laneKeyCase = `CASE ${queueExpression} ${Object.keys(queues).map((queue) => `WHEN ${db.quote(queue)} THEN ${db.quote(laneConcurrencyKey(queue))}`).join(\" \")} ELSE NULL END`\n  const lastClaimedLookup =\n    `(SELECT ${concurrencyTable}.${db.quoteColumn(\"last_claimed_at_ms\")} FROM ${concurrencyTable} ` +\n    `WHERE ${concurrencyTable}.${db.quoteColumn(\"concurrency_key\")} = ${laneKeyCase})`\n\n  return `(${Number(nowMs)} - COALESCE(${lastClaimedLookup}, ${jobsTable}.${db.quoteColumn(\"scheduled_at_ms\")})) DESC`\n}\n\n/**\n * Builds the raw lane-fairness rank used to compose the primary queue rank. A configured capped\n * lane without a claim stamp contributes no service-age bonus: without a claim there is no\n * lane-service history to rank. Once its row reaches its own cap, its configured priority is\n * retained as a small primary-key tie signal so a deep backlog cannot win solely by row age. A\n * long-ago claim stamp contributes its full starvation age to the primary rank. A lane without a\n * durable queue counter contributes zero and keeps the historical row-age fallback.\n * @param {object} args - Options.\n * @param {import(\"../configuration.js\").default} args.configuration - Active configuration.\n * @param {import(\"../database/drivers/base.js\").default} args.db - Connection.\n * @param {number} args.nowMs - Dispatch instant.\n * @param {string} args.jobsTable - Quoted jobs table name.\n * @param {string} args.concurrencyTable - Quoted concurrency counter table name.\n * @returns {string | null} - Raw SQL lane fairness rank, or null when not applicable.\n */\nexport function buildLaneFairnessRankSql({configuration, db, nowMs, jobsTable, concurrencyTable}) {\n  const unitMs = queuePriorityAgingUnitMs(configuration)\n  if (unitMs === null) return null\n\n  const queues = configuration.getBackgroundJobsConfig().queues || {}\n  const highestPriority = Math.max(0, ...Object.values(queues).map((queueConfig) => Number.isFinite(queueConfig?.priority) ? Number(queueConfig.priority) : 0))\n  const queueExpression = `COALESCE(${jobsTable}.${db.quoteColumn(\"queue\")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)})`\n  const cappedQueues = Object.entries(queues).filter(([, queueConfig]) => Number.isInteger(queueConfig?.maxConcurrent) && Number(queueConfig.maxConcurrent) > 0)\n  // Only queues with a `maxConcurrent` get a durable lane counter. With none configured there is\n  // no counter row to read, and a `CASE` with no `WHEN` arms is invalid SQL, so no lane term applies.\n  if (cappedQueues.length === 0) return null\n  const laneKeyCase = `CASE ${queueExpression} ${cappedQueues.map(([queue]) => `WHEN ${db.quote(queue)} THEN ${db.quote(laneConcurrencyKey(queue))}`).join(\" \")} ELSE NULL END`\n  const lastClaimedLookup =\n    `(SELECT ${concurrencyTable}.${db.quoteColumn(\"last_claimed_at_ms\")} FROM ${concurrencyTable} ` +\n    `WHERE ${concurrencyTable}.${db.quoteColumn(\"concurrency_key\")} = ${laneKeyCase})`\n\n  const neverServedTie = `CASE ${queueExpression} ${cappedQueues.map(([queue, queueConfig]) => {\n    const priority = Number.isFinite(queueConfig?.priority) ? Number(queueConfig.priority) : 0\n    const agingCap = (highestPriority - priority + 1) * unitMs\n    return `WHEN ${db.quote(queue)} THEN CASE WHEN ${jobsTable}.${db.quoteColumn(\"scheduled_at_ms\")} <= (${Number(nowMs)} - ${agingCap}) THEN ${priority} ELSE 0 END`\n  }).join(\" \")} ELSE 0 END`\n\n  return `(CASE WHEN ${laneKeyCase} IS NULL THEN 0 WHEN ${lastClaimedLookup} IS NULL THEN (${neverServedTie}) ELSE (${Number(nowMs)} - ${lastClaimedLookup}) END)`\n}\n"]}
package/package.json CHANGED
@@ -3,7 +3,7 @@
3
3
  "velocious": "build/bin/velocious.js"
4
4
  },
5
5
  "name": "velocious",
6
- "version": "1.0.739",
6
+ "version": "1.0.740",
7
7
  "main": "build/index.js",
8
8
  "types": "build/index.d.ts",
9
9
  "files": [
@@ -153,9 +153,11 @@ export function buildLaneFairnessOrderSql({configuration, db, nowMs, jobsTable,
153
153
 
154
154
  /**
155
155
  * Builds the raw lane-fairness rank used to compose the primary queue rank. A configured capped
156
- * lane without a claim stamp receives the full global ceiling boost as never-served work; a lane
157
- * without a durable queue counter contributes zero and keeps the historical row-age fallback.
158
- * A long-ago claim stamp contributes its full starvation age to the primary rank.
156
+ * lane without a claim stamp contributes no service-age bonus: without a claim there is no
157
+ * lane-service history to rank. Once its row reaches its own cap, its configured priority is
158
+ * retained as a small primary-key tie signal so a deep backlog cannot win solely by row age. A
159
+ * long-ago claim stamp contributes its full starvation age to the primary rank. A lane without a
160
+ * durable queue counter contributes zero and keeps the historical row-age fallback.
159
161
  * @param {object} args - Options.
160
162
  * @param {import("../configuration.js").default} args.configuration - Active configuration.
161
163
  * @param {import("../database/drivers/base.js").default} args.db - Connection.
@@ -170,7 +172,6 @@ export function buildLaneFairnessRankSql({configuration, db, nowMs, jobsTable, c
170
172
 
171
173
  const queues = configuration.getBackgroundJobsConfig().queues || {}
172
174
  const highestPriority = Math.max(0, ...Object.values(queues).map((queueConfig) => Number.isFinite(queueConfig?.priority) ? Number(queueConfig.priority) : 0))
173
- const neverServedBoost = (highestPriority + 1) * unitMs
174
175
  const queueExpression = `COALESCE(${jobsTable}.${db.quoteColumn("queue")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)})`
175
176
  const cappedQueues = Object.entries(queues).filter(([, queueConfig]) => Number.isInteger(queueConfig?.maxConcurrent) && Number(queueConfig.maxConcurrent) > 0)
176
177
  // Only queues with a `maxConcurrent` get a durable lane counter. With none configured there is
@@ -181,5 +182,11 @@ export function buildLaneFairnessRankSql({configuration, db, nowMs, jobsTable, c
181
182
  `(SELECT ${concurrencyTable}.${db.quoteColumn("last_claimed_at_ms")} FROM ${concurrencyTable} ` +
182
183
  `WHERE ${concurrencyTable}.${db.quoteColumn("concurrency_key")} = ${laneKeyCase})`
183
184
 
184
- return `(CASE WHEN ${laneKeyCase} IS NULL THEN 0 WHEN ${lastClaimedLookup} IS NULL THEN ${neverServedBoost} ELSE (${Number(nowMs)} - ${lastClaimedLookup}) END)`
185
+ const neverServedTie = `CASE ${queueExpression} ${cappedQueues.map(([queue, queueConfig]) => {
186
+ const priority = Number.isFinite(queueConfig?.priority) ? Number(queueConfig.priority) : 0
187
+ const agingCap = (highestPriority - priority + 1) * unitMs
188
+ return `WHEN ${db.quote(queue)} THEN CASE WHEN ${jobsTable}.${db.quoteColumn("scheduled_at_ms")} <= (${Number(nowMs)} - ${agingCap}) THEN ${priority} ELSE 0 END`
189
+ }).join(" ")} ELSE 0 END`
190
+
191
+ return `(CASE WHEN ${laneKeyCase} IS NULL THEN 0 WHEN ${lastClaimedLookup} IS NULL THEN (${neverServedTie}) ELSE (${Number(nowMs)} - ${lastClaimedLookup}) END)`
185
192
  }