@trap_stevo/filetide 0.0.45 → 0.0.47

package/dist/cjs/FileMessagerClient.js

@@ -25,11 +25,20 @@ class FileMessagerClient {
   constructor(options = {}, transportOptions = {
     parallelChunks: 3,
     maxRetries: 3
+  }, messagerSettings = {
+    maxReconnectionAttempts: 15,
+    reconnectionAttempts: 15,
+    maxReconnectionDelay: 10000
   }) {
+    const {
+      maxReconnectionAttempts = 15,
+      reconnectionAttempts = 15,
+      maxReconnectionDelay = 10000
+    } = messagerSettings;
     this.clientOptions = FileMessagerConfigManager.getClientOptions(options);
     this.transporter = new FileTransferManager(transportOptions);
     this.activeTransferTypes = new Map();
-    this.clientTide = new HUDIoTide();
+    this.clientTide = new HUDIoTide(maxReconnectionAttempts, reconnectionAttempts, maxReconnectionDelay);
     this.clients = new Map();
   }
   createClientInstance(clientID, clientOptions, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
@@ -142,7 +151,7 @@ class FileMessagerClient {
         if (fileInfo.largeFile) {
           return await this.sendDirectoryLargeFile(clientID, recipientId, fileInfo.fileName, fileInfo.filePath, fileDestinationPath, fileInfo.fileSize, index, tideSize, minTideSize, maxTideSize);
         }
-        return await this.sendDirectoryFile(clientID, recipientId, fileInfo.fileName, fileInfo.fileData, fileDestinationPath, fileInfo.size, adjustedDestinationPath, index);
+        return await this.sendDirectoryFile(clientID, recipientId, fileInfo.fileName, fileInfo.filePath, fileInfo.size, fileDestinationPath, index, tideSize, minTideSize, maxTideSize);
       });
       Promise.all(sendFilePromises).then(() => console.log("\nAll files in directory transferred successfully!")).catch(error => console.error("Did not transfer directory: ", error));
     } catch (error) {
@@ -154,12 +163,13 @@ class FileMessagerClient {
     if (index === 0) {
       initiatingTransfer = true;
     }
-    return await this.sendLargeFile(clientID, recipientId, fileName, filePath, destinationPath, fileSize, tideSize, minTideSize, maxTideSize, initiatingTransfer, true);
+    return await this.sendFile(clientID, recipientId, fileName, filePath, destinationPath, fileSize, tideSize, minTideSize, maxTideSize, initiatingTransfer, true, true, true);
   }
-  sendDirectoryFile(clientID, recipientId, fileName, file, filePath = process.cwd(), fileSize, directoryPath = null, index = 0) {
-    if (!file) {
+  async sendDirectoryFile(clientID, recipientId, fileName, filePath = process.cwd(), fileSize, directoryPath = null, index = 0, tideSize = 200, minTideSize = 10, maxTideSize = 2000) {
+    if (!filePath) {
       return;
     }
+    let initiatingTransfer = false;
     if (index === 0) {
       this.clientTide.emitEvent(clientID, "transfer-start", {
         fileName,
@@ -168,53 +178,13 @@ class FileMessagerClient {
         path: directoryPath || filePath,
         fileSize
       });
+      initiatingTransfer = true;
     }
-    this.transporter.sendFile(file, {
-      onSendChunk: (transferId, chunkIndex, chunkSize, chunkData, totalChunks, completedChunks) => {
-        return new Promise((resolve, reject) => {
-          this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
-            senderID: clientID,
-            recipientId,
-            fileName,
-            fileChunk: chunkData,
-            completedChunks,
-            totalChunks,
-            chunkIndex,
-            chunkSize,
-            filePath,
-            fileSize
-          });
-          resolve();
-        });
-      },
-      onComplete: () => {
-        return new Promise((resolve, reject) => {
-          FileTransferRecoveryManager.clearTransferState(clientID, recipientId, `${filePath}-${fileName}`);
-          this.clientTide.emitEvent(clientID, "transfer-complete", {
-            senderID: clientID,
-            recipientId,
-            fileName,
-            filePath
-          });
-          resolve();
-        });
-      },
-      originDetails: {
-        recipientID: recipientId,
-        senderID: clientID
-      },
-      recipientID: recipientId,
-      fileDetails: {
-        destinationPath: filePath,
-        name: fileName,
-        path: filePath,
-        size: fileSize
-      }
-    }, this.clientTide).then(() => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors)).catch(error => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused file transfer: ${error}`, errorMessageColors));
+    return await this.sendFile(clientID, recipientId, fileName, filePath, directoryPath, fileSize, tideSize, minTideSize, maxTideSize, initiatingTransfer, true, true, false);
   }
-  async sendLargeFile(clientID, recipientId, fileName, filePath = process.cwd(), destination = process.cwd(), fileSize, tideSize = 500, minTideSize = 10, maxTideSize = 2000, initiatingTransfer = true, inDirectory = false) {
+  async sendFile(clientID, recipientId, fileName, filePath = process.cwd(), destination = process.cwd(), fileSize, tideSize = 500, minTideSize = 10, maxTideSize = 2000, initiatingTransfer = true, inDirectory = false, largeFile = false) {
     const destinationPath = FileUtilityManager.normalizePath(path.join(destination, fileName));
-    FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Requesting to transfer large file ~ ${destinationPath} to ${recipientId}!`, significantMessageColors);
+    FileNetUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Requesting to transfer large file ~ ${destinationPath} to ${recipientId}!` : `[FileTide ~ File Messager] ~ Requesting to transfer ~ ${destinationPath} to ${recipientId}!`, significantMessageColors);
     const incomingType = this.activeTransferTypes.get(filePath);
     if (!inDirectory && initiatingTransfer) {
       const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, destinationPath, fileSize, "send");
@@ -248,6 +218,7 @@ class FileMessagerClient {
       const maxBatchSize = maxTideSize;
       const minBatchSize = minTideSize;
       let batchSize = tideSize > maxBatchSize || tideSize > minBatchSize ? tideSize : tideSize <= minBatchSize ? minBatchSize : 10;
+      let transferInitiated = false;
       const chunkBatch = [];
       await this.transporter.sendLargeFile(fileHandle, {
         recipientID: recipientId,
@@ -270,6 +241,13 @@ class FileMessagerClient {
               filePath: destination,
               fileSize
             });
+            if (!transferInitiated) {
+              this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
+                chunkBatch
+              });
+              transferInitiated = true;
+              chunkBatch.length = 0;
+            }
             if (chunkBatch.length >= batchSize) {
               const now = Date.now();
               const rtt = now - lastSendTime;
@@ -312,76 +290,13 @@ class FileMessagerClient {
           });
         }
       }, this.clientTide);
-      FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Large file ~ ${fileName} transfer complete!`, significantMessageColors);
+      FileNetUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Large file ~ ${fileName} transfer complete!` : `[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors);
     } catch (error) {
-      FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Error transferring large file: ${error.message}`, errorMessageColors);
+      FileNetUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Error transferring large file: ${error.message}` : `[FileTide ~ File Messager] ~ Error transferring file ~ ${error.message}`, errorMessageColors);
     } finally {
       await fileHandle.close();
     }
   }
-  async sendFile(clientID, recipientId, fileName, file, filePath = process.cwd(), fileSize) {
-    if (!file) {
-      return;
-    }
-    const destinationPath = FileUtilityManager.normalizePath(path.join(filePath, fileName));
-    FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Requesting to transfer ~ ${destinationPath} to ${recipientId}!`, significantMessageColors);
-    const incomingType = this.activeTransferTypes.get(filePath);
-    const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, destinationPath, fileSize, "send");
-    if (incomingType) {
-      this.activeTransferTypes.delete(filePath);
-    }
-    if (!transferAllowed) {
-      return;
-    }
-    this.clientTide.emitEvent(clientID, "transfer-start", {
-      fileName,
-      senderID: clientID,
-      recipientID: recipientId,
-      path: filePath,
-      fileSize
-    });
-    await this.transporter.sendFile(file, {
-      onSendChunk: (transferId, chunkIndex, chunkSize, chunkData, totalChunks, completedChunks) => {
-        return new Promise((resolve, reject) => {
-          this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
-            senderID: clientID,
-            recipientId,
-            fileName,
-            fileChunk: chunkData,
-            completedChunks,
-            totalChunks,
-            chunkIndex,
-            chunkSize,
-            filePath,
-            fileSize
-          });
-          resolve();
-        });
-      },
-      onComplete: () => {
-        return new Promise((resolve, reject) => {
-          FileTransferRecoveryManager.clearTransferState(clientID, recipientId, `${filePath}-${fileName}`);
-          this.clientTide.emitEvent(clientID, "transfer-complete", {
-            senderID: clientID,
-            recipientId,
-            fileName,
-            filePath
-          });
-          resolve();
-        });
-      },
-      originDetails: {
-        recipientID: recipientId,
-        senderID: clientID
-      },
-      fileDetails: {
-        destinationPath,
-        name: fileName,
-        path: filePath,
-        size: fileSize
-      }
-    }, this.clientTide).then(() => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors)).catch(error => FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused file transfer ~ ${error}`, errorMessageColors));
-  }
 }
 ;
 module.exports = FileMessagerClient;

package/dist/cjs/FileTide.js

@@ -4,6 +4,9 @@ var _FileTide;
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
 function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+const {
+  HUDUtilityManager
+} = require("@trap_stevo/legendarybuilderpronodejs-utilities");
 const chalk = require("chalk");
 const path = require("path");
 const fs = require("fs");
@@ -68,6 +71,8 @@ class FileTide {
    * Initialize and start a new client for each user.
    * @param {Object} clientOptions - Configuration for client (e.g., serverUrl)
    * @param {Object} connectionOptions - Configuration for the client connection
+   * @param {Object} transportOptions - Configuration for the file transporter
+   * @param {Object} messagerSettings - Configuration for the messager
    * @param {String} roomName - The name of the room to join
    * @param {String} userID - The ID of the client user
    * @param {Function} onLaunch - Callback for when a file messager launches
@@ -85,11 +90,18 @@ class FileTide {
    * @param {Boolean} [useAuthentication=true] - Whether to enable connection authentication
    * @param {Boolean} [queryAuthToken=false] - Whether to enable connection authentication tokens
    */
-  launchMessager(clientOptions = {}, connectionOptions = {}, roomName, userID, onLaunch, onIncomingFile, onIncomingTransfer, onTransferBarrier, onTransferProgress, enableTransferBarrier = true, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
+  launchMessager(clientOptions = {}, connectionOptions = {}, transportOptions = {
+    parallelChunks: 3,
+    maxRetries: 3
+  }, messagerSettings = {
+    maxReconnectionAttempts: 15,
+    reconnectionAttempts: 15,
+    maxReconnectionDelay: 10000
+  }, roomName, userID, onLaunch, onIncomingFile, onIncomingTransfer, onTransferBarrier, onTransferProgress, enableTransferBarrier = true, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
     if (this.clients.has(userID)) {
       this.stopMessager(userID);
     }
-    const newClient = new FileMessagerClient(clientOptions);
+    const newClient = new FileMessagerClient(clientOptions, transportOptions, messagerSettings);
     const enterRoom = newClient.joinRoom(userID, roomName, connectionOptions, headers, onConnect, onDisconnect, authURL, authHeaders, useAuthentication, queryAuthToken);
     this.transferBarrier = enableTransferBarrier;
     this.clientShorePolicies.set(userID, [FileUtilityManager.getTidePath(">CurrentUser"), FileUtilityManager.getTidePath(">Downloads"), FileUtilityManager.getTidePath(">Documents")]);
@@ -168,46 +180,47 @@ class FileTide {
    * @param {Buffer} fileData - The path of the data to send
    * @param {String} destinationPath - The destination path on the device
    * @param {Array} filterDirectoryContent - List of paths to filter
-   * @param {Number} tideSize - The tide size in sending files (500)
+   * @param {Number} tideSize - The tide size in sending smaller to medium files (200)
+   * @param {Number} tidalSize - The tide size in sending large files (500)
    * @param {Number} minTideSize - The minimum tide size in sending files (10)
    * @param {Number} maxTideSize - The maximum tide size in sending files (2000)
    */
-  async sendToDevice(recipientID, filePath, destinationPath, filterDirectoryContent = [], tideSize = 500, minTideSize = 10, maxTideSize = 2000) {
+  async sendToDevice(recipientID, filePath, destinationPath, filterDirectoryContent = [], tideSize = 200, tidalSize = 500, minTideSize = 10, maxTideSize = 2000) {
     const clientID = this.currentUserID;
     const clientMessager = this.clients.get(clientID);
     if (!clientMessager) {
       FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, ["#F94144", "#F3722C"]);
-      return;
+      return false;
     }
     const recipientOnline = await clientMessager.clientTide.emitEventWithResponse(clientID, "check-client-online", "retrieved-client-online", {
       clientID: recipientID
     }, 5000);
     if (!recipientOnline || !recipientOnline.online) {
       FileTide.outputGradient(`[FileTide] ${recipientID} currently not tiding.`, ["#F94144", "#F3722C"]);
-      return;
+      return false;
     }
     const fileDetails = await this.getPathData(filePath, filterDirectoryContent);
     if (!fileDetails) {
       FileTide.outputGradient(`[${clientID}] File at path ${filePath} not found.`, ["#F94144", "#F3722C"]);
-      return;
+      return false;
     }
     if (fileDetails.type === "file") {
       if (fileDetails.largeFile) {
         FileTide.outputGradient(`[${clientID}] Sending large file ~ ${fileDetails.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
-        await clientMessager.sendLargeFile(clientID, recipientID, fileDetails.fileName, fileDetails.filePath, destinationPath, fileDetails.fileSize, tideSize, minTideSize, maxTideSize);
-        return;
+        await clientMessager.sendFile(clientID, recipientID, fileDetails.fileName, fileDetails.filePath, destinationPath, fileDetails.fileSize, tidalSize, minTideSize, maxTideSize, true, false, true);
+        return true;
       }
       FileTide.outputGradient(`[${clientID}] Sending file ~ ${fileDetails.content.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
-      clientMessager.sendFile(clientID, recipientID, fileDetails.content.fileName, fileDetails.content.fileData, destinationPath, fileDetails.content.size);
-      return;
+      await clientMessager.sendFile(clientID, recipientID, fileDetails.content.fileName, fileDetails.content.filePath, destinationPath, fileDetails.content.size, tideSize, minTideSize, maxTideSize);
+      return true;
     }
     if (fileDetails.type === "directory") {
       FileTide.outputGradient(`[${clientID}] Sending ${fileDetails.content.length} files in directory ~ ${path.basename(filePath)} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
-      clientMessager.sendDirectoryFiles(clientID, recipientID, fileDetails.content, this.getTidePath(filePath), destinationPath, tideSize, minTideSize, maxTideSize);
-      return;
+      await clientMessager.sendDirectoryFiles(clientID, recipientID, fileDetails.content, this.getTidePath(filePath), destinationPath, tideSize, minTideSize, maxTideSize);
+      return true;
     }
     FileTide.outputGradient(`[FileTide] ~ No active client ~ ${recipientID} found.`, errorMessageColors);
-    return;
+    return false;
   }
 
   /**
@@ -522,6 +535,7 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
       const capacitor = new ChunkCapacitor(directoryContents, 100);
       const contents = capacitor.getAllChunks();
       for (let files of contents) {
+        totalFilesSent += files.length;
         client.clientTide.emitEvent(userID, "send-file-list-to-client", {
           senderID: data.recipientID,
           recipientID: data.senderID,
@@ -529,7 +543,6 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
           listedFiles: files
         });
       }
-      totalFilesSent += totalItems;
     });
     setTimeout(() => {
       _FileTide.outputGradient(`[${userID}] Sent file list to ${data.senderID}!`, significantMessageColors);
@@ -544,13 +557,13 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     _FileTide.outputGradient(`[${userID} | FileTide Error] ${error}`, errorMessageColors);
   });
   client.clientTide.onEvent(userID, "client-file-list-received", async data => {
-    _FileTide.outputGradient(`[${userID}] Successfully received all ${data.totalItemsSent} contents in ${data.senderID}'s file list!`, significantMessageColors);
+    _FileTide.outputGradient(`[${userID}] Successfully received all ${HUDUtilityManager.convertNumberToMoneyFormat(data.totalItemsSent, false)} contents in ${data.senderID}'s file list!`, significantMessageColors);
     if (onFileListReceived) {
       onFileListReceived(data);
     }
   });
   client.clientTide.onEvent(userID, "client-file-list", async data => {
-    _FileTide.outputGradient(`[${userID}] Received ${data.totalItems} directory contents from ${data.senderID}'s file list!`, significantMessageColors);
+    _FileTide.outputGradient(`[${userID}] Received ${HUDUtilityManager.convertNumberToMoneyFormat(data.totalItems, false)} directory contents from ${data.senderID}'s file list!`, significantMessageColors);
     if (onListFiles) {
       onListFiles(data);
     }

package/dist/cjs/HUDManagers/FileTransferManager.js

@@ -24,10 +24,11 @@ class FileTransferManager {
     onSendChunk,
     onComplete,
     onProgress,
-    onStart
+    onStart,
+    onTiding
   }, clientTide) {
     const transferId = _assertClassBrand(_FileTransferManager_brand, this, _generateTransferId).call(this, fileDetails);
-    return await _assertClassBrand(_FileTransferManager_brand, this, _startTransfer).call(this, file, transferId, fileDetails, originDetails, onSendChunk, onComplete, onProgress, onStart, clientTide);
+    return await _assertClassBrand(_FileTransferManager_brand, this, _startTransfer).call(this, file, transferId, fileDetails, originDetails, onSendChunk, onComplete, onProgress, onStart, onTiding, clientTide);
   }
   async sendLargeFile(fileHandle, {
     fileDetails,
@@ -107,31 +108,36 @@ class FileTransferManager {
     const keepAliveInterval = setInterval(() => {
       if (onTiding) onTiding();
     }, 5000);
-    try {
-      let adaptiveBatchSize = 100;
-      while (currentBatchStart < totalChunks) {
-        if (transferState.activeChunks < this.parallelChunks) {
-          adaptiveBatchSize = Math.min(adaptiveBatchSize + 10, 100);
-        } else {
-          adaptiveBatchSize = Math.max(adaptiveBatchSize - 10, 10);
+    return new Promise(async (resolve, reject) => {
+      try {
+        let adaptiveBatchSize = 100;
+        while (currentBatchStart < totalChunks) {
+          if (transferState.activeChunks < this.parallelChunks) {
+            adaptiveBatchSize = Math.min(adaptiveBatchSize + 10, 100);
+          } else {
+            adaptiveBatchSize = Math.max(adaptiveBatchSize - 10, 10);
+          }
+          await sendChunkBatch(currentBatchStart, adaptiveBatchSize);
+          currentBatchStart += adaptiveBatchSize;
+          await new Promise(resolve => setTimeout(resolve, 30));
+        }
+      } finally {
+        clearInterval(keepAliveInterval);
+        fileHandle.on("close", resolve);
+        fileHandle.on("error", error => {
+          this.activeTransfers.delete(transferId);
+          reject(error);
+        });
+        try {
+          await fileHandle.close();
+        } catch (error) {
+          console.error(`[FileTide ~ Transporter] ~ Error closing file handle ~ ${error.message}`);
         }
-        await sendChunkBatch(currentBatchStart, adaptiveBatchSize);
-        currentBatchStart += adaptiveBatchSize;
-        await new Promise(resolve => setTimeout(resolve, 30));
       }
-    } finally {
-      clearInterval(keepAliveInterval);
-    }
-    return new Promise((resolve, reject) => {
-      fileHandle.on("close", resolve);
-      fileHandle.on("error", error => {
-        this.activeTransfers.delete(transferId);
-        reject(error);
-      });
     });
   }
 }
-async function _startTransfer(file, transferId, fileDetails, originDetails, onSendChunk, onComplete, onProgress, onStart, clientTide) {
+async function _startTransfer(file, transferId, fileDetails, originDetails, onSendChunk, onComplete, onProgress, onStart, onTiding, clientTide) {
   const recoveredTransferState = (await clientTide.emitEventWithResponse(originDetails.senderID, "get-client-transfer-state", "sent-current-transfer-state", {
     recipientID: originDetails.recipientID,
     senderID: originDetails.senderID,
@@ -142,6 +148,8 @@ async function _startTransfer(file, transferId, fileDetails, originDetails, onSe
     lastChunkSent: 0
   };
   const totalChunks = Math.ceil(file.length / this.chunkSize);
+  let nextExpectedChunk = recoveredTransferState.lastChunkSent;
+  const chunkBuffer = new Map();
   this.activeTransfers.set(transferId, {
     totalChunks,
     transferredSize: recoveredTransferState.transferredSize,
@@ -151,64 +159,187 @@ async function _startTransfer(file, transferId, fileDetails, originDetails, onSe
     currentChunk: recoveredTransferState.lastChunkSent,
     size: fileDetails.size
   });
+  const transferState = this.activeTransfers.get(transferId);
   const updateProgress = () => {
-    const transferState = this.activeTransfers.get(transferId);
     if (onProgress) {
       onProgress(transferState.completedChunks / transferState.totalChunks * 100, this.chunkSize);
     }
   };
   const exponentialBackoff = retryCount => Math.min(1000 * 2 ** retryCount, 10000);
-  return new Promise((resolve, reject) => {
-    const sendChunk = async chunkIndex => {
-      const transferState = this.activeTransfers.get(transferId);
-      if (chunkIndex >= transferState.totalChunks) {
-        return;
-      }
-      const start = chunkIndex * this.chunkSize;
-      const end = Math.min(start + this.chunkSize, file.length);
-      const chunk = file.slice(start, end);
-      if (onStart && chunkIndex === 0) {
-        onStart({
-          name: fileDetails.name,
-          path: fileDetails.path,
-          size: fileDetails.size,
-          totalChunks: transferState.totalChunks
-        });
-      }
-      transferState.activeChunks++;
-      try {
-        await onSendChunk(transferId, chunkIndex, this.chunkSize, chunk, transferState.totalChunks, transferState.completedChunks + 1);
-        transferState.transferredSize += this.chunkSize;
+  const sendChunk = async chunkIndex => {
+    const start = chunkIndex * this.chunkSize;
+    const end = Math.min(start + this.chunkSize, file.length);
+    const chunk = file.slice(start, end);
+    transferState.activeChunks++;
+    try {
+      await onSendChunk(transferId, chunkIndex, this.chunkSize, chunk, totalChunks, transferState.completedChunks + 1);
+      chunkBuffer.set(chunkIndex, chunk);
+      while (chunkBuffer.has(nextExpectedChunk)) {
+        chunkBuffer.delete(nextExpectedChunk);
+        nextExpectedChunk++;
         transferState.completedChunks++;
-        transferState.activeChunks--;
         updateProgress();
-        if (transferState.activeChunks < this.parallelChunks && transferState.currentChunk < transferState.totalChunks) {
-          sendChunk(transferState.currentChunk++);
-        }
-        if (transferState.completedChunks === transferState.totalChunks) {
-          await onComplete(transferId);
-          this.activeTransfers.delete(transferId);
-          resolve();
-        }
-      } catch (error) {
-        console.error(`[FileTide ~ File Messager] ~ Did not send chunk ${chunkIndex} ~ ${error.message}`);
-        transferState.activeChunks--;
-        const retryCount = (transferState.failedChunks.get(chunkIndex) || 0) + 1;
-        if (retryCount > this.maxRetries) {
-          this.activeTransfers.delete(transferId);
-          reject(new Error(`Did not send chunk ${chunkIndex} after ${this.maxRetries} retries.`));
-        } else {
-          transferState.failedChunks.set(chunkIndex, retryCount);
-          setTimeout(() => sendChunk(chunkIndex), exponentialBackoff(retryCount));
-        }
       }
-    };
-    const transferState = this.activeTransfers.get(transferId);
-    for (let i = 0; i < Math.min(this.parallelChunks, transferState.totalChunks); i++) {
-      sendChunk(transferState.currentChunk++);
+      if (transferState.completedChunks === transferState.totalChunks) {
+        clearInterval(keepAliveInterval);
+        await onComplete(transferId);
+        this.activeTransfers.delete(transferId);
+      }
+    } catch (error) {
+      console.error(`[FileTide ~ Transporter] ~ Did not send chunk ${chunkIndex} ~ ${error.message}`);
+      const retryCount = (transferState.failedChunks.get(chunkIndex) || 0) + 1;
+      if (retryCount > this.maxRetries) {
+        clearInterval(keepAliveInterval);
+        this.activeTransfers.delete(transferId);
+        throw new Error(`[FileTide ~ Transporter] ~ Did not send chunk ${chunkIndex} after ${this.maxRetries} retries.`);
+      }
+      transferState.failedChunks.set(chunkIndex, retryCount);
+      setTimeout(() => sendChunk(chunkIndex), exponentialBackoff(retryCount));
+    } finally {
+      transferState.activeChunks--;
     }
-  });
+  };
+  const sendChunkBatch = async (startChunkIndex, batchSize = 100, miniBatchSize = 10) => {
+    for (let i = 0; i < batchSize && startChunkIndex + i < totalChunks; i += miniBatchSize) {
+      const miniBatchPromises = [];
+      for (let j = 0; j < miniBatchSize && startChunkIndex + i + j < totalChunks; j++) {
+        const chunkIndex = startChunkIndex + i + j;
+        miniBatchPromises.push(sendChunk(chunkIndex));
+      }
+      await Promise.all(miniBatchPromises);
+      await new Promise(resolve => setTimeout(resolve, 5));
+    }
+  };
+  const keepAliveInterval = setInterval(() => {
+    if (onTiding) onTiding();
+  }, 5000);
+  let currentBatchStart = transferState.currentChunk;
+  let adaptiveBatchSize = 100;
+  try {
+    while (currentBatchStart < totalChunks) {
+      adaptiveBatchSize = transferState.activeChunks < this.parallelChunks ? Math.min(adaptiveBatchSize + 10, 100) : Math.max(adaptiveBatchSize - 10, 10);
+      await sendChunkBatch(currentBatchStart, adaptiveBatchSize);
+      currentBatchStart += adaptiveBatchSize;
+      await new Promise(resolve => setTimeout(resolve, 30));
+    }
+  } finally {
+    clearInterval(keepAliveInterval);
+  }
 }
+/*async #startTransfer(file, transferId, fileDetails, originDetails, onSendChunk, onComplete, onProgress, onStart, onTiding, clientTide)
+{
+    const recoveredTransferState = await clientTide.emitEventWithResponse(originDetails.senderID, "get-client-transfer-state", "sent-current-transfer-state", { recipientID : originDetails.recipientID, senderID : originDetails.senderID, filePath : fileDetails.destinationPath, fileName : fileDetails.name }, 30000) || { transferredSize : 0, lastChunkSent : 0 };
+    
+    const totalChunks = Math.ceil(file.length / this.chunkSize);
+    
+    this.activeTransfers.set(transferId, {
+        totalChunks,
+        transferredSize : recoveredTransferState.transferredSize,
+        completedChunks : recoveredTransferState.lastChunkSent,
+        activeChunks : 0,
+        failedChunks : new Map(),
+        currentChunk : recoveredTransferState.lastChunkSent,
+        size : fileDetails.size
+    });
+      const updateProgress = () => {
+        const transferState = this.activeTransfers.get(transferId);
+        
+        if (onProgress)
+        {
+            onProgress((transferState.completedChunks / transferState.totalChunks) * 100, this.chunkSize);
+        }
+    };
+    
+    const keepAliveInterval = setInterval(() => {
+        if (onTiding) onTiding();
+    }, 5000);
+    
+    const exponentialBackoff = (retryCount) => Math.min(1000 * (2 ** retryCount), 10000);
+    
+    return new Promise((resolve, reject) => {
+        const sendChunk = async (chunkIndex) => {
+            const transferState = this.activeTransfers.get(transferId);
+            
+            if (chunkIndex >= transferState.totalChunks) { return; }
+              const start = chunkIndex * this.chunkSize;
+            
+            const end = Math.min(start + this.chunkSize, file.length);
+            
+            const chunk = file.slice(start, end);
+            
+            if (onStart && chunkIndex === 0)
+            {
+                onStart({
+                    name : fileDetails.name,
+                    path : fileDetails.path,
+                    size : fileDetails.size,
+                    totalChunks : transferState.totalChunks
+                });
+            }
+            
+            transferState.activeChunks++;
+            
+            try
+            {
+                await onSendChunk(transferId, chunkIndex, this.chunkSize, chunk, transferState.totalChunks, transferState.completedChunks + 1);
+                
+                transferState.transferredSize += this.chunkSize;
+                
+                transferState.completedChunks++;
+                
+                transferState.activeChunks--;
+                
+                updateProgress();
+                
+                if (transferState.activeChunks < this.parallelChunks && transferState.currentChunk < transferState.totalChunks)
+                {
+                    sendChunk(transferState.currentChunk++);
+                }
+                
+                if (transferState.completedChunks === transferState.totalChunks)
+                {
+                    await onComplete(transferId);
+                    
+                    this.activeTransfers.delete(transferId);
+                    
+                    clearInterval(keepAliveInterval);
+                    
+                    resolve();
+                }
+            }
+            catch (error)
+            {
+                console.error(`[FileTide ~ File Messager] ~ Did not send chunk ${chunkIndex} ~ ${error.message}`);
+                
+                transferState.activeChunks--;
+                
+                const retryCount = (transferState.failedChunks.get(chunkIndex) || 0) + 1;
+                
+                if (retryCount > this.maxRetries)
+                {
+                    this.activeTransfers.delete(transferId);
+                    
+                    clearInterval(keepAliveInterval);
+                    
+                    reject(new Error(`Did not send chunk ${chunkIndex} after ${this.maxRetries} retries.`));
+                }
+                else
+                {
+                    transferState.failedChunks.set(chunkIndex, retryCount);
+                    
+                    setTimeout(() => sendChunk(chunkIndex), exponentialBackoff(retryCount));
+                }
+            }
+        };
+        
+        const transferState = this.activeTransfers.get(transferId);
+        
+        for (let i = 0; i < Math.min(this.parallelChunks, transferState.totalChunks); i++)
+        {
+            sendChunk(transferState.currentChunk++);
+        }
+    });
+}*/
 function _generateTransferId(file) {
   return `${file.name}-${Date.now()}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "description": "Revolutionizing real-time file transfer with seamless, instant communication across any device. Deliver files instantly, regardless of platform, and experience unparalleled speed and control in managing transfers. Elevate your file-sharing capabilities with a tool designed for precision, efficiency, and effortless connectivity.",
   "main": "dist/cjs/FileTide.js",
   "scripts": {
@@ -31,7 +31,7 @@
   "dependencies": {
     "@trap_stevo/iotide": "^0.0.37",
     "@trap_stevo/iotide-client": "^0.0.23",
-    "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.42",
+    "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.43",
     "chalk": "^4.1.2",
     "readline": "^1.3.0"
   },