@trap_stevo/filetide 0.0.51 → 0.0.53

package/dist/cjs/FileMessager.js

@@ -1,5 +1,8 @@
 "use strict";
 
+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 {
   OmniMap
 } = require("@trap_stevo/legendarybuilderpronodejs-utilities/HUDStructs");
@@ -7,6 +10,9 @@ const IoTide = require("@trap_stevo/iotide");
 const {
   FileMessagerConfigManager
 } = require("./HUDManagers/FileMessagerConfigManager");
+const {
+  FileNetUtilityManager
+} = require("./HUDManagers/FileNetUtilityManager");
 const {
   FileNetClientManager
 } = require("./HUDManagers/FileNetClientManager");
@@ -14,6 +20,7 @@ const {
   FileTransferManager
 } = require("./HUDManagers/FileTransferManager");
 const HUDTargetQueue = require("./HUDManagers/HUDTargetQueueManager");
+var _FileMessager_brand = /*#__PURE__*/new WeakSet();
 class FileMessager {
   constructor(options = {
     pingTimeout: 3600000,
@@ -21,7 +28,8 @@ class FileMessager {
   }, transportOptions = {
     parallelChunks: 3,
     maxRetries: 3
-  }) {
+  }, debugMode = false) {
+    _classPrivateMethodInitSpec(this, _FileMessager_brand);
     const serverOptions = FileMessagerConfigManager.getServerOptions(options);
     this.transporter = new FileTransferManager(transportOptions);
     this.transferQueue = new HUDTargetQueue();
@@ -30,6 +38,7 @@ class FileMessager {
     this.currentTidingTransfers = new Map();
     this.fileNet = new IoTide(serverOptions.port, serverOptions, true, this.onConnect.bind(this), this.onDisconnect.bind(this));
     this.onlineClients = new OmniMap();
+    this.debugMode = debugMode;
     return;
   }
   onConnect(socket) {
@@ -46,6 +55,7 @@ class FileMessager {
     this.fileNet.on("get-client-transfer-barrier-response", this.handleClientTransferBarrierResponse.bind(this));
     this.fileNet.on("get-client-transfer-state", this.handleGetClientTransferState.bind(this));
     this.fileNet.on("get-client", this.handleGetClient.bind(this));
+    this.fileNet.on("acknowledge-transfer-tide", this.handleAcknowledgeTransferTide.bind(this));
     this.fileNet.on("notify-transfer-barrier", this.handleNotifyTransferBarrier.bind(this));
     this.fileNet.on("send-current-transfer-state", this.handleSendCurrentTransferState.bind(this));
     this.fileNet.on("sent-file-list-to-client", this.handleSentFileListToClient.bind(this));
@@ -121,11 +131,13 @@ class FileMessager {
       path: filePath,
       fileSize
     });
-    console.log(`[FileTide ~ File Messager] ~ Sent chunk ${chunkIndex} of ${fileName} to client ~ ${clientData.userID}!`);
+    _assertClassBrand(_FileMessager_brand, this, _log).call(this, `[FileTide ~ File Messager] ~ Sent chunk ${chunkIndex} of ${fileName} to client ~ ${clientData.userID}!`);
     if (senderClient) {
       this.fileNet.emitToTide(senderClient.tideID, "transfer-status", {
         status: `Chunk ${chunkIndex} of ${fileName} sent to client ${clientData.userID}!`,
         recipientID: clientData.userID,
+        senderName: senderData.userID,
+        senderID: senderData.id,
         success: true,
         fileName,
         chunkIndex,
@@ -136,7 +148,7 @@ class FileMessager {
       });
     }
   }
-  handleRequestTransferFromClient(transferData) {
+  handleRequestTransferFromClient(senderTide, transferData) {
     const {
       requesterID,
       senderID,
@@ -145,7 +157,7 @@ class FileMessager {
     } = transferData;
     this.requestFromClient(requesterID, senderID, filePath, destinationPath);
   }
-  handleSentFileListToClient(listData) {
+  handleSentFileListToClient(senderTide, listData) {
     const {
       totalItemsSent,
       recipientID,
@@ -164,10 +176,11 @@ class FileMessager {
         totalItemsSent
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Scanner] ~ `, error);
       return;
     }
   }
-  handleSendFileListToClient(listData) {
+  handleSendFileListToClient(senderTide, listData) {
     const {
       listedFiles,
       totalItems,
@@ -188,10 +201,11 @@ class FileMessager {
         listedFiles
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Scanner] ~ `, error);
       return;
     }
   }
-  handleListClientFiles(clientData) {
+  handleListClientFiles(senderTide, clientData) {
     const {
       requesterID,
       recipientID,
@@ -211,10 +225,11 @@ class FileMessager {
         depth
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Scanner] ~ `, error);
       return;
     }
   }
-  handleClientToClientTransfer(transferData) {
+  handleClientToClientTransfer(senderTide, transferData) {
     try {
       const {
         chunkBatch
@@ -233,7 +248,7 @@ class FileMessager {
             completedChunks,
             totalChunks
           } = chunkData;
-          console.log(`[FileTide ~ File Messager] ~ Transferring file ~ ${fileName} | chunk ${chunkIndex + 1} >> ${completedChunks} of ${totalChunks} to client (${recipientId})`);
+          _assertClassBrand(_FileMessager_brand, this, _log).call(this, `[FileTide ~ File Messager] ~ Transferring file ~ ${fileName} | chunk ${chunkIndex + 1} >> ${completedChunks} of ${totalChunks} to client (${recipientId})`);
           const recipientClient = FileNetClientManager.getOnlineClient(recipientId);
           const senderClient = FileNetClientManager.getOnlineClient(senderID);
           this.sendFileChunkToClient({
@@ -277,7 +292,7 @@ class FileMessager {
         completedChunks,
         totalChunks
       } = transferData;
-      console.log(`[FileTide ~ File Messager] ~ Transferring file ~ ${fileName} | chunk ${chunkIndex + 1} >> ${completedChunks} of ${totalChunks} to client (${recipientId})`);
+      _assertClassBrand(_FileMessager_brand, this, _log).call(this, `[FileTide ~ File Messager] ~ Transferring file ~ ${fileName} | chunk ${chunkIndex + 1} >> ${completedChunks} of ${totalChunks} to client (${recipientId})`);
       const recipientClient = FileNetClientManager.getOnlineClient(recipientId);
       const senderClient = FileNetClientManager.getOnlineClient(senderID);
       this.sendFileChunkToClient({
@@ -307,11 +322,11 @@ class FileMessager {
         }
       }
     } catch (error) {
-      console.log(error);
+      console.error(`[FileTide ~ Net Transporter] ~ `, error);
       return;
     }
   }
-  handleClientTransferBarrierResponse(data) {
+  handleClientTransferBarrierResponse(senderTide, data) {
     console.log(`[FileTide ~ Net] Checking ${data.recipientID}'s transfer barrier for transfer ~ ${data.transferID}...`);
     try {
       const recipientConnectionID = FileNetClientManager.getOnlineClient(data.recipientID).id;
@@ -319,6 +334,7 @@ class FileMessager {
       const senderClient = this.getClientFromID(senderConnectionID);
       const client = this.getClientFromID(recipientConnectionID);
       if (!client || !senderClient) {
+        console.log(`[FileTide ~ Net Barrier] ~ Both, recipient and sender connection authorization required.`);
         return;
       }
       this.fileNet.emitToTide(client.tideID, "queue-incoming-transfer", {
@@ -341,18 +357,20 @@ class FileMessager {
           ...data
         });
       }).catch(error => {
-        console.error(error.message);
+        console.error(`[FileTide ~ Net Barrier] ~ ${error.message}`);
       });
       return;
     } catch (error) {
+      console.error(`[FileTide ~ Net Barrier] ~ `, error);
       return;
     }
   }
-  handleSendCurrentTransferState(data) {
+  handleSendCurrentTransferState(senderTide, data) {
     try {
       const senderConnectionID = FileNetClientManager.getOnlineClient(data.senderID).id;
       const senderClient = this.getClientFromID(senderConnectionID);
       if (!senderClient) {
+        console.log(`[FileTide ~ Net Transfers] ~ Sender ~ ${senderConnectionID.truncate(0, senderConnectionID.length / 2)}... not found.`);
         return;
       }
       this.fileNet.emitToTide(senderClient.tideID, "sent-current-transfer-state", data.transferState || {
@@ -360,10 +378,11 @@ class FileMessager {
         lastChunkSent: 0
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Transfers] ~ `, error);
       return;
     }
   }
-  handleGetClientTransferState(data) {
+  handleGetClientTransferState(senderTide, data) {
     const filePath = data.filePath || data.path;
     console.log(`[FileTide ~ Net] ~ Getting ${data.recipientID}'s transfer state for ~ ${filePath}...`);
     try {
@@ -378,10 +397,11 @@ class FileMessager {
         filePath
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Transfers] ~ `, error);
       return;
     }
   }
-  handleGetClient(data) {
+  handleGetClient(senderTide, data) {
     console.log(`[FileTide ~ Net] ~ Getting client ~ ${data.clientID}...`);
     try {
       const senderConnectionID = FileNetClientManager.getOnlineClient(data.senderID).id;
@@ -394,15 +414,23 @@ class FileMessager {
       console.log(`[FileTide ~ Net] Got client ~ ${data.clientID}!`);
       this.fileNet.emitToTide(senderClient.tideID, "retrieved-current-client", client);
     } catch (error) {
+      console.error(`[FileTide ~ Net Activity] ~ `, error);
       return;
     }
   }
-  handleNotifyTransferBarrier(data, emitToChannel) {
+  handleAcknowledgeTransferTide(senderTide, data) {
+    try {
+      console.log(`[FileTide ~ Net Activity] ~ ${data.recipientName} acknowledged tide transfer from ${data.senderName}.\n\n\t~ [${data.fileName}-${data.transferStats.startTime}] ~\n\n\t\tFile Name ~ ${data.fileName}\n\t\tDestination ~ ${data.path}\n\n\t\t\tProgress ~ ${data.transferStats.progress.toFixed(2)}%\n\t\t\tETA ~ ${data.transferStats.timeLeft <= 0 ? "Now" : FileNetUtilityManager.convertSeconds(data.transferStats.timeLeft.toFixed(2))}\n\t\t\tSpeed ~ ${FileNetUtilityManager.getFormattedSize(data.transferStats.speed, true)}/s\n\t\t\tSize ~ ${FileNetUtilityManager.getFormattedSize(data.transferStats.totalSize, true)}\n\t\t\tTransferred ~ ${FileNetUtilityManager.getFormattedSize(data.transferStats.current, true)}\n`);
+    } catch (error) {
+      console.error(`[FileTide ~ Net Activity] ~  ${data.recipientName} acknowledged tide transfer from ${data.senderName}.\n\n${error}`);
+    }
+  }
+  handleNotifyTransferBarrier(senderTide, data, emitToChannel) {
     const accepted = data.accepted;
     const transferID = data.data.transferID;
     this.currentTransferBarrierTransfers.set(transferID, accepted);
   }
-  handleFileTransferStart(data, emitToChannel) {
+  handleFileTransferStart(senderTide, data, emitToChannel) {
     console.log(`[FileTide ~ File Messager] ~ Alerting client of incoming transfer from ${data.senderID}...`);
     try {
       const recipientConnectionID = FileNetClientManager.getOnlineClient(data.recipientID).id;
@@ -417,7 +445,7 @@ class FileMessager {
         ...data,
         currentSender: data.senderID
       });
-      if (!this.currentTidingTransfers.get(senderID) || this.currentTidingTransfers.get(senderID).length <= 0) {
+      if (!this.currentTidingTransfers.get(data.senderID) || this.currentTidingTransfers.get(data.senderID).length <= 0) {
         const tidingTransfers = new Map();
         tidingTransfers.set(data.recipientID, {
           recipientID: data.recipientID,
@@ -428,23 +456,24 @@ class FileMessager {
         this.currentTidingTransfers.set(data.senderID, tidingTransfers);
         return;
       }
-      this.currentTidingTransfers.get(senderID).set(data.recipientID, {
+      this.currentTidingTransfers.get(data.senderID).set(data.recipientID, {
         recipientID: data.recipientID,
         startedOn: new Date(),
         size: data.fileSize,
         path: data.path
       });
     } catch (error) {
+      console.error(`[FileTide ~ Net Transfers] ~ `, error);
       return;
     }
   }
-  handleFileTransferProgress(data, emitToChannel) {
+  handleFileTransferProgress(senderTide, data, emitToChannel) {
     console.log(`Progress: ${data.progress}`);
   }
-  handleFileTransferComplete(data) {
+  handleFileTransferComplete(senderTide, data) {
     console.log(`File transfer completed: ${data.fileName}`);
   }
-  handleCheckClientOnline(data) {
+  handleCheckClientOnline(senderTide, data) {
     console.log(`[FileTide ~ Net Activity] ~ Checking if client ~ ${data.clientID} online...`);
     try {
       const client = FileNetClientManager.getOnlineClient(data.clientID);
@@ -468,7 +497,7 @@ class FileMessager {
       return;
     }
   }
-  handleClientsOnline(clientID) {
+  handleClientsOnline(senderTide, clientID) {
     const connectionDetails = FileNetClientManager.getOnlineClient(clientID);
     if (!connectionDetails) {
       console.log(`[FileTide ~ Net Activity] ~ Client ~ ${clientID} not authorized.`);
@@ -482,13 +511,21 @@ class FileMessager {
     this.fileNet.emitToTide(connectionDetails.tideID, "current-online-clients", Object.fromEntries(FileNetClientManager.getOnlineClients()));
     return;
   }
-  handleClientOnline(clientID, tideID, pClientID, connectionID, activeTransferBarrier) {
+  handleClientOnline(senderTide, clientID, tideID, pClientID, connectionID, activeTransferBarrier) {
     if (!this.onlineClients.contains(connectionID)) {
       return;
     }
     if (FileNetClientManager.getOnlineClient(clientID) && this.onlineClients.get(connectionID)) {
-      clientID = `${clientID}_${connectionID.slice(0, 4)}`;
+      const nClientID = `${clientID}_${connectionID.slice(0, 4)}`;
+      const currentClientID = clientID;
+      clientID = nClientID;
       this.fileNet.emitToTide(tideID, "current-client-id-already-online", clientID);
+      FileNetClientManager.updateOnlineClient(nClientID, {
+        pClientID: currentClientID,
+        clientID: nClientID,
+        tideID: senderTide.tideID,
+        id: senderTide.id
+      });
       return;
     }
     FileNetClientManager.addOnlineClient(clientID, pClientID, tideID, connectionID);
@@ -501,7 +538,7 @@ class FileMessager {
     this.fileNet.emit("current-clients", currentOnlineClients);
     return;
   }
-  handleClientOffline(clientData) {
+  handleClientOffline(senderTide, clientData) {
     console.log(`[FileTide ~ Net Activity] ~ Client ~ ${clientData.clientID} | connection origin ~ ${clientData.connectionID} going offline...`);
     try {
       const clientDetails = FileNetClientManager.getOnlineClient(clientData.clientID);
@@ -535,7 +572,7 @@ class FileMessager {
     }
     return;
   }
-  handleClientTiding(data) {
+  handleClientTiding(senderTide, data) {
     try {
       const senderConnectionID = FileNetClientManager.getOnlineClient(data.senderID).id;
       const senderClient = this.getClientFromID(senderConnectionID);
@@ -548,9 +585,16 @@ class FileMessager {
       });
       return;
     } catch (error) {
+      console.error(`[FileTide ~ Net Activity] ~ `, error);
       return;
     }
   }
 }
+function _log(...message) {
+  if (!this.debugMode) {
+    return;
+  }
+  console.log(...message);
+}
 ;
 module.exports = FileMessager;

package/dist/cjs/FileMessagerClient.js

@@ -7,10 +7,13 @@ const chalk = require("chalk");
 const path = require("path");
 const fs = require("fs");
 const {
-  FileNetUtilityManager,
+  FileTideDebugUtilityManager,
   significantMessageColors,
   errorMessageColors
-} = require("./HUDManagers/FileNetUtilityManager");
+} = require("./HUDManagers/FileTideDebugUtilityManager");
+const {
+  FileTransferTrackingManager
+} = require("./HUDManagers/FileTransferTrackingManager.js");
 const FileTransferRecoveryManager = require("./HUDManagers/FileTransferRecoveryManager");
 const {
   FileMessagerConfigManager
@@ -46,12 +49,13 @@ class FileMessagerClient {
       transports: ["websocket"],
       ...options
     }, headers, authURL, authHeaders, useAuthentication, queryAuthToken, onConnect, () => {
+      FileTransferTrackingManager.outputCurrentTransfers();
       FileTransferRecoveryManager.flushToDisk();
       if (onDisconnect) {
         onDisconnect();
       }
     });
-    FileNetUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Created client with ID ${clientID} and socket ${clientID}!`, significantMessageColors);
+    FileTideDebugUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Created client with ID ${clientID} and socket ${clientID}!`, significantMessageColors);
     return clientID;
   }
   joinRoom(userID, roomName, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
@@ -60,7 +64,7 @@ class FileMessagerClient {
     }, options, headers, onConnect, onDisconnect, authURL, authHeaders, useAuthentication, queryAuthToken);
     return () => {
       this.clientTide.joinChannel(socketName, roomName, userID, () => {
-        FileNetUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Client ~ ${userID} joined room ${roomName} successfully!`, significantMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Client ~ ${userID} joined room ${roomName} successfully!`, significantMessageColors);
         this.clients.set(userID, {
           roomName
         });
@@ -109,18 +113,18 @@ class FileMessagerClient {
         transferType
       }, transferExpirationTime);
       if (!transferAccepted) {
-        FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} denied your transfer.`, errorMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} denied your transfer.`, errorMessageColors);
         return false;
       } else if (transferAccepted) {
-        FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} accepted your transfer!`, significantMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} accepted your transfer!`, significantMessageColors);
         return true;
       }
     } catch (error) {
       if (error.message.startsWith("Timeout: No response")) {
-        FileNetUtilityManager.outputGradient("[FileTide ~ File Messager] Transfer approval timed out.", errorMessageColors);
+        FileTideDebugUtilityManager.outputGradient("[FileTide ~ File Messager] Transfer approval timed out.", errorMessageColors);
         return false;
       }
-      FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] Transfer approval refused.\n${error}`, errorMessageColors);
+      FileTideDebugUtilityManager.outputGradient(`[FileTide ~ File Messager] Transfer approval refused.\n${error}`, errorMessageColors);
       return false;
     }
   }
@@ -163,7 +167,7 @@ class FileMessagerClient {
       });
       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);
+      FileTideDebugUtilityManager.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, transferRequestExpirationTime = 30000) {
@@ -192,7 +196,7 @@ class FileMessagerClient {
   }
   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(largeFile ? `[FileTide ~ File Messager] ~ Requesting to transfer large file ~ ${destinationPath} to ${recipientId}!` : `[FileTide ~ File Messager] ~ Requesting to transfer ~ ${destinationPath} to ${recipientId}!`, significantMessageColors);
+    FileTideDebugUtilityManager.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, filePath, fileSize, 1, "file", "send", transferRequestExpirationTime);
@@ -298,9 +302,9 @@ class FileMessagerClient {
           });
         }
       }, this.clientTide);
-      FileNetUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Large file ~ ${fileName} transfer complete!` : `[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors);
+      FileTideDebugUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Large file ~ ${fileName} transfer complete!` : `[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`, significantMessageColors);
     } catch (error) {
-      FileNetUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Error transferring large file: ${error.message}` : `[FileTide ~ File Messager] ~ Error transferring file ~ ${error.message}`, errorMessageColors);
+      FileTideDebugUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Error transferring large file: ${error.message}` : `[FileTide ~ File Messager] ~ Error transferring file ~ ${error.message}`, errorMessageColors);
     } finally {
       await fileHandle.close();
     }

package/dist/cjs/FileTide.js

@@ -11,10 +11,13 @@ const chalk = require("chalk");
 const path = require("path");
 const fs = require("fs");
 const {
-  FileNetUtilityManager,
+  FileTideDebugUtilityManager,
   significantMessageColors,
   errorMessageColors
-} = require("./HUDManagers/FileNetUtilityManager.js");
+} = require("./HUDManagers/FileTideDebugUtilityManager.js");
+const {
+  FileTransferTrackingManager
+} = require("./HUDManagers/FileTransferTrackingManager.js");
 const {
   FileTransferReceiverManager
 } = require("./HUDManagers/FileTransferReceiverManager.js");
@@ -32,7 +35,7 @@ const FileMessagerClient = require("./FileMessagerClient");
 const FileMessager = require("./FileMessager");
 var _FileTide_brand = /*#__PURE__*/new WeakSet();
 class FileTide {
-  constructor() {
+  constructor(debugMode = true) {
     /**
      * Set up file transfer event listeners natively.
      * Automatically checks and creates directories as needed.
@@ -45,10 +48,12 @@ class FileTide {
     this.transferBarrier = false;
     this.clients = new Map();
     this.currentUserID = "";
+    this.inDebugMode = debugMode;
+    FileTideDebugUtilityManager.setDebugMode(debugMode);
     return;
   }
   static outputGradient(text, colors) {
-    FileNetUtilityManager.outputGradient(text, colors);
+    FileTideDebugUtilityManager.outputGradient(text, colors);
     return;
   }
 
@@ -104,7 +109,7 @@ class FileTide {
     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")]);
+    this.clientShorePolicies.set(userID, [FileUtilityManager.getTidePath(">Downloads"), FileUtilityManager.getTidePath(">Documents"), FileUtilityManager.getTidePath(">Pictures"), FileUtilityManager.getTidePath(">Desktop"), FileUtilityManager.getTidePath(">Videos"), FileUtilityManager.getTidePath(">Music")]);
     this.clients.set(userID, newClient);
     FileTide.outputGradient(`[FileTide] ~ Messager launched successfully for client ~ ${userID}!`, significantMessageColors);
     _assertClassBrand(_FileTide_brand, this, _setupFileEventListeners).call(this, userID, newClient, onTransferProgress, onIncomingTransfer, onIncomingFile, onTransferBarrier, options);
@@ -142,7 +147,7 @@ class FileTide {
     const clientID = this.currentUserID;
     const clientMessager = this.clients.get(clientID);
     if (!clientMessager) {
-      FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, errorMessageColors);
       return;
     }
     clientMessager.listFiles(clientID, recipientID, depth);
@@ -153,7 +158,7 @@ class FileTide {
   clearShorePolicies(clientID, shores = []) {
     let clientShorePolicies = this.clientShorePolicies.get(clientID);
     if (!shores || shores.length <= 0 || !clientShorePolicies || !clientID) {
-      FileTide.outputGradient(`[FileTide] Did not clear from client ~ ${clientID} shore policies.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[FileTide] Did not clear from client ~ ${clientID} shore policies.`, errorMessageColors);
       return false;
     }
     const shorePolicies = Array.from(clientShorePolicies.values());
@@ -164,7 +169,7 @@ class FileTide {
   addShorePolicies(clientID, shores = []) {
     const clientShorePolicies = this.clientShorePolicies.get(clientID);
     if (!shores || shores.length <= 0 || !clientShorePolicies || !clientID) {
-      FileTide.outputGradient(`[FileTide] Did not add to client ~ ${clientID} shore policies.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[FileTide] Did not add to client ~ ${clientID} shore policies.`, errorMessageColors);
       return false;
     }
     this.clientShorePolicies.set(clientID, [...new Set([...clientShorePolicies, ...shores])]);
@@ -190,33 +195,33 @@ class FileTide {
     const clientID = this.currentUserID;
     const clientMessager = this.clients.get(clientID);
     if (!clientMessager) {
-      FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, errorMessageColors);
       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"]);
+      FileTide.outputGradient(`[FileTide] ${recipientID} currently not tiding.`, errorMessageColors);
       return false;
     }
     const fileDetails = await this.getPathData(filePath, filterDirectoryContent);
     if (!fileDetails) {
-      FileTide.outputGradient(`[${clientID}] File at path ${filePath} not found.`, ["#F94144", "#F3722C"]);
+      FileTide.outputGradient(`[${clientID}] File at path ${filePath} not found.`, errorMessageColors);
       return false;
     }
     if (fileDetails.type === "file") {
       if (fileDetails.largeFile) {
-        FileTide.outputGradient(`[${clientID}] Sending large file ~ ${fileDetails.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
+        FileTide.outputGradient(`[${clientID}] Sending large file ~ ${fileDetails.fileName} to client ~ ${recipientID}...`, significantMessageColors);
         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"]);
+      FileTide.outputGradient(`[${clientID}] Sending file ~ ${fileDetails.content.fileName} to client ~ ${recipientID}...`, significantMessageColors);
       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"]);
+      FileTide.outputGradient(`[${clientID}] Sending ${fileDetails.content.length} files in directory ~ ${path.basename(filePath)} to client ~ ${recipientID}...`, significantMessageColors);
       await clientMessager.sendDirectoryFiles(clientID, recipientID, fileDetails.content, this.getTidePath(filePath), destinationPath, tideSize, minTideSize, maxTideSize, transferRequestExpirationTime);
       return true;
     }
@@ -439,7 +444,7 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
         onIncomingFile(verifiedSender, {
           ...data,
           stats: taskBarStats
-        }, fileTransferReceiver.activeTransfers);
+        }, FileTransferTrackingManager.activeTransfers);
       }
       if (verifiedSender && !fs.existsSync(saveDir)) {
         fs.mkdirSync(saveDir, {
@@ -465,6 +470,8 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
   });
   client.clientTide.onEvent(userID, "transfer-progress", async data => {
     if (!data || data.fileChunk === undefined || data.fileChunk === null) {
+      FileTideDebugUtilityManager.log("notice", true, `Received invalid data chunk from ~ ${data.senderName} in transfer progress ~ ${data.fileName}`);
+      FileTransferTrackingManager.outputCurrentTransfers();
       return;
     }
     await fileTransferReceiver.handleTransferProgress(data);
@@ -474,8 +481,16 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     };
     currentTransferState.transferredSize += data.chunkSize || 512 * 1024;
     FileTransferRecoveryManager.saveTransferState(userID, data.senderName, `${data.path}-${data.fileName}`, data.chunkIndex, currentTransferState.transferredSize);
+    const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+    client.clientTide.emitEvent(userID, "acknowledge-transfer-tide", {
+      fileName: data.fileName,
+      senderName: data.senderName,
+      recipientName: userID,
+      transferStateID: `${data.path}-${data.fileName}`,
+      path: data.path,
+      transferStats: taskBarStats
+    });
     if (onTransferProgress) {
-      const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
       onTransferProgress({
         ...data,
         stats: taskBarStats
@@ -490,12 +505,15 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
       fileSize
     } = data;
     if (chunkIndex === 0) {
+      FileTransferTrackingManager.trackTransfer(data);
       this.progressBarManager.addTask({
         name: fileName,
         size: fileSize
       });
+    } else if (chunkIndex > 0) {
+      FileTransferTrackingManager.updateTransfer(data);
+      this.progressBarManager.updateTaskProgress(fileName, chunkSize);
     }
-    this.progressBarManager.updateTaskProgress(fileName, chunkSize);
     if (onTransferStatus) {
       const taskBarStats = this.progressBarManager.getTaskBar(fileName);
       onTransferStatus({
@@ -508,35 +526,61 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
   client.clientTide.onEvent(userID, "transfer-complete", data => {
     const savePath = FileUtilityManager.getTidePath(path.join(data.filePath, data.fileName));
     try {
-      _FileTide.outputGradient(`[${userID}] File transfer complete : ${data.fileName}`, significantMessageColors);
-      const transferState = fileTransferReceiver.activeTransfers.get(data.fileName);
+      _FileTide.outputGradient(`[${userID}] File transfer complete ~ ${data.fileName}`, significantMessageColors);
+      const transferState = FileTransferTrackingManager.getTransfer(data.fileName);
+      FileTideDebugUtilityManager.log("notice", true, `Transfer state ~ ${data.fileName} active | ${transferState !== null && transferState !== undefined ? true : false}`);
       if (!transferState) {
         return;
       }
-      fileTransferReceiver.completeTransfer(data, (transferData, transfers, success, error) => {
-        if (success) {
-          FileTransferRecoveryManager.clearTransferState(userID, data.senderID, `${data.filePath}-${data.fileName}`);
-          _FileTide.outputGradient(`[${userID}] File saved at : ${savePath}\n`, significantMessageColors);
-        } else if (!success) {
-          _FileTide.outputGradient(`[${userID}] Did not save file at : ${savePath}\n\t${error}\n`, errorMessageColors);
-        }
-        if (onTransferComplete) {
-          const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
-          onTransferComplete({
-            ...data,
-            stats: taskBarStats
-          }, fileTransferReceiver.activeTransfers, success);
-        }
-      });
+      if (transferState.fileStream) {
+        fileTransferReceiver.completeTransfer(data, (transferData, transfers, success, error) => {
+          if (success) {
+            FileTransferRecoveryManager.clearTransferState(userID, data.senderID, `${data.filePath}-${data.fileName}`);
+            _FileTide.outputGradient(`[${userID}] File saved at ~ ${savePath}\n`, significantMessageColors);
+          } else if (!success) {
+            _FileTide.outputGradient(`[${userID}] Did not save file at ~ ${savePath}\n\t${error}\n`, errorMessageColors);
+          }
+          if (onTransferComplete) {
+            const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+            onTransferComplete({
+              ...data,
+              stats: taskBarStats
+            }, FileTransferTrackingManager.activeTransfers, success);
+          }
+          setTimeout(() => {
+            FileTransferTrackingManager.outputCurrentTransfers();
+            this.progressBarManager.clearTaskBar(data.fileName);
+          }, this.progressBarManager.completionTimeout);
+        });
+        return;
+      }
+      FileTransferRecoveryManager.clearTransferState(userID, data.senderID, `${data.filePath}-${data.fileName}`);
+      FileTransferTrackingManager.untrackTransfer(data.fileName);
+      _FileTide.outputGradient(`[${userID}] Transfer successfully sent to ~ ${data.recipientId} and saved at ~ ${path.join(data.filePath, data.fileName)}\n`, significantMessageColors);
+      if (onTransferComplete) {
+        const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+        onTransferComplete({
+          ...data,
+          stats: taskBarStats
+        }, FileTransferTrackingManager.activeTransfers, true);
+      }
+      setTimeout(() => {
+        FileTransferTrackingManager.outputCurrentTransfers();
+        this.progressBarManager.clearTaskBar(data.fileName);
+      }, this.progressBarManager.completionTimeout);
     } catch (error) {
-      _FileTide.outputGradient(`[${userID}] Did not save file at : ${savePath}\n${error}`, errorMessageColors);
+      _FileTide.outputGradient(`[${userID}] Did not save file at ~ ${savePath}\n${error}`, errorMessageColors);
       if (onTransferComplete) {
         const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
         onTransferComplete({
           ...data,
           stats: taskBarStats
-        }, fileTransferReceiver.activeTransfers, false);
+        }, FileTransferTrackingManager.activeTransfers, false);
       }
+      setTimeout(() => {
+        FileTransferTrackingManager.outputCurrentTransfers();
+        this.progressBarManager.clearTaskBar(data.fileName);
+      }, this.progressBarManager.completionTimeout);
     }
   });
   client.clientTide.onEvent(userID, "transfer-requested", async data => {

package/dist/cjs/HUDComponents/ConsoleProgressBarManager.js

@@ -2,6 +2,12 @@
 
 const readline = require("readline");
 const chalk = require("chalk");
+const {
+  FileTideDebugUtilityManager
+} = require("../HUDManagers/FileTideDebugUtilityManager.js");
+const {
+  FileNetUtilityManager
+} = require("../HUDManagers/FileNetUtilityManager");
 class ConsoleProgressBarManager {
   constructor(tasks = [], options = {}) {
     const rows = process.stdout.rows || 24;
@@ -20,41 +26,6 @@ class ConsoleProgressBarManager {
     this.allTasksCompleted = false;
     this.taskBars = tasks.map((task, index) => this.createTaskBar(task, index));
   }
-  convertSeconds(seconds) {
-    if (seconds === 0) return "0 s";
-    const units = [{
-      name: "y",
-      seconds: 60 * 60 * 24 * 365
-    }, {
-      name: "mo",
-      seconds: 60 * 60 * 24 * 30
-    }, {
-      name: "w",
-      seconds: 60 * 60 * 24 * 7
-    }, {
-      name: "d",
-      seconds: 60 * 60 * 24
-    }, {
-      name: "h",
-      seconds: 60 * 60
-    }, {
-      name: "m",
-      seconds: 60
-    }, {
-      name: "s",
-      seconds: 1
-    }];
-    let remainingSeconds = seconds;
-    let result = "";
-    for (const unit of units) {
-      const count = Math.floor(remainingSeconds / unit.seconds);
-      if (count > 0) {
-        result += `${count}${unit.name} `;
-        remainingSeconds %= unit.seconds;
-      }
-    }
-    return result.trim();
-  }
   createTaskBar(task, index) {
     const defaultOptions = {
       barLength: 40,
@@ -81,32 +52,6 @@ class ConsoleProgressBarManager {
       startTime: Date.now(),
       taskIndex: index,
       completed: false,
-      getFormattedSize: size => {
-        if (!settings.dynamicUnits) return `${size.toFixed(1)} B`;
-        const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-        let unitIndex = 0;
-        while (size >= 1024 && unitIndex < units.length - 1) {
-          size /= 1024;
-          unitIndex++;
-        }
-        return `${size.toFixed(2)} ${units[unitIndex]}`;
-      },
-      getUnitData: size => {
-        if (!settings.dynamicUnits) return {
-          current: size.toFixed(1),
-          unit: "B"
-        };
-        const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-        let unitIndex = 0;
-        while (size >= 1024 && unitIndex < units.length - 1) {
-          size /= 1024;
-          unitIndex++;
-        }
-        return {
-          current: size.toFixed(2),
-          unit: units[unitIndex]
-        };
-      },
       redraw: () => {
         if (!isNaN(newBar.taskIndex) && !isNaN(this.barsPerPage) && process.stdout.isTTY) {
           readline.cursorTo(process.stdout, 0, newBar.taskIndex % this.barsPerPage);
@@ -119,7 +64,7 @@ class ConsoleProgressBarManager {
         const percentage = newBar.current / newBar.totalSize * 100;
         const elapsedTime = (Date.now() - newBar.startTime) / 1000;
         const speed = newBar.current / elapsedTime;
-        const speedData = newBar.getUnitData(speed);
+        const speedData = FileNetUtilityManager.getFormattedSize(speed, settings.dynamicUnits);
         const timeLeft = (newBar.totalSize - newBar.current) / (speed || 1);
         newBar.progress = percentage;
         newBar.timeLeft = timeLeft;
@@ -127,7 +72,7 @@ class ConsoleProgressBarManager {
         const filledLength = Math.round(settings.barLength * (newBar.current / newBar.totalSize));
         const bar = settings.barColor(settings.filledChar.repeat(filledLength)) + settings.unfilledChar.repeat(settings.barLength - filledLength);
         try {
-          process.stdout.write(`${settings.taskNameColor(newBar.taskName)} > ${settings.totalSizeColor(newBar.getFormattedSize(newBar.totalSize))} | ${settings.sizeTransferredColor(newBar.getFormattedSize(newBar.current))} ${settings.speedColor(`${speedData.current} ${speedData.unit}/s`)} | ${settings.taskETAColor(this.convertSeconds(timeLeft.toFixed(2)))} [${bar}] ${settings.percentageColor(percentage.toFixed(2) + "%")}`);
+          process.stdout.write(`${settings.taskNameColor(newBar.taskName)} > ${settings.totalSizeColor(FileNetUtilityManager.getFormattedSize(newBar.totalSize, settings.dynamicUnits))} | ${settings.sizeTransferredColor(FileNetUtilityManager.getFormattedSize(newBar.current, settings.dynamicUnits))} ${settings.speedColor(`${speedData}/s`)} | ${settings.taskETAColor(FileNetUtilityManager.convertSeconds(timeLeft.toFixed(2)))} [${bar}] ${settings.percentageColor(percentage.toFixed(2) + "%")}`);
         } catch (error) {
           console.log(error);
         }
@@ -165,7 +110,9 @@ class ConsoleProgressBarManager {
         setTimeout(() => {
           this.completionFeed = this.completionFeed.filter(task => task !== newBar.taskName);
         }, this.completionTimeout);
+        FileTideDebugUtilityManager.log("notice", true, `Tasks Completion Status ~\n\n\tTasks ~ (${this.completedTasksCount}/${this.totalTasks})`);
         if (this.completedTasksCount === this.totalTasks) {
+          FileTideDebugUtilityManager.log("notice", true, `All Tasks Complete!`);
           this.allTasksCompleted = true;
           this.exitInputListener();
           this.displayPage();
@@ -211,7 +158,7 @@ class ConsoleProgressBarManager {
   getCurrentStats() {
     const completedTasks = this.taskBars.filter(bar => bar.completed).length;
     const totalTasks = this.taskBars.length;
-    const overallProgress = this.taskBars.reduce((acc, bar) => acc + bar.current / bar.totalSize * 100, 0) / totalTasks;
+    const overallProgress = totalTasks === 0 ? 0 : this.taskBars.reduce((acc, bar) => acc + bar.current / bar.totalSize * 100, 0) / totalTasks;
     const stats = {
       completedTasks,
       totalTasks,
@@ -220,10 +167,10 @@ class ConsoleProgressBarManager {
         taskName: bar.taskName,
         progress: `${(bar.current / bar.totalSize * 100).toFixed(2)}%`,
         completed: bar.completed,
-        currentSize: bar.getFormattedSize(bar.current),
-        totalSize: bar.getFormattedSize(bar.totalSize),
-        speed: `${bar.getUnitData(bar.speed).current} ${bar.getUnitData(bar.speed).unit}/s`,
-        timeLeft: this.convertSeconds(bar.timeLeft.toFixed(2))
+        currentSize: FileNetUtilityManager.getFormattedSize(bar.current, true),
+        totalSize: FileNetUtilityManager.getFormattedSize(bar.totalSize, true),
+        speed: `${FileNetUtilityManager.getUnitData(bar.speed, true).current} ${FileNetUtilityManager.getUnitData(bar.speed, true).unit}/s`,
+        timeLeft: FileNetUtilityManager.convertSeconds(bar.timeLeft.toFixed(2))
       }))
     };
     return stats;
@@ -317,14 +264,20 @@ class ConsoleProgressBarManager {
   }
   exitInputListener() {
     process.stdin.removeListener("data", this.inputListener);
+    FileTideDebugUtilityManager.log("notice", true, `Exiting input listener...`);
+    FileTideDebugUtilityManager.log("notice", true, `Process TTY ~ ${process.stdout.isTTY}`);
     if (process.stdout.isTTY) {
       process.stdin.setRawMode(false);
       process.stdin.resume();
+      FileTideDebugUtilityManager.log("notice", true, `Resumed process.`);
     }
+    FileTideDebugUtilityManager.log("notice", true, `Exited input listener.`);
   }
   displayCompletionMessage() {
     const lastLine = Math.min(this.taskBars.length, this.barsPerPage);
     readline.cursorTo(process.stdout, 0, lastLine);
+    FileTideDebugUtilityManager.log("notice", true, `Displaying task completion message...`);
+    FileTideDebugUtilityManager.log("notice", true, `Process TTY ~ ${process.stdout.isTTY}`);
     if (process.stdout.isTTY) {
       process.stdout.clearLine();
     }

package/dist/cjs/HUDManagers/FileNetClientManager.js

@@ -14,6 +14,17 @@ class FileNetClientManager {
     });
     return currentOnlineClients;
   }
+  static updateOnlineClient(clientID, data) {
+    const onlineClient = currentOnlineClients.get(clientID);
+    if (!onlineClient) {
+      return false;
+    }
+    currentOnlineClients.set(clientID, {
+      ...onlineClient,
+      ...data
+    });
+    return true;
+  }
   static clearOnlineClient(clientID) {
     if (!currentOnlineClients.get(clientID)) {
       return currentOnlineClients;

package/dist/cjs/HUDManagers/FileNetUtilityManager.js

@@ -3,23 +3,69 @@
 const {
   HUDUtilityManager
 } = require("@trap_stevo/legendarybuilderpronodejs-utilities");
-const chalk = require("chalk");
-const significantMessageColors = ["#00C897", "#00E0FF"];
-const errorMessageColors = ["#F94144", "#F3722C"];
 class FileNetUtilityManager {
-  static outputGradient(text, colors) {
-    const gradient = HUDUtilityManager.generateGradientColors(colors, text.length);
-    let coloredText = "";
-    for (let i = 0; i < text.length; i++) {
-      const [r, g, b] = gradient[i];
-      coloredText += chalk.rgb(r, g, b)(text[i]);
+  static convertSeconds(seconds) {
+    if (seconds === 0) return "0 s";
+    const units = [{
+      name: "y",
+      seconds: 60 * 60 * 24 * 365
+    }, {
+      name: "mo",
+      seconds: 60 * 60 * 24 * 30
+    }, {
+      name: "w",
+      seconds: 60 * 60 * 24 * 7
+    }, {
+      name: "d",
+      seconds: 60 * 60 * 24
+    }, {
+      name: "h",
+      seconds: 60 * 60
+    }, {
+      name: "m",
+      seconds: 60
+    }, {
+      name: "s",
+      seconds: 1
+    }];
+    let remainingSeconds = seconds;
+    let result = "";
+    for (const unit of units) {
+      const count = Math.floor(remainingSeconds / unit.seconds);
+      if (count > 0) {
+        result += `${count}${unit.name} `;
+        remainingSeconds %= unit.seconds;
+      }
     }
-    console.log(coloredText);
-    return;
+    return result.trim();
+  }
+  static getFormattedSize(size, dynamicUnits = true) {
+    if (!dynamicUnits) return `${size.toFixed(1)} B`;
+    const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    return `${size.toFixed(2)} ${units[unitIndex]}`;
+  }
+  static getUnitData(size, dynamicUnits = true) {
+    if (!dynamicUnits) return {
+      current: size.toFixed(1),
+      unit: "B"
+    };
+    const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    return {
+      current: size.toFixed(2),
+      unit: units[unitIndex]
+    };
   }
 }
 module.exports = {
-  FileNetUtilityManager,
-  significantMessageColors,
-  errorMessageColors
+  FileNetUtilityManager
 };

package/dist/cjs/HUDManagers/FileTideDebugUtilityManager.js

@@ -0,0 +1,73 @@
+"use strict";
+
+const {
+  HUDUtilityManager
+} = require("@trap_stevo/legendarybuilderpronodejs-utilities");
+const chalk = require("chalk");
+const significantMessageColors = ["#00C897", "#00E0FF"];
+const noticeMessageColors = ["#4A90E2", "#A3D8F4"];
+const errorMessageColors = ["#F94144", "#F3722C"];
+const infoMessageColors = ["#028090", "#56cfe1"];
+const logHandler = {
+  "significant": function (includeDate = false, ...message) {
+    const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
+    outputGradient(log + message.join(" "), significantMessageColors);
+  },
+  "notice": function (includeDate = false, ...message) {
+    const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
+    outputGradient(log + message.join(" "), noticeMessageColors);
+  },
+  "error": function (includeDate = false, ...message) {
+    const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
+    outputGradient(log + message.join(" "), errorMessageColors);
+  },
+  "info": function (includeDate = false, ...message) {
+    const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
+    outputGradient(log + message.join(" "), infoMessageColors);
+  }
+};
+function outputGradient(text, colors) {
+  const gradient = HUDUtilityManager.generateGradientColors(colors, text.length);
+  let coloredText = "";
+  for (let i = 0; i < text.length; i++) {
+    const [r, g, b] = gradient[i];
+    coloredText += chalk.rgb(r, g, b)(text[i]);
+  }
+  console.log(coloredText);
+  return;
+}
+;
+class FileTideDebugUtilityManager {
+  constructor() {
+    if (FileTideDebugUtilityManager.instance) {
+      return FileTideDebugUtilityManager.instance;
+    }
+    this.debugMode = false;
+    FileTideDebugUtilityManager.instance = this;
+  }
+  outputGradient(text, colors) {
+    outputGradient(text, colors);
+    return;
+  }
+  setDebugMode(mode) {
+    this.debugMode = mode;
+  }
+  log(type = "info", includeDate = false, ...message) {
+    if (!this.debugMode && type !== "error") {
+      return;
+    }
+    if (logHandler[type]) {
+      logHandler[type](includeDate, ...message);
+      return;
+    }
+    console.log(new Date().toLocaleString(), chalk.gray("Unknown log type ~ "), type, ...message);
+  }
+}
+const instance = new FileTideDebugUtilityManager();
+module.exports = {
+  FileTideDebugUtilityManager: instance,
+  significantMessageColors,
+  noticeMessageColors,
+  errorMessageColors,
+  infoMessageColors
+};

package/dist/cjs/HUDManagers/FileTransferManager.js

@@ -77,16 +77,23 @@ class FileTransferManager {
       } = await fileHandle.read(Buffer.alloc(end - start), 0, end - start, start);
       const transferState = this.activeTransfers.get(transferId);
       chunkBuffer.set(chunkIndex, buffer);
-      while (chunkBuffer.has(nextExpectedChunk)) {
-        const nextChunkBuffer = chunkBuffer.get(nextExpectedChunk);
-        await onSendChunk(transferId, nextExpectedChunk, this.chunkSize, nextChunkBuffer, totalChunks, this.activeTransfers.get(transferId).completedChunks + 1);
-        chunkBuffer.delete(nextExpectedChunk);
-        nextExpectedChunk++;
-        transferState.transferredSize += this.chunkSize;
-        transferState.completedChunks++;
-        updateProgress();
-      }
-      if (transferState.completedChunks === transferState.totalChunks) {
+      try {
+        while (chunkBuffer.has(nextExpectedChunk)) {
+          const nextChunkBuffer = chunkBuffer.get(nextExpectedChunk);
+          await onSendChunk(transferId, nextExpectedChunk, this.chunkSize, nextChunkBuffer, totalChunks, this.activeTransfers.get(transferId).completedChunks + 1);
+          chunkBuffer.delete(nextExpectedChunk);
+          nextExpectedChunk++;
+          transferState.transferredSize += this.chunkSize;
+          transferState.completedChunks++;
+          updateProgress();
+        }
+        if (transferState.completedChunks === transferState.totalChunks) {
+          return onComplete(transferId).then(() => {
+            this.activeTransfers.delete(transferId);
+          });
+        }
+      } catch (error) {
+        console.error(`[FileTide ~ Transporter] ~ Did not send chunk ${chunkIndex} ~ ${error.message}`);
         return onComplete(transferId).then(() => {
           this.activeTransfers.delete(transferId);
         });

package/dist/cjs/HUDManagers/FileTransferReceiverManager.js

@@ -1,21 +1,25 @@
 "use strict";
 
-const fs = require("fs");
 const path = require("path");
+const fs = require("fs");
+const {
+  FileTransferTrackingManager
+} = require("./FileTransferTrackingManager.js");
+const {
+  FileTideDebugUtilityManager
+} = require("./FileTideDebugUtilityManager.js");
 const {
   FileUtilityManager
 } = require("./FileUtilityManager.js");
 class FileTransferReceiverManager {
-  constructor() {
-    this.activeTransfers = new Map();
-  }
+  constructor() {}
   async initializeTransfer(data, onError) {
     const savePath = FileUtilityManager.getTidePath(path.join(data.path || data.filePath, data.fileName));
-    if (this.activeTransfers.has(data.fileName)) {
+    FileTideDebugUtilityManager.log("notice", true, `Initializing transfer ~ ${data.fileName} | ${savePath}...`);
+    if (FileTransferTrackingManager.containsTransfer(data.fileName)) {
+      FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${data.fileName} | ${savePath} already initialized.`);
       return;
     }
-    const totalChunks = data.totalChunks || Math.ceil(data.fileSize / (data.chunkSize || 512 * 1024));
-    const chunkSize = data.chunkSize || 512 * 1024;
     try {
       const dir = path.dirname(savePath);
       if (!fs.existsSync(dir)) {
@@ -26,53 +30,58 @@ class FileTransferReceiverManager {
       const fileStream = fs.createWriteStream(savePath, {
         flags: "w"
       });
-      this.activeTransfers.set(data.fileName, {
-        receivedChunks: new Set(),
-        fileInfo: data,
-        totalChunks,
-        fileStream,
-        chunkSize
-      });
+      FileTransferTrackingManager.trackTransfer(data, fileStream);
+      FileTideDebugUtilityManager.log("notice", true, `Initialized transfer ~ ${data.fileName} | ${savePath}!`);
     } catch (error) {
+      FileTideDebugUtilityManager.log("error", true, `Did not initialize transfer ~ ${data.fileName} | ${savePath}.\n\t\t${error}`);
       if (onError) {
         onError(`[${data.fileName}] Did not initialize transfer ~ ${error.message}`);
       }
     }
   }
   async handleTransferProgress(data, onError) {
-    let transferState = this.activeTransfers.get(data.fileName);
+    let transferState = FileTransferTrackingManager.getTransfer(data.fileName);
     if (!transferState) {
       await this.initializeTransfer(data);
-      transferState = this.activeTransfers.get(data.fileName);
+      transferState = tFileTransferTrackingManager.getTransfer(data.fileName);
     }
     const chunkBuffer = Buffer.from(data.fileChunk);
     try {
       transferState.fileStream.write(chunkBuffer);
       transferState.receivedChunks.add(data.chunkIndex);
     } catch (error) {
+      FileTideDebugUtilityManager.log("error", true, `Did not write chunk ${data.chunkIndex} ~ ${data.fileName}.\n\t\t${error}`);
       if (onError) {
         onError(`[${data.fileName}] Did not write chunk ${data.chunkIndex} ~ ${error.message}`);
       }
     }
   }
   async completeTransfer(data, onComplete) {
-    let transferState = this.activeTransfers.get(data.fileName);
+    let transferState = FileTransferTrackingManager.getTransfer(data.fileName);
+    FileTideDebugUtilityManager.log("notice", true, `Completing transfer ~ ${data.fileName}...`);
     if (!transferState) {
+      FileTideDebugUtilityManager.log("notice", true, `Did not get transfer state ~ ${data.fileName}...re-initializing....`);
       await this.initializeTransfer(data);
-      transferState = this.activeTransfers.get(data.fileName);
+      transferState = FileTransferTrackingManager.getTransfer(data.fileName);
     }
     try {
+      FileTideDebugUtilityManager.log("notice", true, `Verifying transfer state ~ ${data.fileName} completion (${transferState.receivedChunks.size}/${transferState.totalChunks})...`);
+      FileTideDebugUtilityManager.log("notice", true, `Transfer state ~ ${data.fileName} completed ~ (${transferState.receivedChunks.size === transferState.totalChunks}).`);
       if (transferState.receivedChunks.size === transferState.totalChunks) {
         transferState.fileStream.end();
         console.log(`[${data.fileName}] Transfer complete. All chunks received and file written.`);
-        this.activeTransfers.delete(data.fileName);
-        if (onComplete) onComplete(data, this.activeTransfers, true);
+        FileTransferTrackingManager.untrackTransfer(data.fileName);
+        FileTideDebugUtilityManager.log("notice", true, `Cleared transfer state ~ ${data.fileName}.`);
+        FileTransferTrackingManager.outputCurrentTransfers();
+        if (onComplete) onComplete(data, FileTransferTrackingManager.activeTransfers, true);
       } else {
+        FileTideDebugUtilityManager.log("error", true, `Transfer incomplete. Received ${transferState.receivedChunks.size}/${transferState.totalChunks} chunks.`);
         throw new Error(`[${data.fileName}] Transfer incomplete. Received ${transferState.receivedChunks.size}/${transferState.totalChunks} chunks.`);
       }
     } catch (error) {
+      FileTideDebugUtilityManager.log("error", true, `Transfer incomplete.\n\t\t${error}`);
       if (onComplete) {
-        onComplete(data, this.activeTransfers, false, error);
+        onComplete(data, FileTransferTrackingManager.activeTransfers, false, error);
       }
     }
   }

package/dist/cjs/HUDManagers/FileTransferTrackingManager.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const {
+  FileTideDebugUtilityManager
+} = require("./FileTideDebugUtilityManager.js");
+class FileTransferTrackingManager {
+  constructor() {
+    if (FileTransferTrackingManager.instance) {
+      return FileTransferTrackingManager.instance;
+    }
+    this.activeTransfers = new Map();
+    FileTransferTrackingManager.instance = this;
+  }
+  trackTransfer(data, fileStream) {
+    FileTideDebugUtilityManager.log("notice", true, `Tracking transfer ~ ${data.fileName} | ${data.senderName}...`);
+    if (this.containsTransfer(data.fileName)) {
+      FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${data.fileName} | ${data.senderName} already tracked.`);
+      return;
+    }
+    const totalChunks = data.totalChunks || Math.ceil(data.fileSize / (data.chunkSize || 512 * 1024));
+    const chunkSize = data.chunkSize || 512 * 1024;
+    this.activeTransfers.set(data.fileName, {
+      receivedChunks: new Set(),
+      fileInfo: data,
+      totalChunks,
+      fileStream,
+      chunkSize
+    });
+    FileTideDebugUtilityManager.log("notice", true, `Tracked transfer ~ ${data.fileName} | ${data.senderName}!`);
+  }
+  updateTransfer(data) {
+    FileTideDebugUtilityManager.log("notice", true, `Updating tracked transfer ~ ${data.fileName} | ${data.senderName}...`);
+    if (!this.containsTransfer(data.fileName)) {
+      FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${data.fileName} | ${data.senderName} not tracked.`);
+      return;
+    }
+    const transferState = this.getTransfer(data.fileName);
+    transferState.receivedChunks.add(data.chunkIndex);
+    FileTideDebugUtilityManager.log("notice", true, `Updated tracked transfer ~ ${data.fileName} | ${data.senderName}!`);
+  }
+  containsTransfer(transferID) {
+    return this.activeTransfers.has(transferID);
+  }
+  getTransfer(transferID) {
+    return this.activeTransfers.get(transferID);
+  }
+  untrackTransfer(transferID) {
+    FileTideDebugUtilityManager.log("notice", true, `Untracking transfer ~ ${transferID}...`);
+    if (this.containsTransfer(transferID)) {
+      this.activeTransfers.delete(transferID);
+      FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${transferID} untracked!`);
+      return;
+    }
+    FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${transferID} already untracked.`);
+  }
+  outputCurrentTransfers() {
+    if (this.activeTransfers.size === 0) {
+      FileTideDebugUtilityManager.log("notice", true, "No active file transfers.");
+      return;
+    }
+    FileTideDebugUtilityManager.log("notice", true, "Ongoing Transfers ~\n");
+    this.activeTransfers.forEach((transfer, fileName) => {
+      const {
+        totalChunks,
+        receivedChunks,
+        fileInfo
+      } = transfer;
+      const percentage = (receivedChunks.size / totalChunks * 100).toFixed(2);
+      FileTideDebugUtilityManager.log("notice", false, `\nFile Name ~ ${fileName}`);
+      FileTideDebugUtilityManager.log("notice", false, `File Path ~ ${fileInfo.path || fileInfo.filePath}`);
+      FileTideDebugUtilityManager.log("notice", false, `File Size ~ ${fileInfo.fileSize} bytes`);
+      FileTideDebugUtilityManager.log("notice", false, `Chunk Size ~ ${transfer.chunkSize} bytes`);
+      FileTideDebugUtilityManager.log("notice", false, `Total Chunks ~ ${totalChunks}`);
+      FileTideDebugUtilityManager.log("notice", false, `Received Chunks ~ ${receivedChunks.size}`);
+      FileTideDebugUtilityManager.log("notice", false, `Progress ~ ${percentage}%`);
+    });
+    FileTideDebugUtilityManager.log("notice", false, "=================================\n");
+  }
+}
+;
+const instance = new FileTransferTrackingManager();
+module.exports = {
+  FileTransferTrackingManager: instance
+};

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "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": {
     "build": "babel src -d dist/cjs --env-name cjs",
+    "start-file-generation": "node demos/FileGenerator.js",
     "start-messager": "node demos/FileTideClientDemo.js",
     "start-net": "node demos/FileTideNetDemo.js",
     "start": "node dist/cjs/FileTide.js"
@@ -33,7 +34,7 @@
   "author": "Steven Compton",
   "license": "See License in LICENSE.md",
   "dependencies": {
-    "@trap_stevo/iotide": "^0.0.37",
+    "@trap_stevo/iotide": "^0.0.41",
     "@trap_stevo/iotide-client": "^0.0.23",
     "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.43",
     "chalk": "^4.1.2",