@dbos-inc/dbos-sdk 4.26.10 → 4.27.3-preview

package/dist/src/wfqueue.d.ts

@@ -21,21 +21,32 @@ export interface QueueRateLimit {
 }
 /**
  * Limit the number of concurrent workflows running for a queue.
- * This limit may be per worker or global
+ *
+ * Queue-wide limits bound the queue as a whole. Setting any `partition` limit
+ * additionally partitions the queue, so every enqueue must supply a partition
+ * key, and that limit is then enforced separately within each partition.
  */
 export interface QueueParameters {
     /** If defined, this limits the number of running workflows for a single DBOS process */
     workerConcurrency?: number;
     /** If defined, this limits the number of running workflows globally in the app */
-    concurrency?: number;
+    globalConcurrency?: number;
     /** If set, this limits the rate at which queued workflows are started */
     rateLimit?: QueueRateLimit;
-    /** If set, this queue supports priority */
-    priorityEnabled?: boolean;
-    /** If set, this queue supports partitioning */
-    partitionQueue?: boolean;
+    /** If defined, this limits the number of running workflows globally within each partition */
+    partitionConcurrency?: number;
+    /** If defined, this limits the number of running workflows on a single DBOS process within each partition */
+    partitionWorkerConcurrency?: number;
+    /** If set, this limits the rate at which queued workflows are started within each partition */
+    partitionRateLimit?: QueueRateLimit;
     /** Base (minimum) polling interval in ms for this queue's dispatch loop (default 1000) */
     minPollingIntervalMs?: number;
+    /** @deprecated Use `globalConcurrency`. */
+    concurrency?: number;
+    /** @deprecated Priority is always enabled. */
+    priorityEnabled?: boolean;
+    /** @deprecated Use the partition limits, any of which partitions the queue. */
+    partitionQueue?: boolean;
 }
 /**
  * Behavior of `DBOS.registerQueue` / `DBOSClient.registerQueue` when a queue
@@ -53,6 +64,17 @@ export interface RegisterQueueOptions extends QueueParameters {
     /** How to behave when a queue with the same name already exists. */
     onConflict?: QueueConflictResolution;
 }
+/** A queue's limits, each resolved to the scope it is enforced at. */
+export interface ResolvedQueueLimits {
+    globalConcurrency?: number;
+    workerConcurrency?: number;
+    rateLimit?: QueueRateLimit;
+    partitionConcurrency?: number;
+    partitionWorkerConcurrency?: number;
+    partitionRateLimit?: QueueRateLimit;
+}
+/** Resolve every limit on a queue to the scope it is actually enforced at. */
+export declare function resolveQueueLimits(q: WorkflowQueue): ResolvedQueueLimits;
 /**
  * Settings structure for a named workflow queue.
  * Workflow queues limit the rate and concurrency at which DBOS executes workflows.
@@ -70,6 +92,9 @@ export declare class WorkflowQueue {
     workerConcurrency?: number;
     priorityEnabled: boolean;
     partitionQueue: boolean;
+    partitionConcurrency?: number;
+    partitionWorkerConcurrency?: number;
+    partitionRateLimit?: QueueRateLimit;
     minPollingIntervalMs?: number;
     /** Owner from the queues table; undefined for in-memory and unclaimed queues. */
     applicationName?: string;
@@ -105,16 +130,30 @@ export declare class WorkflowQueue {
      * @internal
      */
     static _fromRecord(record: QueueRecord, clientSystemDatabase?: SystemDatabase): WorkflowQueue;
+    /** @deprecated Use `setGlobalConcurrency`. */
     setConcurrency(value: number | undefined): Promise<void>;
+    setGlobalConcurrency(value: number | undefined): Promise<void>;
     setWorkerConcurrency(value: number | undefined): Promise<void>;
     setRateLimit(value: QueueRateLimit | undefined): Promise<void>;
+    setPartitionConcurrency(value: number | undefined): Promise<void>;
+    setPartitionWorkerConcurrency(value: number | undefined): Promise<void>;
+    setPartitionRateLimit(value: QueueRateLimit | undefined): Promise<void>;
+    /** @deprecated Priority is always enabled. */
     setPriorityEnabled(value: boolean): Promise<void>;
+    /** @deprecated Use the partition limit setters. */
     setPartitionQueue(value: boolean): Promise<void>;
     setMinPollingIntervalMs(value: number): Promise<void>;
+    /** @deprecated Use `getGlobalConcurrency`. */
     getConcurrency(): Promise<number | undefined>;
+    getGlobalConcurrency(): Promise<number | undefined>;
     getWorkerConcurrency(): Promise<number | undefined>;
     getRateLimit(): Promise<QueueRateLimit | undefined>;
+    getPartitionConcurrency(): Promise<number | undefined>;
+    getPartitionWorkerConcurrency(): Promise<number | undefined>;
+    getPartitionRateLimit(): Promise<QueueRateLimit | undefined>;
+    /** @deprecated Priority is always enabled. */
     getPriorityEnabled(): Promise<boolean>;
+    /** @deprecated Use the partition limit getters. */
     getPartitionQueue(): Promise<boolean>;
     getMinPollingIntervalMs(): Promise<number | undefined>;
 }

package/dist/src/wfqueue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wfqueue.d.ts","sourceRoot":"","sources":["../../src/wfqueue.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"wfqueue.d.ts","sourceRoot":"","sources":["../../src/wfqueue.ts"],"names":[],"mappings":"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"}

package/dist/src/wfqueue.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wfQueueRunner = exports.WorkflowQueue = exports.logQueue = void 0;
+exports.wfQueueRunner = exports.WorkflowQueue = exports.resolveQueueLimits = exports.logQueue = void 0;
 const dbos_executor_1 = require("./dbos-executor");
 const dbos_1 = require("./dbos");
 const debugpoint_1 = require("./debugpoint");
@@ -12,12 +12,22 @@ const utils_1 = require("./utils");
  */
 function logQueue(logger, q) {
     const opts = [];
-    if (q.concurrency !== undefined)
-        opts.push(`concurrency=${q.concurrency}`);
+    if (q.concurrency !== undefined) {
+        // On a partitioned queue the queue-wide scope is worth naming explicitly.
+        opts.push(`${hasPartitionLimits(q) ? 'global_concurrency' : 'concurrency'}=${q.concurrency}`);
+    }
     if (q.workerConcurrency !== undefined)
         opts.push(`worker_concurrency=${q.workerConcurrency}`);
     if (q.rateLimit !== undefined)
         opts.push(`limit=${q.rateLimit.limitPerPeriod}/${q.rateLimit.periodSec}s`);
+    if (q.partitionConcurrency !== undefined)
+        opts.push(`partition_concurrency=${q.partitionConcurrency}`);
+    if (q.partitionWorkerConcurrency !== undefined) {
+        opts.push(`partition_worker_concurrency=${q.partitionWorkerConcurrency}`);
+    }
+    if (q.partitionRateLimit !== undefined) {
+        opts.push(`partition_limit=${q.partitionRateLimit.limitPerPeriod}/${q.partitionRateLimit.periodSec}s`);
+    }
     if (q.priorityEnabled)
         opts.push('priority');
     if (q.partitionQueue)
@@ -26,6 +36,67 @@ function logQueue(logger, q) {
     logger.info(`Queue: ${q.name}${optsStr}`);
 }
 exports.logQueue = logQueue;
+/** True when any per-partition limit is set, which is what partitions a queue. */
+function hasPartitionLimits(limits) {
+    return (limits.partitionConcurrency !== undefined ||
+        limits.partitionWorkerConcurrency !== undefined ||
+        limits.partitionRateLimit !== undefined);
+}
+/**
+ * True for the deprecated `partitionQueue` mode, under which `concurrency`,
+ * `workerConcurrency`, and `rateLimit` all apply per partition.
+ */
+function isLegacyPartitioned(q) {
+    return q.partitionQueue && !hasPartitionLimits(q);
+}
+/** Resolve every limit on a queue to the scope it is actually enforced at. */
+function resolveQueueLimits(q) {
+    if (isLegacyPartitioned(q)) {
+        return {
+            partitionConcurrency: q.concurrency,
+            partitionWorkerConcurrency: q.workerConcurrency,
+            partitionRateLimit: q.rateLimit,
+        };
+    }
+    return {
+        globalConcurrency: q.concurrency,
+        workerConcurrency: q.workerConcurrency,
+        rateLimit: q.rateLimit,
+        partitionConcurrency: q.partitionConcurrency,
+        partitionWorkerConcurrency: q.partitionWorkerConcurrency,
+        partitionRateLimit: q.partitionRateLimit,
+    };
+}
+exports.resolveQueueLimits = resolveQueueLimits;
+/**
+ * Room left under this worker's queue-wide concurrency limit, given how many of
+ * its workflows are already running or claimed.
+ */
+function workerBudget(limits, running) {
+    if (limits.partitionWorkerConcurrency !== undefined && limits.partitionWorkerConcurrency <= 0) {
+        // Zero per partition pauses this worker; the batched sweep enforces no per-partition worker limit of its own.
+        return 0;
+    }
+    if (limits.workerConcurrency === undefined) {
+        // A non-zero per-partition worker limit is enforced per partition instead.
+        return Infinity;
+    }
+    return Math.max(0, limits.workerConcurrency - running);
+}
+/** 40001 serialization_failure or 55P03 lock_not_available: a peer is claiming the same rows. */
+function isContentionError(e) {
+    const code = e.code;
+    return code === '40001' || code === '55P03';
+}
+/** Fisher-Yates copy, so a sweep visits partitions in a different order each poll. */
+function shuffled(items) {
+    const result = [...items];
+    for (let i = result.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}
 /**
  * Per-instance association of a client-bound queue to its `SystemDatabase`.
  * Stored off-class because any class member — including TS `private` — gives
@@ -49,6 +120,54 @@ function sysDBFor(q) {
     }
     return exec.systemDatabase;
 }
+/** Reject a write that would silently re-scope the other limits on a legacy queue. */
+function requireNotLegacyPartitioned(q, field) {
+    if (isLegacyPartitioned(q)) {
+        throw new Error(`Cannot set ${field} on queue ${q.name}: it is registered with the deprecated partitionQueue option, ` +
+            `under which concurrency, workerConcurrency, and rateLimit apply per partition. ` +
+            `Re-register the queue with the partition limits instead.`);
+    }
+}
+/** Validate a new queue-wide concurrency against the queue's other cached limits. */
+function checkConcurrencyBounds(q, value) {
+    if (value === undefined)
+        return;
+    if (q.workerConcurrency !== undefined && q.workerConcurrency > value) {
+        throw new Error('workerConcurrency must be less than or equal to concurrency');
+    }
+    if (q.partitionConcurrency !== undefined && q.partitionConcurrency > value) {
+        throw new Error('partitionConcurrency must be less than or equal to globalConcurrency');
+    }
+    if (q.partitionWorkerConcurrency !== undefined && q.partitionWorkerConcurrency > value) {
+        throw new Error('partitionWorkerConcurrency must be less than or equal to concurrency');
+    }
+}
+/** Whether the queue is still partitioned once these limits take these values. */
+function partitionedAfter(q, overrides) {
+    return hasPartitionLimits({
+        partitionConcurrency: q.partitionConcurrency,
+        partitionWorkerConcurrency: q.partitionWorkerConcurrency,
+        partitionRateLimit: q.partitionRateLimit,
+        ...overrides,
+    });
+}
+function rateLimitFromRecord(max, periodSec) {
+    return max !== null && periodSec !== null ? { limitPerPeriod: max, periodSec } : undefined;
+}
+/** Copy a persisted row's configuration onto a queue instance. */
+function applyRecord(q, record) {
+    q.concurrency = record.concurrency ?? undefined;
+    q.workerConcurrency = record.workerConcurrency ?? undefined;
+    q.rateLimit = rateLimitFromRecord(record.rateLimitMax, record.rateLimitPeriodSec);
+    q.priorityEnabled = record.priorityEnabled;
+    q.partitionConcurrency = record.partitionConcurrency ?? undefined;
+    q.partitionWorkerConcurrency = record.partitionWorkerConcurrency ?? undefined;
+    q.partitionRateLimit = rateLimitFromRecord(record.partitionRateLimitMax, record.partitionRateLimitPeriodSec);
+    // Partitioning is inferred from the limits, so a row whose flag disagrees with them heals on read.
+    q.partitionQueue = record.partitionQueue || hasPartitionLimits(q);
+    q.minPollingIntervalMs = record.pollingIntervalSec * 1000;
+    q.applicationName = record.applicationName;
+}
 /**
  * Re-read the queue's row from the database and update the cached fields on
  * `q` in place. No-op for in-memory queues. Throws if the row has been
@@ -61,16 +180,7 @@ async function refreshFromDb(q) {
     if (record === null) {
         throw new Error(`Queue '${q.name}' was not found in the database.`);
     }
-    q.concurrency = record.concurrency ?? undefined;
-    q.workerConcurrency = record.workerConcurrency ?? undefined;
-    q.rateLimit =
-        record.rateLimitMax !== null && record.rateLimitPeriodSec !== null
-            ? { limitPerPeriod: record.rateLimitMax, periodSec: record.rateLimitPeriodSec }
-            : undefined;
-    q.priorityEnabled = record.priorityEnabled;
-    q.partitionQueue = record.partitionQueue;
-    q.minPollingIntervalMs = record.pollingIntervalSec * 1000;
-    q.applicationName = record.applicationName;
+    applyRecord(q, record);
 }
 /**
  * Settings structure for a named workflow queue.
@@ -89,6 +199,9 @@ class WorkflowQueue {
     workerConcurrency;
     priorityEnabled = false;
     partitionQueue = false;
+    partitionConcurrency;
+    partitionWorkerConcurrency;
+    partitionRateLimit;
     minPollingIntervalMs;
     /** Owner from the queues table; undefined for in-memory and unclaimed queues. */
     applicationName;
@@ -120,11 +233,15 @@ class WorkflowQueue {
             params = { concurrency: arg2, rateLimit };
         }
         WorkflowQueue.validateQueueParams(params);
-        this.concurrency = params.concurrency;
+        this.concurrency = params.globalConcurrency ?? params.concurrency;
         this.rateLimit = params.rateLimit;
         this.workerConcurrency = params.workerConcurrency;
         this.priorityEnabled = params.priorityEnabled ?? false;
-        this.partitionQueue = params.partitionQueue ?? false;
+        this.partitionConcurrency = params.partitionConcurrency;
+        this.partitionWorkerConcurrency = params.partitionWorkerConcurrency;
+        this.partitionRateLimit = params.partitionRateLimit;
+        // Partitioning is inferred from any per-partition limit; the deprecated flag tracks it.
+        this.partitionQueue = (params.partitionQueue ?? false) || hasPartitionLimits(params);
         this.minPollingIntervalMs = params.minPollingIntervalMs;
         if (exports.wfQueueRunner.wfQueuesByName.has(name)) {
             throw Error(`Workflow Queue '${name}' defined multiple times`);
@@ -133,10 +250,51 @@ class WorkflowQueue {
     }
     /** Throws if any combination of queue parameters is invalid. */
     static validateQueueParams(params) {
-        const { concurrency, workerConcurrency, rateLimit, minPollingIntervalMs } = params;
-        if (workerConcurrency !== undefined && concurrency !== undefined && workerConcurrency > concurrency) {
+        const { concurrency, globalConcurrency, workerConcurrency, rateLimit, partitionConcurrency, partitionWorkerConcurrency, partitionRateLimit, partitionQueue, minPollingIntervalMs, } = params;
+        if (concurrency !== undefined && globalConcurrency !== undefined) {
+            throw new Error('concurrency is deprecated in favor of globalConcurrency; set only one of them');
+        }
+        if (partitionQueue && hasPartitionLimits(params)) {
+            throw new Error('partitionQueue is deprecated in favor of the partition limits; set only one of them');
+        }
+        if (partitionQueue && globalConcurrency !== undefined) {
+            throw new Error('partitionQueue applies every limit per partition, so it cannot be combined with globalConcurrency; use partitionConcurrency instead');
+        }
+        if (partitionConcurrency !== undefined && partitionConcurrency < 1) {
+            throw new Error('partitionConcurrency must be at least 1');
+        }
+        if (partitionWorkerConcurrency !== undefined && partitionWorkerConcurrency < 1) {
+            throw new Error('partitionWorkerConcurrency must be at least 1');
+        }
+        if (partitionRateLimit !== undefined &&
+            (partitionRateLimit.limitPerPeriod === undefined || partitionRateLimit.periodSec === undefined)) {
+            throw new Error('partitionRateLimit must specify both limitPerPeriod and periodSec');
+        }
+        if (partitionWorkerConcurrency !== undefined &&
+            partitionConcurrency !== undefined &&
+            partitionWorkerConcurrency > partitionConcurrency) {
+            throw new Error('partitionConcurrency must be greater than or equal to partitionWorkerConcurrency');
+        }
+        if (partitionWorkerConcurrency !== undefined &&
+            workerConcurrency !== undefined &&
+            partitionWorkerConcurrency > workerConcurrency) {
+            throw new Error('workerConcurrency must be greater than or equal to partitionWorkerConcurrency');
+        }
+        // Under the deprecated partitionQueue mode concurrency is itself a per-partition limit, so these compare like with like.
+        const queueConcurrency = globalConcurrency ?? concurrency;
+        if (workerConcurrency !== undefined && queueConcurrency !== undefined && workerConcurrency > queueConcurrency) {
             throw new Error('concurrency must be greater than or equal to workerConcurrency');
         }
+        if (partitionConcurrency !== undefined &&
+            queueConcurrency !== undefined &&
+            partitionConcurrency > queueConcurrency) {
+            throw new Error('globalConcurrency must be greater than or equal to partitionConcurrency');
+        }
+        if (partitionWorkerConcurrency !== undefined &&
+            queueConcurrency !== undefined &&
+            partitionWorkerConcurrency > queueConcurrency) {
+            throw new Error('concurrency must be greater than or equal to partitionWorkerConcurrency');
+        }
         if (minPollingIntervalMs !== undefined && minPollingIntervalMs <= 0) {
             throw new Error('minPollingIntervalMs must be positive');
         }
@@ -148,12 +306,17 @@ class WorkflowQueue {
     static recordFromParams(name, params) {
         return {
             name,
-            concurrency: params.concurrency ?? null,
+            concurrency: params.globalConcurrency ?? params.concurrency ?? null,
             workerConcurrency: params.workerConcurrency ?? null,
             rateLimitMax: params.rateLimit ? params.rateLimit.limitPerPeriod : null,
             rateLimitPeriodSec: params.rateLimit ? params.rateLimit.periodSec : null,
             priorityEnabled: params.priorityEnabled ?? false,
-            partitionQueue: params.partitionQueue ?? false,
+            // Any per-partition limit implies partitioning, whichever mode was used.
+            partitionQueue: (params.partitionQueue ?? false) || hasPartitionLimits(params),
+            partitionConcurrency: params.partitionConcurrency ?? null,
+            partitionWorkerConcurrency: params.partitionWorkerConcurrency ?? null,
+            partitionRateLimitMax: params.partitionRateLimit ? params.partitionRateLimit.limitPerPeriod : null,
+            partitionRateLimitPeriodSec: params.partitionRateLimit ? params.partitionRateLimit.periodSec : null,
             pollingIntervalSec: (params.minPollingIntervalMs ?? 1000) / 1000,
         };
     }
@@ -168,35 +331,42 @@ class WorkflowQueue {
         // in `wfQueuesByName`) and strip `readonly` so we can set the fields here.
         const q = Object.create(WorkflowQueue.prototype);
         q.name = record.name;
-        q.concurrency = record.concurrency ?? undefined;
-        q.workerConcurrency = record.workerConcurrency ?? undefined;
-        q.rateLimit =
-            record.rateLimitMax !== null && record.rateLimitPeriodSec !== null
-                ? { limitPerPeriod: record.rateLimitMax, periodSec: record.rateLimitPeriodSec }
-                : undefined;
-        q.priorityEnabled = record.priorityEnabled;
-        q.partitionQueue = record.partitionQueue;
-        q.minPollingIntervalMs = record.pollingIntervalSec * 1000;
-        q.applicationName = record.applicationName;
         q.databaseBacked = true;
         q.clientBound = clientSystemDatabase !== undefined;
+        applyRecord(q, record);
         if (clientSystemDatabase !== undefined) {
             clientSystemDatabases.set(q, clientSystemDatabase);
         }
         return q;
     }
+    /** @deprecated Use `setGlobalConcurrency`. */
     async setConcurrency(value) {
         requireDatabaseBacked(this);
-        if (value !== undefined && this.workerConcurrency !== undefined && this.workerConcurrency > value) {
-            throw new Error('workerConcurrency must be less than or equal to concurrency');
-        }
+        // Refresh so the cross-field checks see the limits currently stored in the database.
+        await refreshFromDb(this);
+        checkConcurrencyBounds(this, value);
+        await sysDBFor(this).updateQueue(this.name, { concurrency: value ?? null });
+        this.concurrency = value;
+    }
+    async setGlobalConcurrency(value) {
+        requireDatabaseBacked(this);
+        await refreshFromDb(this);
+        requireNotLegacyPartitioned(this, 'globalConcurrency');
+        checkConcurrencyBounds(this, value);
         await sysDBFor(this).updateQueue(this.name, { concurrency: value ?? null });
         this.concurrency = value;
     }
     async setWorkerConcurrency(value) {
         requireDatabaseBacked(this);
-        if (value !== undefined && this.concurrency !== undefined && value > this.concurrency) {
-            throw new Error('workerConcurrency must be less than or equal to concurrency');
+        await refreshFromDb(this);
+        requireNotLegacyPartitioned(this, 'workerConcurrency');
+        if (value !== undefined) {
+            if (this.concurrency !== undefined && value > this.concurrency) {
+                throw new Error('workerConcurrency must be less than or equal to concurrency');
+            }
+            if (this.partitionWorkerConcurrency !== undefined && this.partitionWorkerConcurrency > value) {
+                throw new Error('partitionWorkerConcurrency must be less than or equal to workerConcurrency');
+            }
         }
         await sysDBFor(this).updateQueue(this.name, { workerConcurrency: value ?? null });
         this.workerConcurrency = value;
@@ -206,19 +376,95 @@ class WorkflowQueue {
         if (value !== undefined && (value.limitPerPeriod === undefined || value.periodSec === undefined)) {
             throw new Error('rateLimit must specify both limitPerPeriod and periodSec');
         }
+        // Refresh so the check below sees the partition limits currently stored in the database.
+        await refreshFromDb(this);
+        requireNotLegacyPartitioned(this, 'rateLimit');
         await sysDBFor(this).updateQueue(this.name, {
             rateLimitMax: value ? value.limitPerPeriod : null,
             rateLimitPeriodSec: value ? value.periodSec : null,
         });
         this.rateLimit = value;
     }
+    async setPartitionConcurrency(value) {
+        requireDatabaseBacked(this);
+        if (value !== undefined && value < 1) {
+            throw new Error('partitionConcurrency must be at least 1');
+        }
+        await refreshFromDb(this);
+        requireNotLegacyPartitioned(this, 'partitionConcurrency');
+        if (value !== undefined) {
+            if (this.concurrency !== undefined && value > this.concurrency) {
+                throw new Error('partitionConcurrency must be less than or equal to globalConcurrency');
+            }
+            if (this.partitionWorkerConcurrency !== undefined && this.partitionWorkerConcurrency > value) {
+                throw new Error('partitionConcurrency must be greater than or equal to partitionWorkerConcurrency');
+            }
+        }
+        // Partitioning is inferred from the limits, so the deprecated flag follows them.
+        const partitioned = partitionedAfter(this, { partitionConcurrency: value });
+        await sysDBFor(this).updateQueue(this.name, {
+            partitionConcurrency: value ?? null,
+            partitionQueue: partitioned,
+        });
+        this.partitionConcurrency = value;
+        this.partitionQueue = partitioned;
+    }
+    async setPartitionWorkerConcurrency(value) {
+        requireDatabaseBacked(this);
+        if (value !== undefined && value < 1) {
+            throw new Error('partitionWorkerConcurrency must be at least 1');
+        }
+        await refreshFromDb(this);
+        requireNotLegacyPartitioned(this, 'partitionWorkerConcurrency');
+        if (value !== undefined) {
+            if (this.partitionConcurrency !== undefined && value > this.partitionConcurrency) {
+                throw new Error('partitionWorkerConcurrency must be less than or equal to partitionConcurrency');
+            }
+            if (this.workerConcurrency !== undefined && value > this.workerConcurrency) {
+                throw new Error('partitionWorkerConcurrency must be less than or equal to workerConcurrency');
+            }
+            if (this.concurrency !== undefined && value > this.concurrency) {
+                throw new Error('partitionWorkerConcurrency must be less than or equal to concurrency');
+            }
+        }
+        const partitioned = partitionedAfter(this, { partitionWorkerConcurrency: value });
+        await sysDBFor(this).updateQueue(this.name, {
+            partitionWorkerConcurrency: value ?? null,
+            partitionQueue: partitioned,
+        });
+        this.partitionWorkerConcurrency = value;
+        this.partitionQueue = partitioned;
+    }
+    async setPartitionRateLimit(value) {
+        requireDatabaseBacked(this);
+        if (value !== undefined && (value.limitPerPeriod === undefined || value.periodSec === undefined)) {
+            throw new Error('partitionRateLimit must specify both limitPerPeriod and periodSec');
+        }
+        await refreshFromDb(this);
+        requireNotLegacyPartitioned(this, 'partitionRateLimit');
+        const partitioned = partitionedAfter(this, { partitionRateLimit: value });
+        await sysDBFor(this).updateQueue(this.name, {
+            partitionRateLimitMax: value ? value.limitPerPeriod : null,
+            partitionRateLimitPeriodSec: value ? value.periodSec : null,
+            partitionQueue: partitioned,
+        });
+        this.partitionRateLimit = value;
+        this.partitionQueue = partitioned;
+    }
+    /** @deprecated Priority is always enabled. */
     async setPriorityEnabled(value) {
         requireDatabaseBacked(this);
         await sysDBFor(this).updateQueue(this.name, { priorityEnabled: value });
         this.priorityEnabled = value;
     }
+    /** @deprecated Use the partition limit setters. */
     async setPartitionQueue(value) {
         requireDatabaseBacked(this);
+        // Refresh so the check below sees the partition limits currently stored in the database.
+        await refreshFromDb(this);
+        if (hasPartitionLimits(this)) {
+            throw new Error(`Cannot set partitionQueue on queue ${this.name}: it is partitioned by its partition limits. Clear those instead.`);
+        }
         await sysDBFor(this).updateQueue(this.name, { partitionQueue: value });
         this.partitionQueue = value;
     }
@@ -230,22 +476,41 @@ class WorkflowQueue {
         await sysDBFor(this).updateQueue(this.name, { pollingIntervalSec: value / 1000 });
         this.minPollingIntervalMs = value;
     }
+    /** @deprecated Use `getGlobalConcurrency`. */
     async getConcurrency() {
         await refreshFromDb(this);
         return this.concurrency;
     }
+    async getGlobalConcurrency() {
+        await refreshFromDb(this);
+        return resolveQueueLimits(this).globalConcurrency;
+    }
     async getWorkerConcurrency() {
         await refreshFromDb(this);
-        return this.workerConcurrency;
+        return resolveQueueLimits(this).workerConcurrency;
     }
     async getRateLimit() {
         await refreshFromDb(this);
-        return this.rateLimit;
+        return resolveQueueLimits(this).rateLimit;
     }
+    async getPartitionConcurrency() {
+        await refreshFromDb(this);
+        return resolveQueueLimits(this).partitionConcurrency;
+    }
+    async getPartitionWorkerConcurrency() {
+        await refreshFromDb(this);
+        return resolveQueueLimits(this).partitionWorkerConcurrency;
+    }
+    async getPartitionRateLimit() {
+        await refreshFromDb(this);
+        return resolveQueueLimits(this).partitionRateLimit;
+    }
+    /** @deprecated Priority is always enabled. */
     async getPriorityEnabled() {
         await refreshFromDb(this);
         return this.priorityEnabled;
     }
+    /** @deprecated Use the partition limit getters. */
     async getPartitionQueue() {
         await refreshFromDb(this);
         return this.partitionQueue;
@@ -515,35 +780,54 @@ class WFQueueRunner {
             }
             await exec.dispatchDequeuedWorkflows(wfids);
         };
+        const limits = resolveQueueLimits(queue);
+        const sysdb = exec.systemDatabase;
         // Dequeue workflows for this queue, either in one batched sweep across partitions or one partition at a time.
         try {
-            if (queue.partitionQueue &&
-                queue.concurrency === 1 &&
-                queue.rateLimit === undefined &&
-                queue.workerConcurrency !== 0) {
-                // Batched path: one transaction claims every partition's head (valid only for concurrency=1, see findAndMarkStartablePartitionedWorkflows).
-                const wfids = await exec.systemDatabase.findAndMarkStartablePartitionedWorkflows(queue, exec.executorID, utils_1.globalParams.appVersion);
+            if (!queue.partitionQueue) {
+                const wfids = await sysdb.findAndMarkStartableWorkflows(queue, exec.executorID, utils_1.globalParams.appVersion, undefined, sysdb.countRunningWorkflowsForQueue(queue.name));
                 await dispatch(wfids);
             }
-            else if (queue.partitionQueue) {
-                // Every other partitioned config sweeps one partition at a time.
-                const partitionKeys = await exec.systemDatabase.getQueuePartitions(queue.name);
+            else if (limits.partitionConcurrency === 1 &&
+                limits.globalConcurrency === undefined &&
+                limits.rateLimit === undefined &&
+                limits.partitionRateLimit === undefined) {
+                // Batched path: one transaction claims every partition's head (see findAndMarkStartablePartitionedWorkflows).
+                const maxTasks = workerBudget(limits, sysdb.countRunningWorkflowsForQueue(queue.name));
+                if (maxTasks > 0) {
+                    const wfids = await sysdb.findAndMarkStartablePartitionedWorkflows(queue, exec.executorID, utils_1.globalParams.appVersion, maxTasks);
+                    await dispatch(wfids);
+                }
+            }
+            else {
+                // Every other partitioned config sweeps one partition at a time, in random order to prevent starvation.
+                const partitionKeys = shuffled(await sysdb.getQueuePartitions(queue.name));
+                // Snapshot once: dispatch is asynchronous, so re-reading would count this sweep's own claims twice.
+                const running = sysdb.countRunningWorkflowsForQueue(queue.name);
+                let claimed = 0;
                 for (const partitionKey of partitionKeys) {
-                    const partitionWfids = await exec.systemDatabase.findAndMarkStartableWorkflows(queue, exec.executorID, utils_1.globalParams.appVersion, partitionKey);
+                    if (workerBudget(limits, running + claimed) <= 0)
+                        break;
+                    let partitionWfids;
+                    try {
+                        partitionWfids = await sysdb.findAndMarkStartableWorkflows(queue, exec.executorID, utils_1.globalParams.appVersion, partitionKey, running + claimed, sysdb.countRunningWorkflowsForPartition(queue.name, partitionKey));
+                    }
+                    catch (e) {
+                        // Lock held or claim raced by another worker: skip just this partition, no queue-wide backoff.
+                        if (isContentionError(e))
+                            continue;
+                        throw e;
+                    }
+                    claimed += partitionWfids.length;
                     await dispatch(partitionWfids);
                     await (0, debugpoint_1.debugTriggerPoint)(debugpoint_1.DEBUG_TRIGGER_BETWEEN_PARTITION_DISPATCHES);
                 }
             }
-            else {
-                const wfids = await exec.systemDatabase.findAndMarkStartableWorkflows(queue, exec.executorID, utils_1.globalParams.appVersion, undefined);
-                await dispatch(wfids);
-            }
         }
         catch (e) {
             const err = e;
             // Handle serialization errors and lock contention with backoff
-            if ('code' in err && (err.code === '40001' || err.code === '55P03')) {
-                // 40001: serialization_failure, 55P03: lock_not_available
+            if (isContentionError(err)) {
                 contentionDetected = true;
                 exec.logger.warn(`Contention detected in queue ${queue.name}.`);
             }