dicom-curate 0.40.0 → 0.40.2

package/README.md

@@ -436,6 +436,27 @@ When a file is excluded, `curateOne` / `curateMany` still returns a result objec
 result.excluded // => 'pre' | 'post' | undefined
 ```
 
+## Testing
+
+Vitest is split into three projects in `vitest.config.ts`:
+
+| Command | Project | Location | Purpose |
+|---------|---------|----------|---------|
+| `pnpm test` | `unit` | `src/**/*.test.ts` | Unit and integration tests co-located with source |
+| `pnpm test:e2e` | `e2e` | `e2e/` | Pipeline smoke tests (runs `build:esm` first; uses `dist/`) |
+| `pnpm test:conformance` | `conformance` | `conformance/` | `dciodvfy` regression (synthetic; optional public/local via env) |
+
+Other scripts:
+
+| Script | Purpose |
+|--------|---------|
+| `pnpm test:coverage` | Unit project with coverage |
+| `pnpm update:conformance-baselines` | Regenerate committed `dciodvfy` baseline JSON |
+
+Conformance tests require the external `dciodvfy` binary from [dicom3tools](https://www.dclunie.com/dicom3tools.html). See [conformance/README.md](conformance/README.md) for install, CI behaviour, baseline refresh, and optional `RUN_PUBLIC_CONFORMANCE` / `CONFORMANCE_LOCAL_*` env vars.
+
+Shared test helpers: `testutils/` (minimal DICOM files, worker mocks). Fixture generation and public-case fetch: devDependency [`dicom-synth`](https://github.com/clintools/dicom-synth).
+
 ## DICOM Conformance Notes
 
 dicom-curate

package/dist/esm/applyMappingsWorker.js

@@ -86824,10 +86824,12 @@ async function curateOne({
         error3
       );
       const mapResults = {
-        anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
-        errors: [
-          `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
-        ],
+        // PHI-safe strings: the raw filename is intentionally omitted because
+        // anomalies/errors are shared between the private (input) log and the
+        // server-bound (output) log. The raw name/path is carried only in
+        // fileInfo, keeping it in the private log. See #283.
+        anomalies: [`Could not parse file as DICOM data`],
+        errors: [`File is not a valid DICOM file or is corrupted`],
         sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
         fileInfo: {
           name: fileInfo.name,

package/dist/esm/curateOne.js

@@ -80533,10 +80533,12 @@ async function curateOne({
         error3
       );
       const mapResults = {
-        anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
-        errors: [
-          `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
-        ],
+        // PHI-safe strings: the raw filename is intentionally omitted because
+        // anomalies/errors are shared between the private (input) log and the
+        // server-bound (output) log. The raw name/path is carried only in
+        // fileInfo, keeping it in the private log. See #283.
+        anomalies: [`Could not parse file as DICOM data`],
+        errors: [`File is not a valid DICOM file or is corrupted`],
         sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
         fileInfo: {
           name: fileInfo.name,

package/dist/esm/index.js

@@ -88427,10 +88427,12 @@ async function curateOne({
         error3
       );
       const mapResults = {
-        anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
-        errors: [
-          `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
-        ],
+        // PHI-safe strings: the raw filename is intentionally omitted because
+        // anomalies/errors are shared between the private (input) log and the
+        // server-bound (output) log. The raw name/path is carried only in
+        // fileInfo, keeping it in the private log. See #283.
+        anomalies: [`Could not parse file as DICOM data`],
+        errors: [`File is not a valid DICOM file or is corrupted`],
         sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
         fileInfo: {
           name: fileInfo.name,
@@ -94704,8 +94706,24 @@ async function dispatchMappingJobs() {
     console.log("job is finished");
     if (!mapResultsList)
       mapResultsList = [];
-    if (!mappingWorkerOptions.skipWrite) {
-      scanAnomalies.forEach(({ fileInfo, anomalies }) => {
+    scanAnomalies.forEach(({ fileInfo, anomalies, errors }) => {
+      const hasReadErrors = !!errors && errors.length > 0;
+      if (hasReadErrors) {
+        const scanErrorResult = {
+          sourceInstanceUID: `scan_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+          // Intentionally no outputFilePath: an unread file has no
+          // de-identified output path, and we must not place the raw input
+          // path in the server-bound channel.
+          mappings: {},
+          anomalies: anomalies ?? [],
+          errors,
+          quarantine: {},
+          fileInfo
+        };
+        mapResultsList.push(scanErrorResult);
+        return;
+      }
+      if (!mappingWorkerOptions.skipWrite && anomalies.length > 0) {
         const scanAnomalyResult = {
           sourceInstanceUID: `scan_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
           outputFilePath: `${fileInfo.path}/${fileInfo.name}`,
@@ -94717,8 +94735,8 @@ async function dispatchMappingJobs() {
           quarantine: {}
         };
         mapResultsList.push(scanAnomalyResult);
-      });
-    }
+      }
+    });
     progressCallback({
       response: "done",
       mapResultsList,
@@ -94945,8 +94963,8 @@ async function initializeFileListWorker(rejectCallback) {
           break;
         }
         case "scanAnomalies": {
-          const { fileInfo: anomalyFileInfo, anomalies } = event.data;
-          scanAnomalies.push({ fileInfo: anomalyFileInfo, anomalies });
+          const { fileInfo: anomalyFileInfo, anomalies, errors } = event.data;
+          scanAnomalies.push({ fileInfo: anomalyFileInfo, anomalies, errors });
           break;
         }
         case "count": {

package/dist/esm/mappingWorkerPool.js

@@ -86824,10 +86824,12 @@ async function curateOne({
         error3
       );
       const mapResults = {
-        anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
-        errors: [
-          `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
-        ],
+        // PHI-safe strings: the raw filename is intentionally omitted because
+        // anomalies/errors are shared between the private (input) log and the
+        // server-bound (output) log. The raw name/path is carried only in
+        // fileInfo, keeping it in the private log. See #283.
+        anomalies: [`Could not parse file as DICOM data`],
+        errors: [`File is not a valid DICOM file or is corrupted`],
         sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
         fileInfo: {
           name: fileInfo.name,
@@ -93104,8 +93106,24 @@ async function dispatchMappingJobs() {
     console.log("job is finished");
     if (!mapResultsList)
       mapResultsList = [];
-    if (!mappingWorkerOptions.skipWrite) {
-      scanAnomalies.forEach(({ fileInfo, anomalies }) => {
+    scanAnomalies.forEach(({ fileInfo, anomalies, errors }) => {
+      const hasReadErrors = !!errors && errors.length > 0;
+      if (hasReadErrors) {
+        const scanErrorResult = {
+          sourceInstanceUID: `scan_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+          // Intentionally no outputFilePath: an unread file has no
+          // de-identified output path, and we must not place the raw input
+          // path in the server-bound channel.
+          mappings: {},
+          anomalies: anomalies ?? [],
+          errors,
+          quarantine: {},
+          fileInfo
+        };
+        mapResultsList.push(scanErrorResult);
+        return;
+      }
+      if (!mappingWorkerOptions.skipWrite && anomalies.length > 0) {
         const scanAnomalyResult = {
           sourceInstanceUID: `scan_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
           outputFilePath: `${fileInfo.path}/${fileInfo.name}`,
@@ -93117,8 +93135,8 @@ async function dispatchMappingJobs() {
           quarantine: {}
         };
         mapResultsList.push(scanAnomalyResult);
-      });
-    }
+      }
+    });
     progressCallback({
       response: "done",
       mapResultsList,

package/dist/esm/scanDirectoryWorker.js

@@ -37136,6 +37136,10 @@ var DEFAULT_EXCLUDED_FILETYPES = [
   "thumbs.db",
   ".ds_store"
 ];
+function safeReadErrorMessage(error2) {
+  const detail = error2 instanceof Error ? `${error2.name}: ${error2.message}` : String(error2);
+  return `Unable to read file (filesystem error): ${detail}`;
+}
 var keepScanning = true;
 var pauseResolve = null;
 var pausePromise = null;
@@ -37445,9 +37449,36 @@ async function scanDirectory(dir) {
       if (!keepScanning)
         return;
       if (entry.kind === "file") {
-        const file = await entry.getFile();
         const key = `${prefix}/${entry.name}`;
         const prev = previousIndex ? previousIndex[key] : void 0;
+        let file;
+        try {
+          file = await entry.getFile();
+        } catch (readError) {
+          if (cheapFilterNameOnly(entry.name, key)) {
+            totalDiscovered--;
+            globalThis.postMessage({
+              response: "count",
+              totalDiscovered
+            });
+          }
+          globalThis.postMessage({
+            response: "scanAnomalies",
+            fileInfo: {
+              path: prefix,
+              name: entry.name,
+              size: 0,
+              kind: "handle",
+              fileHandle: entry
+            },
+            anomalies: [],
+            errors: [safeReadErrorMessage(readError)],
+            previousFileInfo: prev
+          });
+          if (!await waitIfPaused())
+            return;
+          continue;
+        }
         const fileAnomalies = [];
         if (await shouldProcessFile(file, fileAnomalies, key)) {
           globalThis.postMessage({
@@ -37545,9 +37576,36 @@ async function scanDirectoryNode(dirPath) {
           return;
         if (entry.isFile()) {
           const filePath = path.join(currentPath, entry.name);
-          const stats = await fs.stat(filePath);
           const key = `${prefix}/${entry.name}`;
           const prev = previousIndex ? previousIndex[key] : void 0;
+          let stats;
+          try {
+            stats = await fs.stat(filePath);
+          } catch (readError) {
+            if (cheapFilterNameOnly(entry.name, key)) {
+              totalDiscovered--;
+              globalThis.postMessage({
+                response: "count",
+                totalDiscovered
+              });
+            }
+            globalThis.postMessage({
+              response: "scanAnomalies",
+              fileInfo: {
+                path: prefix,
+                name: entry.name,
+                size: 0,
+                kind: "path",
+                fullPath: filePath
+              },
+              anomalies: [],
+              errors: [safeReadErrorMessage(readError)],
+              previousFileInfo: prev
+            });
+            if (!await waitIfPaused())
+              return;
+            continue;
+          }
           const fileAnomalies = [];
           if (await shouldProcessFileNode(
             filePath,

package/dist/types/mappingWorkerPool.d.ts

@@ -27,6 +27,7 @@ export declare function setDirectoryScanFinished(value: boolean): void;
 export declare let scanAnomalies: {
     fileInfo: TFileInfo;
     anomalies: string[];
+    errors?: string[];
 }[];
 export declare function setMappingWorkerOptions(opts: TMappingWorkerOptions): void;
 export declare function setCustomUploader(uploader: TCustomUploader | undefined): void;

package/dist/types/scanDirectoryWorker.d.ts

@@ -11,6 +11,15 @@ export type FileScanMsg = {
     response: 'scanAnomalies';
     fileInfo: TFileInfo;
     anomalies: string[];
+    /**
+     * Hard errors discovered during scanning (e.g. a file that cannot be
+     * read at all via the FileSystem API / fs.stat). Unlike `anomalies`
+     * (benign findings such as non-DICOM or too-small files), these are
+     * surfaced as errors so they are visible regardless of pass. The string
+     * MUST NOT contain the raw filename/path — that is carried only in
+     * `fileInfo` so it stays in the private (input) log.
+     */
+    errors?: string[];
     previousFileInfo?: {
         size?: number;
         mtime?: string;

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

@@ -55131,10 +55131,12 @@
               catch (error) {
                   console.warn(`[dicom-curate] Could not parse ${fileInfo.name} as DICOM data:`, error);
                   const mapResults = {
-                      anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
-                      errors: [
-                          `File ${fileInfo.name} is not a valid DICOM file or is corrupted`,
-                      ],
+                      // PHI-safe strings: the raw filename is intentionally omitted because
+                      // anomalies/errors are shared between the private (input) log and the
+                      // server-bound (output) log. The raw name/path is carried only in
+                      // fileInfo, keeping it in the private log. See #283.
+                      anomalies: [`Could not parse file as DICOM data`],
+                      errors: [`File is not a valid DICOM file or is corrupted`],
                       sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, '_')}`,
                       fileInfo: {
                           name: fileInfo.name,
@@ -68860,6 +68862,17 @@
             'thumbs.db',
             '.ds_store',
         ];
+        /**
+         * Build a PHI-safe error message for a file that could not be read during
+         * scanning. Intentionally omits the filename/path so the string is safe to
+         * place in `errors` (which is shared between the private and server-bound
+         * logs). The raw path/name is carried separately in `fileInfo` so it appears
+         * only in the private (input) log.
+         */
+        function safeReadErrorMessage(error) {
+            const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+            return `Unable to read file (filesystem error): ${detail}`;
+        }
         let keepScanning = true;
         // Backpressure gate: when the main thread signals 'stop', the feeder
         // awaits this promise before emitting the next file. 'resume' resolves it.
@@ -69242,9 +69255,42 @@
                     if (!keepScanning)
                         return;
                     if (entry.kind === 'file') {
-                        const file = await entry.getFile();
                         const key = `${prefix}/${entry.name}`;
                         const prev = previousIndex ? previousIndex[key] : undefined;
+                        let file;
+                        try {
+                            file = await entry.getFile();
+                        }
+                        catch (readError) {
+                            // A single file we cannot read (corrupted, locked, permission
+                            // revoked via the Chromium FileSystem API) must NOT abort the whole
+                            // scan. Report it as a hard error and continue. The error string is
+                            // PHI-safe (no filename); the raw path/name lives only in fileInfo,
+                            // which keeps it in the private (input) log.
+                            if (cheapFilterNameOnly(entry.name, key)) {
+                                totalDiscovered--;
+                                globalThis.postMessage({
+                                    response: 'count',
+                                    totalDiscovered,
+                                });
+                            }
+                            globalThis.postMessage({
+                                response: 'scanAnomalies',
+                                fileInfo: {
+                                    path: prefix,
+                                    name: entry.name,
+                                    size: 0,
+                                    kind: 'handle',
+                                    fileHandle: entry,
+                                },
+                                anomalies: [],
+                                errors: [safeReadErrorMessage(readError)],
+                                previousFileInfo: prev,
+                            });
+                            if (!(await waitIfPaused()))
+                                return;
+                            continue;
+                        }
                         const fileAnomalies = [];
                         if (await shouldProcessFile(file, fileAnomalies, key)) {
                             globalThis.postMessage({
@@ -69362,9 +69408,41 @@
                             return;
                         if (entry.isFile()) {
                             const filePath = path.join(currentPath, entry.name);
-                            const stats = await fs.stat(filePath);
                             const key = `${prefix}/${entry.name}`;
                             const prev = previousIndex ? previousIndex[key] : undefined;
+                            let stats;
+                            try {
+                                stats = await fs.stat(filePath);
+                            }
+                            catch (readError) {
+                                // A single file we cannot stat (vanished, permission denied) must
+                                // NOT abort the whole scan. Report it as a hard error and continue.
+                                // The error string is PHI-safe (no path); the raw path lives only
+                                // in fileInfo, keeping it in the private (input) log.
+                                if (cheapFilterNameOnly(entry.name, key)) {
+                                    totalDiscovered--;
+                                    globalThis.postMessage({
+                                        response: 'count',
+                                        totalDiscovered,
+                                    });
+                                }
+                                globalThis.postMessage({
+                                    response: 'scanAnomalies',
+                                    fileInfo: {
+                                        path: prefix,
+                                        name: entry.name,
+                                        size: 0,
+                                        kind: 'path',
+                                        fullPath: filePath,
+                                    },
+                                    anomalies: [],
+                                    errors: [safeReadErrorMessage(readError)],
+                                    previousFileInfo: prev,
+                                });
+                                if (!(await waitIfPaused()))
+                                    return;
+                                continue;
+                            }
                             const fileAnomalies = [];
                             if (await shouldProcessFileNode(filePath, entry.name, stats.size, fileAnomalies, key)) {
                                 globalThis.postMessage({
@@ -126773,10 +126851,12 @@
             catch (error) {
                 console.warn(`[dicom-curate] Could not parse ${fileInfo.name} as DICOM data:`, error);
                 const mapResults = {
-                    anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
-                    errors: [
-                        `File ${fileInfo.name} is not a valid DICOM file or is corrupted`,
-                    ],
+                    // PHI-safe strings: the raw filename is intentionally omitted because
+                    // anomalies/errors are shared between the private (input) log and the
+                    // server-bound (output) log. The raw name/path is carried only in
+                    // fileInfo, keeping it in the private log. See #283.
+                    anomalies: [`Could not parse file as DICOM data`],
+                    errors: [`File is not a valid DICOM file or is corrupted`],
                     sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, '_')}`,
                     fileInfo: {
                         name: fileInfo.name,
@@ -140785,10 +140865,39 @@
             console.log('job is finished');
             if (!mapResultsList)
                 mapResultsList = [];
-            // Create individual mapResults entries for each scan anomaly
-            // Only do this during actual processing (not first pass)
-            if (!mappingWorkerOptions.skipWrite) {
-                scanAnomalies.forEach(({ fileInfo, anomalies }) => {
+            // Create individual mapResults entries for each scan finding.
+            //
+            // Two kinds of scan findings are surfaced differently:
+            //
+            //  - Benign anomalies (non-DICOM, too-small, excluded filetypes): noise
+            //    during the first pass (form generation), so only emitted on the
+            //    write pass (!skipWrite), and they carry the input path in
+            //    `outputFilePath` as before.
+            //
+            //  - Hard read errors (file could not be read at all): always surfaced,
+            //    in both passes, via `errors`. We deliberately OMIT `outputFilePath`
+            //    so the raw input path is not leaked into the server-bound log; the
+            //    raw path is retained in `fileInfo` for the private (input) log, and a
+            //    path-less trace is rendered in the server-bound log by the consumer.
+            scanAnomalies.forEach(({ fileInfo, anomalies, errors }) => {
+                const hasReadErrors = !!errors && errors.length > 0;
+                if (hasReadErrors) {
+                    const scanErrorResult = {
+                        sourceInstanceUID: `scan_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, '_')}`,
+                        // Intentionally no outputFilePath: an unread file has no
+                        // de-identified output path, and we must not place the raw input
+                        // path in the server-bound channel.
+                        mappings: {},
+                        anomalies: anomalies ?? [],
+                        errors,
+                        quarantine: {},
+                        fileInfo,
+                    };
+                    mapResultsList.push(scanErrorResult);
+                    return;
+                }
+                // Benign anomalies: only on the write pass.
+                if (!mappingWorkerOptions.skipWrite && anomalies.length > 0) {
                     const scanAnomalyResult = {
                         sourceInstanceUID: `scan_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, '_')}`,
                         outputFilePath: `${fileInfo.path}/${fileInfo.name}`, // Use the actual file path
@@ -140797,10 +140906,9 @@
                         errors: [],
                         quarantine: {},
                     };
-                    // Add each scan anomaly result to the final results
                     mapResultsList.push(scanAnomalyResult);
-                });
-            }
+                }
+            });
             progressCallback({
                 response: 'done',
                 mapResultsList: mapResultsList,
@@ -141086,8 +141194,8 @@
                 }
                 case 'scanAnomalies': {
                     // Handle scan anomalies separately - they don't go to processing
-                    const { fileInfo: anomalyFileInfo, anomalies } = event.data;
-                    scanAnomalies.push({ fileInfo: anomalyFileInfo, anomalies });
+                    const { fileInfo: anomalyFileInfo, anomalies, errors } = event.data;
+                    scanAnomalies.push({ fileInfo: anomalyFileInfo, anomalies, errors });
                     break;
                 }
                 case 'count': {