cairnq 0.15.0 → 0.15.1

package/dist/worker.d.ts

@@ -87,6 +87,8 @@ export declare class Worker {
     private readonly backoffMaxMs;
     private stopped;
     private stopWake;
+    private freed$;
+    private freedWake;
     private readonly stopped$;
     private ownsStore;
     constructor(store: TaskStore, queues: string[], opts?: WorkerOptions);
@@ -279,6 +281,9 @@ export declare class Worker {
      * cuts it short when a task on this worker's queues becomes claimable;
      * stop() interrupts it either way, and sleepOrStop bounds it at `ms` so the
      * poll fallback — which also drives lease recovery — never stretches.
+     *
+     * `freed` is the third way out: a resource unit coming back frees a claim the
+     * store has no reason to announce (see `freed$`).
      */
     private idle;
     private sleepOrStop;

package/dist/worker.js

@@ -162,6 +162,13 @@ export class Worker {
     backoffMaxMs;
     stopped = false;
     stopWake;
+    // Re-armed before each claim, resolved when a call gives a resource unit
+    // back. A claim can come back empty because a resource is at capacity rather
+    // than the queue, and that release is local — no store notification covers
+    // it, so the idle sleep waits on this too. Armed before the claim, so a
+    // release landing *during* it still shortens the sleep that follows.
+    freed$ = Promise.resolve();
+    freedWake = () => { };
     // Resolved once by stop(); every sleep races against it. A stopped worker
     // never restarts, so one promise serves the instance's lifetime.
     stopped$ = new Promise((r) => (this.stopWake = r));
@@ -353,6 +360,7 @@ export class Worker {
                 await this.idle(pollMs);
                 continue;
             }
+            this.freed$ = new Promise((r) => (this.freedWake = r));
             let drawn;
             try {
                 drawn = await this.store.claimSession(
@@ -369,7 +377,7 @@ export class Worker {
                 continue;
             }
             if (!drawn?.length) {
-                await this.idle(pollMs);
+                await this.idle(pollMs, this.freed$);
                 continue;
             }
             for (const { src, calls } of drawn) {
@@ -384,6 +392,8 @@ export class Worker {
                     const p = call.finally(() => {
                         this.planner.release(resource);
                         running.delete(p);
+                        if (resource != null)
+                            this.freedWake();
                     });
                     running.add(p);
                 }
@@ -746,9 +756,15 @@ export class Worker {
      * cuts it short when a task on this worker's queues becomes claimable;
      * stop() interrupts it either way, and sleepOrStop bounds it at `ms` so the
      * poll fallback — which also drives lease recovery — never stretches.
+     *
+     * `freed` is the third way out: a resource unit coming back frees a claim the
+     * store has no reason to announce (see `freed$`).
      */
-    idle(ms) {
-        return Promise.race([this.sleepOrStop(ms), this.store.claimWake(this.queues, ms)]);
+    idle(ms, freed) {
+        const racers = [this.sleepOrStop(ms), this.store.claimWake(this.queues, ms)];
+        if (freed)
+            racers.push(freed);
+        return Promise.race(racers);
     }
     sleepOrStop(ms) {
         if (this.stopped)

package/package.json

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

package/src/worker.ts

@@ -281,6 +281,13 @@ export class Worker {
   private readonly backoffMaxMs: number;
   private stopped = false;
   private stopWake!: () => void;
+  // Re-armed before each claim, resolved when a call gives a resource unit
+  // back. A claim can come back empty because a resource is at capacity rather
+  // than the queue, and that release is local — no store notification covers
+  // it, so the idle sleep waits on this too. Armed before the claim, so a
+  // release landing *during* it still shortens the sleep that follows.
+  private freed$ = Promise.resolve();
+  private freedWake: () => void = () => {};
   // Resolved once by stop(); every sleep races against it. A stopped worker
   // never restarts, so one promise serves the instance's lifetime.
   private readonly stopped$ = new Promise<void>((r) => (this.stopWake = r));
@@ -519,6 +526,7 @@ export class Worker {
         await this.idle(pollMs);
         continue;
       }
+      this.freed$ = new Promise<void>((r) => (this.freedWake = r));
       let drawn: Draw[] | undefined;
       try {
         drawn = await this.store.claimSession(
@@ -536,7 +544,7 @@ export class Worker {
         continue;
       }
       if (!drawn?.length) {
-        await this.idle(pollMs);
+        await this.idle(pollMs, this.freed$);
         continue;
       }
       for (const { src, calls } of drawn) {
@@ -552,6 +560,7 @@ export class Worker {
           const p = call.finally(() => {
             this.planner.release(resource);
             running.delete(p);
+            if (resource != null) this.freedWake();
           });
           running.add(p);
         }
@@ -929,9 +938,14 @@ export class Worker {
    * cuts it short when a task on this worker's queues becomes claimable;
    * stop() interrupts it either way, and sleepOrStop bounds it at `ms` so the
    * poll fallback — which also drives lease recovery — never stretches.
+   *
+   * `freed` is the third way out: a resource unit coming back frees a claim the
+   * store has no reason to announce (see `freed$`).
    */
-  private idle(ms: number): Promise<void> {
-    return Promise.race([this.sleepOrStop(ms), this.store.claimWake(this.queues, ms)]);
+  private idle(ms: number, freed?: Promise<void>): Promise<void> {
+    const racers = [this.sleepOrStop(ms), this.store.claimWake(this.queues, ms)];
+    if (freed) racers.push(freed);
+    return Promise.race(racers);
   }
 
   private sleepOrStop(ms: number): Promise<void> {