dicom-curate 0.26.0 → 0.26.2

package/dist/types/applyMappingsWorker.d.ts

@@ -1,11 +1,8 @@
-import { type TFileInfo, type TSerializedMappingOptions, type THTTPOptions, type TFileInfoIndex, type THashMethod } from './types';
+import { type TFileInfo, type TFileInfoIndex, type THashMethod, type TOutputTarget, type TSerializedMappingOptions } from './types';
 export type MappingRequest = {
     request: 'apply';
     fileInfo: TFileInfo;
-    outputTarget?: {
-        http?: THTTPOptions;
-        directory?: FileSystemDirectoryHandle | string;
-    };
+    outputTarget?: TOutputTarget;
     previousFileInfo?: {
         size?: number;
         mtime?: string;

package/dist/types/curateOne.d.ts

@@ -1,11 +1,7 @@
-import type { TFileInfo, THashMethod, THTTPOptions, TMappingOptions, TMapResults, TS3BucketOptions } from './types';
+import type { TFileInfo, THashMethod, TOutputTarget, TMappingOptions, TMapResults } from './types';
 export type TCurateOneArgs = {
     fileInfo: TFileInfo;
-    outputTarget: {
-        http?: THTTPOptions;
-        s3?: TS3BucketOptions;
-        directory?: FileSystemDirectoryHandle | string;
-    };
+    outputTarget: TOutputTarget;
     mappingOptions: TMappingOptions;
     hashMethod?: THashMethod;
     previousSourceFileInfo?: {

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/types/httpHeaders.d.ts

@@ -0,0 +1,9 @@
+/**
+ * HTTP header resolution helpers for dynamic header providers.
+ *
+ * Extracted from index.ts to avoid circular dependencies between
+ * index.ts and mappingWorkerPool.ts.
+ */
+import type { TFileInfo, TOutputTarget } from './types';
+export declare function getHttpInputHeaders(fileInfo: TFileInfo): Promise<TFileInfo>;
+export declare function getHttpOutputHeaders(outputTarget: TOutputTarget | undefined): Promise<TOutputTarget | undefined>;

package/dist/types/index.d.ts

@@ -1,7 +1,8 @@
 import { extractColumnMappings } from './csvMapping';
 import { curateOne } from './curateOne';
-import type { OrganizeOptions, TProgressMessage, TProgressMessageDone } from './types';
-export type ProgressCallback = (message: TProgressMessage) => void;
+import type { OrganizeOptions, TProgressMessageDone } from './types';
+import { type ProgressCallback } from './mappingWorkerPool';
+export type { ProgressCallback } from './mappingWorkerPool';
 export type { TPs315Options, TMapResults, TProgressMessage, OrganizeOptions, TCurationSpecification, } from './types';
 export { TCurateOneArgs } from './curateOne';
 export { specVersion } from './config/specVersion';

package/dist/types/mappingWorkerPool.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Mapping worker pool management.
+ *
+ * Manages the pool of web workers that apply curation mappings to DICOM files.
+ * Handles worker creation, crash recovery, replacement spawning, dispatch, and
+ * the stall watchdog. Extracted from index.ts for maintainability.
+ */
+import type { TMappingOptions, TFileInfo, TProgressMessage, TOutputTarget, TFileInfoIndex, THashMethod } from './types';
+export type TMappingWorkerOptions = TMappingOptions & {
+    outputTarget?: TOutputTarget;
+    hashMethod?: THashMethod;
+};
+export type ProgressCallback = (message: TProgressMessage) => void;
+export declare const availableMappingWorkers: Worker[];
+export declare let filesToProcess: {
+    fileInfo: TFileInfo;
+    scanAnomalies: string[];
+    previousFileInfo?: {
+        size?: number;
+        mtime?: string;
+        preMappedHash?: string;
+    };
+}[];
+export declare let directoryScanFinished: boolean;
+export declare function setDirectoryScanFinished(value: boolean): void;
+export declare let scanAnomalies: {
+    fileInfo: TFileInfo;
+    anomalies: string[];
+}[];
+export declare function setMappingWorkerOptions(opts: TMappingWorkerOptions): void;
+/**
+ * Initialize the mapping worker pool. Call once per curateMany invocation.
+ */
+export declare function initializeMappingWorkers(skipCollectingMappings?: boolean, fileInfoIndex?: TFileInfoIndex, progressCb?: ProgressCallback): Promise<void>;
+/**
+ * Dispatch queued files to available mapping workers.
+ * Also checks the termination condition (all files processed, no pending
+ * replacements, scan finished) and emits the 'done' progress message.
+ */
+export declare function dispatchMappingJobs(): Promise<void>;
+/**
+ * Get the workerCurrentFile map. Used by the stall watchdog in curateMany
+ * to iterate over stuck workers.
+ */
+export declare function getWorkerCurrentFile(): Map<Worker, TFileInfo>;
+/**
+ * Get the current count of active workers. Used by the stall watchdog.
+ */
+export declare function getWorkersActive(): number;
+/**
+ * Get the last time a worker reported progress. Used by the stall watchdog.
+ */
+export declare function getLastWorkerProgressTime(): number;

package/dist/types/types.d.ts

@@ -66,6 +66,12 @@ export type TS3BucketOptions = {
     endpoint?: string;
     forcePathStyle?: boolean;
 };
+/** Output target for curation -- at most one of http, directory, or s3. */
+export type TOutputTarget = {
+    http?: THTTPOptions;
+    directory?: FileSystemDirectoryHandle | string;
+    s3?: TS3BucketOptions;
+};
 export type TMappingOptions = {
     columnMappings?: TColumnMappings;
     curationSpec: (() => TCurationSpecification | SpecPart[]) | NoneSpecification;