dicom-curate 0.29.0 → 0.30.0

package/dist/esm/index.js

@@ -48613,14 +48613,14 @@ var require_dist_cjs70 = __commonJS({
       const exitConditions = [runPolling(params, input, acceptorChecks)];
       const finalize = [];
       if (options.abortSignal) {
-        const { aborted, clearListener } = abortTimeout(options.abortSignal);
+        const { aborted: aborted2, clearListener } = abortTimeout(options.abortSignal);
         finalize.push(clearListener);
-        exitConditions.push(aborted);
+        exitConditions.push(aborted2);
       }
       if (options.abortController?.signal) {
-        const { aborted, clearListener } = abortTimeout(options.abortController.signal);
+        const { aborted: aborted2, clearListener } = abortTimeout(options.abortController.signal);
         finalize.push(clearListener);
-        exitConditions.push(aborted);
+        exitConditions.push(aborted2);
       }
       return Promise.race(exitConditions).then((result) => {
         for (const fn of finalize) {
@@ -87483,6 +87483,7 @@ var filesMapped = 0;
 var workerCurrentFile = /* @__PURE__ */ new Map();
 var lastWorkerProgressTime = 0;
 var pendingReplacements = 0;
+var aborted = false;
 var currentFileInfoIndex;
 var filesToProcess = [];
 var directoryScanFinished = false;
@@ -87505,12 +87506,32 @@ function setScanResumeCallback(cb) {
 function markScanPaused() {
   scanPaused = true;
 }
+function terminateAllWorkers() {
+  aborted = true;
+  while (availableMappingWorkers.length) {
+    availableMappingWorkers.pop().terminate();
+  }
+  for (const [worker] of workerCurrentFile) {
+    try {
+      worker.terminate();
+    } catch {
+    }
+  }
+  workerCurrentFile.clear();
+  filesToProcess.length = 0;
+  workersActive = 0;
+  pendingReplacements = 0;
+  directoryScanFinished = false;
+  scanPaused = false;
+  scanResumeCallback = null;
+}
 async function initializeMappingWorkers(skipCollectingMappings, fileInfoIndex, progressCb, workerCount) {
   mappingWorkerOptions = {};
   workersActive = 0;
   mapResultsList = skipCollectingMappings ? void 0 : [];
   filesMapped = 0;
   pendingReplacements = 0;
+  aborted = false;
   workerCurrentFile.clear();
   lastWorkerProgressTime = Date.now();
   currentFileInfoIndex = fileInfoIndex;
@@ -87526,6 +87547,8 @@ async function initializeMappingWorkers(skipCollectingMappings, fileInfoIndex, p
   availableMappingWorkers.push(...workers);
 }
 async function dispatchMappingJobs() {
+  if (aborted)
+    return;
   while (filesToProcess.length > 0 && availableMappingWorkers.length > 0) {
     const { fileInfo, previousFileInfo } = filesToProcess.pop();
     const mappingWorker = availableMappingWorkers.pop();
@@ -87588,6 +87611,8 @@ async function getHardwareConcurrency() {
   return cpus().length;
 }
 function recoverCrashedWorker(mappingWorker, errorMessage) {
+  if (aborted)
+    return;
   if (!workerCurrentFile.has(mappingWorker)) {
     return;
   }
@@ -87623,6 +87648,10 @@ function recoverCrashedWorker(mappingWorker, errorMessage) {
   pendingReplacements += 1;
   void createMappingWorker().then((worker) => {
     pendingReplacements -= 1;
+    if (aborted) {
+      worker.terminate();
+      return;
+    }
     availableMappingWorkers.push(worker);
     dispatchMappingJobs();
   }).catch((error2) => {
@@ -87652,6 +87681,8 @@ async function createMappingWorker() {
     });
   }
   mappingWorker.addEventListener("message", (event) => {
+    if (aborted)
+      return;
     if (event.data.response === "lookup") {
       const outputPath = event.data.outputPath;
       const entry = currentFileInfoIndex?.[OUTPUT_FILE_PREFIX + outputPath];
@@ -87870,7 +87901,14 @@ function queueUrlsForMapping(organizeOptions) {
   setDirectoryScanFinished(true);
 }
 async function curateMany(organizeOptions, onProgress) {
+  if (organizeOptions.signal?.aborted) {
+    return Promise.reject(
+      new DOMException("The operation was aborted.", "AbortError")
+    );
+  }
   return new Promise(async (resolve, reject) => {
+    let settled = false;
+    const signal = organizeOptions.signal;
     const STALL_TIMEOUT_MS = 10 * 60 * 1e3;
     const stallWatchdog = setInterval(() => {
       if (getWorkersActive() > 0 && Date.now() - getLastWorkerProgressTime() > STALL_TIMEOUT_MS) {
@@ -87889,15 +87927,42 @@ async function curateMany(organizeOptions, onProgress) {
     }, 6e4);
     const progressCallback2 = (msg) => {
       onProgress?.(msg);
-      if (msg.response === "done") {
+      if (msg.response === "done" && !settled) {
+        settled = true;
         clearInterval(stallWatchdog);
+        signal?.removeEventListener("abort", onAbort);
         resolve(msg);
       }
     };
     const rejectCallback = (reason) => {
+      if (settled)
+        return;
+      settled = true;
       clearInterval(stallWatchdog);
+      signal?.removeEventListener("abort", onAbort);
       reject(reason);
     };
+    let fileListWorker;
+    const onAbort = () => {
+      try {
+        fileListWorker?.terminate();
+      } catch {
+      }
+      terminateAllWorkers();
+      rejectCallback(
+        new DOMException("The operation was aborted.", "AbortError")
+      );
+    };
+    if (signal) {
+      if (signal.aborted) {
+        clearInterval(stallWatchdog);
+        rejectCallback(
+          new DOMException("The operation was aborted.", "AbortError")
+        );
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
     try {
       await initializeMappingWorkers(
         organizeOptions.skipCollectingMappings,
@@ -87909,7 +87974,7 @@ async function curateMany(organizeOptions, onProgress) {
         await collectMappingOptions(organizeOptions)
       );
       if (organizeOptions.inputType === "directory" || organizeOptions.inputType === "path" || organizeOptions.inputType === "s3") {
-        const fileListWorker = await initializeFileListWorker(rejectCallback);
+        fileListWorker = await initializeFileListWorker(rejectCallback);
         setScanResumeCallback(() => {
           fileListWorker.postMessage({ request: "resume" });
         });
@@ -87966,7 +88031,7 @@ async function curateMany(organizeOptions, onProgress) {
       }
       dispatchMappingJobs();
     } catch (error2) {
-      reject(error2);
+      rejectCallback(error2);
     }
   });
 }

package/dist/esm/mappingWorkerPool.js

@@ -12055,6 +12055,7 @@ var filesMapped = 0;
 var workerCurrentFile = /* @__PURE__ */ new Map();
 var lastWorkerProgressTime = 0;
 var pendingReplacements = 0;
+var aborted = false;
 var currentFileInfoIndex;
 var filesToProcess = [];
 var directoryScanFinished = false;
@@ -12077,12 +12078,35 @@ function setScanResumeCallback(cb) {
 function markScanPaused() {
   scanPaused = true;
 }
+function terminateAllWorkers() {
+  aborted = true;
+  while (availableMappingWorkers.length) {
+    availableMappingWorkers.pop().terminate();
+  }
+  for (const [worker] of workerCurrentFile) {
+    try {
+      worker.terminate();
+    } catch {
+    }
+  }
+  workerCurrentFile.clear();
+  filesToProcess.length = 0;
+  workersActive = 0;
+  pendingReplacements = 0;
+  directoryScanFinished = false;
+  scanPaused = false;
+  scanResumeCallback = null;
+}
+function isAborted() {
+  return aborted;
+}
 async function initializeMappingWorkers(skipCollectingMappings, fileInfoIndex, progressCb, workerCount) {
   mappingWorkerOptions = {};
   workersActive = 0;
   mapResultsList = skipCollectingMappings ? void 0 : [];
   filesMapped = 0;
   pendingReplacements = 0;
+  aborted = false;
   workerCurrentFile.clear();
   lastWorkerProgressTime = Date.now();
   currentFileInfoIndex = fileInfoIndex;
@@ -12098,6 +12122,8 @@ async function initializeMappingWorkers(skipCollectingMappings, fileInfoIndex, p
   availableMappingWorkers.push(...workers);
 }
 async function dispatchMappingJobs() {
+  if (aborted)
+    return;
   while (filesToProcess.length > 0 && availableMappingWorkers.length > 0) {
     const { fileInfo, previousFileInfo } = filesToProcess.pop();
     const mappingWorker = availableMappingWorkers.pop();
@@ -12160,6 +12186,8 @@ async function getHardwareConcurrency() {
   return cpus().length;
 }
 function recoverCrashedWorker(mappingWorker, errorMessage) {
+  if (aborted)
+    return;
   if (!workerCurrentFile.has(mappingWorker)) {
     return;
   }
@@ -12195,6 +12223,10 @@ function recoverCrashedWorker(mappingWorker, errorMessage) {
   pendingReplacements += 1;
   void createMappingWorker().then((worker) => {
     pendingReplacements -= 1;
+    if (aborted) {
+      worker.terminate();
+      return;
+    }
     availableMappingWorkers.push(worker);
     dispatchMappingJobs();
   }).catch((error) => {
@@ -12224,6 +12256,8 @@ async function createMappingWorker() {
     });
   }
   mappingWorker.addEventListener("message", (event) => {
+    if (aborted)
+      return;
     if (event.data.response === "lookup") {
       const outputPath = event.data.outputPath;
       const entry = currentFileInfoIndex?.[OUTPUT_FILE_PREFIX + outputPath];
@@ -12299,9 +12333,11 @@ export {
   getWorkerCurrentFile,
   getWorkersActive,
   initializeMappingWorkers,
+  isAborted,
   markScanPaused,
   scanAnomalies,
   setDirectoryScanFinished,
   setMappingWorkerOptions,
-  setScanResumeCallback
+  setScanResumeCallback,
+  terminateAllWorkers
 };

package/dist/types/mappingWorkerPool.d.ts

@@ -39,6 +39,18 @@ export declare function setScanResumeCallback(cb: (() => void) | null): void;
  * index.ts when the queue exceeds the high-water mark.
  */
 export declare function markScanPaused(): void;
+/**
+ * Hard-terminate all workers (idle and active) and reset pool state.
+ * Called when curateMany is aborted via AbortSignal. Equivalent to a
+ * tab reload — partially written files are handled by hash checks on
+ * the next run.
+ */
+export declare function terminateAllWorkers(): void;
+/**
+ * Whether the current run has been aborted. Used by worker message handlers
+ * to bail out on messages arriving after teardown.
+ */
+export declare function isAborted(): boolean;
 /**
  * Initialize the mapping worker pool. Call once per curateMany invocation.
  */

package/dist/types/types.d.ts

@@ -33,6 +33,7 @@ export type OrganizeOptions = {
     fileInfoIndex?: TFileInfoIndex;
     excludedPathGlobs?: string[];
     workerCount?: number;
+    signal?: AbortSignal;
 } & ({
     inputType: 'directory';
     inputDirectory: FileSystemDirectoryHandle;

package/dist/umd/dicom-curate.umd.js

@@ -126940,6 +126940,10 @@
     // The termination condition in dispatchMappingJobs() waits for this to reach 0
     // before finishing, to avoid orphaning in-flight replacements.
     let pendingReplacements = 0;
+    // Set to true when curateMany is aborted via AbortSignal. Guards dispatch,
+    // crash recovery, and worker message handlers against acting on stale state
+    // after teardown.
+    let aborted = false;
     // Stored fileInfoIndex from initializeMappingWorkers, used for lookup
     // responses when workers query for previousMappedFileInfo.
     let currentFileInfoIndex;
@@ -126984,6 +126988,36 @@
     function markScanPaused() {
         scanPaused = true;
     }
+    /**
+     * Hard-terminate all workers (idle and active) and reset pool state.
+     * Called when curateMany is aborted via AbortSignal. Equivalent to a
+     * tab reload — partially written files are handled by hash checks on
+     * the next run.
+     */
+    function terminateAllWorkers() {
+        aborted = true;
+        // Terminate idle workers
+        while (availableMappingWorkers.length) {
+            availableMappingWorkers.pop().terminate();
+        }
+        // Terminate active workers (those with an in-flight file)
+        for (const [worker] of workerCurrentFile) {
+            try {
+                worker.terminate();
+            }
+            catch {
+                /* already terminated */
+            }
+        }
+        workerCurrentFile.clear();
+        // Clear the queue and reset counters
+        filesToProcess.length = 0;
+        workersActive = 0;
+        pendingReplacements = 0;
+        directoryScanFinished = false;
+        scanPaused = false;
+        scanResumeCallback = null;
+    }
     /**
      * Initialize the mapping worker pool. Call once per curateMany invocation.
      */
@@ -126993,6 +127027,7 @@
         mapResultsList = skipCollectingMappings ? undefined : [];
         filesMapped = 0;
         pendingReplacements = 0;
+        aborted = false;
         workerCurrentFile.clear();
         lastWorkerProgressTime = Date.now();
         currentFileInfoIndex = fileInfoIndex;
@@ -127011,6 +127046,8 @@
      * replacements, scan finished) and emits the 'done' progress message.
      */
     async function dispatchMappingJobs() {
+        if (aborted)
+            return;
         while (filesToProcess.length > 0 && availableMappingWorkers.length > 0) {
             const { fileInfo, previousFileInfo } = filesToProcess.pop();
             const mappingWorker = availableMappingWorkers.pop();
@@ -127097,6 +127134,9 @@
      * on('exit'), and the stall watchdog.
      */
     function recoverCrashedWorker(mappingWorker, errorMessage) {
+        // Bail out if processing has been aborted — no recovery needed.
+        if (aborted)
+            return;
         // Guard against double-recovery (e.g., both onerror and on('exit') firing
         // for the same crash). Without this, workersActive could go negative.
         if (!workerCurrentFile.has(mappingWorker)) {
@@ -127137,6 +127177,12 @@
         void createMappingWorker()
             .then((worker) => {
             pendingReplacements -= 1;
+            // If processing was aborted while the replacement was being created,
+            // terminate it immediately instead of adding it to the pool.
+            if (aborted) {
+                worker.terminate();
+                return;
+            }
             availableMappingWorkers.push(worker);
             dispatchMappingJobs();
         })
@@ -127174,6 +127220,9 @@
             });
         }
         mappingWorker.addEventListener('message', (event) => {
+            // Ignore messages from workers after abort — the pool is torn down.
+            if (aborted)
+                return;
             // Handle lookup requests from the worker. The worker sends these when
             // curateOne needs to check if a mapped file was already uploaded
             // (previousMappedFileInfo). The index is kept on the main thread to
@@ -127423,7 +127472,14 @@
         setDirectoryScanFinished(true);
     }
     async function curateMany(organizeOptions, onProgress) {
+        // Early rejection for pre-aborted signal — don't create any workers.
+        if (organizeOptions.signal?.aborted) {
+            return Promise.reject(new DOMException('The operation was aborted.', 'AbortError'));
+        }
         return new Promise(async (resolve, reject) => {
+            // Prevents double-settle when abort races with natural completion.
+            let settled = false;
+            const signal = organizeOptions.signal;
             // Stall watchdog: if no mapping worker at all has reported back for 10
             // minutes (i.e., all active workers are stuck), terminate them and count
             // their in-flight files as mapping errors. This guards against undetectable
@@ -127453,15 +127509,46 @@
             // Progress callback wraps the user's callback and handles lifecycle
             const progressCallback = (msg) => {
                 onProgress?.(msg);
-                if (msg.response === 'done') {
+                if (msg.response === 'done' && !settled) {
+                    settled = true;
                     clearInterval(stallWatchdog);
+                    signal?.removeEventListener('abort', onAbort);
                     resolve(msg);
                 }
             };
             const rejectCallback = (reason) => {
+                if (settled)
+                    return;
+                settled = true;
                 clearInterval(stallWatchdog);
+                signal?.removeEventListener('abort', onAbort);
                 reject(reason);
             };
+            // Reference to the scan worker, hoisted so the abort handler can
+            // terminate it. Assigned later when a directory/path/s3 input is used.
+            let fileListWorker;
+            const onAbort = () => {
+                // Terminate the scan worker if it exists
+                try {
+                    fileListWorker?.terminate();
+                }
+                catch {
+                    /* already terminated */
+                }
+                // Hard-terminate all mapping workers and reset pool state
+                terminateAllWorkers();
+                // Reject with standard AbortError
+                rejectCallback(new DOMException('The operation was aborted.', 'AbortError'));
+            };
+            if (signal) {
+                // Re-check in case abort happened between the early check and here
+                if (signal.aborted) {
+                    clearInterval(stallWatchdog);
+                    rejectCallback(new DOMException('The operation was aborted.', 'AbortError'));
+                    return;
+                }
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
             try {
                 // create the mapping workers
                 await initializeMappingWorkers(organizeOptions.skipCollectingMappings, organizeOptions.fileInfoIndex, progressCallback, organizeOptions.workerCount);
@@ -127476,7 +127563,7 @@
                 if (organizeOptions.inputType === 'directory' ||
                     organizeOptions.inputType === 'path' ||
                     organizeOptions.inputType === 's3') {
-                    const fileListWorker = await initializeFileListWorker(rejectCallback);
+                    fileListWorker = await initializeFileListWorker(rejectCallback);
                     // Wire up backpressure resume: when the dispatch loop drains the
                     // queue below the low-water mark, it calls this to resume scanning.
                     setScanResumeCallback(() => {
@@ -127543,7 +127630,7 @@
                 dispatchMappingJobs();
             }
             catch (error) {
-                reject(error);
+                rejectCallback(error);
             }
         });
     }