@dbos-inc/dbos-sdk 4.28.8-preview → 4.28.12-preview

package/dist/src/wfqueue.js

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wfQueueRunner = exports.WorkflowQueue = exports.resolveQueueLimits = exports.logQueue = void 0;
+exports.wfQueueRunner = exports.registerInternalQueue = exports.WorkflowQueue = exports.isPartitionedQueue = exports.logQueue = void 0;
 const dbos_executor_1 = require("./dbos-executor");
-const dbos_1 = require("./dbos");
 const debugpoint_1 = require("./debugpoint");
 const utils_1 = require("./utils");
 /**
  * Log a single queue's name and its set parameters. Unset parameters are
  * omitted, matching `Queue: <name> (concurrency=…, worker_concurrency=…,
- * limit=N/Ts, priority, partitioned)`.
+ * limit=N/Ts, partition_concurrency=…)`.
  */
 function logQueue(logger, q) {
     const opts = [];
     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}`);
+        opts.push(`${isPartitionedQueue(q) ? 'global_concurrency' : 'concurrency'}=${q.concurrency}`);
     }
     if (q.workerConcurrency !== undefined)
         opts.push(`worker_concurrency=${q.workerConcurrency}`);
@@ -28,60 +27,38 @@ function logQueue(logger, q) {
     if (q.partitionRateLimit !== undefined) {
         opts.push(`partition_limit=${q.partitionRateLimit.limitPerPeriod}/${q.partitionRateLimit.periodSec}s`);
     }
-    if (q.priorityEnabled)
-        opts.push('priority');
-    if (q.partitionQueue)
-        opts.push('partitioned');
     const optsStr = opts.length > 0 ? ` (${opts.join(', ')})` : '';
     logger.info(`Queue: ${q.name}${optsStr}`);
 }
 exports.logQueue = logQueue;
+/**
+ * Options removed in 5.0, and what replaces each.
+ */
+const REMOVED_QUEUE_PARAMS = {
+    priorityEnabled: 'every queue dispatches in priority order, so the option can be deleted',
+    partitionQueue: 'set partitionConcurrency, partitionWorkerConcurrency, or partitionRateLimit instead, any of which partitions the queue',
+};
 /** 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);
+/** True when a queue is partitioned, which is to say any per-partition limit is set on it. */
+function isPartitionedQueue(queue) {
+    return hasPartitionLimits(queue);
 }
-/** 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;
+exports.isPartitionedQueue = isPartitionedQueue;
 /**
  * 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.
+function workerBudget(queue, running) {
+    if (queue.workerConcurrency === undefined) {
+        // A per-partition worker limit is enforced per partition instead.
         return Infinity;
     }
-    return Math.max(0, limits.workerConcurrency - running);
+    return Math.max(0, queue.workerConcurrency - running);
 }
 /** 40001 serialization_failure or 55P03 lock_not_available: a peer is claiming the same rows. */
 function isContentionError(e) {
@@ -120,14 +97,6 @@ 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)
@@ -159,18 +128,15 @@ 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
+ * `q` in place. No-op for internal queues. Throws if the row has been
  * deleted.
  */
 async function refreshFromDb(q) {
@@ -193,73 +159,69 @@ class WorkflowQueue {
     /**
      * Last-known cached values. May be stale for database-backed queues if
      * another process has modified the row. Use getters instead.
+     * `concurrency` is the queue-wide limit, across every worker and partition.
      */
     concurrency;
     rateLimit;
     workerConcurrency;
-    priorityEnabled = false;
-    partitionQueue = false;
     partitionConcurrency;
     partitionWorkerConcurrency;
     partitionRateLimit;
     minPollingIntervalMs;
-    /** Owner from the queues table; undefined for in-memory and unclaimed queues. */
+    /** Owner from the queues table; undefined for internal and unclaimed queues. */
     applicationName;
     /**
      * When true, this queue's configuration is persisted in the `queues` system
-     * table and may be mutated at runtime via the `setX` methods. When false,
-     * the queue's configuration is fixed at construction and lives only in
-     * process memory.
+     * table and may be mutated at runtime via the `setX` methods. False only for
+     * the process-local queues DBOS registers for its own use.
      */
-    databaseBacked = false;
+    databaseBacked;
     /**
      * True when configuration reads/writes target a `DBOSClient`-supplied
      * SystemDatabase rather than the global executor's. The actual handle is
      * kept off this class's public type — see the module-level WeakMap below —
      * so that `WorkflowQueue` does not transitively depend on `SystemDatabase`.
      */
-    clientBound = false;
-    constructor(name, arg2, rateLimit) {
-        this.name = name;
-        if (dbos_1.DBOS.isInitialized()) {
-            dbos_1.DBOS.logger.warn(`In-memory workflow queue '${name}' was created after DBOS initialization and will not be picked up by the queue dispatcher. ` +
-                `Use DBOS.registerQueue to register a database-backed queue at runtime.`);
-        }
-        let params;
-        if (typeof arg2 === 'object' && arg2 !== null) {
-            params = arg2;
+    clientBound;
+    /**
+     * Not reachable from the published package, which exports `WorkflowQueue` as a
+     * type only: applications obtain queues from `DBOS.registerQueue`,
+     * `DBOS.retrieveQueue`, or `DBOS.listQueues`.
+     *
+     * @param record - The queue's configuration, persisted or not.
+     * @param databaseBacked - False only for the process-local queues DBOS registers for its own use.
+     * @param clientSystemDatabase - When set, config reads and writes target this client's database.
+     */
+    constructor(record, databaseBacked = true, clientSystemDatabase) {
+        this.name = record.name;
+        this.databaseBacked = databaseBacked;
+        this.clientBound = clientSystemDatabase !== undefined;
+        applyRecord(this, record);
+        if (clientSystemDatabase !== undefined) {
+            clientSystemDatabases.set(this, clientSystemDatabase);
         }
-        else {
-            params = { concurrency: arg2, rateLimit };
+    }
+    /**
+     * Throws if a user-supplied queue registration is invalid. Internal queues bypass the name
+     * check: the reserved prefix is theirs, and they validate their parameters directly.
+     */
+    static validateQueueRegistration(name, params) {
+        if (name.startsWith(utils_1.RESERVED_QUEUE_NAME_PREFIX)) {
+            throw new Error(`Queue name ${name} is reserved: names starting with '${utils_1.RESERVED_QUEUE_NAME_PREFIX}' belong to DBOS's internal queues.`);
         }
         WorkflowQueue.validateQueueParams(params);
-        this.concurrency = params.globalConcurrency ?? params.concurrency;
-        this.rateLimit = params.rateLimit;
-        this.workerConcurrency = params.workerConcurrency;
-        this.priorityEnabled = params.priorityEnabled ?? 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`);
-        }
-        exports.wfQueueRunner.wfQueuesByName.set(name, this);
     }
     /** Throws if any combination of queue parameters is invalid. */
     static validateQueueParams(params) {
-        const { concurrency, globalConcurrency, workerConcurrency, rateLimit, partitionConcurrency, partitionWorkerConcurrency, partitionRateLimit, partitionQueue, minPollingIntervalMs, } = params;
+        for (const [option, replacement] of Object.entries(REMOVED_QUEUE_PARAMS)) {
+            if (Object.hasOwn(params, option)) {
+                throw new Error(`${option} was removed: ${replacement}.`);
+            }
+        }
+        const { concurrency, globalConcurrency, workerConcurrency, rateLimit, partitionConcurrency, partitionWorkerConcurrency, partitionRateLimit, 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');
         }
@@ -280,7 +242,6 @@ class WorkflowQueue {
             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');
@@ -310,9 +271,7 @@ class WorkflowQueue {
             workerConcurrency: params.workerConcurrency ?? null,
             rateLimitMax: params.rateLimit ? params.rateLimit.limitPerPeriod : null,
             rateLimitPeriodSec: params.rateLimit ? params.rateLimit.periodSec : null,
-            priorityEnabled: params.priorityEnabled ?? false,
-            // Any per-partition limit implies partitioning, whichever mode was used.
-            partitionQueue: (params.partitionQueue ?? false) || hasPartitionLimits(params),
+            partitionQueue: hasPartitionLimits(params),
             partitionConcurrency: params.partitionConcurrency ?? null,
             partitionWorkerConcurrency: params.partitionWorkerConcurrency ?? null,
             partitionRateLimitMax: params.partitionRateLimit ? params.partitionRateLimit.limitPerPeriod : null,
@@ -320,38 +279,14 @@ class WorkflowQueue {
             pollingIntervalSec: (params.minPollingIntervalMs ?? 1000) / 1000,
         };
     }
-    /**
-     * Construct a database-backed queue from a persisted record. Bypasses the
-     * legacy constructor so the instance is not added to the global registry —
-     * the queues table is the source of truth.
-     * @internal
-     */
-    static _fromRecord(record, clientSystemDatabase) {
-        // Allocate without invoking the constructor (which would auto-register
-        // in `wfQueuesByName`) and strip `readonly` so we can set the fields here.
-        const q = Object.create(WorkflowQueue.prototype);
-        q.name = record.name;
-        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);
-        // 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;
+        return this.setGlobalConcurrency(value);
     }
     async setGlobalConcurrency(value) {
         requireDatabaseBacked(this);
+        // Refresh so the cross-field checks see the limits currently stored in the database.
         await refreshFromDb(this);
-        requireNotLegacyPartitioned(this, 'globalConcurrency');
         checkConcurrencyBounds(this, value);
         await sysDBFor(this).updateQueue(this.name, { concurrency: value ?? null });
         this.concurrency = value;
@@ -359,7 +294,6 @@ class WorkflowQueue {
     async setWorkerConcurrency(value) {
         requireDatabaseBacked(this);
         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');
@@ -376,9 +310,6 @@ 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,
@@ -391,7 +322,6 @@ class WorkflowQueue {
             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');
@@ -400,14 +330,13 @@ class WorkflowQueue {
                 throw new Error('partitionConcurrency must be greater than or equal to partitionWorkerConcurrency');
             }
         }
-        // Partitioning is inferred from the limits, so the deprecated flag follows them.
+        // Partitioning is inferred from the limits, so the stored 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);
@@ -415,7 +344,6 @@ class WorkflowQueue {
             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');
@@ -433,7 +361,6 @@ class WorkflowQueue {
             partitionQueue: partitioned,
         });
         this.partitionWorkerConcurrency = value;
-        this.partitionQueue = partitioned;
     }
     async setPartitionRateLimit(value) {
         requireDatabaseBacked(this);
@@ -441,7 +368,6 @@ class WorkflowQueue {
             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,
@@ -449,24 +375,6 @@ class WorkflowQueue {
             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;
     }
     async setMinPollingIntervalMs(value) {
         requireDatabaseBacked(this);
@@ -478,42 +386,31 @@ class WorkflowQueue {
     }
     /** @deprecated Use `getGlobalConcurrency`. */
     async getConcurrency() {
-        await refreshFromDb(this);
-        return this.concurrency;
+        return this.getGlobalConcurrency();
     }
     async getGlobalConcurrency() {
         await refreshFromDb(this);
-        return resolveQueueLimits(this).globalConcurrency;
+        return this.concurrency;
     }
     async getWorkerConcurrency() {
         await refreshFromDb(this);
-        return resolveQueueLimits(this).workerConcurrency;
+        return this.workerConcurrency;
     }
     async getRateLimit() {
         await refreshFromDb(this);
-        return resolveQueueLimits(this).rateLimit;
+        return this.rateLimit;
     }
     async getPartitionConcurrency() {
         await refreshFromDb(this);
-        return resolveQueueLimits(this).partitionConcurrency;
+        return this.partitionConcurrency;
     }
     async getPartitionWorkerConcurrency() {
         await refreshFromDb(this);
-        return resolveQueueLimits(this).partitionWorkerConcurrency;
+        return 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;
+        return this.partitionRateLimit;
     }
     async getMinPollingIntervalMs() {
         await refreshFromDb(this);
@@ -521,8 +418,35 @@ class WorkflowQueue {
     }
 }
 exports.WorkflowQueue = WorkflowQueue;
+/**
+ * Register a queue that DBOS itself needs — the internal queue, a Kafka receiver's
+ * queue — or return the one already registered under `name`.
+ *
+ * Internal queues are not persisted in the `queues` table: their configuration is
+ * fixed here and lives only in this process's memory. They are always dispatched,
+ * bypassing any `listenQueues` filter, since this process is the only one that
+ * enqueues onto them.
+ *
+ * Callers must resolve their queues through this rather than caching them: a registry
+ * clear (`DBOS.shutdown({ deregister: true })`) drops the registration, and a cached
+ * queue would silently stop being dispatched, leaving its workflows ENQUEUED forever.
+ *
+ * Not a user-facing API: applications register queues with `DBOS.registerQueue`.
+ * @internal
+ */
+function registerInternalQueue(name, params = {}) {
+    const existing = exports.wfQueueRunner.getInternalQueue(name);
+    if (existing)
+        return existing;
+    WorkflowQueue.validateQueueParams(params);
+    const queue = new WorkflowQueue(WorkflowQueue.recordFromParams(name, params), false);
+    exports.wfQueueRunner.addInternalQueue(queue);
+    return queue;
+}
+exports.registerInternalQueue = registerInternalQueue;
 class WFQueueRunner {
-    wfQueuesByName = new Map();
+    /** DBOS's own process-local queues, registered via `registerInternalQueue`. */
+    internalQueues = new Map();
     /**
      * Queues fed by this process's own pollers (e.g. a Kafka consumer). Always dispatched,
      * regardless of any listenQueues filter, so this process executes what it enqueues.
@@ -533,8 +457,6 @@ class WFQueueRunner {
     listenQueueNames = null;
     /** Per-queue scheduling state, keyed by queue name. */
     states = new Map();
-    /** Names already warned about colliding with an in-memory queue (warn-once). */
-    conflictWarned = new Set();
     static defaultMinPollingIntervalMs = 1000;
     static defaultMaxPollingIntervalMs = 120000;
     static reconcileIntervalMs = 1000;
@@ -543,6 +465,12 @@ class WFQueueRunner {
     scalebackFactor = 0.9;
     jitterMin = 0.95;
     jitterMax = 1.05;
+    addInternalQueue(queue) {
+        this.internalQueues.set(queue.name, queue);
+    }
+    getInternalQueue(name) {
+        return this.internalQueues.get(name);
+    }
     stop() {
         if (!this.isRunning)
             return;
@@ -550,24 +478,17 @@ class WFQueueRunner {
         this.abortController?.abort();
     }
     clearRegistrations() {
-        this.wfQueuesByName.clear();
+        this.internalQueues.clear();
         this.pollerQueueNames.clear();
     }
     async dispatchLoop(exec, listenQueuesArg, maxConcurrentQueueDispatches = 3) {
         this.isRunning = true;
         this.states.clear();
-        this.conflictWarned.clear();
-        this.listenQueueNames = listenQueuesArg
-            ? new Set(listenQueuesArg.map((entry) => (typeof entry === 'string' ? entry : entry.name)))
-            : null;
+        this.listenQueueNames = listenQueuesArg ? new Set(listenQueuesArg) : null;
         this.abortController = new AbortController();
         const startNow = Date.now();
-        // The internal queue is process-private and bypasses the listenQueues filter.
-        const internal = this.wfQueuesByName.get(utils_1.INTERNAL_QUEUE_NAME);
-        if (internal)
-            this.ensureState(internal, startNow);
-        // Unmatched string entries are deferred to refreshDbQueues as DB-backed queues.
-        for (const q of this.resolveInMemoryQueues(listenQueuesArg)) {
+        // Internal queues are process-private and bypass the listenQueues filter.
+        for (const q of this.internalQueues.values()) {
             this.ensureState(q, startNow);
         }
         // Add pre-launch DB-backed queues now so an immediate enqueue can't race the first reconcile.
@@ -577,31 +498,6 @@ class WFQueueRunner {
         // One loop drives global maintenance; queue polls run in a bounded set of independent lanes.
         await this.schedulerLoop(exec, startNow, maxConcurrentQueueDispatches);
     }
-    /** Resolve the listenQueues argument to the set of in-memory queues to dispatch for. */
-    resolveInMemoryQueues(listenQueuesArg) {
-        if (listenQueuesArg === null) {
-            return Array.from(this.wfQueuesByName.values()).filter((q) => q.name !== utils_1.INTERNAL_QUEUE_NAME);
-        }
-        const result = [];
-        for (const entry of listenQueuesArg) {
-            if (typeof entry === 'string') {
-                const q = this.wfQueuesByName.get(entry);
-                if (q)
-                    result.push(q);
-            }
-            else {
-                result.push(entry);
-            }
-        }
-        // Poller-fed queues are always dispatched: this process enqueues onto them, so under a
-        // listenQueues filter their workflows would otherwise sit ENQUEUED forever.
-        for (const name of this.pollerQueueNames) {
-            const q = this.wfQueuesByName.get(name);
-            if (q && !result.some((r) => r.name === name))
-                result.push(q);
-        }
-        return result;
-    }
     /** Begin tracking a queue if it isn't already, scheduling its first poll one interval out. */
     ensureState(queue, now) {
         if (this.states.has(queue.name))
@@ -621,17 +517,9 @@ class WFQueueRunner {
         }
         const present = new Set();
         for (const record of records) {
-            if (record.name === utils_1.INTERNAL_QUEUE_NAME)
-                continue;
-            if (this.wfQueuesByName.has(record.name)) {
-                if (!this.conflictWarned.has(record.name)) {
-                    this.conflictWarned.add(record.name);
-                    exec.logger.warn(`Database-backed queue '${record.name}' has the same name as an in-memory queue. ` +
-                        `The in-memory queue's configuration is being used; the database-backed queue is ignored. ` +
-                        `Rename one of them to resolve the conflict.`);
-                }
+            // An internal queue owns its name outright; its process-local configuration wins.
+            if (this.internalQueues.has(record.name))
                 continue;
-            }
             if (this.listenQueueNames !== null &&
                 !this.listenQueueNames.has(record.name) &&
                 !this.pollerQueueNames.has(record.name)) {
@@ -641,10 +529,10 @@ class WFQueueRunner {
             const existing = this.states.get(record.name);
             if (existing) {
                 // Refresh config in place, preserving this queue's polling/backoff state.
-                existing.queue = WorkflowQueue._fromRecord(record);
+                existing.queue = new WorkflowQueue(record);
             }
             else {
-                this.ensureState(WorkflowQueue._fromRecord(record), now);
+                this.ensureState(new WorkflowQueue(record), now);
             }
         }
         // A database-backed queue whose row is gone stops being dispatched.
@@ -659,7 +547,7 @@ class WFQueueRunner {
     }
     /** Log every queue this process will dispatch for, once at startup after discovery. */
     logRunningQueues(exec) {
-        const names = Array.from(this.states.keys()).filter((n) => n !== utils_1.INTERNAL_QUEUE_NAME);
+        const names = Array.from(this.states.keys()).filter((n) => !this.internalQueues.has(n));
         exec.logger.info(`Listening to ${names.length} queues:`);
         for (const name of names) {
             logQueue(exec.logger, this.states.get(name).queue);
@@ -780,20 +668,19 @@ 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) {
+            if (!isPartitionedQueue(queue)) {
                 const wfids = await sysdb.findAndMarkStartableWorkflows(queue, exec.executorID, utils_1.globalParams.appVersion, undefined, sysdb.countRunningWorkflowsForQueue(queue.name));
                 await dispatch(wfids);
             }
-            else if (limits.partitionConcurrency === 1 &&
-                limits.globalConcurrency === undefined &&
-                limits.rateLimit === undefined &&
-                limits.partitionRateLimit === undefined) {
+            else if (queue.partitionConcurrency === 1 &&
+                queue.concurrency === undefined &&
+                queue.rateLimit === undefined &&
+                queue.partitionRateLimit === undefined) {
                 // Batched path: one transaction claims every partition's head (see findAndMarkStartablePartitionedWorkflows).
-                const maxTasks = workerBudget(limits, sysdb.countRunningWorkflowsForQueue(queue.name));
+                const maxTasks = workerBudget(queue, sysdb.countRunningWorkflowsForQueue(queue.name));
                 if (maxTasks > 0) {
                     const wfids = await sysdb.findAndMarkStartablePartitionedWorkflows(queue, exec.executorID, utils_1.globalParams.appVersion, maxTasks);
                     await dispatch(wfids);
@@ -806,7 +693,7 @@ class WFQueueRunner {
                 const running = sysdb.countRunningWorkflowsForQueue(queue.name);
                 let claimed = 0;
                 for (const partitionKey of partitionKeys) {
-                    if (workerBudget(limits, running + claimed) <= 0)
+                    if (workerBudget(queue, running + claimed) <= 0)
                         break;
                     let partitionWfids;
                     try {