filemail-sdk 9.4.10 → 10.2.0

package/dist/src/uploader/transferUpload.js

@@ -1,12 +1,12 @@
-import sleep from 'abortable-sleep';
-import ApiError from '../utils/api/apiError.js';
-import FsError from '../utils/fileSystem/fsError.js';
 import TransferUploadState from "./state/transferUploadState.js";
 import TransferUploadError from "./transferUploadError.js";
 import TransferStatus from "../utils/types/transferStatus.js";
 import TransferUploadEvent from './transferUploadEvent.js';
 import ChunksIterator from './chunksIterator/chunksIterator.js';
+import TransferFilesRegistrar from './transferFilesRegistrar.js';
 import mergeAbortAndPauseSignals from '../utils/mergeAbortAndPauseSignals.js';
+import ApiError from '../utils/api/apiError.js';
+import FsError from '../utils/fileSystem/fsError.js';
 import ApiFilemail449Error from '../utils/api/apiFilemail449Error.js';
 import { promiseAllSettled } from '../utils/promiseAll.js';
 import { isTransferFailureAbortReason } from './transferFailureAbortReason.js';
@@ -19,8 +19,9 @@ export default class TransferUpload {
     #eventsEngine;
     #info;
     #config;
-    #optimizer;
+    #concurrencyController;
     #cryptography;
+    #acker;
     #transferState;
     #transferMetadata;
     #transferDownloadUrl;
@@ -28,11 +29,10 @@ export default class TransferUpload {
     #transferRecipientTrackingLinks;
     #pauseSignal;
     #abortSignal;
-    #mergedPauseAndAbortSignal;
+    #mergedPauseAndAbortController;
+    #filesRegistrar;
     pauseEventListener;
     abortEventListener;
-    #isUdpUploadMode;
-    #serverLatencyInMs;
     #isRunMethodRunning = false;
     get status() {
         return this.#transferState?.status ?? TransferStatus.Initialized;
@@ -63,21 +63,23 @@ export default class TransferUpload {
     get transferId() {
         return this.#transferMetadata?.transferId;
     }
-    constructor(chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, info, config, optimizer, cryptography) {
+    constructor(chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, info, config, concurrencyController, cryptography, acker) {
         if (info.files.length === 0)
             throw new TransferUploadError(`Files can't be empty`);
         this.#totalSizeInBytes = info.files.reduce((partialSum, file) => partialSum + file.fileSizeInBytes, 0);
-        this.#isUdpUploadMode = false;
         this.#chunkStreamProviderFactory = chunkStreamProviderFactory;
         this.#apiClient = apiClient;
         this.#fileServerClientFactory = fileServerClientFactory;
         this.#eventsEngine = eventsEngine;
         this.#info = info;
         this.#config = config;
-        this.#optimizer = optimizer;
+        this.#concurrencyController = concurrencyController;
         this.#cryptography = cryptography;
-        if (this.isUploadAppendInfo(this.#info))
-            this.createTransferMetadataFromInfo(this.#info);
+        this.#acker = acker;
+        this.#filesRegistrar = this.isLegacyTransferAppend() ? undefined : new TransferFilesRegistrar(apiClient, eventsEngine, info.files);
+    }
+    isLegacyTransferAppend() {
+        return this.isUploadAppendInfo(this.#info) && (this.#info.isLegacyTransfer === undefined || this.#info.isLegacyTransfer === true);
     }
     isUploadAppend() {
         return this.isUploadAppendInfo(this.#info);
@@ -85,16 +87,16 @@ export default class TransferUpload {
     isUploadAppendInfo(info) {
         return info.transferKey !== undefined;
     }
-    createTransferMetadataFromInfo(info) {
-        if (!this.isUploadAppendInfo(info))
+    createTransferMetadataFromInfo() {
+        if (!this.isUploadAppendInfo(this.#info))
             throw new TransferUploadError(`Options are not TransferUploadAppendOptions`);
-        this.#transferDownloadUrl = info.transferDownloadUrl;
+        this.#transferDownloadUrl = this.#info.transferDownloadUrl;
         this.#transferMetadata = {
-            transferId: info.transferId,
-            transferKey: info.transferKey,
-            transferFileServerUrl: info.transferFileServerUrl,
-            transferRegion: info.transferRegion,
-            encryptionData: info.e2eeData,
+            transferId: this.#info.transferId,
+            transferKey: this.#info.transferKey,
+            transferFileServerUrl: this.#info.transferFileServerUrl,
+            transferRegion: this.#info.transferRegion,
+            encryptionData: this.#info.e2eeData,
         };
     }
     async run(transferPauseSignal, transferAbortSignal) {
@@ -103,34 +105,36 @@ export default class TransferUpload {
         try {
             this.#pauseSignal = transferPauseSignal;
             this.#abortSignal = transferAbortSignal;
-            this.#mergedPauseAndAbortSignal = mergeAbortAndPauseSignals(transferPauseSignal, transferAbortSignal);
+            this.#mergedPauseAndAbortController = mergeAbortAndPauseSignals(transferPauseSignal, transferAbortSignal);
             if (!this.#transferState)
                 this.#transferState = new TransferUploadState(this.files, this.#eventsEngine, this.#config.currentRatesTimespanInMs, this.#config.progressEventThrottlingInMs);
             else
                 this.#transferState.recover();
             this.#transferState.transferRun();
             this.addPauseAndStopListeners();
-            if (!this.#transferMetadata)
+            if (this.isUploadAppend() && !this.#transferMetadata)
+                this.createTransferMetadataFromInfo();
+            else if (!this.#transferMetadata)
                 await this.startApiTransferAndCreateMetadata();
             this.notifyMetadataDetermined();
-            await this.pingServerAndChooseUploadMode();
-            if (this.#isUdpUploadMode && !this.#transferMetadata.udpData.handshakeData)
-                await this.serverUdpHandshake();
-            this.#optimizer.start(this.#isUdpUploadMode, this.#serverLatencyInMs);
+            this.startBackgroundWorkers(transferPauseSignal, transferAbortSignal);
             const ongoingChunkUploads = new Set();
             for (const file of this.files) {
                 const fileStatus = this.#transferState.getFile(file.externalId);
                 if (fileStatus.isCompleted)
                     continue;
+                const registrationResult = await this.waitUntilFileRegistered(file);
+                if (!registrationResult.isRegisteredSuccessfully)
+                    continue;
+                if (fileStatus.isUploadCompleted) {
+                    this.enqueueFileAck(file);
+                    continue;
+                }
                 const alreadySentChunks = this.#transferState.getChunksForFile(file.externalId);
-                const chunksIterator = new ChunksIterator(alreadySentChunks, file.fileSizeInBytes, this.#optimizer);
+                const chunksIterator = new ChunksIterator(alreadySentChunks, file.fileSizeInBytes, this.#config.chunkSizeInBytes);
                 for (const chunk of chunksIterator.getChunksIterator()) {
-                    // eslint-disable-next-line no-await-in-loop
-                    const releaseSemaphore = await this.#optimizer.semaphoreAcquire();
-                    if (this.#optimizer.currentSleepTimeInMs >= 1)
-                        // eslint-disable-next-line no-await-in-loop
-                        await sleep(this.#optimizer.currentSleepTimeInMs, this.#mergedPauseAndAbortSignal);
-                    if (this.shouldStopSchedulingChunks()) {
+                    const releaseSemaphore = await this.#concurrencyController.acquire();
+                    if (this.shouldStopProcessing()) {
                         releaseSemaphore();
                         break;
                     }
@@ -139,21 +143,19 @@ export default class TransferUpload {
                         ongoingChunkUploads.delete(trackedChunkUploadPromise);
                     });
                     ongoingChunkUploads.add(trackedChunkUploadPromise);
-                    if (this.shouldStopSchedulingChunks())
+                    if (this.shouldStopProcessing())
                         break;
                 }
-                if (this.shouldStopSchedulingChunks())
+                if (this.shouldStopProcessing())
                     break;
             }
             await promiseAllSettled(Array.from(ongoingChunkUploads));
-            this.#optimizer.stop();
+            await this.#acker.flush();
             if (this.#transferState.status === TransferStatus.Pausing)
                 this.#transferState.transferPaused();
             else if (this.#transferState.status === TransferStatus.Aborting)
                 this.#transferState.transferAborted();
-            // else if (this.isFailureAbortRequested())
-            //     this.#transferState.transferFailed();
-            else if (this.uploadedBytesCount !== this.totalSizeInBytes)
+            else if (this.uploadedBytesCount !== this.totalSizeInBytes || this.hasUnackedFiles())
                 this.#transferState.transferFailed();
             else {
                 await this.finalizeTransfer();
@@ -164,10 +166,6 @@ export default class TransferUpload {
             // We can get here with pausing or aborting status if any API call fails (e.g., finalizeTransfer) so we need to check the status again
             if (!this.#transferState)
                 this.#eventsEngine.emit(TransferUploadEvent.TransferFailed);
-            // else if (this.isFailureAbortRequested()) {
-            //     this.#transferState.transferFailed();
-            //     return;
-            // }
             else if (this.#transferState.status === TransferStatus.Pausing) {
                 this.#transferState.transferPaused();
                 return;
@@ -184,80 +182,55 @@ export default class TransferUpload {
                 throw new TransferUploadError(`Unhandled error occured. See 'cause' for more details`, { cause: error });
         }
         finally {
+            await this.stopBackgroundWorkers();
             this.removePauseAndStopListeners();
-            this.#optimizer.stop();
             this.#isRunMethodRunning = false;
         }
     }
+    startBackgroundWorkers(transferPauseSignal, transferAbortSignal) {
+        const fileAckSuccessfullCallback = (externalFileId, uploadItemId) => this.#transferState.fileCompleted(externalFileId, uploadItemId);
+        const fileAckFailedCallback = (externalFileId, uploadItemId, reason, error) => this.#transferState.fileAckFailed(externalFileId, uploadItemId, reason, error);
+        this.#acker.start(this.#transferMetadata.transferId, this.#transferMetadata.transferKey, fileAckSuccessfullCallback, fileAckFailedCallback, transferPauseSignal, transferAbortSignal);
+        this.#filesRegistrar?.start(this.#transferMetadata.transferId, this.#transferMetadata.transferKey, this.#mergedPauseAndAbortController?.signal);
+    }
+    async stopBackgroundWorkers() {
+        await Promise.allSettled([
+            this.#filesRegistrar?.stop(),
+            this.#acker.stop(),
+        ]);
+    }
+    async waitUntilFileRegistered(file) {
+        if (this.isLegacyTransfer())
+            return { isRegisteredSuccessfully: true };
+        return await this.#filesRegistrar.waitUntilFileRegistered(file.externalId);
+    }
     notifyMetadataDetermined() {
-        if (!this.#transferMetadata)
-            return;
         const eventArgs = {
             transferId: this.#transferMetadata.transferId,
             fileServerUrl: this.#transferMetadata.transferFileServerUrl,
             region: this.#transferMetadata.transferRegion,
         };
         this.#eventsEngine.emit(TransferUploadEvent.TransferMetadataDetermined, eventArgs);
-    }
-    async pingServerAndChooseUploadMode() {
-        try {
-            if (this.#config.turnOffUdp)
-                throw new Error(`UDP is turned off`);
-            const udpData = this.#transferMetadata?.udpData;
-            if (!udpData)
-                throw new Error(`No UDP data is available`);
-            const requestTimeout = this.#config.forceUdp ? 3 * 1000 : this.getPingTimeout(udpData.threshold);
-            const retryDelay = 1000;
-            const udpClient = this.#fileServerClientFactory.createFileServerUdpUploadClient(udpData.ip, udpData.port, requestTimeout, this.#mergedPauseAndAbortSignal, undefined, retryDelay);
-            await udpClient.connect();
-            const pingResult = await udpClient.ping();
-            udpClient.close().catch(() => { });
-            this.#serverLatencyInMs = pingResult.latencyInMs;
-            this.#isUdpUploadMode = pingResult.latencyInMs >= udpData.threshold;
-            const eventArgs = { isUdpMode: this.#isUdpUploadMode, latency: pingResult.latencyInMs };
-            this.#eventsEngine.emit(TransferUploadEvent.TransferUploadModeChosen, eventArgs);
-        }
-        catch (error) {
-            this.#isUdpUploadMode = false;
-            const eventArgs = { isUdpMode: this.#isUdpUploadMode, error: error };
-            this.#eventsEngine.emit(TransferUploadEvent.TransferUploadModeChosen, eventArgs);
-        }
-    }
-    getPingTimeout(udpPingThreshold) {
-        const pingTimeout = Math.min(3 * 1000, udpPingThreshold * 20);
-        return Math.max(500, pingTimeout);
-    }
-    async serverUdpHandshake() {
-        const transferMetadata = this.#transferMetadata;
-        const udpData = transferMetadata.udpData;
-        const requestTimeout = this.getHandshakeTimeout();
-        const retryDelay = 1000;
-        const udpClient = this.#fileServerClientFactory.createFileServerUdpUploadClient(udpData.ip, udpData.port, requestTimeout, this.#mergedPauseAndAbortSignal, undefined, retryDelay);
-        await udpClient.connect();
-        const handshakeRequest = { transferId: transferMetadata.transferId, transferKey: transferMetadata.transferKey };
-        const handshakeResponse = await udpClient.handshake(handshakeRequest);
-        udpClient.close().catch(() => { });
-        this.#transferMetadata.udpData.handshakeData = handshakeResponse;
-    }
-    getHandshakeTimeout() {
-        const timeout = Math.min(this.#serverLatencyInMs * 30, 30 * 1000);
-        return Math.max(2000, timeout);
+        this.#eventsEngine.emit(TransferUploadEvent.RecreateDataUpdated);
     }
     async sendChunkAndKeepUpdatingState(file, chunkStartPosition, chunkSizeInBytes, releaseSemaphore) {
         let uploadedBytesCount = 0;
+        const registeredFile = this.getRegisteredFile(file.externalId);
+        const uploadItemId = registeredFile?.uploadItemId;
         try {
-            this.#transferState.chunkUploadStarted(file.externalId, chunkStartPosition, chunkSizeInBytes);
+            this.#transferState.chunkUploadStarted(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes);
             const chunkStreamProvider = this.#chunkStreamProviderFactory.createChunkStreamProvider(file, chunkStartPosition, chunkSizeInBytes, this.#transferMetadata?.encryptionData);
             const progressEventHandler = (eventArgs) => {
                 uploadedBytesCount += eventArgs.transferredBytesSinceLastEvent;
-                this.#transferState.chunkUploadProgressed(file.externalId, chunkStartPosition, chunkSizeInBytes, eventArgs);
+                this.#transferState.chunkUploadProgressed(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes, eventArgs);
             };
-            const response = await this.sendChunk(file, chunkStreamProvider, progressEventHandler);
-            const latencyInMsIfUdp = this.#isUdpUploadMode ? response.latencyInMs : undefined;
+            await this.sendChunk(file, registeredFile?.fileId, chunkStreamProvider, progressEventHandler);
             if (uploadedBytesCount === chunkSizeInBytes)
-                this.#transferState.chunkUploadCompleted(file.externalId, chunkStartPosition, chunkSizeInBytes, latencyInMsIfUdp);
+                this.#transferState.chunkUploadCompleted(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes);
             else
-                this.#transferState.chunkUploadCompletedPartially(file.externalId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, this.#pauseSignal.paused, latencyInMsIfUdp);
+                this.#transferState.chunkUploadCompletedPartially(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, this.#pauseSignal.paused);
+            if (this.#transferState.getFile(file.externalId).isUploadCompleted)
+                this.enqueueFileAck(file);
         }
         catch (error) {
             const chunkError = error;
@@ -266,46 +239,22 @@ export default class TransferUpload {
                 && chunkError.cause.message === `Wrong md5 hash`
                 && this.#pauseSignal?.paused === true;
             if (isTcpPausingError)
-                this.#transferState.chunkUploadCompletedPartially(file.externalId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, this.#pauseSignal.paused);
+                this.#transferState.chunkUploadCompletedPartially(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, this.#pauseSignal.paused);
             else {
                 const failedReason = this.getChunkFailedReason(error);
-                this.#transferState.chunkUploadFailed(file.externalId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, failedReason, error);
+                this.#transferState.chunkUploadFailed(file.externalId, uploadItemId, chunkStartPosition, chunkSizeInBytes, uploadedBytesCount, failedReason, error);
             }
         }
         finally {
             releaseSemaphore();
         }
     }
-    async sendChunk(file, chunkStreamProvider, progressEventHandler) {
-        if (this.#isUdpUploadMode)
-            return await this.sendChunkUsingUdp(file, chunkStreamProvider, progressEventHandler);
-        return await this.sendChunkUsingTcp(file, chunkStreamProvider, progressEventHandler);
-    }
-    async sendChunkUsingUdp(file, chunkStreamProvider, progressEventHandler) {
-        const transferMetadata = this.#transferMetadata;
-        const udpData = transferMetadata.udpData;
-        const udpClient = this.#fileServerClientFactory.createFileServerUdpUploadClient(udpData.ip, udpData.port, this.#optimizer.currentRequestTimeoutInMs, this.#mergedPauseAndAbortSignal, 0);
-        const sendChunkRequest = {
-            sessionGuid: this.#transferMetadata.udpData.handshakeData.sessionGuid,
-            aesKey: this.#transferMetadata.udpData.handshakeData.aesKey,
-            chunkStartPosition: chunkStreamProvider.chunkStartPosition,
-            fileSizeInBytes: file.fileSizeInBytes,
-            fileDestinationPathInTransfer: file.fileDestinationPathInTransfer,
-            fileName: file.fileName,
-        };
-        await udpClient.connect();
-        const result = await udpClient.sendChunk(sendChunkRequest, chunkStreamProvider);
-        udpClient.close().catch(() => { });
-        const chunkProgressEventArgs = { transferredBytesTotal: chunkStreamProvider.chunkLengthInBytes, transferredBytesSinceLastEvent: chunkStreamProvider.chunkLengthInBytes };
-        progressEventHandler(chunkProgressEventArgs);
-        return result;
-    }
-    async sendChunkUsingTcp(file, chunkStreamProvider, progressEventHandler) {
+    async sendChunk(file, fileId, chunkStreamProvider, progressEventHandler) {
         const request = {
             chunkLengthInBytes: chunkStreamProvider.chunkLengthInBytes,
             chunkStartPosition: chunkStreamProvider.chunkStartPosition,
         };
-        const fileServerClient = this.#fileServerClientFactory.createFileServerTcpUploadClient(this.#transferMetadata.transferFileServerUrl, this.#transferMetadata.transferId, this.#transferMetadata.transferKey, file.fileName, file.fileDestinationPathInTransfer, file.fileSizeInBytes);
+        const fileServerClient = this.#fileServerClientFactory.createFileServerUploadClient(this.#transferMetadata.transferFileServerUrl, this.#transferMetadata.transferId, this.#transferMetadata.transferKey, file.fileName, file.fileDestinationPathInTransfer, file.fileSizeInBytes, fileId);
         const ongoingRequestPromise = fileServerClient.sendFileChunk(request, chunkStreamProvider, this.#pauseSignal, this.#abortSignal);
         fileServerClient.addEventListener(`progress`, progressEventHandler);
         await ongoingRequestPromise;
@@ -354,8 +303,9 @@ export default class TransferUpload {
     removePauseAndStopListeners() {
         this.#pauseSignal.removeEventListener(`pause`, this.pauseEventListener);
         this.#abortSignal.removeEventListener(`abort`, this.abortEventListener);
+        this.#mergedPauseAndAbortController?.dispose();
     }
-    shouldStopSchedulingChunks() {
+    shouldStopProcessing() {
         return this.#transferState.status !== TransferStatus.Running || this.#abortSignal?.aborted === true || this.#pauseSignal?.paused === true;
     }
     isFailureAbortRequested() {
@@ -385,20 +335,40 @@ export default class TransferUpload {
                 filerequestshareid: this.#info.fileRequestShareId,
                 customfields: this.#info.customFields,
             };
-            const response = await this.#apiClient.initializeTransfer(request, this.#mergedPauseAndAbortSignal);
+            const response = await this.#apiClient.initializeTransfer(request, this.#mergedPauseAndAbortController?.signal);
             this.#transferMetadata = {
                 transferId: response.transferId,
                 transferKey: response.transferKey,
                 transferFileServerUrl: response.transferUrl,
                 transferRegion: response.transferRegion,
                 encryptionData: encryptionDataAndIvSaltHex?.encryptionData,
-                udpData: this.getResponseOrForcedUdpData(response),
             };
         }
         catch (error) {
             throw new TransferUploadError(`Error initializing transfer through the API`, { cause: error });
         }
     }
+    getRegisteredFile(externalFileId) {
+        return this.#filesRegistrar?.getRegisteredFile(externalFileId);
+    }
+    enqueueFileAck(file) {
+        if (this.isLegacyTransfer()) {
+            this.#transferState.fileCompleted(file.externalId, undefined);
+            return;
+        }
+        const registeredFile = this.getRegisteredFile(file.externalId);
+        if (!registeredFile)
+            throw new TransferUploadError(`Can't ack file with external id = ${file.externalId} - no registered file found. The transfer state is malformed.`);
+        this.#acker.enqueue({ externalFileId: file.externalId, uploadItemId: registeredFile.uploadItemId, sizeInBytes: file.fileSizeInBytes });
+    }
+    hasUnackedFiles() {
+        if (this.isLegacyTransfer())
+            return false;
+        return this.files.some(file => !this.#transferState.getFile(file.externalId).isCompleted);
+    }
+    isLegacyTransfer() {
+        return this.#filesRegistrar === undefined;
+    }
     async generateEncryptionDataAndIvSaltHmacHex(e2eeKey) {
         if (!e2eeKey)
             return undefined;
@@ -415,14 +385,6 @@ export default class TransferUpload {
             ivSaltHmacHex,
         };
     }
-    getResponseOrForcedUdpData(response) {
-        if (!this.#config.forceUdp || !response.udp)
-            return response.udp;
-        return {
-            ...response.udp,
-            threshold: 0,
-        };
-    }
     async finalizeTransfer() {
         this.#eventsEngine.emit(TransferUploadEvent.TransferFinalizing);
         if (this.isUploadAppend())
@@ -435,7 +397,7 @@ export default class TransferUpload {
             const request = {
                 transferid: this.#transferMetadata.transferId,
             };
-            await this.#apiClient.resetTransfer(request, this.#mergedPauseAndAbortSignal);
+            await this.#apiClient.resetTransfer(request, this.#mergedPauseAndAbortController?.signal);
         }
         catch (error) {
             throw new TransferUploadError(`Error resetting transfer through the API`, { cause: error });
@@ -446,9 +408,9 @@ export default class TransferUpload {
             const request = {
                 transferid: this.#transferMetadata.transferId,
                 transferkey: this.#transferMetadata.transferKey,
-                protocol: this.#isUdpUploadMode ? `udp` : `tcp`,
+                protocol: `tcp`,
             };
-            const response = await this.#apiClient.finalizeTransfer(request, this.#mergedPauseAndAbortSignal);
+            const response = await this.#apiClient.finalizeTransfer(request, this.#mergedPauseAndAbortController?.signal);
             this.#transferDownloadUrl = response.downloadUrl;
             this.#transferConfirmationUrl = response.confirmationUrl;
             this.#transferRecipientTrackingLinks = response.recipientTrackingLinks;
@@ -459,7 +421,7 @@ export default class TransferUpload {
     }
     async cancel(abortSignal) {
         try {
-            const isTransferApiInitialized = Boolean(this.#transferState) && Boolean(this.#transferMetadata);
+            const isTransferApiInitialized = Boolean(this.#transferState) && (Boolean(this.#transferMetadata) || this.isUploadAppend());
             if (!isTransferApiInitialized) {
                 this.emitCancelEvents();
                 return;
@@ -523,10 +485,22 @@ export default class TransferUpload {
             throw new TransferUploadError(`Can't export not started Transfer`); // fileStatuses are not created yet and it really doesn't make any sens to export not started transfer
         return {
             transferMetadata: this.getTransferMetadataExportValue(),
-            info: this.#info,
+            info: this.getInfoExportValue(),
             state: this.#transferState.export(),
+            registeredFiles: this.#filesRegistrar ? Array.from(this.#filesRegistrar.export().entries()) : undefined,
         };
     }
+    getInfoExportValue() {
+        if (this.isUploadAppendInfo(this.#info)) {
+            const { e2eeData, ...appendInfoWithoutE2eeData } = this.#info;
+            return appendInfoWithoutE2eeData;
+        }
+        // Until the transfer is initialized the key is still needed - a resumed run re-initializes from the info.
+        if (!this.#transferMetadata)
+            return this.#info;
+        const { e2eeKey, ...infoWithoutE2eeKey } = this.#info;
+        return infoWithoutE2eeKey;
+    }
     getTransferMetadataExportValue() {
         if (!this.#transferMetadata)
             return undefined;
@@ -539,12 +513,18 @@ export default class TransferUpload {
             },
         };
     }
-    static recreate(transferExportData, config, chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, optimizer, cryptography) {
+    static recreate(transferExportData, config, chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, concurrencyController, cryptography, acker) {
         try {
             TransferUpload.validateRecreateParams(transferExportData);
-            const transfer = new TransferUpload(chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, transferExportData.info, config, optimizer, cryptography);
+            const transfer = new TransferUpload(chunkStreamProviderFactory, apiClient, fileServerClientFactory, eventsEngine, transferExportData.info, config, concurrencyController, cryptography, acker);
             transfer.#transferMetadata = this.recreateTransferMetadata(transferExportData.transferMetadata);
             transfer.#transferState = new TransferUploadState(transferExportData.info.files, eventsEngine, config.currentRatesTimespanInMs, config.progressEventThrottlingInMs, transferExportData.state);
+            if (transfer.isUploadAppendInfo(transferExportData.info))
+                transfer.#transferDownloadUrl = transferExportData.info.transferDownloadUrl;
+            if (transferExportData.registeredFiles)
+                transfer.#filesRegistrar.recoverFromExportedState(transferExportData.registeredFiles);
+            else
+                transfer.#filesRegistrar = undefined;
             return transfer;
         }
         catch (error) {