@trap_stevo/filetide 0.0.70 → 0.0.71

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;
   }

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/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.70",
+  "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",
@@ -37,6 +38,8 @@
     "@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",