@devrev/ts-adaas 1.19.4 → 1.19.5

package/dist/attachments-streaming/attachments-streaming-pool.test.js

@@ -44,10 +44,6 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
                 parent_id: 'parent-3',
             },
         ];
-        // Mock console methods
-        jest.spyOn(console, 'log').mockImplementation();
-        jest.spyOn(console, 'error').mockImplementation();
-        jest.spyOn(console, 'warn').mockImplementation();
     });
     afterEach(() => {
         jest.clearAllMocks();
@@ -60,7 +56,6 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
                 attachments: mockAttachments,
                 stream: mockStream,
             });
-            expect(pool).toBeDefined();
             expect(pool['adapter']).toBe(mockAdapter);
             expect(pool['attachments']).toEqual(mockAttachments);
             expect(pool['batchSize']).toBe(10);
@@ -227,6 +222,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             ]);
         });
         it('should handle processing errors gracefully', async () => {
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
             const error = new Error('Processing failed');
             mockAdapter.processAttachment
                 .mockResolvedValueOnce({}) // First attachment succeeds
@@ -238,7 +234,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
                 stream: mockStream,
             });
             await pool.streamAll();
-            expect(console.warn).toHaveBeenCalledWith('Skipping attachment with ID attachment-2 with extension jpg due to error in processAttachment function', error);
+            expect(warnSpy).toHaveBeenCalledWith('Skipping attachment with ID attachment-2 with extension jpg due to error in processAttachment function', error);
             expect(mockAdapter.state.toDevRev.attachmentsMetadata
                 .lastProcessedAttachmentsIdsList).toEqual([
                 {
@@ -490,6 +486,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             const mockStreamFn = jest
                 .fn()
                 .mockImplementation(async () => {
+                await Promise.resolve();
                 userCallbackExecuted = true;
                 // Record that the callback executed
                 return Promise.resolve({

package/dist/common/event-type-translation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-type-translation.test.d.ts.map

package/dist/common/event-type-translation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-type-translation.test.d.ts","sourceRoot":"","sources":["../../src/common/event-type-translation.test.ts"],"names":[],"mappings":""}

package/dist/common/event-type-translation.test.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extraction_1 = require("../types/extraction");
+const loading_1 = require("../types/loading");
+const event_type_translation_1 = require("./event-type-translation");
+describe(event_type_translation_1.translateIncomingEventType.name, () => {
+    it.each([
+        [
+            extraction_1.EventType.ExtractionExternalSyncUnitsStart,
+            extraction_1.EventType.StartExtractingExternalSyncUnits,
+        ],
+        [extraction_1.EventType.ExtractionMetadataStart, extraction_1.EventType.StartExtractingMetadata],
+        [extraction_1.EventType.ExtractionDataStart, extraction_1.EventType.StartExtractingData],
+        [extraction_1.EventType.ExtractionDataContinue, extraction_1.EventType.ContinueExtractingData],
+        [extraction_1.EventType.ExtractionDataDelete, extraction_1.EventType.StartDeletingExtractorState],
+        [
+            extraction_1.EventType.ExtractionAttachmentsStart,
+            extraction_1.EventType.StartExtractingAttachments,
+        ],
+        [
+            extraction_1.EventType.ExtractionAttachmentsContinue,
+            extraction_1.EventType.ContinueExtractingAttachments,
+        ],
+        [
+            extraction_1.EventType.ExtractionAttachmentsDelete,
+            extraction_1.EventType.StartDeletingExtractorAttachmentsState,
+        ],
+    ])('maps legacy extraction event %s to %s', (legacy, modern) => {
+        expect((0, event_type_translation_1.translateIncomingEventType)(legacy)).toBe(modern);
+    });
+    it.each([
+        [extraction_1.EventType.StartExtractingExternalSyncUnits],
+        [extraction_1.EventType.StartExtractingMetadata],
+        [extraction_1.EventType.StartExtractingData],
+        [extraction_1.EventType.ContinueExtractingData],
+        [extraction_1.EventType.StartDeletingExtractorState],
+        [extraction_1.EventType.StartExtractingAttachments],
+        [extraction_1.EventType.ContinueExtractingAttachments],
+        [extraction_1.EventType.StartDeletingExtractorAttachmentsState],
+        [extraction_1.EventType.StartLoadingData],
+        [extraction_1.EventType.ContinueLoadingData],
+        [extraction_1.EventType.StartLoadingAttachments],
+        [extraction_1.EventType.ContinueLoadingAttachments],
+        [extraction_1.EventType.StartDeletingLoaderState],
+        [extraction_1.EventType.StartDeletingLoaderAttachmentState],
+        [extraction_1.EventType.UnknownEventType],
+    ])('is a no-op for already-modern event type %s', (eventType) => {
+        expect((0, event_type_translation_1.translateIncomingEventType)(eventType)).toBe(eventType);
+    });
+    it('returns the input verbatim for an unrecognised event type', () => {
+        const result = (0, event_type_translation_1.translateIncomingEventType)('NONSENSE_EVENT');
+        expect(result).toBe('NONSENSE_EVENT');
+    });
+});
+describe(event_type_translation_1.translateExtractorEventType.name, () => {
+    it.each([
+        [
+            extraction_1.ExtractorEventType.ExtractionExternalSyncUnitsDone,
+            extraction_1.ExtractorEventType.ExternalSyncUnitExtractionDone,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionExternalSyncUnitsError,
+            extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionMetadataDone,
+            extraction_1.ExtractorEventType.MetadataExtractionDone,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionMetadataError,
+            extraction_1.ExtractorEventType.MetadataExtractionError,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionDataProgress,
+            extraction_1.ExtractorEventType.DataExtractionProgress,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionDataDelay,
+            extraction_1.ExtractorEventType.DataExtractionDelayed,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionDataDone,
+            extraction_1.ExtractorEventType.DataExtractionDone,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionDataError,
+            extraction_1.ExtractorEventType.DataExtractionError,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionDataDeleteDone,
+            extraction_1.ExtractorEventType.ExtractorStateDeletionDone,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionDataDeleteError,
+            extraction_1.ExtractorEventType.ExtractorStateDeletionError,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionAttachmentsProgress,
+            extraction_1.ExtractorEventType.AttachmentExtractionProgress,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionAttachmentsDelay,
+            extraction_1.ExtractorEventType.AttachmentExtractionDelayed,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionAttachmentsDone,
+            extraction_1.ExtractorEventType.AttachmentExtractionDone,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionAttachmentsError,
+            extraction_1.ExtractorEventType.AttachmentExtractionError,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionAttachmentsDeleteDone,
+            extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionDone,
+        ],
+        [
+            extraction_1.ExtractorEventType.ExtractionAttachmentsDeleteError,
+            extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError,
+        ],
+    ])('maps legacy extractor event %s to %s', (legacy, modern) => {
+        expect((0, event_type_translation_1.translateExtractorEventType)(legacy)).toBe(modern);
+    });
+    it.each([
+        [extraction_1.ExtractorEventType.DataExtractionDone],
+        [extraction_1.ExtractorEventType.DataExtractionProgress],
+        [extraction_1.ExtractorEventType.AttachmentExtractionDone],
+        [extraction_1.ExtractorEventType.MetadataExtractionDone],
+        [extraction_1.ExtractorEventType.UnknownEventType],
+    ])('is a no-op for already-modern extractor event %s', (eventType) => {
+        expect((0, event_type_translation_1.translateExtractorEventType)(eventType)).toBe(eventType);
+    });
+});
+describe(event_type_translation_1.translateLoaderEventType.name, () => {
+    it.each([
+        [loading_1.LoaderEventType.DataLoadingDelay, loading_1.LoaderEventType.DataLoadingDelayed],
+        [
+            loading_1.LoaderEventType.AttachmentsLoadingProgress,
+            loading_1.LoaderEventType.AttachmentLoadingProgress,
+        ],
+        [
+            loading_1.LoaderEventType.AttachmentsLoadingDelayed,
+            loading_1.LoaderEventType.AttachmentLoadingDelayed,
+        ],
+        [
+            loading_1.LoaderEventType.AttachmentsLoadingDone,
+            loading_1.LoaderEventType.AttachmentLoadingDone,
+        ],
+        [
+            loading_1.LoaderEventType.AttachmentsLoadingError,
+            loading_1.LoaderEventType.AttachmentLoadingError,
+        ],
+    ])('maps legacy loader event %s to %s', (legacy, modern) => {
+        expect((0, event_type_translation_1.translateLoaderEventType)(legacy)).toBe(modern);
+    });
+    it.each([
+        [loading_1.LoaderEventType.DataLoadingDone],
+        [loading_1.LoaderEventType.DataLoadingProgress],
+        [loading_1.LoaderEventType.AttachmentLoadingDone],
+    ])('is a no-op for already-modern loader event %s', (eventType) => {
+        expect((0, event_type_translation_1.translateLoaderEventType)(eventType)).toBe(eventType);
+    });
+});
+describe(event_type_translation_1.translateOutgoingEventType.name, () => {
+    it('routes extractor events through translateExtractorEventType', () => {
+        expect((0, event_type_translation_1.translateOutgoingEventType)(extraction_1.ExtractorEventType.ExtractionDataDone)).toBe(extraction_1.ExtractorEventType.DataExtractionDone);
+    });
+    it('routes loader events through translateLoaderEventType', () => {
+        expect((0, event_type_translation_1.translateOutgoingEventType)(loading_1.LoaderEventType.AttachmentsLoadingDone)).toBe(loading_1.LoaderEventType.AttachmentLoadingDone);
+    });
+    it('passes through unknown event types unchanged', () => {
+        const unknown = 'SOME_UNKNOWN_EVENT';
+        expect((0, event_type_translation_1.translateOutgoingEventType)(unknown)).toBe(unknown);
+    });
+});

package/dist/common/time-value-resolver.test.js

@@ -135,7 +135,6 @@ describe('time-value-resolver', () => {
                 const before = new Date().toISOString();
                 const result = (0, time_value_resolver_1.resolveTimeValue)({ type: extraction_1.TimeValueType.CURRENT_TIME }, baseState);
                 const after = new Date().toISOString();
-                expect(result).toBeDefined();
                 expect(result >= before).toBe(true);
                 expect(result <= after).toBe(true);
             });

package/dist/multithreading/create-worker.test.js

@@ -7,16 +7,20 @@ const extraction_1 = require("../types/extraction");
 const create_worker_1 = require("./create-worker");
 describe(create_worker_1.createWorker.name, () => {
     it('should create a Worker instance when valid parameters are provided', async () => {
+        // Arrange
         const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.ExtractionExternalSyncUnitsStart },
+        });
+        // Act
         const worker = worker_threads_1.isMainThread
             ? await (0, create_worker_1.createWorker)({
-                event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                    payload: { event_type: extraction_1.EventType.ExtractionExternalSyncUnitsStart },
-                }),
+                event,
                 initialState: {},
                 workerPath,
             })
             : null;
+        // Assert
         expect(worker).not.toBeNull();
         expect(worker).toBeInstanceOf(worker_threads_1.Worker);
         if (worker) {
@@ -24,36 +28,43 @@ describe(create_worker_1.createWorker.name, () => {
         }
     });
     it('should throw error when not in main thread', async () => {
+        // Arrange
         const originalIsMainThread = worker_threads_1.isMainThread;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         worker_threads_1.isMainThread = false;
         const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.ExtractionExternalSyncUnitsStart },
+        });
+        // Act & Assert
         await expect((0, create_worker_1.createWorker)({
-            event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: { event_type: extraction_1.EventType.ExtractionExternalSyncUnitsStart },
-            }),
+            event,
             initialState: {},
             workerPath,
         })).rejects.toThrow('Worker threads can not start more worker threads.');
-        // Restore original value
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         worker_threads_1.isMainThread = originalIsMainThread;
     });
     it('[edge] should handle worker creation with minimal valid data', async () => {
+        // Arrange
         const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.ExtractionExternalSyncUnitsStart },
+        });
         if (worker_threads_1.isMainThread) {
+            // Act
             const worker = await (0, create_worker_1.createWorker)({
-                event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                    payload: { event_type: extraction_1.EventType.ExtractionExternalSyncUnitsStart },
-                }),
+                event,
                 initialState: {},
                 workerPath,
             });
+            // Assert
             expect(worker).toBeInstanceOf(worker_threads_1.Worker);
             await worker.terminate();
         }
     });
     it('[edge] should handle worker creation with complex initial state', async () => {
+        // Arrange
         const workerPath = __dirname + '../tests/dummy-worker.ts';
         const complexState = {
             nested: {
@@ -61,28 +72,35 @@ describe(create_worker_1.createWorker.name, () => {
                 config: { enabled: true },
             },
         };
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.ExtractionDataStart },
+        });
         if (worker_threads_1.isMainThread) {
+            // Act
             const worker = await (0, create_worker_1.createWorker)({
-                event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                    payload: { event_type: extraction_1.EventType.ExtractionDataStart },
-                }),
+                event,
                 initialState: complexState,
                 workerPath,
             });
+            // Assert
             expect(worker).toBeInstanceOf(worker_threads_1.Worker);
             await worker.terminate();
         }
     });
     it('[edge] should handle different event types', async () => {
+        // Arrange
         const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.ExtractionMetadataStart },
+        });
         if (worker_threads_1.isMainThread) {
+            // Act
             const worker = await (0, create_worker_1.createWorker)({
-                event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                    payload: { event_type: extraction_1.EventType.ExtractionMetadataStart },
-                }),
+                event,
                 initialState: {},
                 workerPath,
             });
+            // Assert
             expect(worker).toBeInstanceOf(worker_threads_1.Worker);
             await worker.terminate();
         }

package/dist/multithreading/process-task.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=process-task.test.d.ts.map

package/dist/multithreading/process-task.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-task.test.d.ts","sourceRoot":"","sources":["../../src/multithreading/process-task.test.ts"],"names":[],"mappings":""}

package/dist/multithreading/process-task.test.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extraction_1 = require("../types/extraction");
+const workers_1 = require("../types/workers");
+// These tests cover logic that is NOT exercised by the end-to-end integration
+// tests under src/tests/timeout-handling/:
+//   - translation of legacy wire event types into the new enum (mutates event in place)
+//   - the hasWorkerEmitted guard that prevents onTimeout from firing after a
+//     successful emit (integration tests only exercise the positive case)
+//   - the error branch that posts WorkerMessageFailed and exits(1)
+//   - the WorkerMessage handler's guard that only flips isTimeout on
+//     WorkerMessageExit (integration tests can't cleanly target non-Exit messages)
+//
+// Tests for the happy path, timeout-signal-reaches-worker behavior, and main-thread
+// early return were removed — they either duplicate what the integration suite
+// already exercises or assert mocked behavior with little signal.
+const mockParentPortPostMessage = jest.fn();
+const mockParentPortOn = jest.fn();
+let mockIsMainThread = false;
+jest.mock('node:worker_threads', () => ({
+    get isMainThread() {
+        return mockIsMainThread;
+    },
+    get parentPort() {
+        return {
+            postMessage: mockParentPortPostMessage,
+            on: mockParentPortOn,
+        };
+    },
+    get workerData() {
+        var _a;
+        return (_a = global.__workerData__) !== null && _a !== void 0 ? _a : {};
+    },
+}));
+jest.mock('../common/event-type-translation', () => ({
+    translateIncomingEventType: jest.fn((t) => t),
+}));
+jest.mock('../logger/logger', () => ({
+    Logger: jest.fn().mockImplementation(() => ({
+        log: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+        logFn: jest.fn(),
+    })),
+    serializeError: jest.fn((e) => String(e)),
+}));
+jest.mock('../logger/logger.context', () => ({
+    runWithSdkLogContext: jest.fn((fn) => fn()),
+    runWithUserLogContext: jest.fn((fn) => fn()),
+}));
+jest.mock('../state/state', () => ({
+    createAdapterState: jest.fn(),
+}));
+jest.mock('./worker-adapter/worker-adapter', () => ({
+    WorkerAdapter: jest.fn().mockImplementation(() => ({
+        isTimeout: false,
+        hasWorkerEmitted: false,
+    })),
+}));
+const process_task_1 = require("./process-task");
+const event_type_translation_1 = require("../common/event-type-translation");
+const state_1 = require("../state/state");
+const worker_adapter_1 = require("./worker-adapter/worker-adapter");
+const test_utils_1 = require("../common/test-utils");
+function setWorkerData(data) {
+    global.__workerData__ = data;
+}
+function makeEvent(eventType = extraction_1.EventType.StartExtractingData) {
+    return (0, test_utils_1.createMockEvent)('http://localhost:0', {
+        payload: { event_type: eventType },
+    });
+}
+// Flush the microtask queue enough to let the async IIFE inside processTask run.
+const flush = async () => new Promise((r) => setTimeout(r, 0));
+describe(process_task_1.processTask.name, () => {
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockIsMainThread = false;
+        processExitSpy = jest
+            .spyOn(process, 'exit')
+            .mockImplementation((() => { }));
+        state_1.createAdapterState.mockResolvedValue({});
+    });
+    afterEach(() => {
+        processExitSpy.mockRestore();
+    });
+    it('should translate incoming event type before passing to task', async () => {
+        // Arrange
+        const event = makeEvent(extraction_1.EventType.StartExtractingData);
+        setWorkerData({ event, initialState: {}, options: {} });
+        event_type_translation_1.translateIncomingEventType.mockReturnValue(extraction_1.EventType.StartExtractingMetadata);
+        const task = jest.fn().mockResolvedValue(undefined);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processTask)({ task, onTimeout });
+        await flush();
+        // Assert
+        expect(event_type_translation_1.translateIncomingEventType).toHaveBeenCalledWith(extraction_1.EventType.StartExtractingData);
+        // The event is mutated in place — downstream code (including task) sees the
+        // translated type, not the original wire type.
+        expect(event.payload.event_type).toBe(extraction_1.EventType.StartExtractingMetadata);
+    });
+    it('should NOT call onTimeout when the worker already emitted before timeout check', async () => {
+        // Arrange
+        const event = makeEvent();
+        setWorkerData({ event, initialState: {}, options: {} });
+        // Both flags true: a timeout arrived but the worker had already emitted —
+        // onTimeout must be skipped. This is the guard the integration suite cannot
+        // target cleanly because it requires a precise race between emit and timeout.
+        const mockAdapter = { isTimeout: true, hasWorkerEmitted: true };
+        worker_adapter_1.WorkerAdapter.mockImplementation(() => mockAdapter);
+        const task = jest.fn().mockResolvedValue(undefined);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processTask)({ task, onTimeout });
+        await flush();
+        // Assert
+        expect(onTimeout).not.toHaveBeenCalled();
+        expect(processExitSpy).toHaveBeenCalledWith(0);
+    });
+    it('should NOT flip adapter.isTimeout when a non-Exit WorkerMessage arrives', async () => {
+        // Arrange
+        const event = makeEvent();
+        setWorkerData({ event, initialState: {}, options: {} });
+        const mockAdapter = { isTimeout: false, hasWorkerEmitted: false };
+        worker_adapter_1.WorkerAdapter.mockImplementation(() => mockAdapter);
+        const task = jest.fn().mockResolvedValue(undefined);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processTask)({ task, onTimeout });
+        await flush();
+        // Grab the handler registered for WorkerMessage events and invoke it with
+        // subjects that must NOT flip isTimeout (log messages, unknown subjects).
+        const messageHandlerCall = mockParentPortOn.mock.calls.find(([eventName]) => eventName === workers_1.WorkerEvent.WorkerMessage);
+        expect(messageHandlerCall).toBeDefined();
+        const handler = messageHandlerCall[1];
+        handler({ subject: workers_1.WorkerMessageSubject.WorkerMessageLog });
+        handler({ subject: 'NONSENSE_SUBJECT' });
+        // Assert
+        expect(mockAdapter.isTimeout).toBe(false);
+    });
+    it('should post WorkerMessageFailed with the error message and exit(1) when task throws', async () => {
+        // Arrange
+        const event = makeEvent();
+        setWorkerData({ event, initialState: {}, options: {} });
+        const mockAdapter = { isTimeout: false, hasWorkerEmitted: false };
+        worker_adapter_1.WorkerAdapter.mockImplementation(() => mockAdapter);
+        const taskError = new Error('task boom');
+        const task = jest.fn().mockRejectedValue(taskError);
+        const onTimeout = jest.fn().mockResolvedValue(undefined);
+        // Act
+        (0, process_task_1.processTask)({ task, onTimeout });
+        await flush();
+        // Assert
+        expect(mockParentPortPostMessage).toHaveBeenCalledWith(expect.objectContaining({
+            subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+            payload: expect.objectContaining({
+                message: expect.stringContaining('task boom'),
+            }),
+        }));
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+        expect(onTimeout).not.toHaveBeenCalled();
+    });
+});

package/dist/multithreading/spawn/spawn.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spawn.test.d.ts.map

package/dist/multithreading/spawn/spawn.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn.test.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.test.ts"],"names":[],"mappings":""}