cairnq 0.13.0 → 0.14.0

package/dist/worker.js

@@ -1,6 +1,6 @@
 import { DEFAULT_RETRY_BACKOFF_MAX_MS, DEFAULT_RETRY_BACKOFF_MS, failDelayMs } from "./backoff.js";
 import { TaskContext } from "./context.js";
-import { asEnvelope, errorEnvelope, EventLoopBlocked, exceptionEnvelope, LostLease, SerializationError, } from "./errors.js";
+import { asEnvelope, errorEnvelope, exceptionEnvelope, LostLease, SerializationError, } from "./errors.js";
 import { newId } from "./ids.js";
 import { SQLiteStore } from "./store/sqlite.js";
 import { PostgresStore } from "./store/postgres.js";
@@ -29,43 +29,122 @@ function timeoutEnvelope(name, maxRunMs) {
 }
 const TIMED_OUT = Symbol("cairnq.timedOut");
 /**
- * Resident size of a task's payload, for the maxInFlightBytes budget.
+ * The worker's claim-scheduling state, in one object: which names draw together
+ * and at what batch size, which shared resource each draw spends, how many
+ * calls each resource still has room for, and whose turn it is.
  *
- * Re-serializes because by this point the wire form is gone: `pg` parses a jsonb
- * column with JSON.parse and discards the text, so on Postgres there is nothing
- * cheaper to read. On SQLite the column does arrive as a string that rowToTask
- * sees before parsing — capturing its length there would make this free, at the
- * cost of carrying a non-protocol field on Task in both SDKs. Left for when the
- * measurement shows up in a profile.
+ * A name that limits itself — by `batch`, or by a `resource` — needs a quota
+ * the shared draw cannot express, so it gets a source of its own; every other
+ * name shares one, where a task is a call.
  *
- * What the budget is really after is the memory a payload pins while its handler
- * runs, and its JSON length tracks that closely enough to size one by.
+ * A resource is deliberately *not* one source spanning its names: `batch` is
+ * per name, and a single source carries one batch size, so two members that
+ * batch differently could not share a draw. Keeping a source per name and
+ * letting several of them draw down one shared ceiling composes with batching
+ * instead of excluding it.
  */
-function payloadBytes(task) {
-    try {
-        return Buffer.byteLength(JSON.stringify(task.payload) ?? "");
+class ClaimPlanner {
+    capacities;
+    sources = [];
+    /** The union of names the claim probe spans. */
+    names = [];
+    /** Calls holding units of each declared resource. */
+    inFlight = new Map();
+    /** Rotates which source is offered the free budget first — see plan(). */
+    cursor = 0;
+    constructor(capacities) {
+        this.capacities = capacities;
     }
-    catch {
-        // Unmeasurable, and it came out of the store, so it is already resident:
-        // charging nothing under-counts, but failing the claim over an accounting
-        // detail would drop a task the worker can otherwise run.
-        return 0;
+    /** Rebuild the sources from the registrations. Called from task(), which is
+     * the only place the set changes, so a poll never pays for the rebuild. */
+    rebuild(handlers) {
+        const sources = [];
+        const shared = [];
+        for (const [name, reg] of handlers) {
+            if (reg.batch != null || reg.resource != null) {
+                sources.push({ names: [name], batch: reg.batch ?? 1, resource: reg.resource });
+            }
+            else
+                shared.push(name);
+        }
+        if (shared.length)
+            sources.push({ names: shared, batch: 1 });
+        this.sources = sources;
+        this.names = [...handlers.keys()];
+    }
+    get empty() {
+        return this.sources.length === 0;
+    }
+    /**
+     * Draw up to `free` handler calls from one claim transaction.
+     *
+     * Sources are served in rotating order — without rotating, the first source
+     * would take every free slot and the rest would starve behind its backlog.
+     * Each draw sizes itself from what the previous ones took, so a source with
+     * nothing queued costs nothing; that feedback is why this runs inside the
+     * claim transaction rather than dividing the budget up front. It must await
+     * nothing but `claim` — the store holds the write lock while it runs.
+     *
+     * `split` is the worker's deliveries(): rows become handler calls there, so
+     * spending the budget against its result is the only way the two cannot
+     * disagree.
+     */
+    async plan(free, claim, split) {
+        const cursor = this.cursor % this.sources.length;
+        const order = [...this.sources.slice(cursor), ...this.sources.slice(0, cursor)];
+        this.cursor = (cursor + 1) % this.sources.length;
+        const drawn = [];
+        let left = free;
+        // Resource units this poll has already drawn. `inFlight` only moves when a
+        // call is dispatched, which happens after this whole plan returns — so
+        // without a local tally two sources sharing a resource would each see its
+        // full ceiling and together overshoot it.
+        const taken = new Map();
+        for (const src of order) {
+            if (left <= 0)
+                break;
+            const quota = Math.min(this.headroom(src, taken) ?? left, left);
+            if (quota <= 0)
+                continue;
+            const rows = await claim(src.names, src.batch * quota);
+            if (!rows.length)
+                continue;
+            const calls = split(rows);
+            drawn.push({ src, calls });
+            left -= calls.length;
+            if (src.resource != null) {
+                taken.set(src.resource, (taken.get(src.resource) ?? 0) + calls.length);
+            }
+        }
+        return drawn;
+    }
+    /** A source's own call ceiling for one poll, or undefined when only the
+     * worker-wide budget applies: its resource's capacity less what is running
+     * and what earlier draws in this same poll already took. */
+    headroom(src, taken) {
+        if (src.resource == null)
+            return undefined;
+        return Math.max(0, this.capacities[src.resource] -
+            (this.inFlight.get(src.resource) ?? 0) -
+            (taken.get(src.resource) ?? 0));
+    }
+    /** Charge one dispatched call to its resource, for the span of the call. */
+    acquire(resource) {
+        if (resource == null)
+            return;
+        this.inFlight.set(resource, (this.inFlight.get(resource) ?? 0) + 1);
+    }
+    /** Give the unit back. Deleting at zero keeps the map to the resources
+     * actually in flight, so an idle worker holds no entries at all. */
+    release(resource) {
+        if (resource == null)
+            return;
+        const rest = (this.inFlight.get(resource) ?? 1) - 1;
+        if (rest > 0)
+            this.inFlight.set(resource, rest);
+        else
+            this.inFlight.delete(resource);
     }
-}
-/**
- * Give back one call's unit of a counted budget. Deleting at zero is what keeps
- * the map to the keys actually in flight, so an idle worker holds no entries at
- * all — and both budgets (a name's own concurrency, a resource's capacity)
- * settle the same way, from one place.
- */
-function release(counts, key) {
-    if (key == null)
-        return;
-    const rest = (counts.get(key) ?? 1) - 1;
-    if (rest > 0)
-        counts.set(key, rest);
-    else
-        counts.delete(key);
 }
 export class Worker {
     store;
@@ -73,22 +152,7 @@ export class Worker {
     opts;
     handlers = new Map();
     ownId = newId("worker");
-    /** Payload bytes charged to running handlers — see maxInFlightBytes. */
-    inFlightBytes = 0;
-    /** Calls in flight, for the names that cap their own concurrency. */
-    callsInFlight = new Map();
-    /**
-     * Calls holding units of each declared resource. A resource is the same shape
-     * of budget as a name's own `concurrency` — a ceiling on calls — differing
-     * only in who draws from it: several names rather than one. That is what
-     * expresses "these handlers share one GPU" without inventing a queue per
-     * resource.
-     */
-    resourceCalls = new Map();
-    /** Rotates which source is offered the free budget first — see loop(). */
-    claimCursor = 0;
-    /** Invalidated by task(); see schedule(). */
-    scheduleCache = null;
+    planner;
     /**
      * Retry backoff, resolved once. Both settlement paths read these — the
      * worker's own `safeFail` and the TaskContext it hands a handler — so
@@ -111,19 +175,18 @@ export class Worker {
         if (opts.maxRunMs != null && opts.maxRunMs <= 0) {
             throw new Error(`maxRunMs must be > 0, got ${opts.maxRunMs}`);
         }
-        // 0 would make the budget permanently spent, so the worker would claim
-        // nothing and look hung. Rejected here, as the Python SDK does.
-        if (opts.maxInFlightBytes != null && opts.maxInFlightBytes <= 0) {
-            throw new Error(`maxInFlightBytes must be > 0, got ${opts.maxInFlightBytes}`);
-        }
         for (const [resource, capacity] of Object.entries(opts.resources ?? {})) {
             if (!Number.isInteger(capacity) || capacity < 1) {
                 throw new Error(`resources[${JSON.stringify(resource)}] must be an integer >= 1, got ${capacity}`);
             }
         }
         if (opts.maxQueueDepth != null) {
-            store.useBackpressure(opts);
+            store.useBackpressure({
+                maxQueueDepth: opts.maxQueueDepth,
+                maxQueueWaitMs: opts.maxQueueWaitMs,
+            });
         }
+        this.planner = new ClaimPlanner(opts.resources ?? {});
         this.backoffMs = opts.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
         this.backoffMaxMs = opts.retryBackoffMaxMs ?? DEFAULT_RETRY_BACKOFF_MAX_MS;
     }
@@ -148,11 +211,10 @@ export class Worker {
         return this.ownId;
     }
     task(arg, second, third) {
-        // Option form: (name | def, { batch?, concurrency?, resource? }, handler).
-        // Peel the options off and fall through, so name resolution and registration
-        // stay single-sited.
+        // Option form: (name | def, { batch?, resource? }, handler). Peel the
+        // options off and fall through, so name resolution and registration stay
+        // single-sited.
         let batch;
-        let concurrency;
         let resource;
         let handler = second;
         if (second != null && typeof second === "object") {
@@ -162,12 +224,6 @@ export class Worker {
                 }
                 batch = second.batch;
             }
-            if (second.concurrency != null) {
-                if (!Number.isInteger(second.concurrency) || second.concurrency < 1) {
-                    throw new Error(`concurrency must be an integer >= 1, got ${second.concurrency}`);
-                }
-                concurrency = second.concurrency;
-            }
             resource = second.resource;
             handler = third;
         }
@@ -197,8 +253,8 @@ export class Worker {
             throw new Error(`task ${JSON.stringify(name)} declares resource ${JSON.stringify(resource)}, ` +
                 `which is not in WorkerOptions.resources; declared: ${known}`);
         }
-        this.handlers.set(name, { fn, batch, concurrency, resource });
-        this.scheduleCache = null;
+        this.handlers.set(name, { fn, batch, resource });
+        this.planner.rebuild(this.handlers);
         return this;
     }
     stop() {
@@ -231,7 +287,7 @@ export class Worker {
         const leaseMs = this.opts.leaseMs ?? 30_000;
         await this.store.connect();
         // The calls in flight — `concurrency` counts these, so the set's size is the
-        // budget. How many tasks they carry is `maxInFlightBytes`'s business.
+        // budget. How many tasks they carry is the batch sizes' business.
         const running = new Set();
         try {
             await this.loop(concurrency, leaseMs, running);
@@ -281,139 +337,29 @@ export class Worker {
             retryBackoffMaxMs: this.backoffMaxMs,
         });
     }
-    /**
-     * How this poll's claim is split into per-name quotas, plus the union of names
-     * the probe spans.
-     *
-     * Cached and invalidated by `task()`, rather than rebuilt each poll: handlers
-     * may be registered after run() started, but only there, and this otherwise
-     * allocates a source per name on every tick for a worker's whole lifetime.
-     *
-     * A name that limits itself — by `batch`, by its own `concurrency`, or by a
-     * `resource` — needs a quota the shared draw cannot express, so it gets a
-     * source of its own; every other name shares one, where a task is a call.
-     *
-     * A resource is deliberately *not* one source spanning its names: `batch` is
-     * per name, and a single source carries one batch size, so two members that
-     * batch differently could not share a draw. Keeping a source per name and
-     * letting several of them draw down one shared ceiling composes with batching
-     * instead of excluding it.
-     */
-    schedule() {
-        if (this.scheduleCache)
-            return this.scheduleCache;
-        const sources = [];
-        const shared = [];
-        for (const [name, reg] of this.handlers) {
-            if (reg.batch != null || reg.concurrency != null || reg.resource != null) {
-                sources.push({
-                    key: reg.concurrency == null ? undefined : name,
-                    names: [name],
-                    batch: reg.batch ?? 1,
-                    concurrency: reg.concurrency,
-                    resource: reg.resource,
-                });
-            }
-            else
-                shared.push(name);
-        }
-        if (shared.length)
-            sources.push({ names: shared, batch: 1 });
-        return (this.scheduleCache = { sources, names: [...this.handlers.keys()] });
-    }
-    /**
-     * A source's own call ceiling for one poll, or undefined when only the
-     * worker-wide budget applies.
-     *
-     * Three independent ceilings, whichever binds first: the name's own concurrency
-     * less what it is already running; its resource's capacity less what is running
-     * *and* what earlier draws in this same poll already took (`taken`); and
-     * `claimBatch`. The last is a ceiling on *rows* per poll, so it converts at this
-     * source's batch size — and never below one call, or a `claimBatch` under some
-     * name's batch would stall that name outright.
-     */
-    sourceCalls(src, taken) {
-        const rows = this.opts.claimBatch;
-        const byRows = rows == null ? undefined : Math.max(1, Math.floor(rows / src.batch));
-        const byName = src.concurrency == null
-            ? undefined
-            : Math.max(0, src.concurrency - (this.callsInFlight.get(src.key) ?? 0));
-        const byResource = src.resource == null
-            ? undefined
-            : Math.max(0, this.opts.resources[src.resource] -
-                (this.resourceCalls.get(src.resource) ?? 0) -
-                (taken.get(src.resource) ?? 0));
-        const limits = [byRows, byName, byResource].filter((n) => n != null);
-        return limits.length ? Math.min(...limits) : undefined;
-    }
     async loop(concurrency, leaseMs, running) {
         const pollMs = this.opts.pollIntervalMs ?? 500;
-        const byteBudget = this.opts.maxInFlightBytes;
         while (!this.stopped) {
             // `concurrency` counts calls, so the calls in flight *are* the running
             // promises — a batch holding 256 tasks is one of them.
             const free = concurrency - running.size;
-            // Two ceilings, either of which stops the claim: calls in flight and
-            // resident payload bytes. The byte arm is guarded on running.size because
-            // it must never be the reason we race an empty set — Promise.race([]) is
-            // pending forever, past even stop(). With nothing running, nothing is
-            // resident, so the budget cannot be the thing holding us back anyway.
-            const overBudget = byteBudget != null && this.inFlightBytes >= byteBudget;
-            if (running.size > 0 && (free <= 0 || overBudget)) {
+            if (free <= 0) {
                 // Wait for a slot rather than spinning. runCall() never rejects, so
                 // racing these is safe.
                 await Promise.race([...running]);
                 continue;
             }
-            const { sources, names } = this.schedule();
-            if (!sources.length) {
+            if (this.planner.empty) {
                 await this.idle(pollMs);
                 continue;
             }
-            // Round-robin the starting point. The draws are served in order, so without
-            // rotating it the first source would take every free slot and the rest
-            // would starve behind its backlog.
-            const cursor = this.claimCursor % sources.length;
-            const order = [...sources.slice(cursor), ...sources.slice(0, cursor)];
-            this.claimCursor = (cursor + 1) % sources.length;
-            let claimed;
+            let drawn;
             try {
-                claimed = await this.store.claimSession(
+                drawn = await this.store.claimSession(
                 // Only what this worker can run. Queues do not partition work by task
                 // name, so another worker's tasks would otherwise be claimed here and
                 // failed for want of a handler.
-                { queues: this.queues, workerId: this.ownId, leaseMs, names }, async (claim) => {
-                    const drawn = [];
-                    let left = free;
-                    // Resource units this poll has already drawn. resourceCalls only
-                    // moves when a call is dispatched, which happens after this whole
-                    // plan returns — so without a local tally two sources sharing a
-                    // resource would each see its full ceiling and together overshoot
-                    // it. Same shape as `left`, one budget down.
-                    const taken = new Map();
-                    for (const src of order) {
-                        if (left <= 0)
-                            break;
-                        const quota = Math.min(this.sourceCalls(src, taken) ?? left, left);
-                        if (quota <= 0)
-                            continue;
-                        const rows = await claim(src.names, src.batch * quota);
-                        if (!rows.length)
-                            continue;
-                        // deliveries() is what actually turns rows into handler calls, so
-                        // spending the budget against its result is the only way the two
-                        // cannot disagree. A source with nothing queued costs nothing,
-                        // which is why the budget is spent here, draw by draw, rather than
-                        // divided up before the claim.
-                        const calls = this.deliveries(rows);
-                        drawn.push({ src, calls });
-                        left -= calls.length;
-                        if (src.resource != null) {
-                            taken.set(src.resource, (taken.get(src.resource) ?? 0) + calls.length);
-                        }
-                    }
-                    return drawn;
-                });
+                { queues: this.queues, workerId: this.ownId, leaseMs, names: this.planner.names }, (claim) => this.planner.plan(free, claim, (rows) => this.deliveries(rows)));
             }
             catch (err) {
                 // A claim can fail transiently (lock contention, a dropped connection).
@@ -422,31 +368,21 @@ export class Worker {
                 await this.sleepOrStop(CLAIM_ERROR_BACKOFF_MS);
                 continue;
             }
-            if (!claimed?.length) {
+            if (!drawn?.length) {
                 await this.idle(pollMs);
                 continue;
             }
-            for (const { src, calls } of claimed) {
+            for (const { src, calls } of drawn) {
                 for (const [reg, group] of calls) {
                     // Charged before the handler starts and refunded when it settles, so
-                    // the budgets cover exactly the span the call holds its slot and its
-                    // payloads stay pinned in memory.
-                    const bytes = byteBudget == null ? 0 : group.reduce((sum, t) => sum + payloadBytes(t), 0);
-                    this.inFlightBytes += bytes;
-                    const key = src.key;
+                    // the resource covers exactly the span the call holds its slot.
                     const resource = src.resource;
-                    if (key != null)
-                        this.callsInFlight.set(key, (this.callsInFlight.get(key) ?? 0) + 1);
-                    if (resource != null) {
-                        this.resourceCalls.set(resource, (this.resourceCalls.get(resource) ?? 0) + 1);
-                    }
+                    this.planner.acquire(resource);
                     // An unregistered name has nothing to run, so it never starts a handler
                     // or a heartbeat; everything else is one call, batched or not.
                     const call = reg == null ? this.failNoHandler(group[0], leaseMs) : this.runCall(reg, group, leaseMs);
                     const p = call.finally(() => {
-                        this.inFlightBytes -= bytes;
-                        release(this.callsInFlight, key);
-                        release(this.resourceCalls, resource);
+                        this.planner.release(resource);
                         running.delete(p);
                     });
                     running.add(p);
@@ -471,17 +407,50 @@ export class Worker {
             await this.closeIfOwned();
         }
     }
-    /** Run the worker in the same process for the duration of fn (deployment mode A). */
+    /**
+     * Run the worker in the same process for the duration of fn (deployment mode A).
+     *
+     * `run()` can fail before `fn` has even started — a database that will not
+     * open, a migration that will not apply, a protocol version this SDK does not
+     * speak — so its rejection is captured from the first tick rather than only at
+     * the `await` in the teardown. Left uncaught until then it is an unhandled
+     * rejection, which Node terminates the process for by default: the caller
+     * never saw the error, and `fn` never finished. (The same mistake `runCall`
+     * documents having made.)
+     *
+     * If `fn` returned, the worker's failure is what the caller hears: a value
+     * produced with no worker running is not a success worth reporting quietly. If
+     * `fn` threw, its own error wins — it is the caller's code, and replacing it
+     * would hide what they were actually doing — with the worker's failure
+     * attached as `cause` so the root of it stays reachable.
+     */
     async background(fn, opts = {}) {
         const runner = this.run(opts);
-        try {
-            return await fn();
-        }
-        finally {
+        // Attached now, not at the await in the teardown: that is what keeps an
+        // early rejection from being an unhandled one. Carried as a value rather
+        // than assigned to a captured variable, so the outcome flows out of
+        // `shutdown` and needs no cast to be read.
+        const settled = runner.then(() => null, (err) => ({ err }));
+        const shutdown = async () => {
             this.stop();
-            await runner;
+            const failure = await settled;
             await this.closeIfOwned();
+            return failure;
+        };
+        let value;
+        try {
+            value = await fn();
+        }
+        catch (err) {
+            const failure = await shutdown();
+            if (failure && err instanceof Error && err.cause === undefined)
+                err.cause = failure.err;
+            throw err;
         }
+        const failure = await shutdown();
+        if (failure)
+            throw failure.err;
+        return value;
     }
     /**
      * Record a claimed task this worker cannot run. Reachable only if a name is
@@ -661,10 +630,13 @@ export class Worker {
      * set.
      *
      * On timeout the attempt is abandoned: every context it covers is flagged
-     * lease-lost first (ctx.signal aborts, and a handler that keeps running can
-     * never write again, nor settle anything behind the worker's back — see
-     * TaskContext.owned), then the still-pending promise is left to settle on its
-     * own, its outcome discarded. The caller records the handler_timeout failure;
+     * lease-lost first (ctx.signal aborts; a handler that keeps running can never
+     * write to its task again, nor settle anything behind the worker's back — see
+     * TaskContext.owned — and cannot create child tasks either, which would
+     * otherwise be created a second time by the retry), then the still-pending
+     * promise is left to settle on its own, its outcome discarded. What a zombie
+     * does OUTSIDE cairnq is its own business: `ctx.signal` is how a handler is
+     * told to stop, and only the handler can act on it. The caller records the handler_timeout failure;
      * lease recovery is NOT involved, so redelivery is immediate.
      */
     async attempt(invoke, ctxs) {
@@ -705,27 +677,7 @@ export class Worker {
         let active = true;
         let wake = null;
         // lease/3 gives two beats of slack; the floor only matters for sub-150ms leases.
-        const interval = this.opts.heartbeatIntervalMs ?? Math.max(50, Math.floor(leaseMs / 3));
-        // When this heartbeat last ran. A loop cannot report its own absence — a
-        // handler that blocks for its whole attempt never lets the timer fire at all
-        // — so the check lives outside the loop and cancel() runs it too.
-        let lastBeatAt = Date.now();
-        /** Report a heartbeat that has not run for more than two intervals: a whole
-         * beat missed, which at lease/3 means the next such block loses the lease
-         * outright. Fires while the lease still holds — after it expires the only
-         * evidence is a task that ran twice, in two workers' logs, with no error in
-         * either. */
-        const checkBeat = () => {
-            const now = Date.now();
-            const lateMs = now - lastBeatAt - interval;
-            if (lateMs > interval) {
-                this.report(new EventLoopBlocked(lateMs, interval, leaseMs), {
-                    phase: "execute",
-                    taskId: ctxs[0].taskId,
-                });
-            }
-            lastBeatAt = now;
-        };
+        const interval = Math.max(50, Math.floor(leaseMs / 3));
         const done = (async () => {
             while (active) {
                 // Cancellable sleep: cancel() resolves this immediately and clears the
@@ -740,7 +692,6 @@ export class Worker {
                 wake = null;
                 if (!active)
                     break;
-                checkBeat();
                 const live = ctxs.filter((c) => !c.settled && !c.lostLease);
                 if (!live.length)
                     break;
@@ -770,10 +721,6 @@ export class Worker {
                 active = false;
                 if (wake)
                     wake();
-                // The attempt is over, so this is the last chance to notice that the
-                // heartbeat never got one — the whole-attempt block, which is also the
-                // one where the lease is already gone.
-                checkBeat();
             },
             done,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cairnq",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "SQLite-first, cross-language, storage-centered durable task runtime",
   "license": "MIT",
   "author": "Jannchie <jannchie@gmail.com>",

package/src/backpressure.ts

@@ -30,8 +30,6 @@ export interface BackpressureOptions {
   maxQueueDepth: QueueDepthLimit;
   /** How long a blocked submit waits before raising QueueFull. Default 600_000. */
   maxQueueWaitMs?: number;
-  /** First backoff between depth probes; doubles to a 5s ceiling. Default 250. */
-  queuePollIntervalMs?: number;
 }
 
 /**
@@ -60,7 +58,6 @@ export class QueueDepthGate {
   private readonly probing = new Map<string, Promise<void>>();
   private readonly limits: QueueDepthLimit;
   private readonly maxWaitMs: number;
-  private readonly initialProbeMs: number;
 
   constructor(
     private readonly store: TaskStore,
@@ -68,7 +65,6 @@ export class QueueDepthGate {
   ) {
     this.limits = opts.maxQueueDepth;
     this.maxWaitMs = opts.maxQueueWaitMs ?? DEFAULT_MAX_WAIT_MS;
-    this.initialProbeMs = opts.queuePollIntervalMs ?? INITIAL_PROBE_INTERVAL_MS;
     if (typeof this.limits === "number") this.validate("*", this.limits);
     else for (const [q, v] of Object.entries(this.limits)) this.validate(q, v);
   }
@@ -98,7 +94,7 @@ export class QueueDepthGate {
     if (limit == null) return;
 
     const startedAt = Date.now();
-    let waitMs = this.initialProbeMs;
+    let waitMs = INITIAL_PROBE_INTERVAL_MS;
     for (;;) {
       const left = this.headroom.get(queue) ?? 0;
       if (left > 0) {