@trap_stevo/filetide 0.0.69 → 0.0.71

package/LICENSE.md

@@ -30,7 +30,11 @@ Without the express written permission of the Licensor, Licensee shall not:
 2. Include the Package's source code or object code in any distributed software, service, or application.
 3. Use the Package to create a competing product or service that replicates the functionality of the Package.
 4. Make the Package publicly available, including uploading it to public repositories or including it in distributed software bundles.
-5. Use the Package in any way that violates applicable laws, infringes on third-party rights, or breaches this agreement.
+5. Attempt to extract or analyze the functionality, structure, or behavior of the Package through runtime inspection, instrumentation, reflection, or behavioral analysis.
+6. Privately share, sublicense, or distribute the Package or any portion thereof, whether internally within an organization or externally to any third party, without written authorization.
+7. Remove, obscure, obfuscate, or alter any attribution, copyright notices, proprietary labels, or identifiers included in the Package.
+8. Re-upload, rename, fork, or redistribute the Package or any portion thereof on any registry, platform, or namespace other than that explicitly maintained by or authorized by the Licensor.
+9. Use the Package in any way that violates applicable laws, infringes on third-party rights, or breaches this agreement.
 
 ## 5. **Wrapper API Creation**
 Licensee is permitted to create and distribute Wrapper APIs, provided that:
@@ -69,5 +73,7 @@ Licensee agrees to indemnify and hold harmless the Licensor from any and all cla
 ## 10. **Governing Law and Dispute Resolution**
 This Agreement shall be governed by and construed in accordance with the laws of **the state of Georgia**, without regard to its conflict of law principles. Any disputes arising out of this Agreement shall be resolved through arbitration in **the state of Georgia**.
 
-## 9. **Amendments**
+## 11. **Amendments**
 Licensor reserves the right to modify or update this Agreement at any time. Any changes to the Agreement will be effective **30 days** after being posted to **https://www.npmjs.com/package/@trap_stevo/filetide**. The Licensor will notify Licensees of any material changes by **posting a notice in the package’s release notes on NPM**. Continued use of the package after the notice period constitutes acceptance of the modified terms.
+
+**This Agreement applies to all versions of @trap_stevo/filetide downloaded, installed, or used on or after the Effective Date of this license, regardless of version number.** Use of any version of the Package after this date shall be deemed acceptance of and agreement to the terms of this license, unless otherwise explicitly stated by the Licensor.

package/dist/cjs/FileMessager.js

@@ -64,6 +64,13 @@ class FileMessager {
   }
   onDisconnect(connectionRes, socket) {
     console.log(`Client disconnected ~ ${socket.id}`);
+    const currentOnlineClient = FileNetClientManager.getOnlineClientByConnectionID(socket.id);
+    if (currentOnlineClient) {
+      this.handleClientOffline({}, {
+        connectionID: currentOnlineClient.id,
+        ...currentOnlineClient
+      });
+    }
     this.onlineClients.delete(socket.id);
     return;
   }
@@ -1165,6 +1172,14 @@ class FileMessager {
     }
     return client;
   }
+  getClient(clientID) {
+    const client = FileNetClientManager.getOnlineClient(clientID);
+    if (!client) {
+      console.log(`Client ~ ${clientID} not found.`);
+      return;
+    }
+    return client;
+  }
   requestFromClient(requesterID, senderID, filePath = process.cwd(), destinationPath) {
     const senderConnectionID = FileNetClientManager.getOnlineClient(senderID).id;
     const client = this.getClientFromID(senderConnectionID);

package/dist/cjs/FileMessagerClient.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 {
   HUDIoTide
 } = require("@trap_stevo/iotide-client");
@@ -24,8 +27,9 @@ const {
 const {
   FileUtilityManager
 } = require("./HUDManagers/FileUtilityManager");
+var _FileMessagerClient_brand = /*#__PURE__*/new WeakSet();
 class FileMessagerClient {
-  constructor(options = {}, transportOptions = {
+  constructor(_options = {}, transportOptions = {
     parallelChunks: 3,
     maxRetries: 3
   }, messagerSettings = {
@@ -33,13 +37,14 @@ class FileMessagerClient {
     reconnectionAttempts: 15,
     maxReconnectionDelay: 10000
   }) {
+    _classPrivateMethodInitSpec(this, _FileMessagerClient_brand);
     const {
       maxReconnectionAttempts = 15,
       reconnectionAttempts = 15,
       maxReconnectionDelay = 10000,
       ...messagerConfigurations
     } = messagerSettings;
-    this.clientOptions = FileMessagerConfigManager.getClientOptions(options);
+    this.clientOptions = FileMessagerConfigManager.getClientOptions(_options);
     this.transporter = new FileTransferManager(transportOptions);
     this.activeTransferTypes = new Map();
     this.clientTide = new HUDIoTide(maxReconnectionAttempts, reconnectionAttempts, maxReconnectionDelay, {
@@ -49,22 +54,8 @@ class FileMessagerClient {
     });
     this.clients = new Map();
   }
-  createClientInstance(clientID, clientOptions, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
-    this.clientTide.createIO(clientID, clientOptions.url, {
-      transports: ["websocket"],
-      ...options
-    }, headers, authURL, authHeaders, useAuthentication, queryAuthToken, onConnect, async () => {
-      FileTransferTrackingManager.outputCurrentTransfers();
-      FileTransferRecoveryManager.flushToDisk();
-      if (onDisconnect) {
-        await onDisconnect();
-      }
-    });
-    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) {
-    const socketName = this.createClientInstance(userID, {
+    const socketName = _assertClassBrand(_FileMessagerClient_brand, this, _createClientInstance).call(this, userID, {
       url: this.clientOptions.url
     }, options, headers, onConnect, onDisconnect, authURL, authHeaders, useAuthentication, queryAuthToken);
     return () => {
@@ -315,5 +306,19 @@ class FileMessagerClient {
     }
   }
 }
+function _createClientInstance(clientID, clientOptions, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
+  this.clientTide.createIO(clientID, clientOptions.url, {
+    transports: ["websocket"],
+    ...options
+  }, headers, authURL, authHeaders, useAuthentication, queryAuthToken, onConnect, async () => {
+    FileTransferTrackingManager.outputCurrentTransfers();
+    FileTransferRecoveryManager.flushToDisk();
+    if (onDisconnect) {
+      await onDisconnect();
+    }
+  });
+  FileTideDebugUtilityManager.outputGradient(`\n[FileTide ~ File Messager] ~ Created client with ID ${clientID} and socket ${clientID}!`, significantMessageColors);
+  return clientID;
+}
 ;
 module.exports = FileMessagerClient;

package/dist/cjs/FileTide.js

@@ -11,11 +11,18 @@ const chalk = require("chalk");
 const path = require("path");
 const fs = require("fs");
 const os = require("os");
+require("./HUDComponents/FileTideCommunicationConfigurations.js");
+require("./HUDComponents/FileTideEnvironment.js");
 const {
   FileTideDebugUtilityManager,
   significantMessageColors,
   errorMessageColors
 } = require("./HUDManagers/FileTideDebugUtilityManager.js");
+const {
+  displayFileTideAuthor,
+  displayFileTideTitle,
+  displayFileTideLogo
+} = require("./HUDManagers/FileTideUniversalUtilityManager.js");
 const {
   FileTransferTrackingManager
 } = require("./HUDManagers/FileTransferTrackingManager.js");
@@ -23,20 +30,22 @@ const {
   FileTransferReceiverManager
 } = require("./HUDManagers/FileTransferReceiverManager.js");
 const FileTransferRecoveryManager = require("./HUDManagers/FileTransferRecoveryManager.js");
+const TideTokenEnforcer = require("./HUDManagers/TideTokenEnforcementManager.js");
 const {
   FileNetConfigManager
 } = require("./HUDManagers/FileNetConfigManager.js");
 const {
   FileUtilityManager
 } = require("./HUDManagers/FileUtilityManager.js");
-const ConsoleProgressBarManager = require("./HUDComponents/ConsoleProgressBarManager");
+const ConsoleProgressBarManager = require("./HUDComponents/ConsoleProgressBarManager.js");
 const ChunkCapacitor = require("./HUDComponents/ChunkCapacitor.js");
 const ConsoleTable = require("./HUDComponents/ConsoleTable.js");
-const FileMessagerClient = require("./FileMessagerClient");
-const FileMessager = require("./FileMessager");
+const FileMessagerClient = require("./FileMessagerClient.js");
+const FileMessager = require("./FileMessager.js");
 var _FileTide_brand = /*#__PURE__*/new WeakSet();
 class FileTide {
   constructor(debugMode = true) {
+    // --- FileTide Event Management ---
     /**
      * Set up file transfer event listeners natively.
      * Automatically checks and creates directories as needed.
@@ -60,6 +69,23 @@ class FileTide {
     return;
   }
 
+  // --- FileTide TideToken Enforcement Management ---
+
+  updateTideTokenEnforcementCallbackConfigurations(updatedConfigurations = {}) {
+    TideTokenEnforcer.updateTideTokenEnforcementCallbackConfigurations(updatedConfigurations);
+  }
+  async registerTideToken(tideToken, meta = {}) {
+    return await TideTokenEnforcer.seal(tideToken, meta);
+  }
+  async inspectTideToken(tideToken) {
+    return await TideTokenEnforcer.inspect(tideToken);
+  }
+  getTideToken(scope = "default") {
+    return TideTokenEnforcer.getKey(scope);
+  }
+
+  // --- FileTide Gateway Management ---
+
   /**
    * Initialize and start the server.
    * @param {Object} serverOptions - Configuration for server (e.g., port, useCors, useHTTPS)
@@ -67,12 +93,14 @@ class FileTide {
    * @param {...any} tideConfigurations - Additional configuration objects for customizing FileTide behavior
    */
   launchFileTide(serverOptions = {}, onLaunch, ...tideConfigurations) {
-    this.fileNet = new FileMessager(serverOptions, ...tideConfigurations);
-    this.fileNet.start();
-    FileTide.outputGradient("[FileTide] ~ FileNet launched successfully!", significantMessageColors);
-    if (onLaunch) {
-      onLaunch(this.fileNet);
-    }
+    TideTokenEnforcer.protect(() => {
+      this.fileNet = new FileMessager(serverOptions, ...tideConfigurations);
+      this.fileNet.start();
+      FileTide.outputGradient("[FileTide] ~ FileNet launched successfully!", significantMessageColors);
+      if (onLaunch) {
+        onLaunch(this.fileNet);
+      }
+    }, "default")();
     return;
   }
 
@@ -107,39 +135,43 @@ class FileTide {
     reconnectionAttempts: 15,
     maxReconnectionDelay: 10000
   }, roomName, userID, onLaunch, onIncomingFile, onIncomingTransfer, onTransferBarrier, onTransferProgress, enableTransferBarrier = true, options = {}, headers = {}, onConnect = null, onDisconnect = null, authURL = "", authHeaders = {}, useAuthentication = false, queryAuthToken = false) {
-    if (this.clients.has(userID)) {
-      this.stopMessager(userID);
-    }
-    const currentClientDetails = this.clientDetails.get(userID);
-    if (currentClientDetails && currentClientDetails.unauthorized) {
-      const {
-        onCurrentClientUnauthorized
-      } = options;
-      FileTide.outputGradient(`[FileTide ~ FileNet] ~ Unauthorized access detected.`, errorMessageColors);
-      if (onCurrentClientUnauthorized) {
-        onCurrentClientUnauthorized({
-          ...currentClientDetails,
-          userID
-        });
+    TideTokenEnforcer.protect(() => {
+      if (this.clients.has(userID)) {
+        this.stopMessager(userID);
       }
-      return;
-    }
-    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(">Downloads"), FileUtilityManager.getTidePath(">Documents"), FileUtilityManager.getTidePath(">Desktop"), FileUtilityManager.getTidePath(">Photos"), FileUtilityManager.getTidePath(">Videos"), FileUtilityManager.getTidePath(">Music")]);
-    this.clients.set(userID, newClient);
-    this.clientDetails.set(userID, {
-      unauthorized: false,
-      userID
-    });
-    FileTide.outputGradient(`[FileTide] ~ Messager launched successfully for client ~ ${userID}!`, significantMessageColors);
-    _assertClassBrand(_FileTide_brand, this, _setupFileEventListeners).call(this, userID, newClient, onTransferProgress, onIncomingTransfer, onIncomingFile, onTransferBarrier, options);
-    if (onLaunch) {
-      onLaunch(newClient, enterRoom);
-    }
+      const currentClientDetails = this.clientDetails.get(userID);
+      if (currentClientDetails && currentClientDetails.unauthorized) {
+        const {
+          onCurrentClientUnauthorized
+        } = options;
+        FileTide.outputGradient(`[FileTide ~ FileNet] ~ Unauthorized access detected.`, errorMessageColors);
+        if (onCurrentClientUnauthorized) {
+          onCurrentClientUnauthorized({
+            ...currentClientDetails,
+            userID
+          });
+        }
+        return;
+      }
+      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(">Downloads"), FileUtilityManager.getTidePath(">Documents"), FileUtilityManager.getTidePath(">Desktop"), FileUtilityManager.getTidePath(">Photos"), FileUtilityManager.getTidePath(">Videos"), FileUtilityManager.getTidePath(">Music")]);
+      this.clients.set(userID, newClient);
+      this.clientDetails.set(userID, {
+        unauthorized: false,
+        userID
+      });
+      FileTide.outputGradient(`[FileTide] ~ Messager launched successfully for client ~ ${userID}!`, significantMessageColors);
+      _assertClassBrand(_FileTide_brand, this, _setupFileEventListeners).call(this, userID, newClient, onTransferProgress, onIncomingTransfer, onIncomingFile, onTransferBarrier, options);
+      if (onLaunch) {
+        onLaunch(newClient, enterRoom);
+      }
+    }, "default")();
     return;
   }
+  // --- FileTide Path Management ---
+
   async getDirectoryData(directoryPath) {
     return await FileUtilityManager.getDirectoryData(directoryPath);
   }
@@ -152,12 +184,6 @@ class FileTide {
   getTidePath(inputPath) {
     return FileUtilityManager.getTidePath(inputPath);
   }
-  getTidingTransferStates() {
-    return FileTransferRecoveryManager.memoryStorage;
-  }
-  saveTransferStates() {
-    FileTransferRecoveryManager.flushToDisk();
-  }
   filterFilesAndDirectories(dirPath, filterContent = [], callback) {
     FileUtilityManager.filterFilesAndDirectories(dirPath, filterContent, (files, error) => {
       if (callback) {
@@ -165,46 +191,73 @@ class FileTide {
       }
     });
   }
-  listFilesFromClient(recipientID, depth = 1) {
-    const clientID = this.currentUserID;
-    const clientMessager = this.clients.get(clientID);
-    if (!clientMessager) {
-      FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, errorMessageColors);
-      return;
-    }
-    clientMessager.clientTide.emitEvent(clientID, "check-client-banned", {
-      clientID,
-      tideID: clientMessager.clientTide.sockets[clientID].tideID
-    });
-    clientMessager.listFiles(clientID, recipientID, depth);
-  }
   async listFiles(directories, depth = 1, onDirectory) {
     return await FileUtilityManager.listFiles(directories, depth, onDirectory);
   }
-  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.`, errorMessageColors);
-      return false;
-    }
-    const shorePolicies = Array.from(clientShorePolicies.values());
-    const currentShores = new Set(clientShorePolicies);
-    this.clientShorePolicies.set(clientID, shorePolicies.filter(shorePolicy => !currentShores.has(shorePolicy)));
-    return true;
+
+  // --- FileTide Transfer State Management ---
+
+  async getTidingTransferStates() {
+    return await TideTokenEnforcer.protect(() => FileTransferRecoveryManager.memoryStorage, "default")();
   }
-  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.`, errorMessageColors);
-      return false;
-    }
-    this.clientShorePolicies.set(clientID, [...new Set([...clientShorePolicies, ...shores])]);
-    return true;
+  saveTransferStates() {
+    TideTokenEnforcer.protect(() => {
+      FileTransferRecoveryManager.flushToDisk();
+    }, "default")();
+  }
+
+  // --- FileTide Remote Files Management ---
+
+  listFilesFromClient(recipientID, depth = 1) {
+    TideTokenEnforcer.protect(() => {
+      const clientID = this.currentUserID;
+      const clientMessager = this.clients.get(clientID);
+      if (!clientMessager) {
+        FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, errorMessageColors);
+        return;
+      }
+      clientMessager.clientTide.emitEvent(clientID, "check-client-banned", {
+        clientID,
+        tideID: clientMessager.clientTide.sockets[clientID].tideID
+      });
+      clientMessager.listFiles(clientID, recipientID, depth);
+    }, "default")();
+  }
+
+  // --- FileTide Shore Policy Management ---
+
+  async clearShorePolicies(clientID, shores = []) {
+    return await TideTokenEnforcer.protect(() => {
+      let clientShorePolicies = this.clientShorePolicies.get(clientID);
+      if (!shores || shores.length <= 0 || !clientShorePolicies || !clientID) {
+        FileTide.outputGradient(`[FileTide] Did not clear from client ~ ${clientID} shore policies.`, errorMessageColors);
+        return false;
+      }
+      const shorePolicies = Array.from(clientShorePolicies.values());
+      const currentShores = new Set(clientShorePolicies);
+      this.clientShorePolicies.set(clientID, shorePolicies.filter(shorePolicy => !currentShores.has(shorePolicy)));
+      return true;
+    }, "default")();
+  }
+  async addShorePolicies(clientID, shores = []) {
+    return await TideTokenEnforcer.protect(() => {
+      const clientShorePolicies = this.clientShorePolicies.get(clientID);
+      if (!shores || shores.length <= 0 || !clientShorePolicies || !clientID) {
+        FileTide.outputGradient(`[FileTide] Did not add to client ~ ${clientID} shore policies.`, errorMessageColors);
+        return false;
+      }
+      this.clientShorePolicies.set(clientID, [...new Set([...clientShorePolicies, ...shores])]);
+      return true;
+    }, "default")();
   }
-  getShorePolicies(clientID) {
-    return this.clientShorePolicies.get(clientID);
+  async getShorePolicies(clientID) {
+    return await TideTokenEnforcer.protect(() => {
+      return this.clientShorePolicies.get(clientID);
+    }, "default")();
   }
 
+  // --- FileTide Transfer Management ---
+
   /**
    * Send files / directories directly to a device.
    * @param {String} recipientID - The ID of the client device to send the data to.
@@ -218,73 +271,81 @@ class FileTide {
    * @param {Number} transferRequestExpirationTime - The maximum time until the transfer barrier times out the transfer request.
    */
   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.`, errorMessageColors);
-      return false;
-    }
-    clientMessager.clientTide.emitEvent(clientID, "check-client-banned", {
-      clientID,
-      tideID: clientMessager.clientTide.sockets[clientID].tideID
-    });
-    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.`, errorMessageColors);
-      return false;
-    }
-    const fileDetails = await this.getPathData(filePath, filterDirectoryContent);
-    if (!fileDetails) {
-      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}...`, significantMessageColors);
-        await clientMessager.sendFile(clientID, recipientID, fileDetails.fileName, fileDetails.filePath, destinationPath, fileDetails.fileSize, tidalSize, minTideSize, maxTideSize, true, false, true, transferRequestExpirationTime);
+    return await TideTokenEnforcer.protect(async () => {
+      const clientID = this.currentUserID;
+      const clientMessager = this.clients.get(clientID);
+      if (!clientMessager) {
+        FileTide.outputGradient(`[FileTide] Client ~ ${clientID} not found.`, errorMessageColors);
+        return false;
+      }
+      clientMessager.clientTide.emitEvent(clientID, "check-client-banned", {
+        clientID,
+        tideID: clientMessager.clientTide.sockets[clientID].tideID
+      });
+      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.`, errorMessageColors);
+        return false;
+      }
+      const fileDetails = await this.getPathData(filePath, filterDirectoryContent);
+      if (!fileDetails) {
+        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}...`, 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}...`, significantMessageColors);
+        await clientMessager.sendFile(clientID, recipientID, fileDetails.content.fileName, fileDetails.content.filePath, destinationPath, fileDetails.content.size, tideSize, minTideSize, maxTideSize, transferRequestExpirationTime);
         return true;
       }
-      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}...`, significantMessageColors);
-      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 false;
+      if (fileDetails.type === "directory") {
+        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;
+      }
+      FileTide.outputGradient(`[FileTide] ~ No active client ~ ${recipientID} found.`, errorMessageColors);
+      return false;
+    }, "default")();
   }
 
+  // --- FileTide Operational Status Management ---
+
   /**
    * Check if running in server mode.
-   * @returns {Boolean} - True if running as a server
+   * @returns {Boolean} - True if server running
    */
-  fileTideOperational() {
-    return this.fileNet !== null;
+  async fileTideOperational() {
+    return await TideTokenEnforcer.protect(() => this.fileNet !== null, "default")();
   }
 
   /**
    * Check if running in client mode.
-   * @returns {Boolean} - True if any client is active
+   * @returns {Boolean} - True if any connected clients found
    */
-  messagerOperational() {
-    return this.clients.size > 0;
+  async messagerOperational() {
+    return await TideTokenEnforcer.protect(() => this.clients.size > 0, "default")();
   }
 
+  // --- FileTide Cleanup Management ---
+
   /**
    * Stop the server if running.
    */
   stopFileTide() {
-    if (this.fileNet) {
-      FileTide.outputGradient("Stopping FileTide...", significantMessageColors);
-      this.fileNet.close();
-      this.fileNet = null;
-      FileTide.outputGradient("Stopped FileTide.", significantMessageColors);
-    }
+    TideTokenEnforcer.protect(() => {
+      if (this.fileNet) {
+        FileTide.outputGradient("Stopping FileTide...", significantMessageColors);
+        this.fileNet.close();
+        this.fileNet = null;
+        FileTide.outputGradient("Stopped FileTide.", significantMessageColors);
+      }
+    }, "default")();
     return;
   }
 
@@ -296,33 +357,35 @@ class FileTide {
    * @param {Function} onCompletion - Executes upon messager disconnection completion
    */
   async stopMessager(userID, onBeforeDisconnect, onDisconnect, onCompletion) {
-    if (this.clients.has(userID)) {
-      FileTide.outputGradient(`Stopping messager for user ${userID}...`, significantMessageColors);
-      const connectionOrigin = this.clients.get(userID);
-      if (typeof onBeforeDisconnect === "function") {
-        await onBeforeDisconnect(this, userID, connectionOrigin);
-      }
-      if (connectionOrigin?.clientTide?.closeSocket) {
-        const result = connectionOrigin.clientTide.closeSocket(userID);
-        if (result instanceof Promise) {
-          try {
-            await result;
-          } catch (error) {
-            FileTide.outputGradient(`Did not disconnect ~ ${userID} ~ ${error.message}`, errorMessageColors);
+    TideTokenEnforcer.protect(async () => {
+      if (this.clients.has(userID)) {
+        FileTide.outputGradient(`Stopping messager for user ${userID}...`, significantMessageColors);
+        const connectionOrigin = this.clients.get(userID);
+        if (typeof onBeforeDisconnect === "function") {
+          await onBeforeDisconnect(this, userID, connectionOrigin);
+        }
+        if (connectionOrigin?.clientTide?.closeSocket) {
+          const result = connectionOrigin.clientTide.closeSocket(userID);
+          if (result instanceof Promise) {
+            try {
+              await result;
+            } catch (error) {
+              FileTide.outputGradient(`Did not disconnect ~ ${userID} ~ ${error.message}`, errorMessageColors);
+            }
+          }
+          if (typeof onDisconnect === "function") {
+            await onDisconnect(this, userID, connectionOrigin);
           }
         }
-        if (typeof onDisconnect === "function") {
-          await onDisconnect(this, userID, connectionOrigin);
+        this.clients.delete(userID);
+        FileTide.outputGradient(`Stopped messager for user ${userID}.`, significantMessageColors);
+        if (typeof onCompletion === "function") {
+          await onCompletion(this, userID, connectionOrigin);
         }
+        return;
       }
-      this.clients.delete(userID);
-      FileTide.outputGradient(`Stopped messager for user ${userID}.`, significantMessageColors);
-      if (typeof onCompletion === "function") {
-        await onCompletion(this, userID, connectionOrigin);
-      }
-      return;
-    }
-    FileTide.outputGradient(`No active messager found for user ${userID}.`, errorMessageColors);
+      FileTide.outputGradient(`No active messager found for user ${userID}.`, errorMessageColors);
+    }, "default")();
     return;
   }
 
@@ -333,38 +396,52 @@ class FileTide {
    * @param {Function} onCompletion - Executes upon all messager disconnection
    */
   async stopAllMessagers(onBeforeClientDisconnect, onClientDisconnect, onCompletion) {
-    FileTide.outputGradient("Stopping all messagers...", significantMessageColors);
-    const disconnectTasks = [];
-    for (let [userID, connectionOrigin] of this.clients.entries()) {
-      if (typeof onBeforeClientDisconnect === "function") {
-        await onBeforeClientDisconnect(this, userID, connectionOrigin);
-      }
-      if (connectionOrigin?.clientTide?.closeSocket) {
-        const task = async () => {
-          try {
-            const result = connectionOrigin.clientTide.closeSocket(userID);
-            if (result instanceof Promise) {
-              await result;
-            }
-            if (typeof onClientDisconnect === "function") {
-              await onClientDisconnect(this, userID, connectionOrigin);
+    TideTokenEnforcer.protect(async () => {
+      FileTide.outputGradient("Stopping all messagers...", significantMessageColors);
+      const disconnectTasks = [];
+      for (let [userID, connectionOrigin] of this.clients.entries()) {
+        if (typeof onBeforeClientDisconnect === "function") {
+          await onBeforeClientDisconnect(this, userID, connectionOrigin);
+        }
+        if (connectionOrigin?.clientTide?.closeSocket) {
+          const task = async () => {
+            try {
+              const result = connectionOrigin.clientTide.closeSocket(userID);
+              if (result instanceof Promise) {
+                await result;
+              }
+              if (typeof onClientDisconnect === "function") {
+                await onClientDisconnect(this, userID, connectionOrigin);
+              }
+              FileTide.outputGradient(`Disconnected ~ ${userID}`, significantMessageColors);
+            } catch (error) {
+              FileTide.outputGradient(`Did not disconnect ~ ${userID} - ${error.message}`, errorMessageColors);
             }
-            FileTide.outputGradient(`Disconnected ~ ${userID}`, significantMessageColors);
-          } catch (error) {
-            FileTide.outputGradient(`Did not disconnect ~ ${userID} - ${error.message}`, errorMessageColors);
-          }
-        };
-        disconnectTasks.push(task());
+          };
+          disconnectTasks.push(task());
+        }
       }
-    }
-    await Promise.all(disconnectTasks);
-    this.clients.clear();
-    FileTide.outputGradient("All messagers stopped.", significantMessageColors);
-    if (typeof onCompletion === "function") {
-      await onCompletion(this);
-    }
+      await Promise.all(disconnectTasks);
+      this.clients.clear();
+      FileTide.outputGradient("All messagers stopped.", significantMessageColors);
+      if (typeof onCompletion === "function") {
+        await onCompletion(this);
+      }
+    }, "default")();
     return;
   }
+
+  // --- FileTide Display Management ---
+
+  static displayFileTideLogo() {
+    displayFileTideLogo();
+  }
+  static displayFileTideTitle(cli = false) {
+    displayFileTideTitle(cli);
+  }
+  static displayFileTideAuthor() {
+    displayFileTideAuthor();
+  }
 }
 _FileTide = FileTide;
 function _setupFileEventListeners(userID, client, onTransferProgress, onIncomingTransfer, onIncomingFile, onTransferBarrier, options = {}) {
@@ -701,7 +778,7 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
   });
   client.clientTide.onEvent(userID, "list-files", async data => {
     _FileTide.outputGradient(`[${userID}] Sending file list to ${data.senderID}...!`, significantMessageColors);
-    const currentClientShorePolicies = this.getShorePolicies(userID);
+    const currentClientShorePolicies = await this.getShorePolicies(userID);
     let totalFilesSent = 0;
     const listedFiles = await this.listFiles(currentClientShorePolicies || [">Downloads"], data.depth || 1, (totalItems, directoryContents) => {
       const capacitor = new ChunkCapacitor(directoryContents, 100);

package/dist/cjs/FileTideEnvironment.js

@@ -0,0 +1,8 @@
+"use strict";
+
+const LogicTide = require("@trap_stevo/logictide");
+
+// ~ Universal FileTide Environment Mode ~
+
+const productionMode = true;
+LogicTide.setMode(productionMode ? "production" : "development");

package/dist/cjs/HUDComponents/FileTideCommunicationConfigurations.js

@@ -0,0 +1,12 @@
+"use strict";
+
+const LogicTide = require("@trap_stevo/logictide");
+
+// ~ Universal FileTide Communication Configurations ~
+
+LogicTide.defineLogic("filetide-api-origin-url", "development", () => {
+  return "http://localhost:19269";
+});
+LogicTide.defineLogic("filetide-api-origin-url", "production", () => {
+  return "https://api.filetide.com";
+});

package/dist/cjs/HUDComponents/FileTideEnvironment.js

@@ -0,0 +1,8 @@
+"use strict";
+
+const LogicTide = require("@trap_stevo/logictide");
+
+// ~ Universal FileTide Environment Mode ~
+
+const productionMode = true;
+LogicTide.setMode(productionMode ? "production" : "development");

package/dist/cjs/HUDManagers/FileNetClientManager.js

@@ -33,6 +33,14 @@ class FileNetClientManager {
     currentOnlineClients.delete(clientID);
     return currentOnlineClients;
   }
+  static getOnlineClientByConnectionID(connectionID) {
+    for (const clientData of currentOnlineClients.values()) {
+      if (clientData.id === connectionID) {
+        return clientData;
+      }
+    }
+    return null;
+  }
   static getOnlineClient(clientID) {
     return currentOnlineClients.get(clientID);
   }

package/dist/cjs/HUDManagers/FileTideDebugUtilityManager.js

@@ -6,6 +6,7 @@ const {
 const chalk = require("chalk");
 const significantMessageColors = ["#00C897", "#00E0FF"];
 const noticeMessageColors = ["#4A90E2", "#A3D8F4"];
+const infoAccentMessageColors = ["#6B768F", "#8D99AB"];
 const errorMessageColors = ["#F94144", "#F3722C"];
 const infoMessageColors = ["#028090", "#56cfe1"];
 const logHandler = {
@@ -26,14 +27,29 @@ const logHandler = {
     outputGradient(log + message.join(" "), infoMessageColors);
   }
 };
-function outputGradient(text, colors) {
+function gradientText(text, colors, options = {
+  underline: false
+}) {
   const gradient = HUDUtilityManager.generateGradientColors(colors, text.length);
   let coloredText = "";
+  const underlineRange = Array.isArray(options.underline) ? options.underline : null;
+  const underlineNone = options.underline === false;
+  const underlineAll = options.underline === true;
   for (let i = 0; i < text.length; i++) {
     const [r, g, b] = gradient[i];
-    coloredText += chalk.rgb(r, g, b)(text[i]);
+    let styledChar = chalk.rgb(r, g, b);
+    if (underlineAll || underlineRange && i >= underlineRange[0] && i < underlineRange[1]) {
+      styledChar = styledChar.underline;
+    }
+    coloredText += styledChar(text[i]);
   }
-  console.log(coloredText);
+  return coloredText;
+}
+;
+function outputGradient(text, colors, options = {
+  underline: false
+}) {
+  console.log(gradientText(text, colors, options));
   return;
 }
 ;
@@ -45,13 +61,35 @@ class FileTideDebugUtilityManager {
     this.debugMode = false;
     FileTideDebugUtilityManager.instance = this;
   }
-  outputGradient(text, colors) {
-    outputGradient(text, colors);
+  outputGradient(text, colors, options = {
+    underline: false
+  }) {
+    outputGradient(text, colors, options);
     return;
   }
+  gradientText(text, colors, options = {
+    underline: false
+  }) {
+    return gradientText(text, colors, options);
+  }
+  createHyperlink(text, url) {
+    const ESC = "\u001b";
+    const BEL = "\u0007";
+    return `${ESC}]8;;${url}${BEL}${text}${ESC}]8;;${BEL}`;
+  }
   setDebugMode(mode) {
     this.debugMode = mode;
   }
+  logLink(displayText, url, prefix = "➜", colors = noticeMessageColors.slice(0)) {
+    const styledText = gradientText(displayText, colors, {
+      underline: true
+    });
+    const link = this.createHyperlink(styledText, url);
+    const styledPrefix = gradientText(prefix, colors);
+    process.stdout.write(`${styledPrefix} `);
+    process.stdout.write(link);
+    process.stdout.write("\n");
+  }
   log(type = "info", includeDate = false, ...message) {
     if (!this.debugMode && type !== "error") {
       return;
@@ -69,5 +107,6 @@ module.exports = {
   significantMessageColors,
   noticeMessageColors,
   errorMessageColors,
+  infoAccentMessageColors,
   infoMessageColors
 };

package/dist/cjs/HUDManagers/FileTideUniversalUtilityManager.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const {
+  FileTideDebugUtilityManager
+} = require("./FileTideDebugUtilityManager.js");
+function displayFileTideLogo() {
+  FileTideDebugUtilityManager.outputGradient(`
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;:::::;;;;:::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::;+?%%%%%%%?*;::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;:::;*%%?+;:,,,::+?S?;:::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;::::;*S?;,,,,::::::,,;SS;:::;+++++++++;;:::::::;;;;;;:::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;:::+S%:.,::;::;;+++;::*@+:*SSS%%%%%%%%SS%+:::::::::::::::::::::;::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;:+#*,,:;;::+?SSSSS#?+SS+SS;:,,,,,,,,,,;S#?;::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;:;S?.,;;;:;%#%*+;*S##SS%S*,:;;;;;;;;;;;:,+S#%%%%%%%%%%%%%%%%%%%%%?+::::;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;:?#:,;;;:;S#*;::?#%+++%#*.:;;;;;;;;;;;;;;::;++++++++++++++++++++*?#S+::;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;S%,;;;;;%#*;::*#?:::;S#+;+++++++++++++++++++++++++;;;;;;;;;;;;;;;;##;:;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;:;#%:;;;;*#?+::;#S:::::S#*%%SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS?S#;::;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;:;S%;+;;;%#*+::+#%:::::S#S?+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+%##;::;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;:;SS++;;;%#**::+#?::::;#S:,,:::::::::::::::::::::::::::::::::::::::,+#%::;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;SS?*+;;%#?*;:;#S::::+#?,;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,S#;:::::;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;:;S#S*+;;*#%*+::?#*:::+#?,;;;;;;;;;**;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:S#;::::;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;S##?*;;;SS**;::%#*::+#?,;;;;;;;;;++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:S#;::::;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;S##S**;;*#%**;;:?#?:;#?,+++++++++;;+++++++++++++++++++++++++++++++;S#;:::::;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;S%?#?*+;;?#%**;;:*#S?#%:*++++++++++++++++++++++++++++++++++++++++*+S#;:::;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;S%:SS?*+;;?#%**+;;;?##S;******************************************+S#;::::;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;:::;SS,;#S??+;;*#S?*+;;:;?##%?******??%%SSSSSSS%%??********************##;::::::;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;SS;,;#S??+;;;%#S?*+;;;;?S#S%??%SS?*+;:::::;+*%SSS%%????????????????##;::::::;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;SS;;,:S#??*+;;+%#S%?*++;;+?##S*;,,,,:::::::,,,,;?##SSSS%%%???????%%##;::::;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;SS*+;:,*#S??*+;;+?S#S%?**?SS+,,::;;;;;::::;;;;::,:?#%**?%SSSSSSSSS%%S;:::;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;S#%**+;,:?SS%?**+;;+?S###%+,,:;;;;;;+**???**;;;;;:,;%#S*;;;;;;;;;::?S;:::;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;S##S?*++;::*%SSSSS%%%S%*:,,:;;;;;;*%SS%???%SSS?*+;;:,;%##%?**+++++*S#;:::;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;:;SS;%#%?*++;:::;++**+;:,,:;;;;;;;;%#?+;;;;;;;;*%SS?*+;;::+?%SSSSSSSSS#;:::;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;::;SS;:+S#S?**++;;;:::::;;;;;+*+++;*S?+++++++;;;;;;*S#%**+;;:::;;;;;;:*S;:::;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;:;SS*+;;+?SSS%?**+++++++**?%S%+;;?#?*???????**++;;;;*%SS%?**++;;;;;;;%S;:::;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;::?#%?*++;;+*%SSSSS%%%%SSS%?+;;+%#SSSSSSSSSSS%%?**++;;;*%SSSS%%????%%#S;:::;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;::%#%??**++;;;;+**???**++;;;+?S#S%%???**++*?%SSS%?**+++;;++*?%%%%%%##+:::;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;::*##%???****+++;;;;;;+++*?S#S%??????***+++++*%SSS%??****+++++++*%S+:::;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;::;?S#SS%?????******??%%SSS%%%%SSSS%%%%????****?%SSSS%%??????%S#?;::::;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;:::;+?%S##SSSSSSSSS#####SSSSS#SS#######SSSSSSSSSSS#######SSS%*;::::;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::;+++********************************************+++;;::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::::::::::::::::::::::::;;;::::::::::::;;;;;;;;:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::::;::::::::::;;:;;;;;;;;;;::;;:::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::::;;;;;:;;;;;;;;;;;;;;;::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+     `, ["#0077B6", "#00B4D8"]);
+}
+;
+function displayFileTideTitle(cli = false) {
+  if (cli) {
+    FileTideDebugUtilityManager.outputGradient(`
+          \t\t _______  ___   ___      _______  _______  ___   ______   _______       _______  ___      ___  
+          \t\t|       ||   | |   |    |       ||       ||   | |      | |       |     |       ||   |    |   | 
+          \t\t|    ___||   | |   |    |    ___||_     _||   | |  _    ||    ___|     |       ||   |    |   | 
+          \t\t|   |___ |   | |   |    |   |___   |   |  |   | | | |   ||   |___      |       ||   |    |   | 
+          \t\t|    ___||   | |   |___ |    ___|  |   |  |   | | |_|   ||    ___|     |      _||   |___ |   | 
+          \t\t|   |    |   | |       ||   |___   |   |  |   | |       ||   |___      |     |_ |       ||   | 
+          \t\t|___|    |___| |_______||_______|  |___|  |___| |______| |_______|     |_______||_______||___|                                                                                     
+          `, ["#028090", "#56cfe1"]);
+    return;
+  }
+  FileTideDebugUtilityManager.outputGradient(`
+     \t\t\t\t _______  ___   ___      _______  _______  ___   ______   _______
+     \t\t\t\t|       ||   | |   |    |       ||       ||   | |      | |       | 
+     \t\t\t\t|    ___||   | |   |    |    ___||_     _||   | |  _    ||    ___| 
+     \t\t\t\t|   |___ |   | |   |    |   |___   |   |  |   | | | |   ||   |___ 
+     \t\t\t\t|    ___||   | |   |___ |    ___|  |   |  |   | | |_|   ||    ___| 
+     \t\t\t\t|   |    |   | |       ||   |___   |   |  |   | |       ||   |___
+     \t\t\t\t|___|    |___| |_______||_______|  |___|  |___| |______| |_______|                                                                                   
+    `, ["#028090", "#56cfe1"]);
+}
+;
+function displayFileTideAuthor() {
+  FileTideDebugUtilityManager.outputGradient(`
+     ▄▄· ▄▄▄  ▄▄▄ . ▄▄▄· ▄▄▄▄▄▄▄▄ .·▄▄▄▄      ▄▄▄▄·  ▄· ▄▌    .▄▄ · ▄▄▄▄▄▄▄▄ . ▌ ▐·▄▄▄ . ▐ ▄      ▄▄·       • ▌ ▄ ·.  ▄▄▄·▄▄▄▄▄       ▐ ▄ 
+    ▐█ ▌▪▀▄ █·▀▄.▀·▐█ ▀█ •██  ▀▄.▀·██▪ ██     ▐█ ▀█▪▐█▪██▌    ▐█ ▀. •██  ▀▄.▀·▪█·█▌▀▄.▀·•█▌▐█    ▐█ ▌▪▪     ·██ ▐███▪▐█ ▄█•██  ▪     •█▌▐█
+    ██ ▄▄▐▀▀▄ ▐▀▀▪▄▄█▀▀█  ▐█.▪▐▀▀▪▄▐█· ▐█▌    ▐█▀▀█▄▐█▌▐█▪    ▄▀▀▀█▄ ▐█.▪▐▀▀▪▄▐█▐█•▐▀▀▪▄▐█▐▐▌    ██ ▄▄ ▄█▀▄ ▐█ ▌▐▌▐█· ██▀· ▐█.▪ ▄█▀▄ ▐█▐▐▌
+    ▐███▌▐█•█▌▐█▄▄▌▐█ ▪▐▌ ▐█▌·▐█▄▄▌██. ██     ██▄▪▐█ ▐█▀·.    ▐█▄▪▐█ ▐█▌·▐█▄▄▌ ███ ▐█▄▄▌██▐█▌    ▐███▌▐█▌.▐▌██ ██▌▐█▌▐█▪·• ▐█▌·▐█▌.▐▌██▐█▌
+    ·▀▀▀ .▀  ▀ ▀▀▀  ▀  ▀  ▀▀▀  ▀▀▀ ▀▀▀▀▀•     ·▀▀▀▀   ▀ •      ▀▀▀▀  ▀▀▀  ▀▀▀ . ▀   ▀▀▀ ▀▀ █▪    ·▀▀▀  ▀█▄▀▪▀▀  █▪▀▀▀.▀    ▀▀▀  ▀█▄▀▪▀▀ █▪
+    `, ["#1a73e8", "#a0c4ff"]);
+}
+;
+module.exports = {
+  displayFileTideAuthor,
+  displayFileTideTitle,
+  displayFileTideLogo
+};

package/dist/cjs/HUDManagers/TidalyticsUtilityManager.js

@@ -16,6 +16,28 @@ function pickData(data, keys) {
   }, {});
 }
 ;
+function parseSizeString(str) {
+  if (typeof str === "number") {
+    return str;
+  }
+  if (typeof str !== "string") {
+    return 0;
+  }
+  const units = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 ** 2,
+    GB: 1024 ** 3,
+    TB: 1024 ** 4
+  };
+  const match = str.trim().toUpperCase().match(/^([\d.]+)\s*(B|KB|MB|GB|TB)$/);
+  if (!match) {
+    return 0;
+  }
+  const [, numStr, unit] = match;
+  return parseFloat(numStr) * units[unit];
+}
+;
 function aggregateMultiAverageChartData(events, {
   groupBy = ["user"],
   valueKey = "metadata.fileSize",
@@ -38,7 +60,17 @@ function aggregateMultiAverageChartData(events, {
       return getNestedData(event, path) ?? "unknown";
     });
     const label = labelParts.join(" | ");
-    const value = getNestedData(event, valueKey);
+    let rawValue = getNestedData(event, valueKey);
+    let value;
+    if (mode === "sum") {
+      if (valueKey.includes("speed") || valueKey.includes("fileSize")) {
+        value = parseSizeString(rawValue);
+      } else {
+        value = parseFloat(rawValue) || 0;
+      }
+    } else {
+      value = 1;
+    }
     if (typeof value !== "number") {
       continue;
     }
@@ -100,7 +132,17 @@ function aggregateChartData(events, {
       label = event[typeKey] || "other";
     }
     const type = event[typeKey] || "other";
-    const value = mode === "sum" ? getNestedData(event, valueKey) || 0 : 1;
+    let rawValue = mode === "sum" ? getNestedData(event, valueKey) || 0 : 1;
+    let value;
+    if (mode === "sum") {
+      if (valueKey.includes("speed") || valueKey.includes("fileSize")) {
+        value = parseSizeString(rawValue);
+      } else {
+        value = parseFloat(rawValue) || 0;
+      }
+    } else {
+      value = 1;
+    }
     if (!buckets[type]) {
       buckets[type] = {
         previewFileNames: [],

package/dist/cjs/HUDManagers/TideTokenEnforcementManager.js

@@ -0,0 +1,149 @@
+"use strict";
+
+const LogicTide = require("@trap_stevo/logictide");
+const Lockline = require("@trap_stevo/lockline");
+const axios = require("axios");
+const {
+  FileTideDebugUtilityManager,
+  significantMessageColors,
+  noticeMessageColors,
+  infoMessageColors,
+  infoAccentMessageColors,
+  errorMessageColors
+} = require("./FileTideDebugUtilityManager.js");
+const {
+  displayFileTideAuthor,
+  displayFileTideTitle,
+  displayFileTideLogo
+} = require("./FileTideUniversalUtilityManager.js");
+class TideTokenEnforcementManager {
+  constructor(options = {}) {
+    const {
+      tideTokenEnforcementCallbackConfigurations = {},
+      onDidNotLoadRecentTideTokens
+    } = options;
+    this.tideTokenEnforcementCallbackConfigurations = tideTokenEnforcementCallbackConfigurations;
+    this.tideTokenEnforcementComplianceHandlers = this.generateTideTokenEnforcementHandlers();
+    this.lock = new Lockline();
+    this.lock.setStorage(Lockline.lockbox("./lockbox", {
+      namespace: "tide-tokens",
+      encrypt: true
+    }));
+    this.lock.registerValidator("tide-token-authorization", async ({
+      key
+    }) => {
+      const fileTideAPIURL = await LogicTide.run("filetide-api-origin-url");
+      const response = await axios.get(`${fileTideAPIURL}/tide-token-auth/authorized-tide-token`, {
+        params: {
+          inputTideToken: key
+        }
+      });
+      return {
+        valid: response.data.authorizedTideToken,
+        raw: response.data.details,
+        reason: response.data.message
+      };
+    });
+    this.lock.setDefaultValidator("tide-token-authorization");
+    this.loadedRecentLicenseKeys = this.lock.loadRecentLicenseKeys().catch(error => {
+      if (typeof onDidNotLoadRecentTideTokens === "function") {
+        onDidNotLoadRecentTideTokens(error);
+      }
+    });
+    this.enforcerOverviewMetrics = {
+      "tide-token-authorized": 0,
+      "tide-token-blocked": 0,
+      "tide-token-missing": 0,
+      "tide-token-invalid": 0
+    };
+  }
+  updateTideTokenEnforcementCallbackConfigurations(updatedConfigurations = {}) {
+    this.tideTokenEnforcementCallbackConfigurations = {
+      ...this.tideTokenEnforcementCallbackConfigurations,
+      ...updatedConfigurations
+    };
+    this.tideTokenEnforcementComplianceHandlers = this.generateTideTokenEnforcementHandlers();
+  }
+  generateTideTokenEnforcementHandlers() {
+    const {
+      onLicenseBlocked,
+      onMissingLicense,
+      onInvalidLicense,
+      onSuccess
+    } = this.tideTokenEnforcementCallbackConfigurations;
+    const url = "https://filetide.com/tider-portal";
+    return {
+      onLicenseBlocked: enforcedDetails => {
+        FileTideDebugUtilityManager.outputGradient(`[FileTide | ${new Date().toLocaleString()}] ~ ❌ TideToken Blocked\n`, errorMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`\t→ Visit ~ ${url} to configure / create TideTokens.\n`, infoAccentMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`| ${new Date().toLocaleString()} |`, infoAccentMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`${"-".repeat(130)}\n`, infoAccentMessageColors);
+        this.enforcerOverviewMetrics["tide-token-blocked"] += 1;
+        onLicenseBlocked?.(enforcedDetails);
+      },
+      onMissingKey: enforcedDetails => {
+        displayFileTideLogo();
+        displayFileTideTitle();
+        FileTideDebugUtilityManager.outputGradient(`[FileTide] ~ Welcome!\n`, significantMessageColors);
+        FileTideDebugUtilityManager.outputGradient("\t~ No TideToken(s) Detected\n", significantMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`\t→ Visit ~ ${url} to create TideTokens.\n`, infoMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`| ${new Date().toLocaleString()} |`, infoAccentMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`${"-".repeat(130)}\n`, infoAccentMessageColors);
+        this.enforcerOverviewMetrics["tide-token-missing"] += 1;
+        onMissingLicense?.(enforcedDetails);
+      },
+      onInvalidKey: enforcedDetails => {
+        FileTideDebugUtilityManager.outputGradient(`[FileTide | ${new Date().toLocaleString()}] ~ ❌ TideToken Unauthorized\n`, errorMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`\t→ Visit ~ ${url} to configure / create TideTokens.\n`, infoAccentMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`| ${new Date().toLocaleString()} |`, infoAccentMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`${"-".repeat(130)}\n`, infoAccentMessageColors);
+        this.enforcerOverviewMetrics["tide-token-invalid"] += 1;
+        onInvalidLicense?.(enforcedDetails);
+      },
+      onSuccess: enforcedDetails => {
+        FileTideDebugUtilityManager.outputGradient(`[FileTide | ${new Date().toLocaleString()}] ~ ✅ TideToken Authorized\n`, significantMessageColors);
+        if (this.enforcerOverviewMetrics["tide-token-authorized"] <= 0) {
+          FileTideDebugUtilityManager.outputGradient(`\t→ Configure TideTokens at ${url}\n`, noticeMessageColors);
+        }
+        FileTideDebugUtilityManager.outputGradient(`| ${new Date().toLocaleString()} |`, infoAccentMessageColors);
+        FileTideDebugUtilityManager.outputGradient(`${"-".repeat(130)}\n`, infoAccentMessageColors);
+        this.enforcerOverviewMetrics["tide-token-authorized"] += 1;
+        onSuccess?.(enforcedDetails);
+      }
+    };
+  }
+  protect(handler, scope, options = {}) {
+    return async (...args) => {
+      await this.loadedRecentLicenseKeys;
+      const protectedHandler = this.lock.withLicenseProtection(handler, scope, {
+        ...(options ?? {}),
+        ...this.tideTokenEnforcementComplianceHandlers
+      });
+      return await protectedHandler(...args);
+    };
+  }
+  getKey(scope = "default") {
+    return this.lock.getCurrentLicenseKey(scope);
+  }
+  async seal(key, meta = {}) {
+    return await this.lock.sealKey(key, {
+      validators: [{
+        name: "tide-token-authorization"
+      }],
+      meta
+    }, {
+      assumePreviouslyValid: true,
+      fallbackIfOffline: true,
+      autoRemoveExpired: true,
+      storeInvalid: true
+    });
+  }
+  async validate(key) {
+    return await this.lock.validate(key);
+  }
+  async inspect(key) {
+    return await this.lock.inspectKey(key);
+  }
+}
+;
+module.exports = new TideTokenEnforcementManager();

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.69",
+  "version": "0.0.71",
   "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-tide-token-server": "node demos/tideTokenServerDemo.js",
     "start-file-generation": "node demos/FileGenerator.js",
     "start-messager": "node demos/FileTideClientDemo.js",
     "start-net": "node demos/FileTideNetDemo.js",
@@ -34,11 +35,13 @@
   "author": "Steven Compton",
   "license": "See License in LICENSE.md",
   "dependencies": {
-    "@trap_stevo/iotide": "^0.0.43",
-    "@trap_stevo/iotide-client": "^0.0.25",
-    "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.48",
-    "@trap_stevo/metrictide": "^0.0.3",
-    "@trap_stevo/timelyst": "^0.0.5",
+    "@trap_stevo/iotide": "^0.0.44",
+    "@trap_stevo/iotide-client": "^0.0.26",
+    "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.49",
+    "@trap_stevo/lockline": "^0.0.11",
+    "@trap_stevo/logictide": "^0.0.1",
+    "@trap_stevo/metrictide": "^0.0.4",
+    "@trap_stevo/timelyst": "^0.0.6",
     "chalk": "^4.1.2",
     "readline": "^1.3.0"
   },