@danielsimonjr/memoryjs 2.8.0 → 2.8.1

package/dist/index.d.cts

@@ -8480,10 +8480,13 @@ interface TaskSubmitOptions {
 }
 /**
  * Handle returned by `submitWithHandle`. The `result` promise settles when
- * the task finishes; `cancel()` evicts a still-pending task from the queue
- * (returns `true`) or signals a request-cancellation flag on a running task
- * (returns `false` — `workerpool` itself doesn't support hard-cancel and
- * terminating mid-task is destructive).
+ * the task finishes; `cancel()` performs two-tier cancellation:
+ *
+ *   - If still pending in the queue: evict cleanly. Returns `true`.
+ *   - If already dispatched: propagate to the underlying
+ *     `WorkerpoolPromise.cancel()` so the running worker rejects with
+ *     `CancellationError`. Returns `true` if the workerpool promise was
+ *     still pending at the moment of cancel; `false` if it already settled.
  */
 interface TaskHandle<R> {
     id: string;
@@ -8534,6 +8537,7 @@ declare class WorkerTaskManager {
     private readonly touchedPoolIds;
     private readonly cancelledTaskIds;
     private readonly handleStatus;
+    private readonly liveExecPromises;
     constructor(opts?: {
         /** Max concurrent tasks across the queue. Default: cpus − 1. */
         concurrency?: number;

package/dist/index.d.ts

@@ -8480,10 +8480,13 @@ interface TaskSubmitOptions {
 }
 /**
  * Handle returned by `submitWithHandle`. The `result` promise settles when
- * the task finishes; `cancel()` evicts a still-pending task from the queue
- * (returns `true`) or signals a request-cancellation flag on a running task
- * (returns `false` — `workerpool` itself doesn't support hard-cancel and
- * terminating mid-task is destructive).
+ * the task finishes; `cancel()` performs two-tier cancellation:
+ *
+ *   - If still pending in the queue: evict cleanly. Returns `true`.
+ *   - If already dispatched: propagate to the underlying
+ *     `WorkerpoolPromise.cancel()` so the running worker rejects with
+ *     `CancellationError`. Returns `true` if the workerpool promise was
+ *     still pending at the moment of cancel; `false` if it already settled.
  */
 interface TaskHandle<R> {
     id: string;
@@ -8534,6 +8537,7 @@ declare class WorkerTaskManager {
     private readonly touchedPoolIds;
     private readonly cancelledTaskIds;
     private readonly handleStatus;
+    private readonly liveExecPromises;
     constructor(opts?: {
         /** Max concurrent tasks across the queue. Default: cpus − 1. */
         concurrency?: number;

package/dist/index.js

@@ -3441,6 +3441,10 @@ var init_WorkerTaskManager = __esm({
       touchedPoolIds = /* @__PURE__ */ new Set();
       cancelledTaskIds = /* @__PURE__ */ new Set();
       handleStatus = /* @__PURE__ */ new Map();
+      // Live `pool.exec(...)` promises by task id. Populated when a task starts
+      // running so the handle can call `.cancel()` on the workerpool promise
+      // for mid-execution cancellation. Cleared on completion / failure.
+      liveExecPromises = /* @__PURE__ */ new Map();
       constructor(opts = {}) {
         this.queue = new TaskQueue({
           concurrency: opts.concurrency,
@@ -3480,7 +3484,13 @@ var init_WorkerTaskManager = __esm({
             this.handleStatus.set(id, "running" /* RUNNING */);
             const pool = this.poolManager.getPool(input.workerType, opts.poolConfig);
             this.touchedPoolIds.add(input.workerType);
-            return await pool.exec(input.methodName, input.args);
+            const execPromise = pool.exec(input.methodName, input.args);
+            this.liveExecPromises.set(id, execPromise);
+            try {
+              return await execPromise;
+            } finally {
+              this.liveExecPromises.delete(id);
+            }
           }
         };
         const result = this.queue.enqueue(task).then(async (res) => {
@@ -3502,8 +3512,21 @@ var init_WorkerTaskManager = __esm({
             const evicted = this.queue.cancel(id);
             if (evicted) {
               this.handleStatus.set(id, "cancelled" /* CANCELLED */);
+              return true;
+            }
+            const live = this.liveExecPromises.get(id);
+            if (live && typeof live.cancel === "function") {
+              if (live.pending === false) return false;
+              try {
+                live.cancel();
+                this.handleStatus.set(id, "cancelled" /* CANCELLED */);
+                return true;
+              } catch (e) {
+                logger.warn(`[WorkerTaskManager] cancel() on live exec for ${id} threw:`, e);
+                return false;
+              }
             }
-            return evicted;
+            return false;
           },
           status: () => this.handleStatus.get(id) ?? "pending" /* PENDING */
         };