@devrev/airsync-sdk 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/multithreading/worker-adapter/worker-adapter.js

@@ -20,7 +20,7 @@ const extraction_1 = require("../../types/extraction");
 const loading_1 = require("../../types/loading");
 const workers_1 = require("../../types/workers");
 const uploader_1 = require("../../uploader/uploader");
-const event_type_translation_1 = require("../../common/event-type-translation");
+const helpers_1 = require("../../common/helpers");
 function createWorkerAdapter({ event, adapterState, options, }) {
     return new WorkerAdapter({
         event,
@@ -29,7 +29,7 @@ function createWorkerAdapter({ event, adapterState, options, }) {
     });
 }
 /**
- * WorkerAdapter class is used to interact with Airdrop platform. It is passed to the snap-in
+ * WorkerAdapter class is used to interact with AirSync platform. It is passed to the snap-in
  * as parameter in processTask and onTimeout functions. The class provides
  * utilities to emit control events to the platform, update the state of the connector,
  * and upload artifacts to the platform.
@@ -46,6 +46,7 @@ function createWorkerAdapter({ event, adapterState, options, }) {
 class WorkerAdapter {
     constructor({ event, adapterState, options, }) {
         this.repos = [];
+        this.currentEventDataLength = 0;
         this.event = event;
         this.options = options;
         this.adapterState = adapterState;
@@ -79,17 +80,38 @@ class WorkerAdapter {
     get mappers() {
         return this._mappers;
     }
+    get extractionScope() {
+        return this.adapterState.extractionScope;
+    }
+    /**
+     * Returns whether the given item type should be extracted.
+     * Defaults to true if the scope is empty or the item type is not listed.
+     */
+    shouldExtract(itemType) {
+        const scope = this.extractionScope;
+        if (Object.keys(scope).length === 0)
+            return true;
+        if (!(itemType in scope))
+            return true;
+        return scope[itemType].extract;
+    }
     initializeRepos(repos) {
         this.repos = repos.map((repo) => {
-            const shouldNormalize = repo.itemType !== constants_1.AIRDROP_DEFAULT_ITEM_TYPES.EXTERNAL_DOMAIN_METADATA &&
-                repo.itemType !== constants_1.AIRDROP_DEFAULT_ITEM_TYPES.SSOR_ATTACHMENT;
+            const shouldNormalize = repo.itemType !== constants_1.AirSyncDefaultItemTypes.EXTERNAL_DOMAIN_METADATA &&
+                repo.itemType !== constants_1.SSOR_ATTACHMENT;
             return new repo_1.Repo(Object.assign(Object.assign({ event: this.event, itemType: repo.itemType }, (shouldNormalize && { normalize: repo.normalize })), { onUpload: (artifact) => {
                     var _a;
                     // We need to store artifacts ids in state for later use when streaming attachments
-                    if (repo.itemType === constants_1.AIRDROP_DEFAULT_ITEM_TYPES.ATTACHMENTS) {
+                    if (repo.itemType === constants_1.AirSyncDefaultItemTypes.ATTACHMENTS) {
                         (_a = this.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata.artifactIds.push(artifact.id);
                     }
-                }, options: this.options }));
+                    // Calculate size of the entire artifact object that goes in the SQS message
+                    this.currentEventDataLength += Buffer.byteLength(JSON.stringify(artifact), 'utf8');
+                    if (this.currentEventDataLength > constants_1.EVENT_SIZE_THRESHOLD_BYTES &&
+                        !this.isTimeout) {
+                        this.isTimeout = true;
+                    }
+                }, options: Object.assign(Object.assign({}, this.options), repo.overridenOptions) }));
         });
     }
     getRepo(itemType) {
@@ -123,29 +145,42 @@ class WorkerAdapter {
      */
     async emit(newEventType, data) {
         return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            newEventType = (0, event_type_translation_1.translateOutgoingEventType)(newEventType);
+            var _a;
             if (this.hasWorkerEmitted) {
                 console.warn(`Trying to emit event with event type: ${newEventType}. Ignoring emit request because it has already been emitted.`);
                 return;
             }
-            // We want to upload all the repos before emitting the event, except for the external sync units done event
-            if (newEventType !== extraction_1.ExtractorEventType.ExternalSyncUnitExtractionDone) {
-                console.log(`Uploading all repos before emitting event with event type: ${newEventType}.`);
-                try {
-                    await this.uploadAllRepos();
-                }
-                catch (error) {
-                    console.error('Error while uploading repos', error);
-                    node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
-                    this.hasWorkerEmitted = true;
-                    return;
-                }
+            // Upload all repos before emitting the event
+            console.log(`Uploading all repos before emitting event with event type: ${newEventType}.`);
+            try {
+                await this.uploadAllRepos();
+            }
+            catch (error) {
+                console.error('Error while uploading repos', error);
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
+                this.hasWorkerEmitted = true;
+                return;
             }
-            // If the extraction is done, we want to save the timestamp of the last successful sync
             if (newEventType === extraction_1.ExtractorEventType.AttachmentExtractionDone) {
-                console.log(`Overwriting lastSuccessfulSyncStarted with lastSyncStarted (${this.state.lastSyncStarted}).`);
-                this.state.lastSuccessfulSyncStarted = this.state.lastSyncStarted;
-                this.state.lastSyncStarted = '';
+                // Clear pending extraction boundaries now that the cycle is complete
+                this.state.pendingWorkersOldest = '';
+                this.state.pendingWorkersNewest = '';
+                // Update workersOldest and workersNewest boundaries from resolved extraction timestamps.
+                // Expand boundaries: workersOldest gets the earliest timestamp, workersNewest gets the latest.
+                const extractionStart = this.event.payload.event_context.extract_from;
+                const extractionEnd = this.event.payload.event_context.extract_to;
+                if (extractionStart &&
+                    (!this.state.workersOldest ||
+                        extractionStart < this.state.workersOldest)) {
+                    console.log(`Updating workersOldest from '${this.state.workersOldest}' to '${extractionStart}'.`);
+                    this.state.workersOldest = extractionStart;
+                }
+                if (extractionEnd &&
+                    (!this.state.workersNewest ||
+                        extractionEnd > this.state.workersNewest)) {
+                    console.log(`Updating workersNewest from '${this.state.workersNewest}' to '${extractionEnd}'.`);
+                    this.state.workersNewest = extractionEnd;
+                }
             }
             // We want to save the state every time we emit an event, except for the start and delete events
             if (!constants_1.STATELESS_EVENT_TYPES.includes(this.event.payload.event_type)) {
@@ -161,11 +196,17 @@ class WorkerAdapter {
                 }
             }
             try {
+                // Always prune error messages to make them shorter before emit
+                if ((_a = data === null || data === void 0 ? void 0 : data.error) === null || _a === void 0 ? void 0 : _a.message) {
+                    data.error.message = (0, helpers_1.truncateMessage)(data.error.message);
+                }
+                const isExtractionEvent = Object.values(extraction_1.ExtractorEventType).includes(newEventType);
+                const isLoaderEvent = Object.values(loading_1.LoaderEventType).includes(newEventType);
                 await (0, control_protocol_1.emit)({
                     eventType: newEventType,
                     event: this.event,
-                    data: Object.assign(Object.assign({}, data), (constants_1.ALLOWED_EXTRACTION_EVENT_TYPES.includes(this.event.payload.event_type)
-                        ? { artifacts: this.artifacts }
+                    data: Object.assign(Object.assign(Object.assign({}, data), (isExtractionEvent ? { artifacts: this.artifacts } : {})), (isLoaderEvent
+                        ? { reports: this.reports, processed_files: this.processedFiles }
                         : {})),
                 });
                 const message = {
@@ -192,9 +233,6 @@ class WorkerAdapter {
             }
         }
     }
-    handleTimeout() {
-        this.isTimeout = true;
-    }
     async loadItemTypes({ itemTypesToLoad, }) {
         return (0, logger_context_1.runWithSdkLogContext)(async () => {
             var _a;
@@ -223,57 +261,74 @@ class WorkerAdapter {
                 };
             }
             console.log('Files to load in state', (_a = this.adapterState.state.fromDevRev) === null || _a === void 0 ? void 0 : _a.filesToLoad);
-            outerloop: for (const fileToLoad of this.adapterState.state.fromDevRev
-                .filesToLoad) {
-                const itemTypeToLoad = itemTypesToLoad.find((itemTypeToLoad) => itemTypeToLoad.itemType === fileToLoad.itemType);
-                if (!itemTypeToLoad) {
-                    console.error(`Item type to load not found for item type: ${fileToLoad.itemType}.`);
-                    await this.emit(loading_1.LoaderEventType.DataLoadingError, {
-                        error: {
-                            message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
-                        },
-                    });
-                    break;
-                }
-                if (!fileToLoad.completed) {
-                    const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
-                        artifactId: fileToLoad.id,
-                        isGzipped: true,
-                    });
-                    if (transformerFileError) {
-                        console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+            try {
+                outerloop: for (const fileToLoad of this.adapterState.state.fromDevRev
+                    .filesToLoad) {
+                    const itemTypeToLoad = itemTypesToLoad.find((itemTypeToLoad) => itemTypeToLoad.itemType === fileToLoad.itemType);
+                    if (!itemTypeToLoad) {
+                        console.error(`Item type to load not found for item type: ${fileToLoad.itemType}.`);
                         await this.emit(loading_1.LoaderEventType.DataLoadingError, {
                             error: {
-                                message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                                message: `Item type to load not found for item type: ${fileToLoad.itemType}.`,
                             },
                         });
+                        break;
                     }
-                    const transformerFile = response;
-                    for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
-                        const { report, rateLimit } = await this.loadItem({
-                            item: transformerFile[i],
-                            itemTypeToLoad,
+                    if (!fileToLoad.completed) {
+                        const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
+                            artifactId: fileToLoad.id,
+                            isGzipped: true,
                         });
-                        if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                            await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
-                                delay: rateLimit.delay,
-                                reports: this.reports,
-                                processed_files: this.processedFiles,
+                        if (transformerFileError) {
+                            console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+                            await this.emit(loading_1.LoaderEventType.DataLoadingError, {
+                                error: {
+                                    message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                                },
                             });
                             break outerloop;
                         }
-                        if (report) {
-                            (0, worker_adapter_helpers_1.addReportToLoaderReport)({
-                                loaderReports: this.loaderReports,
-                                report,
+                        const transformerFile = response;
+                        for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                            if (this.isTimeout) {
+                                console.log('Timeout detected during data loading. Emitting progress to allow continuation.');
+                                await this.emit(loading_1.LoaderEventType.DataLoadingProgress);
+                                process.exit(0);
+                            }
+                            const { report, rateLimit } = await this.loadItem({
+                                item: transformerFile[i],
+                                itemTypeToLoad,
                             });
-                            fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
+                                await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
+                                    delay: rateLimit.delay,
+                                    reports: this.reports,
+                                    processed_files: this.processedFiles,
+                                });
+                                break outerloop;
+                            }
+                            if (report) {
+                                (0, worker_adapter_helpers_1.addReportToLoaderReport)({
+                                    loaderReports: this.loaderReports,
+                                    report,
+                                });
+                                fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            }
                         }
+                        fileToLoad.completed = true;
+                        this._processedFiles.push(fileToLoad.id);
                     }
-                    fileToLoad.completed = true;
-                    this._processedFiles.push(fileToLoad.id);
                 }
             }
+            catch (error) {
+                console.error('Error during data loading.', (0, logger_1.serializeError)(error));
+                await this.emit(loading_1.LoaderEventType.DataLoadingError, {
+                    error: {
+                        message: `Error during data loading. ${(0, logger_1.serializeError)(error)}`,
+                    },
+                });
+                process.exit(1);
+            }
             return {
                 reports: this.reports,
                 processed_files: this.processedFiles,
@@ -320,42 +375,63 @@ class WorkerAdapter {
                 };
             }
             const filesToLoad = (_b = this.adapterState.state.fromDevRev) === null || _b === void 0 ? void 0 : _b.filesToLoad;
-            outerloop: for (const fileToLoad of filesToLoad) {
-                if (!fileToLoad.completed) {
-                    const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
-                        artifactId: fileToLoad.id,
-                        isGzipped: true,
-                    });
-                    const transformerFile = response;
-                    if (transformerFileError) {
-                        console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
-                        break outerloop;
-                    }
-                    for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
-                        const { report, rateLimit } = await this.loadAttachment({
-                            item: transformerFile[i],
-                            create,
+            try {
+                outerloop: for (const fileToLoad of filesToLoad) {
+                    if (!fileToLoad.completed) {
+                        const { response, error: transformerFileError } = await this.uploader.getJsonObjectByArtifactId({
+                            artifactId: fileToLoad.id,
+                            isGzipped: true,
                         });
-                        if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
-                            await this.emit(loading_1.LoaderEventType.DataLoadingDelayed, {
-                                delay: rateLimit.delay,
-                                reports: this.reports,
-                                processed_files: this.processedFiles,
+                        const transformerFile = response;
+                        if (transformerFileError) {
+                            console.error(`Transformer file not found for artifact ID: ${fileToLoad.id}.`);
+                            await this.emit(loading_1.LoaderEventType.AttachmentLoadingError, {
+                                error: {
+                                    message: `Transformer file not found for artifact ID: ${fileToLoad.id}.`,
+                                },
                             });
                             break outerloop;
                         }
-                        if (report) {
-                            (0, worker_adapter_helpers_1.addReportToLoaderReport)({
-                                loaderReports: this.loaderReports,
-                                report,
+                        for (let i = fileToLoad.lineToProcess; i < fileToLoad.count; i++) {
+                            if (this.isTimeout) {
+                                console.log('Timeout detected during attachment loading. Emitting progress to allow continuation.');
+                                await this.emit(loading_1.LoaderEventType.AttachmentLoadingProgress);
+                                process.exit(0);
+                            }
+                            const { report, rateLimit } = await this.loadAttachment({
+                                item: transformerFile[i],
+                                create,
                             });
-                            fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            if (rateLimit === null || rateLimit === void 0 ? void 0 : rateLimit.delay) {
+                                await this.emit(loading_1.LoaderEventType.AttachmentLoadingDelayed, {
+                                    delay: rateLimit.delay,
+                                    reports: this.reports,
+                                    processed_files: this.processedFiles,
+                                });
+                                break outerloop;
+                            }
+                            if (report) {
+                                (0, worker_adapter_helpers_1.addReportToLoaderReport)({
+                                    loaderReports: this.loaderReports,
+                                    report,
+                                });
+                                fileToLoad.lineToProcess = fileToLoad.lineToProcess + 1;
+                            }
                         }
+                        fileToLoad.completed = true;
+                        this._processedFiles.push(fileToLoad.id);
                     }
-                    fileToLoad.completed = true;
-                    this._processedFiles.push(fileToLoad.id);
                 }
             }
+            catch (error) {
+                console.error('Error during attachment loading.', (0, logger_1.serializeError)(error));
+                await this.emit(loading_1.LoaderEventType.AttachmentLoadingError, {
+                    error: {
+                        message: `Error during attachment loading. ${(0, logger_1.serializeError)(error)}`,
+                    },
+                });
+                process.exit(1);
+            }
             return {
                 reports: this.reports,
                 processed_files: this.processedFiles,
@@ -381,10 +457,12 @@ class WorkerAdapter {
                     };
                 }
                 // Update item in external system
-                const { id, modifiedDate, delay, error } = await itemTypeToLoad.update({
-                    item,
-                    mappers: this._mappers,
-                    event: this.event,
+                const { id, modifiedDate, delay, error } = await (0, logger_context_1.runWithUserLogContext)(async () => {
+                    return await itemTypeToLoad.update({
+                        item,
+                        mappers: this._mappers,
+                        event: this.event,
+                    });
                 });
                 if (id) {
                     try {
@@ -442,10 +520,12 @@ class WorkerAdapter {
                 if (axios_1.default.isAxiosError(error)) {
                     if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
                         // Create item in external system if mapper record not found
-                        const { id, modifiedDate, delay, error } = await itemTypeToLoad.create({
-                            item,
-                            mappers: this._mappers,
-                            event: this.event,
+                        const { id, modifiedDate, delay, error } = await (0, logger_context_1.runWithUserLogContext)(async () => {
+                            return await itemTypeToLoad.create({
+                                item,
+                                mappers: this._mappers,
+                                event: this.event,
+                            });
                         });
                         if (id) {
                             // Create mapper
@@ -513,11 +593,11 @@ class WorkerAdapter {
     }
     async processAttachment(attachment, stream) {
         return (0, logger_context_1.runWithSdkLogContext)(async () => {
-            var _a;
-            const { httpStream, delay, error } = await stream({
+            var _a, _b, _c;
+            const { httpStream, delay, error } = await (0, logger_context_1.runWithUserLogContext)(async () => stream({
                 item: attachment,
                 event: this.event,
-            });
+            }));
             if (error) {
                 return { error };
             }
@@ -525,37 +605,44 @@ class WorkerAdapter {
                 return { delay };
             }
             if (httpStream) {
-                const fileType = httpStream.headers['content-type'] || 'application/octet-stream';
-                const fileSize = httpStream.headers['content-length']
-                    ? parseInt(httpStream.headers['content-length'])
-                    : undefined;
+                const fileType = attachment.content_type ||
+                    ((_a = httpStream.headers['content-type']) === null || _a === void 0 ? void 0 : _a.toString()) ||
+                    'application/octet-stream';
+                const contentLength = (_b = httpStream.headers['content-length']) === null || _b === void 0 ? void 0 : _b.toString();
+                const fileSize = contentLength ? parseInt(contentLength) : undefined;
                 // Get upload URL
                 const { error: artifactUrlError, response: artifactUrlResponse } = await this.uploader.getArtifactUploadUrl(attachment.file_name, fileType, fileSize);
                 if (artifactUrlError) {
-                    console.warn(`Error while preparing artifact for attachment ID ${attachment.id}. Skipping attachment. ` +
-                        (0, logger_1.serializeError)(artifactUrlError));
                     this.destroyHttpStream(httpStream);
-                    return;
-                }
-                if (this.isTimeout) {
-                    this.destroyHttpStream(httpStream);
-                    return;
+                    return {
+                        error: {
+                            message: `Error while preparing artifact for attachment ID ${attachment.id}. Skipping attachment. ${(0, logger_1.serializeError)(artifactUrlError)}`,
+                            fileSize: fileSize,
+                        },
+                    };
                 }
                 // Stream attachment
                 const { error: uploadedArtifactError } = await this.uploader.streamArtifact(artifactUrlResponse, httpStream);
                 if (uploadedArtifactError) {
-                    console.warn(`Error while streaming to artifact for attachment ID ${attachment.id}. Skipping attachment. ` +
-                        (0, logger_1.serializeError)(uploadedArtifactError));
                     this.destroyHttpStream(httpStream);
-                    return;
+                    return {
+                        error: {
+                            message: `Error while streaming to artifact for attachment ID ${attachment.id}. Skipping attachment. ` +
+                                (0, logger_1.serializeError)(uploadedArtifactError),
+                            fileSize: fileSize,
+                        },
+                    };
                 }
                 // Confirm attachment upload
                 const { error: confirmArtifactUploadError } = await this.uploader.confirmArtifactUpload(artifactUrlResponse.artifact_id);
                 if (confirmArtifactUploadError) {
-                    console.warn('Error while confirming upload for attachment ID ' +
-                        attachment.id +
-                        '.', confirmArtifactUploadError);
-                    return;
+                    return {
+                        error: {
+                            message: `Error while confirming upload for attachment ID ${attachment.id}. ` +
+                                (0, logger_1.serializeError)(confirmArtifactUploadError),
+                            fileSize: fileSize,
+                        },
+                    };
                 }
                 const ssorAttachment = {
                     id: {
@@ -579,9 +666,14 @@ class WorkerAdapter {
                 else if (attachment.inline === false) {
                     ssorAttachment.inline = false;
                 }
-                await ((_a = this.getRepo('ssor_attachment')) === null || _a === void 0 ? void 0 : _a.push([ssorAttachment]));
+                await ((_c = this.getRepo('ssor_attachment')) === null || _c === void 0 ? void 0 : _c.push([ssorAttachment]));
+                return;
             }
-            return;
+            return {
+                error: {
+                    message: `Error while opening attachment stream. Skipping attachment.`,
+                },
+            };
         });
     }
     /**
@@ -606,11 +698,11 @@ class WorkerAdapter {
     async loadAttachment({ item, create, }) {
         return (0, logger_context_1.runWithSdkLogContext)(async () => {
             // Create item
-            const { id, delay, error } = await create({
+            const { id, delay, error } = await (0, logger_context_1.runWithUserLogContext)(async () => create({
                 item,
                 mappers: this._mappers,
                 event: this.event,
-            });
+            }));
             if (delay) {
                 return {
                     rateLimit: {
@@ -707,15 +799,17 @@ class WorkerAdapter {
                     console.log(`Using custom processors for attachments.`);
                     const reducer = processors.reducer;
                     const iterator = processors.iterator;
-                    const reducedAttachments = reducer({
+                    const reducedAttachments = (0, logger_context_1.runWithUserLogContext)(() => reducer({
                         attachments,
                         adapter: this,
                         batchSize,
-                    });
-                    response = await iterator({
-                        reducedAttachments,
-                        adapter: this,
-                        stream,
+                    }));
+                    response = await (0, logger_context_1.runWithUserLogContext)(async () => {
+                        return await iterator({
+                            reducedAttachments,
+                            adapter: this,
+                            stream,
+                        });
                     });
                 }
                 else {
@@ -731,6 +825,13 @@ class WorkerAdapter {
                 if ((response === null || response === void 0 ? void 0 : response.delay) || (response === null || response === void 0 ? void 0 : response.error)) {
                     return response;
                 }
+                // On timeout, emit progress and exit to allow continuation.
+                if (this.isTimeout) {
+                    console.log(`Timeout detected after processing attachments for artifact ID: ${attachmentsMetadataArtifactId}. Emitting progress to allow continuation.`);
+                    await this.emit(extraction_1.ExtractorEventType.AttachmentExtractionProgress);
+                    process.exit(0);
+                    return;
+                }
                 console.log(`Finished processing all attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
                 attachmentsMetadata.artifactIds.shift();
                 attachmentsMetadata.lastProcessed = 0;

package/dist/multithreading/worker-adapter/worker-adapter.loading.test.d.ts

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

package/dist/multithreading/worker-adapter/worker-adapter.loading.test.d.ts.map

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