@trap_stevo/filetide 0.0.46 → 0.0.48

package/dist/cjs/FileMessager.js

@@ -325,7 +325,7 @@ class FileMessager {
         ...data,
         transferType: "send"
       });
-      this.transferQueue.waitForData(data.transferID, () => this.currentTransferBarrierTransfers.get(data.transferID), [true, false], 100, 50000).then(accepted => {
+      this.transferQueue.waitForData(data.transferID, () => this.currentTransferBarrierTransfers.get(data.transferID), [true, false], 100, data.transferExpirationTime ? data.transferExpirationTime : 50000).then(accepted => {
         console.log(`[FileTide ~ Net Barrier] ~ Transfer ${accepted ? "accepted!" : "denied."}`);
         this.fileNet.emitToTide(senderClient.tideID, "transfer-barrier-response", accepted);
         this.currentTransferBarrierTransfers.delete(data.transferID);

package/dist/cjs/FileMessagerClient.js

@@ -26,8 +26,8 @@ class FileMessagerClient {
     parallelChunks: 3,
     maxRetries: 3
   }, messagerSettings = {
-    maxReconnectionAttempts: 5,
-    reconnectionAttempts: 5,
+    maxReconnectionAttempts: 15,
+    reconnectionAttempts: 15,
     maxReconnectionDelay: 10000
   }) {
     const {
@@ -67,8 +67,9 @@ class FileMessagerClient {
       });
     };
   }
-  async requestTransfer(clientID, senderID, filePath, destinationPath, filterContent = []) {
-    const transferAllowed = await this.allowedTransfer(clientID, senderID, destinationPath, "N/A", "requestSend");
+  async requestTransfer(clientID, senderID, filePath, destinationPath, filterContent = [], transferRequestExpirationTime = 30000) {
+    const transferContentType = FileUtilityManager.inferPathType(filePath);
+    const transferAllowed = await this.allowedTransfer(clientID, senderID, destinationPath, filePath, "N/A", transferContentType === "file" ? 1 : "N/A", transferContentType, "requestSend", transferRequestExpirationTime);
     if (!transferAllowed) {
       return;
     }
@@ -89,7 +90,7 @@ class FileMessagerClient {
     });
     return;
   }
-  async allowedTransfer(clientID, recipientID, filePath, fileSize, transferType = "send") {
+  async allowedTransfer(clientID, recipientID, filePath, originPath, fileSize, fileCount = 1, transferContentType = "file", transferType = "send", transferExpirationTime = 30000) {
     try {
       const currentDate = Date.now();
       const transferID = `${clientID}_${filePath}_${currentDate}`;
@@ -97,10 +98,16 @@ class FileMessagerClient {
         clientID,
         recipientID,
         transferID,
+        originPath,
         path: filePath,
         date: currentDate,
+        transferExpirationTime,
+        timeUntilTransferExpiration: transferExpirationTime,
+        itemCount: fileCount,
+        itemSize: fileSize,
+        transferContentType,
         transferType
-      }, 30000);
+      }, transferExpirationTime);
       if (!transferAccepted) {
         FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} denied your transfer.`, errorMessageColors);
         return false;
@@ -124,12 +131,13 @@ class FileMessagerClient {
    * @param {string} recipientId - The ID of the recipient.
    * @param {Array} filesData - Array of file data objects from the directory.
    * @param {string} baseDirectory - The base directory path that contains the files.
-   * @param {string} destinationPath - The path to which the files should be sent.
-   * @param {Number} tideSize - The tide size in sending files (500)
-   * @param {Number} minTideSize - The minimum tide size in sending files (10)
-   * @param {Number} maxTideSize - The maximum tide size in sending files (2000)
+   * @param {string} destinationPath - The path to which the files should get sent.
+   * @param {Number} tideSize - The tide size in sending files (500).
+   * @param {Number} minTideSize - The minimum tide size in sending files (10).
+   * @param {Number} maxTideSize - The maximum tide size in sending files (2000).
+   * @param {Number} transferRequestExpirationTime - The maximum time until the transfer barrier times out the transfer request.
    */
-  async sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath, tideSize = 500, minTideSize = 10, maxTideSize = 2000) {
+  async sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath, tideSize = 500, minTideSize = 10, maxTideSize = 2000, transferRequestExpirationTime = 30000) {
     try {
       const baseDirectoryName = path.basename(baseDirectory);
       const adjustedDestinationPath = FileUtilityManager.normalizePath(path.join(destinationPath, baseDirectoryName));
@@ -138,7 +146,7 @@ class FileMessagerClient {
         totalSize += fileInfo.size;
       });
       const incomingType = this.activeTransferTypes.get(destinationPath);
-      const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, adjustedDestinationPath, totalSize, "send");
+      const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, adjustedDestinationPath, baseDirectory, totalSize, filesData.length, "directory", "send", transferRequestExpirationTime);
       if (incomingType) {
         this.activeTransferTypes.delete(destinationPath);
       }
@@ -149,26 +157,27 @@ class FileMessagerClient {
         const relativeFilePath = path.dirname(path.relative(baseDirectory, fileInfo.filePath));
         const fileDestinationPath = FileUtilityManager.normalizePath(path.join(adjustedDestinationPath, relativeFilePath));
         if (fileInfo.largeFile) {
-          return await this.sendDirectoryLargeFile(clientID, recipientId, fileInfo.fileName, fileInfo.filePath, fileDestinationPath, fileInfo.fileSize, index, tideSize, minTideSize, maxTideSize);
+          return await this.sendDirectoryLargeFile(clientID, recipientId, fileInfo.fileName, fileInfo.filePath, fileDestinationPath, fileInfo.fileSize, index, tideSize, minTideSize, maxTideSize, transferRequestExpirationTime);
         }
-        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, transferRequestExpirationTime);
       });
       Promise.all(sendFilePromises).then(() => console.log("\nAll files in directory transferred successfully!")).catch(error => console.error("Did not transfer directory: ", error));
     } catch (error) {
       FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused directory transfer: ${error}`, errorMessageColors);
     }
   }
-  async sendDirectoryLargeFile(clientID, recipientId, fileName, filePath = process.cwd(), destinationPath = null, fileSize, index = 0, tideSize = 500, minTideSize = 10, maxTideSize = 2000) {
+  async sendDirectoryLargeFile(clientID, recipientId, fileName, filePath = process.cwd(), destinationPath = null, fileSize, index = 0, tideSize = 500, minTideSize = 10, maxTideSize = 2000, transferRequestExpirationTime = 30000) {
     let initiatingTransfer = false;
     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, transferRequestExpirationTime);
   }
-  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, transferRequestExpirationTime = 30000) {
+    if (!filePath) {
       return;
     }
+    let initiatingTransfer = false;
     if (index === 0) {
       this.clientTide.emitEvent(clientID, "transfer-start", {
         fileName,
@@ -177,56 +186,16 @@ 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, transferRequestExpirationTime);
   }
-  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, transferRequestExpirationTime = 30000) {
     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");
+      const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, destinationPath, filePath, fileSize, 1, "file", "send", transferRequestExpirationTime);
       if (incomingType) {
         this.activeTransferTypes.delete(filePath);
       }
@@ -257,6 +226,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,
@@ -279,6 +249,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;
@@ -321,76 +298,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

@@ -176,50 +176,52 @@ class FileTide {
 
   /**
    * Send files / directories directly to a device.
-   * @param {String} recipientID - The ID of the client device to send the data to
-   * @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} minTideSize - The minimum tide size in sending files (10)
-   * @param {Number} maxTideSize - The maximum tide size in sending files (2000)
+   * @param {String} recipientID - The ID of the client device to send the data to.
+   * @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 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).
+   * @param {Number} transferRequestExpirationTime - The maximum time until the transfer barrier times out the transfer request.
    */
-  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, transferRequestExpirationTime = 30000) {
     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, transferRequestExpirationTime);
+        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, transferRequestExpirationTime);
+      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, transferRequestExpirationTime);
+      return true;
     }
     FileTide.outputGradient(`[FileTide] ~ No active client ~ ${recipientID} found.`, errorMessageColors);
-    return;
+    return false;
   }
 
   /**

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/dist/cjs/HUDManagers/FileUtilityManager.js

@@ -211,6 +211,19 @@ class FileUtilityManager {
     return stats.isDirectory();
   }
 
+  /**
+   * Determines the type of a given path (directory or file) based on conventions.
+   * @param {string} inputPath - The path to infer.
+   * @returns {string} - Returns "directory" if the path has no extension, "file" if it contains an extension.
+   */
+  static inferPathType(inputPath) {
+    const parsedPath = path.parse(inputPath);
+    if (parsedPath.ext) {
+      return "file";
+    }
+    return "directory";
+  }
+
   /**
    * Helper function to check if a path exists.
    * @param {string} inputPath - The path to check.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "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": {