dicom-curate 0.40.3 → 0.40.5

package/dist/esm/applyMappingsWorker.js

@@ -86801,12 +86801,18 @@ async function curateOne({
       const reader = new async.AsyncDicomReader();
       const parseFeed = cancellableReadableStreamIterable(file.stream());
       const feedDone = reader.stream.fromAsyncStream(parseFeed.iterable);
+      const feedErrorSignal = new Promise((_, reject) => {
+        feedDone.catch(reject);
+      });
       try {
-        await reader.readFile({
-          ignoreErrors: true,
-          noCopy: true,
-          untilTag: "7FE00010"
-        });
+        await Promise.race([
+          reader.readFile({
+            ignoreErrors: true,
+            noCopy: true,
+            untilTag: "7FE00010"
+          }),
+          feedErrorSignal
+        ]);
       } finally {
         await parseFeed.cancel();
         await feedDone.catch(() => {
@@ -86939,7 +86945,11 @@ async function curateOne({
           create: true
         });
         const writable = await fileHandle.createWritable();
-        await writable.write(modifiedBlob);
+        for await (const chunk of readableStreamToAsyncIterable(
+          modifiedBlob.stream()
+        )) {
+          await writable.write(chunk);
+        }
         await writable.close();
       }
     } else if (typeof outputTarget?.directory === "string") {

package/dist/esm/curateOne.js

@@ -80510,12 +80510,18 @@ async function curateOne({
       const reader = new async.AsyncDicomReader();
       const parseFeed = cancellableReadableStreamIterable(file.stream());
       const feedDone = reader.stream.fromAsyncStream(parseFeed.iterable);
+      const feedErrorSignal = new Promise((_, reject) => {
+        feedDone.catch(reject);
+      });
       try {
-        await reader.readFile({
-          ignoreErrors: true,
-          noCopy: true,
-          untilTag: "7FE00010"
-        });
+        await Promise.race([
+          reader.readFile({
+            ignoreErrors: true,
+            noCopy: true,
+            untilTag: "7FE00010"
+          }),
+          feedErrorSignal
+        ]);
       } finally {
         await parseFeed.cancel();
         await feedDone.catch(() => {
@@ -80648,7 +80654,11 @@ async function curateOne({
           create: true
         });
         const writable = await fileHandle.createWritable();
-        await writable.write(modifiedBlob);
+        for await (const chunk of readableStreamToAsyncIterable(
+          modifiedBlob.stream()
+        )) {
+          await writable.write(chunk);
+        }
         await writable.close();
       }
     } else if (typeof outputTarget?.directory === "string") {

package/dist/esm/index.js

@@ -88404,12 +88404,18 @@ async function curateOne({
       const reader = new async.AsyncDicomReader();
       const parseFeed = cancellableReadableStreamIterable(file.stream());
       const feedDone = reader.stream.fromAsyncStream(parseFeed.iterable);
+      const feedErrorSignal = new Promise((_, reject) => {
+        feedDone.catch(reject);
+      });
       try {
-        await reader.readFile({
-          ignoreErrors: true,
-          noCopy: true,
-          untilTag: "7FE00010"
-        });
+        await Promise.race([
+          reader.readFile({
+            ignoreErrors: true,
+            noCopy: true,
+            untilTag: "7FE00010"
+          }),
+          feedErrorSignal
+        ]);
       } finally {
         await parseFeed.cancel();
         await feedDone.catch(() => {
@@ -88542,7 +88548,11 @@ async function curateOne({
           create: true
         });
         const writable = await fileHandle.createWritable();
-        await writable.write(modifiedBlob);
+        for await (const chunk of readableStreamToAsyncIterable(
+          modifiedBlob.stream()
+        )) {
+          await writable.write(chunk);
+        }
         await writable.close();
       }
     } else if (typeof outputTarget?.directory === "string") {

package/dist/esm/mappingWorkerPool.js

@@ -86801,12 +86801,18 @@ async function curateOne({
       const reader = new async.AsyncDicomReader();
       const parseFeed = cancellableReadableStreamIterable(file.stream());
       const feedDone = reader.stream.fromAsyncStream(parseFeed.iterable);
+      const feedErrorSignal = new Promise((_, reject) => {
+        feedDone.catch(reject);
+      });
       try {
-        await reader.readFile({
-          ignoreErrors: true,
-          noCopy: true,
-          untilTag: "7FE00010"
-        });
+        await Promise.race([
+          reader.readFile({
+            ignoreErrors: true,
+            noCopy: true,
+            untilTag: "7FE00010"
+          }),
+          feedErrorSignal
+        ]);
       } finally {
         await parseFeed.cancel();
         await feedDone.catch(() => {
@@ -86939,7 +86945,11 @@ async function curateOne({
           create: true
         });
         const writable = await fileHandle.createWritable();
-        await writable.write(modifiedBlob);
+        for await (const chunk of readableStreamToAsyncIterable(
+          modifiedBlob.stream()
+        )) {
+          await writable.write(chunk);
+        }
         await writable.close();
       }
     } else if (typeof outputTarget?.directory === "string") {

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

@@ -55110,17 +55110,40 @@
                   const reader = new async.AsyncDicomReader();
                   const parseFeed = cancellableReadableStreamIterable(file.stream());
                   const feedDone = reader.stream.fromAsyncStream(parseFeed.iterable);
+                  // Build a "never resolves, only rejects" sentinel from feedDone so we can
+                  // race it against readFile() without letting a normal feedDone resolution
+                  // exit the race too early (fromAsyncStream resolves after setComplete() but
+                  // before readFile() finishes parsing the buffered data).
+                  //
+                  // Attaching .catch() here also prevents "Uncaught (in promise)" in the
+                  // failure case: if the underlying ReadableStream fails (e.g. a mode-0000
+                  // file that Chrome reads via its network service and reports as
+                  // "TypeError: network error"), feedDone rejects while readFile() is still
+                  // blocked inside ensureAvailable() — which has no timeout and can only be
+                  // woken by addBuffer/setComplete, calls that never come when fromAsyncStream
+                  // threw. Without this early .catch() the browser fires "Uncaught (in
+                  // promise)" before the finally block ever runs.
+                  const feedErrorSignal = new Promise((_, reject) => {
+                      feedDone.catch(reject);
+                  });
                   // Stop reading at the PixelData tag.  The fixed dcmjs read() loop breaks
                   // out of the scan when readTagHeader() returns {untilTag: true}, leaving
                   // stream.offset pointing at the byte immediately after the 4-byte tag
                   // (i.e. the VR field for explicit-LE).  Subtracting 4 gives the start of
                   // the PixelData tag, which is exactly the offset we need for the slice.
                   try {
-                      await reader.readFile({
-                          ignoreErrors: true,
-                          noCopy: true,
-                          untilTag: '7FE00010',
-                      });
+                      // Race readFile against feedErrorSignal: on a normal run feedErrorSignal
+                      // stays pending forever so readFile wins; on stream failure feedErrorSignal
+                      // rejects immediately, breaking the deadlock where readFile() would hang
+                      // waiting for data that will never arrive.
+                      await Promise.race([
+                          reader.readFile({
+                              ignoreErrors: true,
+                              noCopy: true,
+                              untilTag: '7FE00010',
+                          }),
+                          feedErrorSignal,
+                      ]);
                   }
                   finally {
                       // Do not await feedDone without cancelling first: dcmjs fromAsyncStream
@@ -55268,7 +55291,12 @@
                           create: true,
                       });
                       const writable = await fileHandle.createWritable();
-                      await writable.write(modifiedBlob);
+                      // Write via stream() rather than write(modifiedBlob): LazyCompositeBlob
+                      // keeps an empty native Blob body and exposes its bytes only through the
+                      // overridden stream(), which write(blob) bypasses (yielding 0-byte files).
+                      for await (const chunk of readableStreamToAsyncIterable(modifiedBlob.stream())) {
+                          await writable.write(chunk);
+                      }
                       await writable.close();
                   }
               }
@@ -126851,17 +126879,40 @@
                 const reader = new async.AsyncDicomReader();
                 const parseFeed = cancellableReadableStreamIterable(file.stream());
                 const feedDone = reader.stream.fromAsyncStream(parseFeed.iterable);
+                // Build a "never resolves, only rejects" sentinel from feedDone so we can
+                // race it against readFile() without letting a normal feedDone resolution
+                // exit the race too early (fromAsyncStream resolves after setComplete() but
+                // before readFile() finishes parsing the buffered data).
+                //
+                // Attaching .catch() here also prevents "Uncaught (in promise)" in the
+                // failure case: if the underlying ReadableStream fails (e.g. a mode-0000
+                // file that Chrome reads via its network service and reports as
+                // "TypeError: network error"), feedDone rejects while readFile() is still
+                // blocked inside ensureAvailable() — which has no timeout and can only be
+                // woken by addBuffer/setComplete, calls that never come when fromAsyncStream
+                // threw. Without this early .catch() the browser fires "Uncaught (in
+                // promise)" before the finally block ever runs.
+                const feedErrorSignal = new Promise((_, reject) => {
+                    feedDone.catch(reject);
+                });
                 // Stop reading at the PixelData tag.  The fixed dcmjs read() loop breaks
                 // out of the scan when readTagHeader() returns {untilTag: true}, leaving
                 // stream.offset pointing at the byte immediately after the 4-byte tag
                 // (i.e. the VR field for explicit-LE).  Subtracting 4 gives the start of
                 // the PixelData tag, which is exactly the offset we need for the slice.
                 try {
-                    await reader.readFile({
-                        ignoreErrors: true,
-                        noCopy: true,
-                        untilTag: '7FE00010',
-                    });
+                    // Race readFile against feedErrorSignal: on a normal run feedErrorSignal
+                    // stays pending forever so readFile wins; on stream failure feedErrorSignal
+                    // rejects immediately, breaking the deadlock where readFile() would hang
+                    // waiting for data that will never arrive.
+                    await Promise.race([
+                        reader.readFile({
+                            ignoreErrors: true,
+                            noCopy: true,
+                            untilTag: '7FE00010',
+                        }),
+                        feedErrorSignal,
+                    ]);
                 }
                 finally {
                     // Do not await feedDone without cancelling first: dcmjs fromAsyncStream
@@ -127009,7 +127060,12 @@
                         create: true,
                     });
                     const writable = await fileHandle.createWritable();
-                    await writable.write(modifiedBlob);
+                    // Write via stream() rather than write(modifiedBlob): LazyCompositeBlob
+                    // keeps an empty native Blob body and exposes its bytes only through the
+                    // overridden stream(), which write(blob) bypasses (yielding 0-byte files).
+                    for await (const chunk of readableStreamToAsyncIterable(modifiedBlob.stream())) {
+                        await writable.write(chunk);
+                    }
                     await writable.close();
                 }
             }