dicom-curate 0.26.1 → 0.26.2

package/dist/esm/applyMappingsWorker.js

@@ -79661,6 +79661,30 @@ function curateDict(inputFilePath, dicomData, mappingOptions) {
   return { dicomData: mappedDicomData, mapResults: (0, import_lodash4.cloneDeep)(mapResults) };
 }
 
+// src/fetchWithRetry.ts
+var MAX_ATTEMPTS = 5;
+var BASE_DELAY_MS = 1e3;
+var BACKOFF_MULTIPLIER = 3;
+async function fetchWithRetry(...args) {
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      return await fetch(...args);
+    } catch (error2) {
+      const isNetworkError = error2 instanceof TypeError;
+      const isLastAttempt = attempt === MAX_ATTEMPTS;
+      if (!isNetworkError || isLastAttempt) {
+        throw error2;
+      }
+      const delayMs = BASE_DELAY_MS * BACKOFF_MULTIPLIER ** (attempt - 1);
+      console.warn(
+        `fetch attempt ${attempt}/${MAX_ATTEMPTS} failed: ${error2.message}. Retrying in ${delayMs}ms...`
+      );
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  throw new Error("fetchWithRetry: unreachable");
+}
+
 // src/hash.ts
 var import_md5 = __toESM(require_md5(), 1);
 var import_js_crc = __toESM(require_crc(), 1);
@@ -80034,7 +80058,7 @@ async function curateOne({
         }
         if (postMappedHashHeader && postMappedHash)
           headers[postMappedHashHeader] = postMappedHash;
-        const resp = await fetch(uploadUrl, {
+        const resp = await fetchWithRetry(uploadUrl, {
           method: "PUT",
           headers,
           body: clonedMapResults.mappedBlob

package/dist/esm/curateOne.js

@@ -73370,6 +73370,30 @@ function curateDict(inputFilePath, dicomData, mappingOptions) {
   return { dicomData: mappedDicomData, mapResults: (0, import_lodash4.cloneDeep)(mapResults) };
 }
 
+// src/fetchWithRetry.ts
+var MAX_ATTEMPTS = 5;
+var BASE_DELAY_MS = 1e3;
+var BACKOFF_MULTIPLIER = 3;
+async function fetchWithRetry(...args) {
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      return await fetch(...args);
+    } catch (error2) {
+      const isNetworkError = error2 instanceof TypeError;
+      const isLastAttempt = attempt === MAX_ATTEMPTS;
+      if (!isNetworkError || isLastAttempt) {
+        throw error2;
+      }
+      const delayMs = BASE_DELAY_MS * BACKOFF_MULTIPLIER ** (attempt - 1);
+      console.warn(
+        `fetch attempt ${attempt}/${MAX_ATTEMPTS} failed: ${error2.message}. Retrying in ${delayMs}ms...`
+      );
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  throw new Error("fetchWithRetry: unreachable");
+}
+
 // src/hash.ts
 var import_md5 = __toESM(require_md5(), 1);
 var import_js_crc = __toESM(require_crc(), 1);
@@ -73743,7 +73767,7 @@ async function curateOne({
         }
         if (postMappedHashHeader && postMappedHash)
           headers[postMappedHashHeader] = postMappedHash;
-        const resp = await fetch(uploadUrl, {
+        const resp = await fetchWithRetry(uploadUrl, {
           method: "PUT",
           headers,
           body: clonedMapResults.mappedBlob

package/dist/esm/fetchWithRetry.js

@@ -0,0 +1,26 @@
+// src/fetchWithRetry.ts
+var MAX_ATTEMPTS = 5;
+var BASE_DELAY_MS = 1e3;
+var BACKOFF_MULTIPLIER = 3;
+async function fetchWithRetry(...args) {
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      return await fetch(...args);
+    } catch (error) {
+      const isNetworkError = error instanceof TypeError;
+      const isLastAttempt = attempt === MAX_ATTEMPTS;
+      if (!isNetworkError || isLastAttempt) {
+        throw error;
+      }
+      const delayMs = BASE_DELAY_MS * BACKOFF_MULTIPLIER ** (attempt - 1);
+      console.warn(
+        `fetch attempt ${attempt}/${MAX_ATTEMPTS} failed: ${error.message}. Retrying in ${delayMs}ms...`
+      );
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  throw new Error("fetchWithRetry: unreachable");
+}
+export {
+  fetchWithRetry
+};

package/dist/esm/index.js

@@ -81221,6 +81221,30 @@ function curateDict(inputFilePath, dicomData, mappingOptions) {
   return { dicomData: mappedDicomData, mapResults: (0, import_lodash4.cloneDeep)(mapResults) };
 }
 
+// src/fetchWithRetry.ts
+var MAX_ATTEMPTS = 5;
+var BASE_DELAY_MS = 1e3;
+var BACKOFF_MULTIPLIER = 3;
+async function fetchWithRetry(...args) {
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      return await fetch(...args);
+    } catch (error2) {
+      const isNetworkError = error2 instanceof TypeError;
+      const isLastAttempt = attempt === MAX_ATTEMPTS;
+      if (!isNetworkError || isLastAttempt) {
+        throw error2;
+      }
+      const delayMs = BASE_DELAY_MS * BACKOFF_MULTIPLIER ** (attempt - 1);
+      console.warn(
+        `fetch attempt ${attempt}/${MAX_ATTEMPTS} failed: ${error2.message}. Retrying in ${delayMs}ms...`
+      );
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  throw new Error("fetchWithRetry: unreachable");
+}
+
 // src/hash.ts
 var import_md5 = __toESM(require_md5(), 1);
 var import_js_crc = __toESM(require_crc(), 1);
@@ -81594,7 +81618,7 @@ async function curateOne({
         }
         if (postMappedHashHeader && postMappedHash)
           headers[postMappedHashHeader] = postMappedHash;
-        const resp = await fetch(uploadUrl, {
+        const resp = await fetchWithRetry(uploadUrl, {
           method: "PUT",
           headers,
           body: clonedMapResults.mappedBlob

package/dist/types/fetchWithRetry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wraps fetch() with retry logic for transient network errors.
+ *
+ * Retries only on TypeError (network failure — request never reached the
+ * server). Does NOT retry on HTTP error responses (4xx, 5xx) since those
+ * indicate the request was received and a retry without changing the request
+ * would likely produce the same result.
+ *
+ * Uses exponential backoff (1s, 3s, 9s, 27s, 81s) which also acts as natural
+ * backpressure — workers block during backoff, reducing concurrent uploads.
+ */
+export declare function fetchWithRetry(...args: Parameters<typeof fetch>): Promise<Response>;

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

@@ -47934,6 +47934,40 @@
           return { dicomData: mappedDicomData, mapResults: lodashExports.cloneDeep(mapResults) };
       }
 
+      /**
+       * Wraps fetch() with retry logic for transient network errors.
+       *
+       * Retries only on TypeError (network failure — request never reached the
+       * server). Does NOT retry on HTTP error responses (4xx, 5xx) since those
+       * indicate the request was received and a retry without changing the request
+       * would likely produce the same result.
+       *
+       * Uses exponential backoff (1s, 3s, 9s, 27s, 81s) which also acts as natural
+       * backpressure — workers block during backoff, reducing concurrent uploads.
+       */
+      const MAX_ATTEMPTS = 5;
+      const BASE_DELAY_MS = 1000;
+      const BACKOFF_MULTIPLIER = 3;
+      async function fetchWithRetry(...args) {
+          for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+              try {
+                  return await fetch(...args);
+              }
+              catch (error) {
+                  const isNetworkError = error instanceof TypeError;
+                  const isLastAttempt = attempt === MAX_ATTEMPTS;
+                  if (!isNetworkError || isLastAttempt) {
+                      throw error;
+                  }
+                  const delayMs = BASE_DELAY_MS * BACKOFF_MULTIPLIER ** (attempt - 1);
+                  console.warn(`fetch attempt ${attempt}/${MAX_ATTEMPTS} failed: ${error.message}. Retrying in ${delayMs}ms...`);
+                  await new Promise((resolve) => setTimeout(resolve, delayMs));
+              }
+          }
+          // Unreachable — the loop either returns or throws on the last attempt.
+          throw new Error('fetchWithRetry: unreachable');
+      }
+
       var md5$1 = {exports: {}};
 
       var crypt = {exports: {}};
@@ -49116,7 +49150,7 @@
                       }
                       if (postMappedHashHeader && postMappedHash)
                           headers[postMappedHashHeader] = postMappedHash;
-                      const resp = await fetch(uploadUrl, {
+                      const resp = await fetchWithRetry(uploadUrl, {
                           method: 'PUT',
                           headers,
                           body: clonedMapResults.mappedBlob,
@@ -109949,6 +109983,40 @@
         return { dicomData: mappedDicomData, mapResults: lodashExports.cloneDeep(mapResults) };
     }
 
+    /**
+     * Wraps fetch() with retry logic for transient network errors.
+     *
+     * Retries only on TypeError (network failure — request never reached the
+     * server). Does NOT retry on HTTP error responses (4xx, 5xx) since those
+     * indicate the request was received and a retry without changing the request
+     * would likely produce the same result.
+     *
+     * Uses exponential backoff (1s, 3s, 9s, 27s, 81s) which also acts as natural
+     * backpressure — workers block during backoff, reducing concurrent uploads.
+     */
+    const MAX_ATTEMPTS = 5;
+    const BASE_DELAY_MS = 1000;
+    const BACKOFF_MULTIPLIER = 3;
+    async function fetchWithRetry(...args) {
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            try {
+                return await fetch(...args);
+            }
+            catch (error) {
+                const isNetworkError = error instanceof TypeError;
+                const isLastAttempt = attempt === MAX_ATTEMPTS;
+                if (!isNetworkError || isLastAttempt) {
+                    throw error;
+                }
+                const delayMs = BASE_DELAY_MS * BACKOFF_MULTIPLIER ** (attempt - 1);
+                console.warn(`fetch attempt ${attempt}/${MAX_ATTEMPTS} failed: ${error.message}. Retrying in ${delayMs}ms...`);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+        // Unreachable — the loop either returns or throws on the last attempt.
+        throw new Error('fetchWithRetry: unreachable');
+    }
+
     var md5$1 = {exports: {}};
 
     var crypt = {exports: {}};
@@ -111133,7 +111201,7 @@
                     }
                     if (postMappedHashHeader && postMappedHash)
                         headers[postMappedHashHeader] = postMappedHash;
-                    const resp = await fetch(uploadUrl, {
+                    const resp = await fetchWithRetry(uploadUrl, {
                         method: 'PUT',
                         headers,
                         body: clonedMapResults.mappedBlob,